@sweny-ai/core 0.1.191 → 0.1.192

package/dist/budget.d.ts

@@ -59,7 +59,7 @@ export declare function spendOf(u: NodeUsage | undefined): {
 export declare function describeOverrun(o: BudgetOverrun, nodeId?: string): string;
 /**
  * Tracks spend for one run. `node()` opens a visit to a node; `attempt()` opens
- * one agent run inside it. Spend is committed when an attempt finishes.
+ * one agent run inside it. Spend is committed once, when an attempt settles.
  */
 export declare class BudgetGuard {
     readonly runLimits: SpendLimits;
@@ -102,6 +102,7 @@ export declare class BudgetAttempt {
     private live;
     private liveUsage;
     private stopped;
+    private settled;
     private readonly onOuterAbort;
     constructor(guard: BudgetGuard, node: NodeBudget, outer?: AbortSignal | undefined);
     get signal(): AbortSignal;
@@ -113,11 +114,20 @@ export declare class BudgetAttempt {
     readonly onUsage: (u: NodeUsage) => void;
     private check;
     /**
-     * The attempt is over. Commit its spend (the larger of what the result
-     * reports and what was seen live) and return the breach, if any: the live
-     * stop, else a crossing visible only in the final usage.
+     * The attempt is over: commit its spend exactly once (#549). The spend is the
+     * larger of `finalUsage` and what was seen live, per unit. The breach (the
+     * live stop, else a crossing visible only in the final usage) is judged
+     * against the totals before this commit. Later calls change nothing and
+     * return the first call's breach, so the executor settles as soon as the
+     * harness returns, before any fallible work, and every exit path may settle
+     * again without double counting.
      */
+    settle(finalUsage?: NodeUsage): BudgetOverrun | undefined;
+    /** Settle with the attempt's final usage and return the breach, if any. */
     finish(finalUsage: NodeUsage | undefined): BudgetOverrun | undefined;
-    /** Release the outer-signal listener when the run threw before `finish`. */
+    /**
+     * Every exit path ends here: an attempt that threw still commits what it
+     * reported live. A no-op once settled.
+     */
     dispose(): void;
 }

package/dist/budget.js

@@ -69,7 +69,7 @@ export function describeOverrun(o, nodeId) {
 }
 /**
  * Tracks spend for one run. `node()` opens a visit to a node; `attempt()` opens
- * one agent run inside it. Spend is committed when an attempt finishes.
+ * one agent run inside it. Spend is committed once, when an attempt settles.
  */
 export class BudgetGuard {
     runLimits;
@@ -139,6 +139,7 @@ export class BudgetAttempt {
     live = { tokens: 0, costUsd: 0 };
     liveUsage;
     stopped;
+    settled;
     onOuterAbort = () => this.controller.abort();
     constructor(guard, node, outer) {
         this.guard = guard;
@@ -184,23 +185,37 @@ export class BudgetAttempt {
             breachOf("run", this.guard.runLimits, { tokens: r.tokens + attempt.tokens, costUsd: r.costUsd + attempt.costUsd }, true));
     }
     /**
-     * The attempt is over. Commit its spend (the larger of what the result
-     * reports and what was seen live) and return the breach, if any: the live
-     * stop, else a crossing visible only in the final usage.
+     * The attempt is over: commit its spend exactly once (#549). The spend is the
+     * larger of `finalUsage` and what was seen live, per unit. The breach (the
+     * live stop, else a crossing visible only in the final usage) is judged
+     * against the totals before this commit. Later calls change nothing and
+     * return the first call's breach, so the executor settles as soon as the
+     * harness returns, before any fallible work, and every exit path may settle
+     * again without double counting.
      */
-    finish(finalUsage) {
+    settle(finalUsage) {
+        if (this.settled)
+            return this.settled.breach;
         this.outer?.removeEventListener("abort", this.onOuterAbort);
         const f = spendOf(finalUsage);
         const spent = {
             tokens: Math.max(this.live.tokens, f.tokens ?? 0),
             costUsd: Math.max(this.live.costUsd, f.costUsd ?? 0),
         };
-        const b = this.stopped ?? this.check(spent);
+        const breach = this.stopped ?? this.check(spent);
+        this.settled = { breach };
         this.node.commit(spent);
-        return b;
+        return breach;
+    }
+    /** Settle with the attempt's final usage and return the breach, if any. */
+    finish(finalUsage) {
+        return this.settle(finalUsage);
     }
-    /** Release the outer-signal listener when the run threw before `finish`. */
+    /**
+     * Every exit path ends here: an attempt that threw still commits what it
+     * reported live. A no-op once settled.
+     */
     dispose() {
-        this.outer?.removeEventListener("abort", this.onOuterAbort);
+        this.settle();
     }
 }

package/dist/executor.js

@@ -598,6 +598,8 @@ async function executeRun(workflow, input, options, results, trace, at) {
                         safeObserve(observer, { type: "node:progress", node: currentId, message }, logger);
                     },
                 });
+                // Commit the attempt's spend before anything here can throw (#549); `finish` below reads the breach.
+                attemptBudget?.settle(result.usage);
             }
             catch (err) {
                 if (journalFault)
@@ -608,8 +610,9 @@ async function executeRun(workflow, input, options, results, trace, at) {
                 throw err;
             }
             finally {
-                parentSignal?.removeEventListener("abort", onParentAbort);
+                // A throw from the harness still commits the spend it reported live; a no-op once settled.
                 attemptBudget?.dispose();
+                parentSignal?.removeEventListener("abort", onParentAbort);
             }
             if (journalFault)
                 throw journalFault;
@@ -632,8 +635,8 @@ async function executeRun(workflow, input, options, results, trace, at) {
                 result = { ...result, degraded: [...new Set([...(result.degraded ?? []), ...budgetCheck.degraded])] };
             }
             if (attemptBudget) {
-                // Commit this attempt's spend; a live stop, or a crossing visible only
-                // in the final usage, fails the node whatever else it did.
+                // The spend was committed when the harness returned; a live stop, or a
+                // crossing visible only in the final usage, fails the node whatever else it did.
                 const breach = attemptBudget.finish(result.usage);
                 if (breach) {
                     const error = describeOverrun(breach, currentId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.191",
+  "version": "0.1.192",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"