@cruxy/cli 1.9.0 → 1.10.0

package/dist/subagent/orchestrator.js

@@ -1,8 +1,8 @@
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { runAgent } from "../agent/loop.js";
-import { classifyProviderError, CruxyError, ErrorCode, messageOf, sessionBudgetExhausted, subagentDepthExceeded, subagentScopeOverlap, } from "../errors/index.js";
-import { UsageCollector } from "../usage/index.js";
+import { CruxyError, ErrorCode, messageOf, poolDenial, sessionBudgetExhausted, subagentDepthExceeded, subagentScopeOverlap, } from "../errors/index.js";
+import { UsageCollector, } from "../usage/index.js";
 import { UNRESOLVED_TIER, } from "../budget/index.js";
 import { resolveTaskModel } from "../routing/index.js";
 import { Workspace } from "../workspace/index.js";
@@ -76,7 +76,30 @@ export class SubagentOrchestrator {
         if (childDepth < maxDepth) {
             registry.register(makeSpawnSubagentTool(this, childDepth));
         }
-        const budget = new Budget(resolveBudget(defaultBudget, spec.budget));
+        // Admission control for the SEQUENTIAL seam (cli#245). `spawnMany` asks for
+        // its whole batch and passes the verdict down; everything else — the
+        // `spawn_subagent` tool, a plan step, a nested child — arrives here having
+        // asked nobody, which is the hole cli#243 left behind. A refusal throws the
+        // same coded error the fan-out throws, and the spawn tool hands it to the
+        // model as a tool error it can act on (see `PROPAGATE` in `spawn-tool.ts`).
+        const admission = opts.admission ?? this.admitRuns(1, [spec]);
+        if (admission.kind === "refused") {
+            throw sessionBudgetExhausted(admission.reason);
+        }
+        if (admission.kind === "narrowed" && !opts.admission) {
+            deps.logger.warn(admission.reason);
+        }
+        // `admit` only ever NARROWS, and `Math.min` is what makes that true here: a
+        // batch verdict carries the heaviest child's ceiling, so applying it raw to
+        // a cheaper sibling would RAISE that child's cap on the strength of an
+        // admission check. `0` means the budget bounded nothing.
+        const resolved = resolveBudget(defaultBudget, spec.budget);
+        const budget = new Budget(admission.maxTokens > 0
+            ? {
+                ...resolved,
+                maxTokens: Math.min(resolved.maxTokens, admission.maxTokens),
+            }
+            : resolved);
         // Root scoping (C.33): a `spec.root` narrows the child's cwd + confinement to
         // that ONE root (its writes land there and nowhere else). Omitted → the full
         // session workspace, unchanged from C.14. An unknown name fails loud here
@@ -150,12 +173,19 @@ export class SubagentOrchestrator {
             // sibling's pool denial cancelled, still drew whatever it drew before it
             // stopped, and the record is what it reported.
             //
-            // NOT ALSO WRITTEN TO THE USAGE STORE. Child requests have never appeared
-            // in `/usage` and this does not change that — `/budget` now counts them
-            // and `/usage` still does not, so the two figures can differ by a
-            // fan-out's worth. That gap is real and pre-dates this; closing it means
-            // persisting child runs, which is a change to what is on disk and belongs
-            // in its own right rather than smuggled in behind an admission fix.
+            // STILL NOT WRITTEN TO THE USAGE STORE AS A RUN OF ITS OWN, and now for a
+            // different reason than when this was written (cli#244 closed the gap the
+            // old note described). The child's requests DO reach `/usage` — forwarded
+            // above into the spawning turn's collector, so they land as entries of the
+            // turn's record. What this record is for is the budget, and only the
+            // budget: it exists so the fold can happen the MOMENT the child finishes
+            // rather than at end of turn, because the next admission check inside the
+            // same turn has to see the spend.
+            //
+            // Which is exactly why the parent must NOT hand these same entries to the
+            // budget again when its turn closes — see the `origin` filter at
+            // `agent/session.ts`. Two folds of one child's tokens would halve the
+            // effective session cap on any turn that fans out.
             this.deps.budget?.record(usage.toRecord(randomUUID(), undefined, startedAt));
         }
     }
