nilometer 0.0.0-stage → 0.2.0

package/dist/viewer/render.js

@@ -0,0 +1,602 @@
+/**
+ * @file The one screen: observed sections first, projections in a separate labeled section (docs/development.md P7.1).
+ *
+ * Wording is part of correctness (CLAUDE.md): labels state what was measured, projections say
+ * "projected" in the label itself, caveats sit next to their numbers, and nothing is advice. Every
+ * label lives in {@link LABELS}, which the JSON output carries too, so the banned-phrase test (A9)
+ * reads every label once. Numbers are rounded only through viewer/format.ts.
+ */
+import { UNKNOWN, formatCoverage, formatInstant, formatNumber, printable, } from "./format.js";
+/** Every heading, column name, and caveat the report prints. */
+export const LABELS = {
+    title: "Claude subscription usage",
+    observed: "OBSERVED",
+    projected: "PROJECTED: estimates derived from the observations above, not observations",
+    interruptions: "Interruptions",
+    // D-090 (step G4.2): lockouts lead; a logged limit hit is a refused request, and one lockout can hold many.
+    limitHits: "Limit hits",
+    limitHitsNote: "Each logged hit is a request the limit refused. A lockout refuses every request until its reset, so one lockout can hold several hits.",
+    midTask: "Mid-task interruptions (the refused request was answering a tool result)",
+    lockout: "Elapsed lockout time (first limit hit to the window's reset, overlapping lockouts counted once)",
+    resetToNextRequest: "reset to next Claude Code request",
+    // D-081 (step G2.9): a status line pointing at a hook file that isn't there records nothing.
+    hookMissing: "Warning: your Claude Code status line runs a Nilometer hook file that doesn't exist, so no usage readings are being recorded. Run nilometer init to point it at this install.",
+    hookMissingPath: "Missing hook file",
+    // D-077 (step G2.4): only the logged marker earns this label; nothing is inferred from timing.
+    autoContinued: "resumed by Claude Code (logged auto-continuation)",
+    // D-075 (step G2.2): interruptions per plan period.
+    byPlan: "By plan period",
+    byPlanNote: "plans as entered with plan-price set; a plan applies from the first day of its month, so a change within a month counts from the month it was entered for",
+    notResumed: "Sessions with no further request after a limit hit",
+    autoResumeCaveat: "A session that continued after its reset may have been resumed automatically; these counts are requests, not who made them.",
+    windows: "Usage windows",
+    noReadings: "No status line readings yet. Readings are recorded only when Claude Code runs in a terminal; the VS Code extension doesn't run the status line.",
+    windowsCaveat: "Last observed usage is a lower bound: usage after the last Claude Code turn isn't seen.",
+    // D-083 (step G2.5): what "open" means, and which reading an open window's usage is from.
+    openNote: "Open: not reset as of this report. An open window's usage is its last reading's, at the time under Reading at.",
+    // D-087 (step G3.2): a weekly window near its limit, stated as readings, without inferring why.
+    crossings: "Weekly windows at 75% and 90%: the first reading at or above each level, and the time from it to the reset",
+    crossingsWhat: "The first reading at or above each level, and the time from it to the reset.",
+    crossingsCaveat: "A level may have been passed earlier, between readings, so the time left is a lower bound.",
+    noCrossings: "No weekly window has a reading at or above 75%.",
+    // D-089 (step G4.1): usage within a window only rises, so a lower reading is stale.
+    staleReadings: "Readings below an earlier reading in their window, not used",
+    byModel: "Claude Code tokens by model",
+    byRepo: "Claude Code tokens by repository",
+    alias: "Alias you entered (nilometer alias)",
+    burnRate: "Burn rate",
+    burnRatePremise: "Premise: each window's usage started at 0% when it began, and its average rate since then continues.",
+    apiListPrice: "Observed tokens at API list price, by month",
+    apiListPriceScope: "Covers Claude Code only: web, mobile, and Claude Design usage leaves no token records.",
+    columns: {
+        window: "Window",
+        resets: "Resets",
+        lastUsage: "Last observed usage",
+        readingAt: "Reading at",
+        peak: "Peak",
+        readings: "Readings",
+        status: "Status",
+        model: "Model",
+        repository: "Repository",
+        kind: "Kind",
+        requests: "Requests",
+        input: "Input",
+        output: "Output",
+        cacheRead: "Cache read",
+        cacheWrite5m: "Cache write 5m",
+        cacheWrite1h: "Cache write 1h",
+        cacheWriteUnsplit: "Cache write, no duration",
+        month: "Month",
+        apiListPrice: "At API list price",
+        planPrice: "Plan price entered",
+        plan: "Plan",
+        months: "Months",
+        hits: "Limit hits",
+        lockouts: "Lockouts",
+        elapsed: "Elapsed lockout time",
+        priced: "Priced requests",
+        unpriced: "Unpriced requests",
+        covers: "Covers",
+    },
+};
+/**
+ * Lays out rows as a text table with a header and a rule.
+ * @param headers - Column names.
+ * @param rawRows - Cell text per row; control characters in them are escaped (D-050).
+ * @param align - Alignment per column; numbers are right-aligned.
+ * @returns Lines, each indented by two spaces.
+ */
+export function renderTable(headers, rawRows, align) {
+    // Cells hold model names and repository paths from the logs, so escape before measuring (D-050).
+    const rows = rawRows.map((row) => row.map(printable));
+    const widths = headers.map((header, column) => Math.max(header.length, ...rows.map((row) => (row[column] ?? "").length)));
+    /**
+     * Pads one row's cells to the column widths.
+     * @param cells - Cell text.
+     * @returns The joined line.
+     */
+    const line = (cells) => `  ${cells
+        .map((cell, column) => align[column] === "right"
+        ? cell.padStart(widths[column] ?? 0)
+        : cell.padEnd(widths[column] ?? 0))
+        .join("  ")
+        .trimEnd()}`;
+    return [line(headers), line(widths.map((width) => "-".repeat(width))), ...rows.map(line)];
+}
+/**
+ * Counts something with its singular or plural noun.
+ * @param count - How many.
+ * @param singular - Noun for exactly one.
+ * @param pluralForm - Noun otherwise.
+ * @returns E.g. `1 hit`, `3 hits`, `unknown hits`.
+ */
+export function plural(count, singular, pluralForm) {
+    return `${formatNumber(count, "count")} ${count === 1 ? singular : pluralForm}`;
+}
+/**
+ * Shortens a path under the home directory to start with `~`.
+ * @param path - Any path.
+ * @param home - The home directory; an empty string leaves paths unchanged.
+ * @returns `~` or `~/rest` (`~\rest` for a Windows path) under home, otherwise the path itself.
+ */
+export function displayPath(path, home) {
+    if (home === "") {
+        return path;
+    }
+    // A Windows home (`C:\Users\<name>`) also matches with `/` separators, which git uses for repository
+    // roots, and with a lowercase drive letter, which some Claude Code logs use (D-049). Both changes
+    // keep the length, so the remainder is sliced from the original path.
+    const windows = /^[A-Za-z]:[\\/]/.test(home);
+    /**
+     * Spells a path for comparison with the home directory.
+     * @param value - A path.
+     * @returns On Windows, the path with an uppercase drive letter and `/` separators; elsewhere unchanged.
+     */
+    const comparable = (value) => windows ? `${value.charAt(0).toUpperCase()}${value.slice(1)}`.replaceAll("\\", "/") : value;
+    const [p, h] = [comparable(path), comparable(home)];
+    if (p !== h && !p.startsWith(`${h}/`)) {
+        return path;
+    }
+    return `~${path.slice(home.length)}`;
+}
+/**
+ * Names a rate-limit window for display.
+ * @param window - Payload window key.
+ * @returns `5-hour`, `weekly`, or the key itself.
+ */
+export function windowName(window) {
+    return window === "five_hour" ? "5-hour" : window === "seven_day" ? "weekly" : window;
+}
+/**
+ * Names how a repository was resolved (D-010).
+ * @param kind - `repo_kind` from the view.
+ * @returns Display text.
+ */
+export function repoKindName(kind) {
+    switch (kind) {
+        case "repo":
+            return "git repository";
+        case "not_git":
+            return "not a git repository";
+        case "missing":
+            return "directory no longer exists";
+        default:
+            return "not resolved yet";
+    }
+}
+/**
+ * Says what one lockout's limit hits were (D-090): requests the limit refused, from how many
+ * sessions, and any status line readings at 100% with no refusal logged (D-023).
+ * @param interval - The lockout.
+ * @returns E.g. `13 refused requests in 3 sessions`, or `1 status line reading at 100%`.
+ */
+export function lockoutHitsText(interval) {
+    const parts = [];
+    if (interval.refused_requests > 0) {
+        parts.push(`${plural(interval.refused_requests, "refused request", "refused requests")} in ${plural(interval.sessions, "session", "sessions")}`);
+    }
+    const readings = interval.hits - interval.refused_requests;
+    if (readings > 0) {
+        parts.push(`${plural(readings, "status line reading", "status line readings")} at 100%`);
+    }
+    return parts.join(" and ");
+}
+/**
+ * States the sessions Claude Code resumed by itself after a lockout, as logged (D-077).
+ * @param interval - The lockout.
+ * @returns `; resumed by Claude Code (logged auto-continuation): 1 session, 4 m 15 s after the
+ *   reset`, or "" when no marker was logged.
+ */
+export function autoContinuedText(interval) {
+    if (interval.auto_continuations === 0) {
+        return "";
+    }
+    const after = `${n(interval.first_auto_continuation_seconds, "duration")} after the reset`;
+    return interval.auto_continuations === 1
+        ? `; ${LABELS.autoContinued}: 1 session, ${after}`
+        : `; ${LABELS.autoContinued}: ${plural(interval.auto_continuations, "session", "sessions")}, the first ${after}`;
+}
+/**
+ * Names a plan period as the report shows it (D-075).
+ * @param row - The period's kind and plan name.
+ * @returns The plan's name as entered, "no plan entered" before the first, or "time unknown".
+ */
+export function planPeriodName(row) {
+    if (row.period_kind === "none") {
+        return "no plan entered";
+    }
+    // Raw: the text table and the page each escape cells themselves (D-050).
+    return row.period_kind === "unknown" ? "time unknown" : (row.plan_name ?? "");
+}
+/**
+ * States which months a plan period covers (D-075).
+ * @param row - The period's kind and months.
+ * @returns `2026-07`, `2026-07 to 2026-09`, `2026-08 onward`, `before 2026-07`, `every month`, or
+ *   `no time` for hits that have none.
+ */
+export function planPeriodMonths(row) {
+    if (row.period_kind === "unknown") {
+        return "no time";
+    }
+    if (row.period_kind === "none") {
+        return row.until_month === null ? "every month" : `before ${row.until_month}`;
+    }
+    if (row.to_month === null) {
+        return `${row.from_month ?? ""} onward`;
+    }
+    return row.to_month === row.from_month
+        ? (row.from_month ?? "")
+        : `${row.from_month ?? ""} to ${row.to_month}`;
+}
+/**
+ * Describes one weekly window's crossings (D-087): each level it reached, or that it wasn't reached.
+ * @param rows - The window's `obs_weekly_crossings` rows, lower level first.
+ * @param timeZone - Display zone.
+ * @returns E.g. `75% first read 2026-10-13 14:05 (4 d 21 h before the reset); 90% not reached`.
+ */
+export function crossingText(rows, timeZone) {
+    return [75, 90]
+        .map((level) => {
+        const row = rows.find((r) => r.threshold === level);
+        return row === undefined
+            ? `${String(level)}% not reached`
+            : `${String(level)}% first read ${formatInstant(row.first_at_utc, timeZone)} (${formatNumber(row.seconds_before_reset, "duration")} before the reset)`;
+    })
+        .join("; ");
+}
+/**
+ * Renders the weekly windows' first readings at or above 75% and 90% (D-087, step G3.2).
+ * @param rows - `obs_weekly_crossings`, newest window first.
+ * @param timeZone - Display zone.
+ * @returns Lines for the windows section.
+ */
+function renderCrossings(rows, timeZone) {
+    if (rows.length === 0) {
+        return [`  ${LABELS.noCrossings}`];
+    }
+    // One line per window, in the rows' order; a Set keeps each reset once.
+    const resets = [...new Set(rows.map((r) => r.reset_at_utc))];
+    return [
+        `  ${LABELS.crossings}`,
+        ...resets.map((reset) => `    weekly window resetting ${formatInstant(reset, timeZone)}: ${crossingText(rows.filter((r) => r.reset_at_utc === reset), timeZone)}`),
+        `    ${LABELS.crossingsCaveat}`,
+    ];
+}
+/**
+ * Renders the per-plan interruption table (D-075), only once a plan has been entered: before
+ * that, every row would be "no plan entered" and repeat the totals above it.
+ * @param rows - `obs_interruptions_by_plan` rows, in the view's order.
+ * @param timeZone - Display zone.
+ * @returns Lines, or none.
+ */
+function renderByPlan(rows, timeZone) {
+    if (!rows.some((row) => row.period_kind === "plan")) {
+        return [];
+    }
+    const c = LABELS.columns;
+    return [
+        `  ${LABELS.byPlan}: ${LABELS.byPlanNote} (months in ${timeZone}).`,
+        ...renderTable([c.plan, c.months, c.hits, c.lockouts, c.elapsed, c.covers], rows.map((row) => [
+            planPeriodName(row),
+            planPeriodMonths(row),
+            n(row.hits, "count"),
+            n(row.lockouts, "count"),
+            n(row.lockout_seconds, "duration"),
+            row.period_kind === "unknown" ? "" : span(row.covers_from, row.covers_to, timeZone),
+        ]), ["left", "left", "right", "right", "right", "left"]).map((line) => `  ${line}`),
+    ];
+}
+/**
+ * Formats a span without the zone, for table cells under a heading that names it.
+ * @param from - First instant.
+ * @param to - Last instant.
+ * @param timeZone - IANA zone.
+ * @returns `YYYY-MM-DD HH:MM to YYYY-MM-DD HH:MM`.
+ */
+function span(from, to, timeZone) {
+    return `${formatInstant(from, timeZone)} to ${formatInstant(to, timeZone)}`;
+}
+/**
+ * Formats a number, shortening the call sites.
+ * @param value - Value.
+ * @param kind - Kind.
+ * @returns Display text.
+ */
+const n = (value, kind) => formatNumber(value, kind);
+/**
+ * Renders the token table shared by the model and repository sections.
+ * @param first - Leading columns' headers.
+ * @param rows - Rows with their leading cells.
+ * @returns Table lines.
+ */
+function tokenTable(first, rows) {
+    const c = LABELS.columns;
+    return renderTable([
+        ...first,
+        c.requests,
+        c.input,
+        c.output,
+        c.cacheRead,
+        c.cacheWrite5m,
+        c.cacheWrite1h,
+        c.cacheWriteUnsplit,
+    ], rows.map(({ lead, row }) => [
+        ...lead,
+        n(row.requests, "count"),
+        n(row.input_tokens, "tokens"),
+        n(row.output_tokens, "tokens"),
+        n(row.cache_read_tokens, "tokens"),
+        n(row.cache_write_5m_tokens, "tokens"),
+        n(row.cache_write_1h_tokens, "tokens"),
+        n(row.cache_write_unsplit_tokens, "tokens"),
+    ]), [
+        ...first.map(() => "left"),
+        "right",
+        "right",
+        "right",
+        "right",
+        "right",
+        "right",
+        "right",
+    ]);
+}
+/**
+ * Renders the observed sections.
+ * @param observed - Observed rows.
+ * @param timeZone - Display zone.
+ * @param home - Home directory to show as `~` in repository paths.
+ * @returns Lines.
+ */
+export function renderObserved(observed, timeZone, home = "") {
+    const { limitHits: hits, midTask, lockout, notResumed } = observed;
+    const logs = formatCoverage(hits.covers_from, hits.covers_to, timeZone);
+    const statusLine = formatCoverage(hits.status_line_covers_from, hits.status_line_covers_to, timeZone);
+    const c = LABELS.columns;
+    const lines = [
+        LABELS.observed,
+        "",
+        LABELS.interruptions,
+        `  Covers: session logs ${logs}; status line ${statusLine}`,
+        // Lockouts first: one lockout is one limit reached, however many requests it refused (D-090).
+        `  ${LABELS.lockout}: ${n(lockout.lockout_seconds, "duration")} across ${plural(lockout.intervals, "lockout", "lockouts")}`,
+        `    Limit hits with an unknown reset time, in no lockout: ${n(lockout.hits_with_unknown_reset, "count")}`,
+        ...observed.lockoutIntervals.map((interval) => `    ${span(interval.locked_from_utc, interval.locked_until_utc, timeZone)}: ${n(interval.lockout_seconds, "duration")}, ${lockoutHitsText(interval)}; ${LABELS.resetToNextRequest}: ${interval.next_request_at_utc === null
+            ? "no request after the reset in the logs"
+            : n(interval.reset_to_next_request_seconds, "duration")}${autoContinuedText(interval)}`),
+        `  ${LABELS.limitHits}: ${n(hits.hits, "count")} in ${plural(lockout.intervals, "lockout", "lockouts")}`,
+        `    ${LABELS.limitHitsNote}`,
+        `    5-hour window: ${n(hits.five_hour_hits, "count")} | weekly window: ${n(hits.seven_day_hits, "count")} | window unknown: ${n(hits.unknown_window_hits, "count")}`,
+        `    From the session logs: ${n(hits.logged_hits, "count")} | seen only in the status line: ${n(hits.status_line_only_hits, "count")}`,
+        `  ${LABELS.midTask}: ${n(midTask.mid_task, "count")}`,
+        `    At the start of a turn: ${n(midTask.turn_start, "count")} | position unknown: ${n(midTask.position_unknown, "count")}`,
+        ...renderByPlan(observed.interruptionsByPlan, timeZone),
+        `  ${LABELS.notResumed}: ${n(notResumed.sessions_not_resumed, "count")} of ${plural(notResumed.sessions_with_hits, "session", "sessions")} with a hit`,
+        `    Reset came after the logs end: ${n(notResumed.reset_after_coverage, "count")} | reset time unknown: ${n(notResumed.reset_unknown, "count")}`,
+        `    ${LABELS.autoResumeCaveat}`,
+        "",
+        LABELS.windows,
+        `  Covers: status line ${statusLine}. Readings start when the collector is installed.`,
+    ];
+    if (observed.windows.length === 0) {
+        lines.push(`  ${LABELS.noReadings}`);
+    }
+    else {
+        lines.push(...renderTable([c.window, c.resets, c.lastUsage, c.readingAt, c.peak, c.readings, c.status], observed.windows.map((w) => [
+            windowName(w.window),
+            formatInstant(w.reset_at_utc, timeZone),
+            n(w.last_used_percentage, "percent"),
+            formatInstant(w.last_reading_at_utc, timeZone),
+            n(w.peak_used_percentage, "percent"),
+            n(w.readings, "count"),
+            // Open only until its reset, as of this report (D-083).
+            w.open_at_report === 1 ? "open" : "reset",
+        ]), ["left", "left", "right", "left", "right", "right", "left"]), `  ${LABELS.windowsCaveat}`, `  ${LABELS.openNote}`);
+        const afterReset = observed.windows.reduce((sum, w) => sum + w.readings_after_reset, 0);
+        if (afterReset > 0) {
+            lines.push(`  Readings captured after their window's reset, not counted: ${n(afterReset, "count")}`);
+        }
+        const stale = observed.windows.reduce((sum, w) => sum + w.readings_stale, 0);
+        if (stale > 0) {
+            lines.push(`  ${LABELS.staleReadings}: ${n(stale, "count")}`);
+        }
+        lines.push(...renderCrossings(observed.weeklyCrossings, timeZone));
+    }
+    const modelCoverage = observed.byModel[0];
+    lines.push("", LABELS.byModel, `  Covers: session logs ${formatCoverage(modelCoverage?.covers_from, modelCoverage?.covers_to, timeZone)}`);
+    if (observed.byModel.length === 0) {
+        lines.push("  No Claude Code requests in the logs yet.");
+    }
+    else {
+        lines.push(...tokenTable([c.model], observed.byModel.map((row) => ({ lead: [row.model], row }))));
+        const unkeyed = observed.byModel.reduce((sum, row) => sum + row.unkeyed_requests, 0);
+        const untimed = observed.byModel.reduce((sum, row) => sum + row.requests_without_timestamp, 0);
+        if (unkeyed > 0) {
+            lines.push(`  Requests without a message or request ID, kept as written: ${n(unkeyed, "count")}`);
+        }
+        if (untimed > 0) {
+            lines.push(`  Requests without a readable timestamp: ${n(untimed, "count")}`);
+        }
+        lines.push("", LABELS.byRepo, `  Covers: session logs ${formatCoverage(modelCoverage?.covers_from, modelCoverage?.covers_to, timeZone)}`, ...tokenTable([c.repository, c.kind], observed.byRepo.map((row) => ({
+            lead: [
+                row.repository === null
+                    ? `${UNKNOWN} (no working directory)`
+                    : displayPath(row.repository, home),
+                repoKindName(row.repo_kind),
+            ],
+            row,
+        }))), 
+        // D-092: each alias the user entered, since it's their link and not something observed.
+        ...observed.repositoryAliases.map((a) => `  ${LABELS.alias}: ${displayPath(a.from, home)} counts under ${displayPath(a.to, home)}`));
+    }
+    return lines;
+}
+/**
+ * Describes one window's burn rate projection.
+ * @param row - A `proj_burn_rate` row.
+ * @param timeZone - Display zone.
+ * @returns One line.
+ */
+export function describeBurnRate(row, timeZone) {
+    const lead = `  ${windowName(row.window)} window resetting ${formatInstant(row.reset_at_utc, timeZone)}: ${n(row.last_used_percentage, "percent")} at ${formatInstant(row.last_reading_at_utc, timeZone)}`;
+    if (row.limit_reached === 1) {
+        return `${lead}; limit reached at that reading.`;
+    }
+    const rate = `projected ${n(row.projected_percentage_points_per_hour, "rate")}`;
+    if (row.projected_limit_at_utc === null) {
+        return `${lead}; ${rate}; projected limit time unknown.`;
+    }
+    const when = row.projected_limit_before_reset === 1 ? "before the reset" : "after the reset";
+    return `${lead}; ${rate}; limit projected for ${formatInstant(row.projected_limit_at_utc, timeZone)}, ${when}.`;
+}
+/**
+ * Formats the plan price cell.
+ * @param row - A `proj_api_list_price` row.
+ * @returns Name and price, or "none entered".
+ */
+function planCell(row) {
+    return row.plan_name === null
+        ? "none entered"
+        : `${row.plan_name}, ${n(row.plan_usd_per_month, "usd")} per month`;
+}
+/**
+ * Renders the projected sections.
+ * @param projected - Projected rows.
+ * @param timeZone - Display zone.
+ * @returns Lines.
+ */
+export function renderProjected(projected, timeZone) {
+    const c = LABELS.columns;
+    // A window whose reset has passed by the report's time has nothing left to project (D-083).
+    const open = projected.burnRate.filter((row) => row.open_at_report === 1);
+    const first = projected.burnRate[0];
+    const lines = [
+        LABELS.projected,
+        "",
+        LABELS.burnRate,
+        `  Covers: status line ${formatCoverage(first?.covers_from, first?.covers_to, timeZone)}`,
+        `  ${LABELS.burnRatePremise}`,
+        ...(open.length === 0
+            ? ["  No open usage window in the status line readings."]
+            : open.map((row) => describeBurnRate(row, timeZone))),
+        "",
+        LABELS.apiListPrice,
+        `  Months in ${timeZone}. ${LABELS.apiListPriceScope}`,
+    ];
+    const months = projected.apiListPrice;
+    if (months.length === 0) {
+        lines.push("  No Claude Code requests in the logs yet.");
+        return lines;
+    }
+    lines.push(...renderTable([c.month, c.apiListPrice, c.planPrice, c.priced, c.unpriced, c.covers], months.map((row) => [
+        row.month,
+        n(row.api_list_price_usd, "usd"),
+        planCell(row),
+        n(row.priced_requests, "count"),
+        n(row.unpriced_requests, "count"),
+        span(row.covers_from, row.covers_to, timeZone),
+    ]), ["left", "right", "left", "right", "right", "left"]));
+    // One line per reading date, each with its own count: summing every count under the latest date
+    // printed the wrong date as soon as two price rows were read on different days.
+    for (const reading of projected.rateReadings) {
+        lines.push(`  Rates were read from Anthropic's pricing page on ${reading.verified_on}; ${n(reading.priced_before_verified_requests, "count")} requests dated before that are priced at those rates.`);
+    }
+    const lowerBound = months.reduce((sum, row) => sum + row.lower_bound_requests, 0);
+    if (lowerBound > 0) {
+        lines.push(`  Requests with cache writes of unrecorded duration, priced at the 5-minute rate (their cost is a lower bound): ${n(lowerBound, "count")}`);
+    }
+    if (months.some((row) => row.unpriced_requests > 0)) {
+        lines.push("  Unpriced requests have no verified rate and are left out of the amounts, not counted as $0.");
+    }
+    if (months.every((row) => row.plan_name === null)) {
+        lines.push("  To show a plan price beside these amounts: plan-price set <YYYY-MM> <usd> --name <plan>");
+    }
+    return lines;
+}
+/**
+ * Renders the whole screen.
+ * @param input - Rows, zone, and ingest facts.
+ * @returns The report text, lines joined with newlines.
+ */
+export function renderReport(input) {
+    const header = [
+        LABELS.title,
+        `Times are in ${input.timeZone}. Last ingest: ${input.lastIngestAt === null ? "none yet" : formatInstant(input.lastIngestAt, input.timeZone)}. Database: ${displayPath(input.databasePath, input.home)}`,
+        // Above everything else: the readings below stop at this point until it's fixed (D-081).
+        ...(input.missingHookPath === undefined || input.missingHookPath === null
+            ? []
+            : [
+                "",
+                LABELS.hookMissing,
+                `${LABELS.hookMissingPath}: ${displayPath(input.missingHookPath, input.home)}`,
+            ]),
+        "",
+    ];
+    // A first run has nothing to report; say what produces the numbers instead of printing empty
+    // sections. `--json` is unchanged, so anything reading this programmatically still sees the
+    // same shape (R2.5).
+    if (hasNoData(input.observed)) {
+        return [...header, ...renderFirstRun()].join("\n");
+    }
+    return [
+        ...header,
+        ...renderObserved(input.observed, input.timeZone, input.home),
+        "",
+        ...renderProjected(input.projected, input.timeZone),
+    ].join("\n");
+}
+/**
+ * Reports whether nothing has been recorded yet: no status line readings, no requests, and no
+ * limit hits.
+ * @param observed - The observed report.
+ * @returns True when no source has produced a row.
+ * @see D-070 (limit hits count: a database holding only hits printed "Nothing has been recorded
+ *   yet" while the HTML page saved beside it drew the lockouts)
+ */
+export function hasNoData(observed) {
+    // A limit hit is recorded data even with no request or reading beside it, and hiding it behind
+    // the first-run text would drop an interruption from the report (principle 1).
+    return (observed.windows.length === 0 && observed.byModel.length === 0 && observed.limitHits.hits === 0);
+}
+/**
+ * What to do next, shown instead of a page of empty sections on a first run.
+ *
+ * Every section of the report says "no data yet" on its own, which is correct and useless: a new
+ * user reads forty lines to learn that nothing happened, and nothing tells them the two sources
+ * arrive separately or that readings need a terminal. This replaces the sections until there is
+ * something to show (R2.5).
+ * @returns Lines for stdout.
+ */
+export function renderFirstRun() {
+    return [
+        "Nothing has been recorded yet.",
+        "",
+        "Two sources feed this report, and they arrive separately:",
+        "  Session logs hold tokens, models, and repositories. `init` read whatever was already there,",
+        "    and `nilometer ingest` reads what Claude Code writes from now on.",
+        "  Status line readings hold the plan's usage percentages and its limits. They are written only",
+        "    while Claude Code runs in a terminal; the VS Code extension doesn't run the status line.",
+        "",
+        "Use Claude Code in a terminal, then run `nilometer ingest` and this report again.",
+        "Usage percentages cover the time since the hook was installed; tokens cover every log still on disk.",
+    ];
+}
+/**
+ * Builds the `--json` output: unrounded rows, kept in separate observed and projected objects,
+ * with the labels the table uses.
+ * @param input - Rows, zone, and ingest facts.
+ * @returns A JSON-serializable object.
+ */
+export function reportJson(input) {
+    return {
+        timeZone: input.timeZone,
+        lastIngestAt: input.lastIngestAt,
+        databasePath: input.databasePath,
+        // D-081: the hook the status line names when its file is missing; null otherwise.
+        missingHookPath: input.missingHookPath ?? null,
+        // Unrounded, unshortened values: JSON is for tools, and a path under ~ would need expanding back.
+        labels: LABELS,
+        observed: input.observed,
+        projected: input.projected,
+    };
+}
+//# sourceMappingURL=render.js.map