@cruxy/cli 1.8.1 → 1.10.0

package/dist/tui/limits-panel.js

@@ -1,4 +1,5 @@
 import { compactTokens } from "../render/units.js";
+import { buildLimitsSummary, } from "../render/limits-view.js";
 import { bindingWindow, usedFraction } from "../limits/index.js";
 /**
  * The limits panel (P9): what this credential may spend, and how much is left.
@@ -20,6 +21,13 @@ import { bindingWindow, usedFraction } from "../limits/index.js";
  * the fraction the bar fills IS the fraction the next request is judged against.
  * A bar is the right claim for a real measurement, and only for one.
  *
+ * WHAT IT NO LONGER DECIDES ALONE (cli#138). Which facts a bucket may state, and
+ * the words for the ones that are sentences, now come from
+ * `render/limits-view.ts` — because `cruxy limits` states the same facts outside
+ * a session and two copies of "no pool cap" are two places it can be softened.
+ * What stays here is everything that is a WIDTH decision: one bar rather than
+ * two, which window earns it, and the labels that fit 24 columns.
+ *
  * The corollary is the rule the rest of this file exists to keep: NO CAP, NO
  * FRACTION. An enterprise pool reports `{enforced: false}` and a developer key
  * reports `metered: true`; neither has an allowance, so neither gets a bar, a
@@ -39,14 +47,15 @@ export function bar(theme, fraction, cells = BAR_CELLS) {
         theme.glyph.barEmpty.repeat(cells - filled));
 }
 /**
- * The styler for a window's state. `low` and `blocked` are the two the user can
+ * The styler for a window's tone. `warn` and `danger` are the two the user can
  * act on, and they are different acts — one is "wrap up", the other is "you are
- * already being refused" — so they are not merged into one warning.
+ * already being refused" — so they are not merged into one warning. The tone
+ * itself is resolved once, in the shared builder.
  */