@@ -183,7 +213,16 @@ export class SubagentOrchestrator {
                 router: deps.router,
                 taskClass: spec.taskClass ?? "subagent",
                 signal: opts.signal,
-                onRequestUsage: (req) => usage.record(req),
+                // Both, and in this order (cli#244). The child's OWN collector is what
+                // the budget fold below reads — it needs a per-child record — while the
+                // parent's sink is what puts this request in `/usage` at all. The
+                // explicit origin is load-bearing: the parent's collector defaults to
+                // `"turn"`, and a child's request inheriting that would be a lie about
+                // what the user did.
+                onRequestUsage: (req) => {
+                    usage.record(req);
+                    opts.onRequestUsage?.({ ...req, origin: "subagent" });
+                },
             });
         }
         catch (err) {
@@ -277,7 +316,7 @@ export class SubagentOrchestrator {
         // AFTER the scope check on purpose: an overlapping fan-out is malformed and
         // must be refused whatever the budget says, and narrowing a malformed batch
         // to two children would hide the overlap rather than report it.
-        const admitted = this.admitFanOut(specs);
+        const admitted = this.admitRuns(specs.length, specs);
         if (admitted.kind === "refused") {
             throw sessionBudgetExhausted(admitted.reason);
         }
@@ -317,6 +356,17 @@ export class SubagentOrchestrator {
                     results[i] = await this.spawn(spec, parentDepth, {
                         signal: controller.signal,
                         slot: `${i + 1}/${total}`,
+                        // The batch verdict, so the child does not ask a second time —
+                        // and so a cut token cap actually reaches the run it was cut
+                        // for. `admit` returns one for a single run it can only
+                        // partially afford, and until cli#245 `spawnMany` read the
+                        // count off that verdict and dropped the ceiling with it.
+                        admission: admitted,
+                        // Every child of the batch reports into the one turn that
+                        // spawned them, exactly as a sequential child does.
+                        ...(opts.onRequestUsage
+                            ? { onRequestUsage: opts.onRequestUsage }
+                            : {}),
                     });
                 }
                 catch (err) {
@@ -347,7 +397,13 @@ export class SubagentOrchestrator {
         }
     }
     /**
-     * Ask the session budget whether this batch fits (P10 track 3 / cli#212).
+     * Ask the session budget whether these runs fit (P10 track 3 / cli#212).
+     *
+     * ONE method for both seams (cli#245): a batch of N from `spawnMany`, and the
+     * single run `spawn` asks for when nobody admitted it. They differ only in
+     * `count` — the arithmetic, the tier resolution and the per-run ceiling are
+     * the same question, and a second copy for the singular case is how the two
+     * would come to disagree.
      *
      * The estimate is the batch's CEILING, not a guess at its actual draw:
      * `count × perChildTokens × multiplier`, where `perChildTokens` is the local
@@ -361,17 +417,17 @@ export class SubagentOrchestrator {
      * the pool, so it is weighed at the worst case rather than skipped — see
      * `UNRESOLVED_TIER`.
      */
-    admitFanOut(specs) {
+    admitRuns(count, specs) {
         const budget = this.deps.budget;
         if (!budget)
-            return { kind: "allow", count: specs.length, maxTokens: 0 };
+            return { kind: "allow", count, maxTokens: 0 };
         const { defaultBudget } = this.deps.config.subagent;
         // The heaviest child in the batch sets the per-run figure. The bound has to
         // hold for the batch as dispatched, and averaging would let one 64k child
         // hide behind four 4k ones.
         const perRunTokens = specs.reduce((max, spec) => Math.max(max, resolveBudget(defaultBudget, spec.budget).maxTokens), 0);
         return budget.admit({
-            count: specs.length,
+            count,
             perRunTokens,
             tier: this.fanOutTier(),
         });
@@ -489,22 +545,6 @@ function taskLabel(task) {
 function isWriter(spec) {
     return (spec.tools ?? []).some((t) => SUBAGENT_WRITE_TOOLS.has(t));
 }
-/**
- * The typed pool denial behind an error, or `null` if it is not one.
- *
- * Two shapes reach here and both are the same fact: the raw SDK
- * `BudgetExhaustedError` from this child's own request, and — when a child that
- * itself spawned re-throws — the `CruxyError` a nested `spawn` already
- * converted. Mapping goes through `classifyProviderError` so there is still ONE
- * place that knows which SDK class means what.
- */
-function poolDenial(err) {
-    if (CruxyError.is(err)) {
-        return err.code === ErrorCode.BudgetExhausted ? err : null;
-    }
-    const typed = classifyProviderError(err);
-    return typed?.code === ErrorCode.BudgetExhausted ? typed : null;
-}
 /**
  * The tokens a child is KNOWN to have spent, or `undefined` when no request
  * reported any.

package/dist/subagent/spawn-tool.js

@@ -91,7 +91,7 @@ export function makeSpawnSubagentTool(orchestrator, depth) {
             "transcript is discarded. Use for independent subtasks whose details you don't " +
             'need in your own context (e.g. "find where X is configured and report the paths").',
         parameters,
-        async execute(input) {
+        async execute(input, ctx) {
             const budget = {
                 ...(input.maxIterations !== undefined
                     ? { maxIterations: input.maxIterations }
@@ -102,7 +102,12 @@ export function makeSpawnSubagentTool(orchestrator, depth) {
             };
             let result;
             try {
-                result = await orchestrator.spawn({ task: input.task, tools: input.tools, budget }, depth);
+                result = await orchestrator.spawn({ task: input.task, tools: input.tools, budget }, depth, 
+                // The calling turn's usage collector (cli#244), the one thing on `ctx`
+                // that is per-turn rather than per-session. Absent outside a turn, in
+                // which case the child's spend still reaches the budget — it just has
+                // no record to join.
+                ctx.onRequestUsage ? { onRequestUsage: ctx.onRequestUsage } : {});
             }
             catch (err) {
                 // Non-interactive default-deny propagates to the boundary (U.3) —
@@ -186,10 +191,12 @@ export function makeSpawnSubagentsTool(orchestrator, depth) {
             "For children that WRITE, give each a distinct `root`; overlapping write scope is " +
             "refused. For a single subtask, use spawn_subagent instead.",
         parameters: batchParameters,
-        async execute(input) {
+        async execute(input, ctx) {
             let results;
             try {
-                results = await orchestrator.spawnMany(input.tasks.map(toSpec), depth);
+                results = await orchestrator.spawnMany(input.tasks.map(toSpec), depth, 
+                // Every child of the batch reports into the one turn that spawned it.
+                ctx.onRequestUsage ? { onRequestUsage: ctx.onRequestUsage } : {});
             }
             catch (err) {
                 // Non-interactive default-deny propagates to the boundary (U.3).

package/dist/tools/schema-depth.js

@@ -59,6 +59,24 @@ export function schemaDepth(node) {
  * does not raise it there — it only moves the failure from a red CI run to every
  * user's terminal. If a schema cannot fit, the schema changes.
  *
+ * THE MIRROR ONLY PROTECTS ONE DIRECTION. Raising this literal is caught by the
+ * paragraph above; the gateway TIGHTENING it is caught by nothing here. If
+ * `maxSchemaDepth` drops to 7, `apply_patch` and `spawn_subagents` — both at
+ * rendered depth 7, a margin accepted deliberately in #233 — are dead in the
+ * field for every user on every turn, and this repo's CI stays green, because
+ * the test written to prevent exactly that outage is asserting against a stale
+ * copy of the number. `mcp/bounds.ts` reads this same constant, so a drift takes
+ * the MCP guard with it.
+ *
+ * Asked on cruxy-ai/api#183 whether the bound could be SERVED rather than
+ * mirrored. Answer, in cruxy-ai/api#187 (merged 2026-08-19): half of it. A
+ * rejection is now self-describing — code `invalid_tool_schema` with `tool`,
+ * `bound` (`bytes` | `depth` | `nodes`) and `limit` as structured fields — but
+ * nothing reports the bound before a request is sent. So this stays a hand-copy,
+ * CI cannot catch a tightening, and the runtime error is the ONLY detector we
+ * have: a rejection whose `limit` disagrees with this constant means the
+ * constant is stale, not that one tool is bad. Fix it here, not at the tool.
+ *
  * The bound is EXCLUSIVE: a schema is safe at `MAX_SCHEMA_DEPTH - 1` and dies at
  * `MAX_SCHEMA_DEPTH`. Both consumers must spell that the same way — the CI gate
  * asserts `depth < MAX_SCHEMA_DEPTH`, the MCP bound trips on

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;
 }

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.9.0",
+  "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.7.0"
+    "@cruxy/sdk": "0.8.0"
   },
   "optionalDependencies": {
     "better-sqlite3": "^12.11.1"