@sweny-ai/core 0.1.199 → 0.1.201

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