-function stateStyle(theme, state) {
-    if (state === "blocked")
+function toneStyle(theme, tone) {
+    if (tone === "danger")
         return theme.danger;
-    if (state === "low")
+    if (tone === "warn")
         return theme.warning;
     return theme.strong;
 }
@@ -108,22 +117,31 @@ const STALE_AFTER_MS = 5 * 60_000;
  * tokens, so it must take the smaller REMAINDER, which is sometimes the other
  * window. `limits/reduce.ts` works the disagreement through.
  */
-function poolLines(theme, pool, now) {
+function poolLines(theme, summary, now) {
+    const pool = summary.budget;
+    if (pool.kind !== "pool")
+        return [];
     const binding = bindingWindow(pool.monthly, pool.burst);
     // Unreachable via `reduceLimits` (a pool with no readable window reduces to
     // `unknown`), but the type permits it and inventing a bar is the one thing
-    // this panel must never do on the way to being defensive.
+    // this panel must never do on the way to being defensive. The words are the
+    // builder's, so `cruxy limits` says the same thing about the same absence.
     if (!binding)
-        return [theme.muted("figures not reported")];
+        return [theme.muted(summary.noAllowance ?? "figures not reported")];
     const { window: w, name } = binding;
     const fraction = usedFraction(w) ?? 0;
-    const style = stateStyle(theme, w.state ?? pool.state);
+    // The tone the shared builder resolved for this window, found by key rather
+    // than recomputed — one place decides what `low` and `blocked` mean.
+    const tone = summary.windows.find((m) => m.key === name)?.tone ?? "normal";
+    const style = toneStyle(theme, tone);
     const lines = [
         `${style(bar(theme, fraction))} ${style(pct(fraction))}`,
         `${compactTokens(w.used)} / ${compactTokens(w.cap)} ${name}`,
     ];
     // The window that is NOT binding, so both dimensions are visible — a user
-    // whose burst is tight still needs to know the month is nearly gone too.
+    // whose burst is tight still needs to know the month is nearly gone too. The
+    // rail shows it as a bare percentage because it has room for one bar; `cruxy
+    // limits` draws both in full, which is the whole reason layout stayed here.
     const other = name === "burst" ? pool.monthly : pool.burst;
     const otherName = name === "burst" ? "month" : "burst";
     const until = untilLabel(w.resetsAt, now);
@@ -139,6 +157,8 @@ function poolLines(theme, pool, now) {
     // Only when it is actionable. A blocked model list is the answer to "why did
     // that request fail"; mira's remaining requests are the answer to "what can I
     // still run" — and neither question is being asked while the pool is healthy.
+    // A WIDTH decision, not a shape one: `cruxy limits` has room to state both
+    // whenever they exist, and does.
     if (pool.blockedModels.length > 0) {
         lines.push(theme.danger(`no ${pool.blockedModels.join(" ")}`));
     }
@@ -161,27 +181,26 @@ function agoLabel(ms) {
 }
 /** The body for a ready reading, chosen by the budget shape. */
 function readingLines(theme, reading, now) {
+    const summary = buildLimitsSummary(reading, now);
     const lines = [];
-    const budget = reading.budget;
-    switch (budget.kind) {
+    switch (summary.budget.kind) {
         case "pool":
-            lines.push(...poolLines(theme, budget, now));
+            lines.push(...poolLines(theme, summary, now));
             break;
         // Enterprise. NO fraction, and no consolation bar drawn at 0% either: a full
         // green bar and "no limit" are read the same way at a glance, and only one
         // of them is true.
         case "unenforced":
-            lines.push(theme.strong(reading.tier));
-            lines.push(theme.muted("pool not enforced"));
+            lines.push(theme.strong(summary.tier));
             break;
         // A developer key: billed per token, gated by nothing it draws down. Saying
         // "no pool" explicitly matters here — an empty budget section would read as
         // a figure that failed to load rather than as a figure that does not exist.
         case "metered":
-            lines.push(`${theme.strong(reading.tier)}${theme.muted(" metered")}`);
-            lines.push(theme.muted("no pool cap"));
+            lines.push(`${theme.strong(summary.tier)}${theme.muted(" metered")}`);
             break;
         case "credits": {
+            const budget = summary.budget;
             const fraction = budget.granted > 0
                 ? Math.min(1, Math.max(0, budget.used / budget.granted))
                 : undefined;
@@ -199,30 +218,34 @@ function readingLines(theme, reading, now) {
         // facts it DOES have are real and server-resolved, so both are shown; what
         // it does not have, it declines to imply.
         case "unknown":
-            lines.push(`${theme.strong(reading.tier)}${theme.muted(` ${theme.glyph.sep} ${reading.bucket}`)}`);
-            lines.push(theme.muted("budget not reported"));
+            lines.push(`${theme.strong(summary.tier)}${theme.muted(` ${theme.glyph.sep} ${summary.bucket}`)}`);
             break;
     }
+    // Why there is nothing to draw, in the builder's words. Skipped for `pool`,
+    // which either drew something or already said so itself.
+    if (summary.budget.kind !== "pool" && summary.noAllowance) {
+        lines.push(theme.muted(summary.noAllowance));
+    }
+    // What this credential could have and does not (cli#263) — an offer, so it
+    // reads as availability to the `--paste` user who is on an apikey on purpose
+    // and can correctly ignore it.
+    for (const note of summary.notes)
+        lines.push(theme.muted(note));
     // Rate and spend caps hang off every bucket, so they are appended once here
     // rather than repeated per branch. They are the ONLY ceilings a metered key
     // has — and they appear only when they exist, which is why they can never
     // stand in for the pool a metered key does not have.
-    if (budget.kind === "metered" && reading.chat) {
-        const { remaining, limit } = reading.chat.perKey;
-        lines.push(theme.muted(`${remaining} / ${limit} rpm`));
-    }
-    if (reading.keySpendCap) {
-        lines.push(spendCapLine(theme, "key", reading.keySpendCap));
+    if (summary.rpm) {
+        lines.push(theme.muted(`${summary.rpm.remaining} / ${summary.rpm.limit} rpm`));
     }
-    if (reading.workspaceSpendCap) {
-        lines.push(spendCapLine(theme, "ws", reading.workspaceSpendCap));
+    for (const { label, cap } of summary.spendCaps) {
+        lines.push(spendCapLine(theme, label, cap));
     }
     // The cache keeps the last good reading through a failed refresh, so the panel
     // owes the user the age of what it is showing rather than the impression that
     // it is live.
-    const age = now - reading.readAt;
-    if (age > STALE_AFTER_MS) {
-        lines.push(theme.muted(`as of ${agoLabel(age)} ago`));
+    if (summary.ageMs > STALE_AFTER_MS) {
+        lines.push(theme.muted(`as of ${agoLabel(summary.ageMs)} ago`));
     }
     return lines;
 }
@@ -241,6 +264,15 @@ export function limitsPanelLines(theme, state, now = Date.now()) {
         switch (state.reason) {
             case "unauthenticated":
                 return [theme.muted("not signed in"), theme.muted("run cruxy login")];
+            case "expired":
+                // The same remedy as "not signed in", but a different fact — and the
+                // fact is the point. "Sign-in expired" tells someone their setup was
+                // right and simply aged out; "not signed in" invites them to go looking
+                // for what they configured wrong.
+                return [
+                    theme.warning("sign-in expired"),
+                    theme.muted("run cruxy login"),
+                ];
             case "unsupported":
                 // The gateway answered — it simply has no limits to report. Sending this
                 // user to debug their network would be the wrong errand entirely.

package/dist/usage/collect.js

@@ -30,9 +30,23 @@ export function accumulateCacheTokens(acc, ev) {
 const systemClock = () => new Date().toISOString();
 export class UsageCollector {
     now;
+    origin;
     entries = [];
-    constructor(now = systemClock) {
+    /**
+     * `origin` is the DEFAULT stamped on entries that don't carry one of their own
+     * (cli#244) — the run this collector belongs to, e.g. `"turn"` for a turn's
+     * collector. A per-request `origin` always wins, because one collector can
+     * legitimately hold requests of two kinds: a turn's collector receives its own
+     * loop's requests AND the requests of every subagent that turn spawned, and
+     * those must not read as the same thing.
+     *
+     * Left unset the entries carry no origin at all — which is what an older
+     * build's entries look like, and is the honest shape for a collector that
+     * genuinely doesn't know.
+     */
+    constructor(now = systemClock, origin) {
         this.now = now;
+        this.origin = origin;
     }
     /**
      * Record one completed request. When `req.usage` is absent the entry's token
@@ -41,6 +55,7 @@ export class UsageCollector {
      */
     record(req) {
         const u = req.usage;
+        const origin = req.origin ?? this.origin;
         this.entries.push({
             tier: req.tier,
             inputTokens: u?.input_tokens,
@@ -75,6 +90,10 @@ export class UsageCollector {
             ...(req.reasoningEffort !== undefined
                 ? { reasoningEffort: req.reasoningEffort }
                 : {}),
+            // Per-request first, collector default second, ABSENT third — absence is
+            // a real state (an older build's entries), so an unset default writes no
+            // key rather than a placeholder that groups would then count.
+            ...(origin !== undefined ? { origin } : {}),
             at: this.now(),
         });
     }

package/dist/usage/summary.js

@@ -29,6 +29,10 @@ export function summarizeRuns(runs) {
     let requestsWithoutUsage = 0;
     let requestsWithoutWeight = 0;
     let requestsWithoutCost = 0;
+    // Keyed by the entry's own origin, and entries WITHOUT one are counted nowhere
+    // (cli#244). Defaulting them to `turn` would relabel every entry an older
+    // build wrote as something the file never said it was.
+    const requestsByOrigin = {};
     // Every distinct currency the gateway stated. Summing across two of them would
     // require an exchange rate we don't have and would never be told, so the set
     // is kept and a >1 outcome withholds the total rather than guessing.
@@ -37,6 +41,9 @@ export function summarizeRuns(runs) {
     for (const run of runs) {
         for (const e of run.entries) {
             requests++;
+            if (e.origin !== undefined) {
+                requestsByOrigin[e.origin] = (requestsByOrigin[e.origin] ?? 0) + 1;
+            }
             const known = e.inputTokens !== undefined || e.outputTokens !== undefined;
             if (!known)
                 requestsWithoutUsage++;
@@ -114,6 +121,7 @@ export function summarizeRuns(runs) {
         requestsWithoutCost,
         requestsWithoutUsage,
         requests,
+        requestsByOrigin,
         runCount: runs.length,
     };
 }
@@ -210,10 +218,49 @@ export function renderSummary(summary, t) {
     if (summary.totalWeightedTokens !== undefined && weightShortfall > 0) {
         parts.push(t.muted(`${weightShortfall} not weighted`));
     }
+    //
+    // Cost has a THIRD case the other two don't: total absence. A partial
+    // shortfall explains itself (`2 without cost` beside a figure), but when NO
+    // request carries one there is no figure to hang the count on and the cost
+    // segment simply isn't emitted — so cost vanished with nothing said (cli#248).
+    //
+    // Gated on `requestsWithoutCost === requests`, NOT on `totalCost === undefined`.
+    // Mixed currencies ALSO withhold the total (see `summarizeRuns`) while costs
+    // genuinely exist, so keying on the total would print "cost not reported" next
+    // to "cost omitted: mixed currencies" — two contradictory claims about the same
+    // requests. The request count is the fact; the total is a rendering of it.
+    //
+    // The subtraction below is load-bearing in both branches: it is what stops this
+    // from restating `requestsWithoutUsage`. A request that reported nothing at all
+    // was already explained above, and is not separately news for having also
+    // carried no cost — so a store where every request reported nothing says
+    // nothing here, rather than saying it twice.
     const costShortfall = summary.requestsWithoutCost - summary.requestsWithoutUsage;
-    if (summary.totalCost !== undefined && costShortfall > 0) {
+    if (summary.requestsWithoutCost === summary.requests) {
+        // No count: it is every request, and a number here would read as a partial.
+        if (costShortfall > 0)
+            parts.push(t.muted("cost not reported"));
+    }
+    else if (summary.totalCost !== undefined && costShortfall > 0) {
         parts.push(t.muted(`${costShortfall} without cost`));
     }
+    // Delegated + between-turns spend, broken out (cli#244). Folding a subagent's
+    // requests into its spawning turn's record is what makes `/usage` agree with
+    // `/budget`, but it also means `requests` stops matching "requests this
+    // conversation made" as the user counts them — three children at the ceiling
+    // can be most of the line. Naming the non-`turn` origins is what keeps the
+    // bigger number legible instead of merely bigger.
+    //
+    // `turn` is omitted deliberately: it is the unmarked case, and so are the
+    // entries carrying no origin at all (an older build's), which is why this
+    // reads `requestsByOrigin` rather than subtracting from `requests` — a
+    // subtraction would attribute every historical entry to whatever was left.
+    const delegated = Object.entries(summary.requestsByOrigin)
+        .filter(([origin]) => origin !== "turn")
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([origin, n]) => `${origin} ${n}`);
+    if (delegated.length > 0)
+        parts.push(t.muted(delegated.join(", ")));
     // Two gateways quoting two currencies: refuse to add them, and say why rather
     // than just dropping the cost silently.
     if (summary.costMixedCurrency) {

package/dist/usage/types.js

@@ -110,6 +110,33 @@ export const UsageEntrySchema = z
      * gateway saying so writes the literal `"none"`.
      */
     reasoningEffort: z.string().optional(),
+    /**
+     * WHAT DROVE THIS REQUEST (cli#244). One of:
+     *
+     *  - `"turn"` — the user's own turn: the main loop, its compaction, and (in
+     *    plan mode) the propose + execution steps. The default for anything a
+     *    turn's collector records without saying otherwise.
+     *  - `"subagent"` — a delegated child. Folded into the SPAWNING TURN's
+     *    record rather than getting one of its own, so `runCount` keeps meaning
+     *    "turns" and a fan-out of three does not become four runs.
+     *  - `"job"` — a background job. A job can start after the turn that
+     *    launched it has returned, so it has no parent record to join and gets
+     *    one of its own.
+     *  - `"compact"` — a manually forced `/compact` (cli#254). Also between
+     *    turns, also its own record. NOT `"turn"`: it is not one, and calling it
+     *    one would make `runCount` count it as a turn the user never took.
+     *
+     * ABSENT MEANS "WRITTEN BY A BUILD BEFORE THIS", NOT "turn". Anything that
+     * groups by origin needs to leave unattributed entries out of every bucket
+     * rather than defaulting them into one — a historical entry relabelled as a
+     * turn is a claim the file never made. {@link UsageSummary.requestsByOrigin}
+     * does exactly that; see its note.
+     *
+     * A STRING, NOT A `z.enum`, for the reason {@link tier} and `routingMode`
+     * already are: an origin a future build introduces should render as itself
+     * here rather than fail the parse and cost the user the whole file.
+     */
+    origin: z.string().optional(),
     /** ISO-8601 timestamp the request completed. */
     at: z.string(),
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "1.8.1",
+  "version": "1.10.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
     "undici": "^6.21.0",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5",
-    "@cruxy/sdk": "0.6.0"
+    "@cruxy/sdk": "0.8.0"
   },
   "optionalDependencies": {
     "better-sqlite3": "^12.11.1"