@sweny-ai/core 0.1.198 → 0.1.200

package/dist/budget.js

@@ -8,8 +8,14 @@
  *
  * Tokens are input + output tokens as the harness reports them (cache reads and
  * writes are not counted, matching the run receipt). Cost is the harness's own
- * reported USD, never estimated. Only agent node runs are counted: judge,
- * routing and retry-reflection completions report no usage and are not metered.
+ * reported USD, never estimated. Every model completion the executor itself
+ * makes is counted too, under its own `kind` (see {@link SpendKind}): judge
+ * scoring, route evaluation, retry reflection and the safe-output screen. A
+ * completion counts when its harness reports usage for it; one that reports
+ * none adds nothing (the same as a node run without usage). The run totals
+ * and the stop are over all kinds together, across a resume too; the split is
+ * `trace.spend`. Once a ceiling is reached no further executor completion
+ * starts. The decision model (`route_by: decider`) is not metered.
  *
  * Enforcement, per unit the harness can report:
  * - live: the harness calls `onUsage` during the node; crossing a limit aborts
@@ -17,9 +23,34 @@
  * - between nodes: usage on the finished result is checked; a crossing fails the
  *   node, and the run halts before the next node starts.
  * - across a resume: the run journal records each attempt's spend (live and
- *   final), and `sweny workflow resume` seeds the run total with it.
+ *   final), and each metered completion (judge, route, reflection, screen)
+ *   as its own record; `sweny workflow resume` seeds the run total with all
+ *   of it, split by kind.
  */
+/** The order kinds are listed in, wherever the split is shown. */
+export const SPEND_KINDS = ["node", "judge", "route", "reflect", "screen"];
+/**
+ * Thrown into an executor completion (judge, route, reflection, screen) the
+ * budget refuses: a ceiling was already reached, so the call is not made.
+ * Callers that swallow a failed completion (a judge's parse retry) must let
+ * this one through, so a refusal is never mistaken for a model answer.
+ */
+export class BudgetRefusal extends Error {
+    breach;
+    constructor(breach) {
+        super(describeOverrun(breach));
+        this.breach = breach;
+        this.name = "BudgetRefusal";
+    }
+}
 const isNum = (v) => typeof v === "number" && Number.isFinite(v);
