@sweny-ai/core 0.1.199 → 0.1.201

package/dist/budget.d.ts

@@ -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,7 +23,9 @@
  * - 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.
  */
 import type { NodeUsage } from "./types.js";
 /** The `budget` field of a node or workflow. */
@@ -36,6 +44,20 @@ export interface Spend {
     tokens: number;
     costUsd: number;
 }
+/** Spend restored on a resume: the total, and its split by kind when the journal has one. */
+export interface SeedSpend extends Spend {
+    byKind?: Partial<Record<SpendKind, Spend>>;
+}
+/** What a unit of spend paid for. `node` is an agent node run; the rest are the executor's own completions. */
+export type SpendKind = "node" | "judge" | "route" | "reflect" | "screen";
+/** The order kinds are listed in, wherever the split is shown. */
+export declare const SPEND_KINDS: readonly SpendKind[];
+/** Spend of one {@link SpendKind}. `calls` counts the completions that reported usage. */
+export interface KindSpend extends Spend {
+    calls: number;
+}
+/** Spend by kind. A kind with no reported usage is absent. */
+export type SpendBreakdown = Partial<Record<SpendKind, KindSpend>>;
 export type BudgetUnit = "tokens" | "cost_usd";
 /** Recorded on the node whose spend crossed a budget (`NodeResult.budget`). */
 export interface BudgetOverrun {
@@ -45,6 +67,18 @@ export interface BudgetOverrun {
     limit: number;
     /** Spend at the moment of the stop (live) or at the end of the node. */
     spent: number;
+    /** The executor completion whose spend crossed it (judge, route, ...). Absent for a node run. */
+    kind?: SpendKind;
+}
+/**
+ * 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 declare class BudgetRefusal extends Error {
+    readonly breach: BudgetOverrun;
+    constructor(breach: BudgetOverrun);
 }
 export declare function toLimits(b: Budget | undefined): SpendLimits;
 /** The tighter of two limit sets, per unit. */
@@ -64,21 +98,43 @@ export declare function describeOverrun(o: BudgetOverrun, nodeId?: string): stri
 export declare class BudgetGuard {
     readonly runLimits: SpendLimits;
     private spent;
+    private kinds;
     constructor(runLimits: SpendLimits);
     get totals(): Spend;
+    /**
+     * Spend by kind, in {@link SPEND_KINDS} order. Resumed spend is restored
+     * under its kind; a journal without meter records seeds `node` only.
+     */
+    breakdown(): SpendBreakdown;
+    /** True once any completion other than a node run reported usage. */
+    get hasMeteredCalls(): boolean;
+    /**
+     * 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: SpendKind, usage: NodeUsage | undefined, nodeBudget?: NodeBudget): BudgetOverrun | undefined;
     /** True when any limit exists at all, so the executor can skip the machinery. */
     active(nodeLimits: SpendLimits): boolean;
     /** The run ceiling is already reached: no further attempt may start. */
     runExhausted(): BudgetOverrun | undefined;
     node(nodeLimits: SpendLimits): NodeBudget;
     /**
-     * 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: Spend): void;
-    /** @internal */
-    commit(s: Spend): void;
+    seed(s: SeedSpend): void;
+    /**
+     * @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: Spend, kind: SpendKind, counted: boolean): void;
 }
 export declare class NodeBudget {
     private readonly guard;
@@ -88,10 +144,18 @@ export declare class NodeBudget {
     /** A limit is already reached before the next attempt (a retry after a spend-heavy attempt, or a spent run). */
     exhausted(): BudgetOverrun | undefined;
     attempt(outer?: AbortSignal): BudgetAttempt;
+    /**
+     * 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: Spend): void;
     /** @internal */
     get committed(): Spend;
-    /** @internal */
-    commit(s: Spend): void;
+    /** Count one executor completion made during this visit (judge, retry reflection, screen). */
+    meter(kind: SpendKind, usage: NodeUsage | undefined): BudgetOverrun | undefined;
+    /** @internal See {@link BudgetGuard.commit}. */
+    commit(s: Spend, kind: SpendKind, counted: boolean): void;
 }
 /** One agent run. Its `signal` is the caller's signal plus a budget stop. */
 export declare class BudgetAttempt {
@@ -101,6 +165,8 @@ export declare class BudgetAttempt {
     private readonly controller;
     private live;
     private liveUsage;
+    /** A live report carried tokens or cost. */
+    private liveReported;
     private stopped;
     private settled;
     private readonly onOuterAbort;

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/config.js

@@ -1,10 +1,11 @@
 import { execSync } from "node:child_process";
 import { hasCodexLogin } from "../agent-env.js";
+import { registerDeprecatedFlags } from "./deprecated-flags.js";
 import { parseAcpAgent, unsupportedAgentError } from "../harness/agents.js";
 export function registerTriageCommand(program) {
     // NOTE: File-eligible options omit Commander defaults so parseCliInputs() can
     // distinguish "user passed flag" from "not passed" and fall through to .sweny.yml.
-    return program
+    const cmd = program
         .command("triage")
         .description("Run the SWEny triage workflow")
         .option("--agent <provider>", "Coding agent: claude (default), codex, pi (experimental), or acp:<command> for any ACP agent (experimental)")
@@ -55,6 +56,7 @@ export function registerTriageCommand(program) {
         .option("--workspace-tools <tools>", "Comma-separated workspace tool integrations to enable (slack, notion, pagerduty, monday)")
         .option("--offline", "Skip URL Sources and fail fast if any are referenced", false)
         .option("--file-root [dir]", "Sandbox file: Sources to this directory tree (defaults to the working directory when the flag is given without a value)");
+    return registerDeprecatedFlags(cmd);
 }
 export function parseCliInputs(options, fileConfig = {}) {
     const env = process.env;
@@ -615,7 +617,7 @@ function parseObservabilityCredentials(provider, options, fileConfig = {}) {
     }
 }
 export function registerImplementCommand(program) {
-    return program
+    const cmd = program
         .command("implement <issueId>")
         .description("Implement a fix for a specific issue and open a PR")
         .option("--agent <provider>", "Coding agent: claude (default), codex, pi (experimental), or acp:<command> for any ACP agent (experimental)")
@@ -634,6 +636,7 @@ export function registerImplementCommand(program) {
         .option("--verbose", "Print each tool call's input and output inline (human-readable, truncated). Use --stream for full untruncated NDJSON.", false)
         .option("--offline", "Skip URL Sources and fail fast if any are referenced", false)
         .option("--file-root [dir]", "Sandbox file: Sources to this directory tree (defaults to the working directory when the flag is given without a value)");
+    return registerDeprecatedFlags(cmd);
 }
 /**
  * Parse a JSON string into MCP server configs.

package/dist/cli/deprecated-flags.d.ts

@@ -0,0 +1,35 @@
+import { type Command } from "commander";
+/**
+ * CLI flags that sweny parsed but never read, removed in #528 and restored
+ * here as deprecated no-ops so existing callers (the swenyai/triage action
+ * passes most of them) keep working through a deprecation period.
+ *
+ * Each one is accepted, hidden from `--help`, changes nothing, and prints one
+ * stderr warning per run. This table is the only place the list lives;
+ * `registerDeprecatedFlags` is the only place it is wired in, once per command.
+ *
+ * Env vars and `.sweny.yml` keys for the same settings are not parsed at all
+ * and are never rejected, so they need no handling.
+ *
+ * Remove an entry (and its command wiring) in a minor release after the
+ * deprecation period; the docs-cloud-positioning test keeps these out of
+ * `--help` and out of the supported-option docs tables.
+ */
+export interface DeprecatedFlag {
+    /** Commander flag spec, e.g. "--cache-dir <path>". */
+    flag: string;
+    /** Commands that accepted this flag before it was removed. */
+    commands: readonly string[];
+    /** Why it has no effect (kept for maintainers; not printed). */
+    note: string;
+}
+export declare const DEPRECATED_FLAGS: readonly DeprecatedFlag[];
+/** `--cache-dir <path>` -> `--cache-dir`. */
+export declare function deprecatedFlagName(spec: string): string;
+export declare function deprecationWarning(flags: readonly string[]): string;
+/**
+ * Accept every deprecated flag that `cmd` used to have. Hidden from help, no
+ * effect, and exactly one stderr warning per run naming the flags that were
+ * passed.
+ */
+export declare function registerDeprecatedFlags(cmd: Command): Command;

package/dist/cli/deprecated-flags.js

@@ -0,0 +1,44 @@
+import { Option } from "commander";
+const TRIAGE_AND_IMPLEMENT = ["triage", "implement"];
+const TRIAGE_ONLY = ["triage"];
+export const DEPRECATED_FLAGS = [
+    { flag: "--cache-dir <path>", commands: TRIAGE_ONLY, note: "no step cache exists" },
+    { flag: "--cache-ttl <seconds>", commands: TRIAGE_ONLY, note: "no step cache exists" },
+    { flag: "--no-cache", commands: TRIAGE_ONLY, note: "no step cache exists" },
+    { flag: "--output-dir <path>", commands: TRIAGE_AND_IMPLEMENT, note: "file providers do not read it" },
+    { flag: "--service-map-path <path>", commands: TRIAGE_ONLY, note: "service maps are not read" },
+    { flag: "--gitlab-base-url <url>", commands: TRIAGE_ONLY, note: "the GitLab provider reads GITLAB_URL" },
+    { flag: "--linear-team-id <id>", commands: TRIAGE_AND_IMPLEMENT, note: "the agent gets team ids from the node" },
+    { flag: "--linear-bug-label-id <id>", commands: TRIAGE_ONLY, note: "never read" },
+    { flag: "--linear-triage-label-id <id>", commands: TRIAGE_ONLY, note: "never read" },
+    { flag: "--linear-state-backlog <name>", commands: TRIAGE_ONLY, note: "never read" },
+    { flag: "--linear-state-in-progress <name>", commands: TRIAGE_AND_IMPLEMENT, note: "never read" },
+    { flag: "--linear-state-peer-review <name>", commands: TRIAGE_AND_IMPLEMENT, note: "never read" },
+];
+/** `--cache-dir <path>` -> `--cache-dir`. */
+export function deprecatedFlagName(spec) {
+    return spec.split(/[ ,]/)[0];
+}
+export function deprecationWarning(flags) {
+    const list = flags.join(", ");
+    const subject = flags.length === 1 ? `${list} is deprecated` : `${list} are deprecated`;
+    return `warning: ${subject}, has no effect and will be removed in a future minor version.\n`;
+}
+/**
+ * Accept every deprecated flag that `cmd` used to have. Hidden from help, no
+ * effect, and exactly one stderr warning per run naming the flags that were
+ * passed.
+ */
+export function registerDeprecatedFlags(cmd) {
+    const options = DEPRECATED_FLAGS.filter((d) => d.commands.includes(cmd.name())).map((d) => new Option(d.flag).hideHelp());
+    for (const option of options)
+        cmd.addOption(option);
+    cmd.hook("preAction", (_thisCommand, actionCommand) => {
+        const used = options
+            .filter((o) => actionCommand.getOptionValueSource(o.attributeName()) === "cli")
+            .map((o) => o.long);
+        if (used.length > 0)
+            process.stderr.write(deprecationWarning(used));
+    });
+    return cmd;
+}

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;
 /**