+/**
+ * Slack for comparing accumulated floats: 0.1 + 0.2 is 0.30000000000000004,
+ * which must not read as over a $0.30 limit. Far below a token or a cent.
+ */
+const EPSILON = 1e-9;
+/** Cost as shown: accumulated float noise rounded off (10 decimal places). */
+const roundCost = (n) => Math.round(n * 1e10) / 1e10;
 export function toLimits(b) {
     return {
         ...(b?.tokens !== undefined ? { tokens: b.tokens } : {}),
@@ -50,14 +81,14 @@ export function spendOf(u) {
 function over(spent, limit, strictlyOver) {
     if (limit === undefined)
         return false;
-    return strictlyOver ? spent > limit : spent >= limit;
+    return strictlyOver ? spent > limit + EPSILON : spent >= limit - EPSILON;
 }
 function breachOf(scope, limits, spent, strictlyOver) {
     if (over(spent.tokens, limits.tokens, strictlyOver)) {
         return { scope, unit: "tokens", limit: limits.tokens, spent: spent.tokens };
     }
     if (over(spent.costUsd, limits.costUsd, strictlyOver)) {
-        return { scope, unit: "cost_usd", limit: limits.costUsd, spent: spent.costUsd };
+        return { scope, unit: "cost_usd", limit: limits.costUsd, spent: roundCost(spent.costUsd) };
     }
     return undefined;
 }
@@ -74,12 +105,53 @@ export function describeOverrun(o, nodeId) {
 export class BudgetGuard {
     runLimits;
     spent = { tokens: 0, costUsd: 0 };
+    kinds = new Map();
     constructor(runLimits) {
         this.runLimits = runLimits;
     }
     get totals() {
         return { ...this.spent };
     }
+    /**
+     * Spend by kind, in {@link SPEND_KINDS} order. Resumed spend is restored
+     * under its kind; a journal without meter records seeds `node` only.
+     */
+    breakdown() {
+        const out = {};
+        for (const k of SPEND_KINDS) {
+            const v = this.kinds.get(k);
+            if (v)
+                out[k] = { tokens: v.tokens, costUsd: roundCost(v.costUsd), calls: v.calls };
+        }
+        return out;
+    }
+    /** True once any completion other than a node run reported usage. */
+    get hasMeteredCalls() {
+        return [...this.kinds.keys()].some((k) => k !== "node");
+    }
+    /**
+     * Count one executor completion (judge, route, ...) against the run. Usage
+     * with no tokens and no cost counts nothing. Returns the breach this report
+     * caused, judged against the totals before it, like a live node report.
+     */
+    meter(kind, usage, nodeBudget) {
+        const u = spendOf(usage);
+        if (u.tokens === undefined && u.costUsd === undefined)
+            return undefined;
+        const s = { tokens: u.tokens ?? 0, costUsd: u.costUsd ?? 0 };
+        const r = this.spent;
+        const breach = (nodeBudget
+            ? breachOf("node", nodeBudget.limits, { tokens: nodeBudget.committed.tokens + s.tokens, costUsd: nodeBudget.committed.costUsd + s.costUsd }, true)
+            : undefined) ??
+            breachOf("run", this.runLimits, { tokens: r.tokens + s.tokens, costUsd: r.costUsd + s.costUsd }, true);
+        if (breach && kind !== "node")
+            breach.kind = kind;
+        if (nodeBudget)
+            nodeBudget.commit(s, kind, true);
+        else
+            this.commit(s, kind, true);
+        return breach;
+    }
     /** True when any limit exists at all, so the executor can skip the machinery. */
     active(nodeLimits) {
         return hasLimits(this.runLimits) || hasLimits(nodeLimits);
@@ -92,17 +164,42 @@ export class BudgetGuard {
         return new NodeBudget(this, nodeLimits);
     }
     /**
-     * Spend the run made before this process (a resumed run's journaled usage).
-     * Counted against the run ceiling like any other spend, so a crash never
-     * resets the whole-run budget.
+     * Spend the run made before this process (a resumed run's journaled usage
+     * and metered completions). Counted against the run ceiling like any other
+     * spend, so a crash never resets the whole-run budget. Restored under its
+     * kind when the journal has the split (a journal written before meter
+     * records existed has node spend only). Seeded spend is not a call: `calls`
+     * is unchanged.
      */
     seed(s) {
-        const ok = (n) => (Number.isFinite(n) && n > 0 ? n : 0);
-        this.commit({ tokens: ok(s.tokens), costUsd: ok(s.costUsd) });
+        const ok = (n) => (typeof n === "number" && Number.isFinite(n) && n > 0 ? n : 0);
+        if (!s.byKind) {
+            this.commit({ tokens: ok(s.tokens), costUsd: ok(s.costUsd) }, "node", false);
+            return;
+        }
+        for (const k of SPEND_KINDS) {
+            const v = s.byKind[k];
+            if (v)
+                this.commit({ tokens: ok(v.tokens), costUsd: ok(v.costUsd) }, k, false);
+        }
     }
-    /** @internal */
-    commit(s) {
+    /**
+     * @internal `counted`: this commit is one completion that reported usage, so
+     * `calls` goes up. A commit that is not (seeded spend, an attempt that
+     * reported nothing) adds its spend only, and a zero one leaves no trace, so
+     * the split is the same with and without a limit.
+     */
+    commit(s, kind, counted) {
         this.spent = { tokens: this.spent.tokens + s.tokens, costUsd: this.spent.costUsd + s.costUsd };
+        const k = this.kinds.get(kind);
+        if (!k && !counted && s.tokens === 0 && s.costUsd === 0)
+            return;
+        const prev = k ?? { tokens: 0, costUsd: 0, calls: 0 };
+        this.kinds.set(kind, {
+            tokens: prev.tokens + s.tokens,
+            costUsd: prev.costUsd + s.costUsd,
+            calls: prev.calls + (counted ? 1 : 0),
+        });
     }
 }
 export class NodeBudget {
@@ -120,14 +217,27 @@ export class NodeBudget {
     attempt(outer) {
         return new BudgetAttempt(this.guard, this, outer);
     }
+    /**
+     * Spend this visit made before a resume (a checkpointed visit's journaled
+     * spend). It counts against the node's own limit only: the run total
+     * already holds it from the seed.
+     */
+    restore(s) {
+        const ok = (n) => (Number.isFinite(n) && n > 0 ? n : 0);
+        this.spent = { tokens: this.spent.tokens + ok(s.tokens), costUsd: this.spent.costUsd + ok(s.costUsd) };
+    }
     /** @internal */
     get committed() {
         return this.spent;
     }
-    /** @internal */
-    commit(s) {
+    /** Count one executor completion made during this visit (judge, retry reflection, screen). */
+    meter(kind, usage) {
+        return this.guard.meter(kind, usage, this);
+    }
+    /** @internal See {@link BudgetGuard.commit}. */
+    commit(s, kind, counted) {
         this.spent = { tokens: this.spent.tokens + s.tokens, costUsd: this.spent.costUsd + s.costUsd };
-        this.guard.commit(s);
+        this.guard.commit(s, kind, counted);
     }
 }
 /** One agent run. Its `signal` is the caller's signal plus a budget stop. */
@@ -138,6 +248,8 @@ export class BudgetAttempt {
     controller = new AbortController();
     live = { tokens: 0, costUsd: 0 };
     liveUsage;
+    /** A live report carried tokens or cost. */
+    liveReported = false;
     stopped;
     settled;
     onOuterAbort = () => this.controller.abort();
@@ -167,6 +279,8 @@ export class BudgetAttempt {
             return;
         this.liveUsage = { ...this.liveUsage, ...u };
         const s = spendOf(u);
+        if (s.tokens !== undefined || s.costUsd !== undefined)
+            this.liveReported = true;
         // Reports are cumulative; never let a partial report move spend backwards.
         this.live = {
             tokens: Math.max(this.live.tokens, s.tokens ?? 0),
@@ -204,7 +318,9 @@ export class BudgetAttempt {
         };
         const breach = this.stopped ?? this.check(spent);
         this.settled = { breach };
-        this.node.commit(spent);
+        // A call only when the attempt reported usage, live or final: an attempt
+        // that reported none is not counted, the same as without a limit.
+        this.node.commit(spent, "node", this.liveReported || f.tokens !== undefined || f.costUsd !== undefined);
         return breach;
     }
     /** Settle with the attempt's final usage and return the breach, if any. */

package/dist/cli/renderer.js

@@ -234,6 +234,11 @@ export class DagRenderer {
                 s.finishedAt = Date.now();
                 break;
             }
+            case "node:amended": {
+                const s = this.getOrCreate(event.node);
+                s.state = event.result.status === "failed" ? "failed" : "completed";
+                break;
+            }
             // These events don't affect per-node rendering state
             case "workflow:start":
             case "workflow:end":

package/dist/cli/run-history.d.ts

@@ -12,6 +12,7 @@
  * know instead of guessing.
  */
 import type { ExecutionEvent, ExecutionTrace, NodeResult, RouteRung, Workflow } from "../types.js";
+import { type SpendKind } from "../budget.js";
 export declare const RUN_HISTORY_SCHEMA_VERSION = 1;
 export declare const RUN_HISTORY_DIR: string;
 export declare const RUN_HISTORY_KEEP = 200;
@@ -58,6 +59,17 @@ export interface RunRecord {
     };
     /** Opinions the harness could not honor natively on some node, deduped. Absent when none. */
     degraded?: string[];
+    /**
+     * Spend by kind (node, judge, route, reflect, screen), present when the
+     * executor's own completions reported usage. `totals` is then its sum, so a
+     * jump in `totals` that no node explains shows here.
+     */
+    spend?: Partial<Record<SpendKind, RunKindSpend>>;
+}
+export interface RunKindSpend {
+    tokens: number;
+    cost_usd: number;
+    calls: number;
 }
 /** sha256 (hex) of the workflow as canonical JSON: keys sorted, undefined dropped. */
 export declare function hashWorkflow(workflow: Workflow): string;

package/dist/cli/run-history.js

@@ -15,6 +15,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { summarizeRun } from "./run-output.js";
+import { SPEND_KINDS } from "../budget.js";
 import { openNoFollow } from "../safe-file.js";
 export const RUN_HISTORY_SCHEMA_VERSION = 1;
 export const RUN_HISTORY_DIR = path.join(".sweny", "runs");
@@ -63,10 +64,15 @@ export function createNodeTimer(now = Date.now) {
                 entered.set(event.node, now());
             else if (event.type === "node:exit") {
                 const start = entered.get(event.node);
+                // Cleared on exit: a repeated exit can never count the same visit twice.
+                entered.delete(event.node);
                 if (start !== undefined)
                     durations.set(event.node, (durations.get(event.node) ?? 0) + (now() - start));
                 lastResults.set(event.node, event.result);
             }
+            else if (event.type === "node:amended") {
+                lastResults.set(event.node, event.result);
+            }
         },
     };
 }
@@ -117,8 +123,18 @@ export function buildRunRecord(i) {
         },
         ...(harness ? { harness: { id: harness.id, version: harness.version } } : {}),
         ...(degraded.length > 0 ? { degraded } : {}),
+        ...(summary.spend ? { spend: recordSpend(summary.spend) } : {}),
     };
 }
+function recordSpend(spend) {
+    const out = {};
+    for (const k of SPEND_KINDS) {
+        const v = spend[k];
+        if (v)
+            out[k] = { tokens: v.tokens, cost_usd: v.costUsd, calls: v.calls };
+    }
+    return out;
+}
 // ── Write, prune, read ──────────────────────────────────────────
 /** Atomic write: temp file in the same directory, fsync, rename. Returns the path, or null on failure. Never throws. */
 export function writeRunRecord(record, cwd = process.cwd()) {

package/dist/cli/run-output.d.ts

@@ -7,6 +7,7 @@
  */
 import { type ExecutionTrace, type Logger, type NodeResult, type Workflow } from "../types.js";
 import { type NodeStatus } from "../mermaid.js";
+import { type SpendKind } from "../budget.js";
 export interface RunSummary {
     ok: boolean;
     nodesOk: number;
@@ -31,6 +32,12 @@ export interface RunSummary {
      * knows none of it.
      */
     policy?: RunPolicy;
+    /**
+     * Spend by kind (`node`, `judge`, `route`, `reflect`, `screen`), when the executor's own
+     * completions reported usage. `tokens` and `costUsd` above are then the sum over every kind
+     * (every attempt and visit), not over the node results. Absent otherwise.
+     */
+    spend?: ExecutionTrace["spend"];
     /** The spend budget a node crossed (#449). Absent when none was. */
     budget?: {
         node: string;
@@ -38,6 +45,8 @@ export interface RunSummary {
         unit: "tokens" | "cost_usd";
         limit: number;
         spent: number;
+        /** The executor completion that crossed it (judge, route, ...); absent for a node run. */
+        kind?: SpendKind;
     };
     /**
      * Who decided the run's conditional routes (#357), counts only: a `when`
@@ -89,8 +98,14 @@ export declare function formatTokenCount(n: number): string;
 export declare function formatCost(usd: number): string;
 /** `tokens 52k of 50k`: the overrun, in the budget's unit. */
 export declare function formatBudgetAmount(b: NonNullable<RunSummary["budget"]>): string;
-/** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
+/** `budget exceeded: tokens 52k of 50k (run, at node gather)`, plus `, judge` when an executor call crossed it. */
 export declare function formatBudgetOverrun(b: NonNullable<RunSummary["budget"]>): string;
+/**
+ * `node $0.15, judge $0.03, route <$0.01`: spend by kind in a fixed order
+ * (node, judge, route, reflect, screen), only the kinds present. In tokens
+ * when no kind reported a cost. Undefined when there is no split to show.
+ */
+export declare function formatSpendSplit(spend: RunSummary["spend"], sep?: string): string | undefined;
 /** `5 (3 decider, 1 expr, 1 agent)`: zero rungs are left out. */
 export declare function formatRouteCounts(r: RouteCounts): string;
 /**

package/dist/cli/run-output.js

@@ -11,6 +11,7 @@ import { toMermaidBlock } from "../mermaid.js";
 import { createPaint } from "./style.js";
 import { colorEnabled, glyphs } from "./terminal.js";
 import { trustedEnvValue } from "../startup-env.js";
+import { SPEND_KINDS } from "../budget.js";
 /** The short key of a `degraded` entry: the text before its first colon. */
 export function degradedKey(entry) {
     const i = entry.indexOf(":");
@@ -70,6 +71,19 @@ export function summarizeRun(results, durationMs, crashed = false, trace) {
     }
     if (staged > 0 || applied > 0)
         policy.outputs = { staged, applied };
+    // The executor's own completions (judge, route, ...) are on no node result,
+    // and a node result holds only its last attempt. With the split present the
+    // totals are its sum, so they reconcile with it on one basis.
+    const split = Object.values(trace?.spend ?? {});
+    const extra = Object.keys(trace?.spend ?? {}).some((k) => k !== "node");
+    if (extra) {
+        const t = split.reduce((n, k) => n + (isNum(k.tokens) ? k.tokens : 0), 0);
+        const c = split.reduce((n, k) => n + (isNum(k.costUsd) ? k.costUsd : 0), 0);
+        if (t > 0 || tokens !== undefined)
+            tokens = t;
+        if (c > 0 || costUsd !== undefined)
+            costUsd = Math.round(c * 1e10) / 1e10;
+    }
     return {
         ok: !failed,
         nodesOk,
@@ -83,6 +97,7 @@ export function summarizeRun(results, durationMs, crashed = false, trace) {
         ...(degraded.size > 0 ? { degraded: [...degraded] } : {}),
         ...(Object.keys(policy).length > 0 ? { policy } : {}),
         ...(budget ? { budget } : {}),
+        ...(extra ? { spend: trace.spend } : {}),
         ...(trace && countRoutes(trace).total > 0 ? { routes: countRoutes(trace) } : {}),
         ...(trace?.deciderOff ? { deciderOff: trace.deciderOff } : {}),
     };
@@ -160,9 +175,34 @@ export function formatBudgetAmount(b) {
     const unit = b.unit === "cost_usd" ? "cost" : "tokens";
     return `${unit} ${amount(b.spent)} of ${amount(b.limit)}`;
 }
-/** `budget exceeded: tokens 52k of 50k (run, at node gather)`. */
+/** `budget exceeded: tokens 52k of 50k (run, at node gather)`, plus `, judge` when an executor call crossed it. */
 export function formatBudgetOverrun(b) {
-    return `budget exceeded: ${formatBudgetAmount(b)} (${b.scope}, at node ${b.node})`;
+    return `budget exceeded: ${formatBudgetAmount(b)} (${b.scope}, at node ${b.node}${b.kind ? `, ${b.kind}` : ""})`;
+}
+/**
+ * `node $0.15, judge $0.03, route <$0.01`: spend by kind in a fixed order
+ * (node, judge, route, reflect, screen), only the kinds present. In tokens
+ * when no kind reported a cost. Undefined when there is no split to show.
+ */
+export function formatSpendSplit(spend, sep = " ") {
+    const kinds = SPEND_KINDS.flatMap((k) => (spend?.[k] ? [[k, spend[k]]] : []));
+    if (kinds.length === 0)
+        return undefined;
+    const byCost = kinds.some(([, v]) => v.costUsd > 0);
+    return kinds.map(([k, v]) => `${k}${sep}${byCost ? formatCost(v.costUsd) : formatTokenCount(v.tokens)}`).join(", ");
+}
+/**
+ * `12k tokens (judge 2k)`: the executor's own kinds in brackets, on the token
+ * segment, or on the cost (`$0.18 (judge $0.03)`) when no tokens were reported.
+ */
+function ownSpendBracket(spend, unit) {
+    const own = SPEND_KINDS.flatMap((k) => {
+        const v = spend?.[k];
+        if (k === "node" || !v || !(v[unit] > 0))
+            return [];
+        return [`${k} ${unit === "tokens" ? formatTokenCount(v.tokens) : formatCost(v.costUsd)}`];
+    });
+    return own.length === 0 ? "" : ` (${own.join(", ")})`;
 }
 /** `5 (3 decider, 1 expr, 1 agent)`: zero rungs are left out. */
 export function formatRouteCounts(r) {
@@ -182,8 +222,10 @@ export function formatReceipt(s) {
         ...(s.nodesSkipped > 0 ? [`${s.nodesSkipped} skipped`] : []),
         `${s.toolCalls} tool ${s.toolCalls === 1 ? "call" : "calls"}`,
         formatReceiptDuration(s.durationMs),
-        ...(s.tokens !== undefined ? [`${formatTokenCount(s.tokens)} tokens`] : []),
-        ...(s.costUsd !== undefined ? [formatCost(s.costUsd)] : []),
+        ...(s.tokens !== undefined ? [`${formatTokenCount(s.tokens)} tokens${ownSpendBracket(s.spend, "tokens")}`] : []),
+        ...(s.costUsd !== undefined
+            ? [`${formatCost(s.costUsd)}${s.tokens === undefined ? ownSpendBracket(s.spend, "costUsd") : ""}`]
+            : []),
         ...(s.harness !== undefined && s.harness !== "claude-code" ? [s.harness] : []),
         ...(s.degraded && s.degraded.length > 0 ? [`degraded: ${s.degraded.join(", ")}`] : []),
         ...(formatPolicySegment(s.policy) ? [formatPolicySegment(s.policy)] : []),

package/dist/cli/runs.js

@@ -5,7 +5,8 @@
  * `color` is true (TTY and no NO_COLOR); the glyph set follows `unicode`.
  * The diff always ends on one plain line with the answer counts.
  */
-import { findRun, listRuns } from "./run-history.js";
+import { findRun, listRuns, } from "./run-history.js";
+import { SPEND_KINDS } from "../budget.js";
 import { compareAnswers, readRunAnswers, } from "./run-answers.js";
 import { formatCost, formatReceiptDuration, formatTokenCount } from "./run-output.js";
 import { createPaint } from "./style.js";
@@ -84,8 +85,25 @@ export function printableRun(r) {
             tokens: finiteOrNull(r.totals.tokens),
             cost_usd: finiteOrNull(r.totals.cost_usd),
         },
+        ...(r.spend && typeof r.spend === "object" ? { spend: printableSpend(r.spend) } : {}),
     };
 }
+/** The record's split, or its totals as all node spend when it has none. */
+function splitOf(r) {
+    if (r.spend)
+        return r.spend;
+    return { node: { tokens: r.totals.tokens ?? 0, cost_usd: r.totals.cost_usd ?? 0, calls: 0 } };
+}
+/** Only the known kinds, own keys, finite numbers. */
+function printableSpend(spend) {
+    const out = {};
+    for (const k of SPEND_KINDS) {
+        const v = Object.hasOwn(spend, k) ? spend[k] : undefined;
+        if (v && typeof v === "object")
+            out[k] = { tokens: finite(v.tokens), cost_usd: finite(v.cost_usd), calls: finite(v.calls) };
+    }
+    return out;
+}
 // ── sweny runs ──────────────────────────────────────────────────
 export function formatRunsTable(records, color, nowMs = Date.now(), unicode = true) {
     const ICON = iconsFor(glyphsFor(unicode));
@@ -312,6 +330,25 @@ export function formatRunDiff(rawA, rawB, color, opts = {}) {
     for (const t of tot)
         if (t)
             out.push(`  ${t}`);
+    // Spend by kind, when either run has the split: what moved the totals. A
+    // record without one (node-only, or written before the split) is all node spend.
+    if (a.spend || b.spend) {
+        const sa = splitOf(a);
+        const sb = splitOf(b);
+        const byCost = SPEND_KINDS.some((k) => (sa[k]?.cost_usd ?? 0) > 0 || (sb[k]?.cost_usd ?? 0) > 0);
+        for (const k of SPEND_KINDS) {
+            const va = sa[k];
+            const vb = sb[k];
+            if (!va && !vb)
+                continue;
+            const label = `  ${pad(k, 10)}`;
+            const line = byCost
+                ? metric(label, va ? va.cost_usd : null, vb ? vb.cost_usd : null, formatCost, deltaCost, g.arrow)
+                : metric(label, va ? va.tokens : null, vb ? vb.tokens : null, formatTokenCount, deltaTokens, g.arrow);
+            if (line)
+                out.push(`  ${line}`);
+        }
+    }
     out.push("", "  nodes");
     const aNodes = new Map(a.nodes.map((n) => [n.id, n]));
     const bNodes = new Map(b.nodes.map((n) => [n.id, n]));

package/dist/cli/ticket.js

@@ -6,7 +6,7 @@
  * METADATA ONLY, like the receipt line: counts, durations, tokens, cost,
  * policy facts. Never prompts, node outputs, tool inputs, or model prose.
  */
-import { formatBudgetAmount, formatCost, formatRouteCounts, formatReceiptDuration, formatTokenCount, policyParts, renderReceiptLine, } from "./run-output.js";
+import { formatBudgetAmount, formatCost, formatRouteCounts, formatSpendSplit, formatReceiptDuration, formatTokenCount, policyParts, renderReceiptLine, } from "./run-output.js";
 import { createPaint } from "./style.js";
 import { colorEnabled, glyphsFor, richOutput, supportsUnicode, terminalColumns, ticketBoxFor } from "./terminal.js";
 /** Widest ticket, in columns, frame included. */
@@ -52,8 +52,11 @@ export function stampWords(summary) {
     }
     return { words, strong };
 }
+const NBSP = "\u00a0";
 /** Field rows, label then value, metadata only. */
 function ticketFields(s) {
+    // A no-break space keeps each kind with its amount when the row wraps (put back after wrapping).
+    const spend = formatSpendSplit(s.spend, NBSP);
     const failed = Math.max(0, s.nodesTotal - s.nodesOk - s.nodesSkipped);
     const nodes = [
         `${s.nodesOk}/${s.nodesTotal}`,
@@ -67,6 +70,7 @@ function ticketFields(s) {
         ["duration", formatReceiptDuration(s.durationMs)],
         ...(s.tokens !== undefined ? [["tokens", formatTokenCount(s.tokens)]] : []),
         ...(s.costUsd !== undefined ? [["cost", formatCost(s.costUsd)]] : []),
+        ...(spend ? [["spend", spend]] : []),
         ...(s.harness !== undefined && s.harness !== "claude-code" ? [["harness", s.harness]] : []),
         ...(s.degraded && s.degraded.length > 0 ? [["degraded", s.degraded.join(", ")]] : []),
         ...(s.routes && s.routes.total > 0 ? [["routes", formatRouteCounts(s.routes)]] : []),
@@ -154,7 +158,8 @@ export function renderTicket(data, opts = {}) {
     lines.push(row(""));
     // Fields, aligned: label column then value column; long values wrap under the value.
     for (const [label, value] of ticketFields(s)) {
-        wrap(value, valueWidth).forEach((part, i) => {
+        wrap(value, valueWidth).forEach((raw, i) => {
+            const part = raw.replaceAll(NBSP, " ");
             const lab = (i === 0 ? label : "").padEnd(LABEL_WIDTH);
             lines.push(row(lab + part, paint.muted(lab) + part));
         });

package/dist/eval/index.d.ts

@@ -10,6 +10,16 @@ export interface EvaluateAllOptions {
     node?: Node;
     /** The workflow being executed. Used to resolve workflow-level `judge_model` overrides. */
     workflow?: Workflow;
+    /**
+     * Run the evaluators one at a time instead of together. The executor sets it
+     * when a spend budget is on, so each judge's usage is counted (and a
+     * crossing stops the rest) before the next one starts.
+     */
+    sequential?: boolean;
+    /** The run's abort signal: checked before each judge when sequential, and forwarded to judge calls. */
+    signal?: AbortSignal;
+    /** Per-call timeout forwarded to judge calls. */
+    timeoutMs?: number;
 }
 /**
  * Run every declared evaluator against the node's result and return one

package/dist/eval/index.js

@@ -41,11 +41,28 @@ export async function evaluateAll(evaluators, result, opts = {}) {
         throw new Error(`evaluator '${orphanJudge.name}' is kind: judge but no Claude client was provided to evaluateAll`);
     }
     // Evaluators are independent, so they run concurrently (#337): N judges on
-    // a node cost one round-trip of wall time, not N. Results keep declaration
-    // order. Every evaluator settles before an error surfaces, and the first
-    // rejection in declaration order is rethrown, so the outcome never depends
-    // on which call finishes first.
-    const settled = await Promise.allSettled(evaluators.map((e) => evaluateOne(e, result, opts)));
+    // a node cost one round-trip of wall time, not N. With `sequential` (a spend
+    // budget is on) they run one at a time, so each judge's spend is counted
+    // before the next starts, and an abort stops the rest. Results keep
+    // declaration order. Every evaluator settles before an error surfaces, and
+    // the first rejection in declaration order is rethrown, so the outcome never
+    // depends on which call finishes first.
+    const settled = [];
+    if (opts.sequential) {
+        for (const e of evaluators) {
+            if (opts.signal?.aborted)
+                throw new Error("workflow aborted");
+            try {
+                settled.push({ status: "fulfilled", value: await evaluateOne(e, result, opts) });
+            }
+            catch (reason) {
+                settled.push({ status: "rejected", reason });
+            }
+        }
+    }
+    else {
+        settled.push(...(await Promise.allSettled(evaluators.map((e) => evaluateOne(e, result, opts)))));
+    }
     const out = [];
     for (const s of settled) {
         if (s.status === "rejected")
@@ -66,7 +83,11 @@ async function evaluateOne(e, result, opts) {
     }
     if (e.kind === "judge" && opts.claude) {
         const model = resolveJudgeModel(e, opts.node, opts.workflow, opts.claude.defaultJudgeModel);
-        const verdict = await evaluateJudge(e, result, opts.claude, { model });
+        const verdict = await evaluateJudge(e, result, opts.claude, {
+            model,
+            ...(opts.signal ? { signal: opts.signal } : {}),
+            ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
+        });
         return { name: e.name, kind: "judge", pass: verdict.pass, reasoning: capReasoning(verdict.reasoning) };
     }
     return null;

package/dist/eval/judge.d.ts

@@ -2,6 +2,9 @@ import type { Claude, Evaluator, NodeResult } from "../types.js";
 export interface JudgeOptions {
     /** Resolved judge model (evaluator > node > workflow > package default). */
     model: string;
+    /** The run's abort signal and per-call timeout, forwarded to the judge call. */
+    signal?: AbortSignal;
+    timeoutMs?: number;
 }
 interface ParsedResponse {
     verdict: string | null;

package/dist/eval/judge.js

@@ -13,6 +13,7 @@
 // For a typical 4-node workflow with 2 judges per node, that's 8 extra
 // calls per run. The workflow-level `judge_budget` (default 50) gives
 // authors a load-time warning when the total stretches past expected.
+import { BudgetRefusal } from "../budget.js";
 /**
  * Build the structured judge prompt.
  *
@@ -122,10 +123,19 @@ export async function evaluateJudge(evaluator, result, claude, opts) {
                 instruction: prompt,
                 context: {},
                 model: opts.model,
+                ...(opts.signal ? { signal: opts.signal } : {}),
+                ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
             });
         }
-        catch {
-            // Treat throws as parse failure for retry purposes; the second attempt
+        catch (err) {
+            // A budget refusal is no answer at all: it reaches the executor, which
+            // stops the node on the budget instead of recording a parse failure.
+            if (err instanceof BudgetRefusal)
+                throw err;
+            // An aborted run is no answer either: never retried as a parse failure.
+            if (opts.signal?.aborted)
+                throw err;
+            // Treat other throws as parse failure for retry purposes; the second attempt
             // either succeeds or surfaces the same path through the same channel.
             continue;
         }