fix(agent): key the rtk savings counter to the task and drop the pct field

counter_id was the run_id, but a warm snapshot-resume restarts the
sandbox with its filesystem — and rtk tally — intact under a new
run_id, so a resumed run's reading re-counted the prior run's savings
under a fresh counter. The task tracks the database's lifetime; a cold
resume reads a dropped value, which the reset rule already handles.
Also make the zero-baseline rule explicit in the consumption contract
(a single reading counts in full) and stop emitting avg_savings_pct —
an average cannot be differenced; consumers derive the ratio from the
two cumulative token columns.

Generated-By: PostHog Code
Task-Id: b86391cc-4634-4a2b-ae34-fe1f9c0626a0

Author: pauldambra

packages/agent/src/server/agent-server.test.ts

@@ -509,7 +509,6 @@ describe("AgentServer HTTP Mode", () => {
             inputTokens: 1000,
             outputTokens: 350,
             tokensSaved: 650,
-            avgSavingsPct: 65,
           }),
         }),
       );
@@ -534,8 +533,12 @@ describe("AgentServer HTTP Mode", () => {
               task_id: "test-task-id",
               run_id: "test-run-id",
               team_id: 1,
-              counter_id: "test-run-id",
+              // The counter follows the task: a warm snapshot-resume keeps
+              // the sandbox's rtk tally across run_ids.
+              counter_id: "test-task-id",
               cumulative_commands: 4,
+              cumulative_input_tokens: 1000,
+              cumulative_output_tokens: 350,
               cumulative_tokens_saved: 650,
             }),
           }),
@@ -559,7 +562,6 @@ describe("AgentServer HTTP Mode", () => {
           inputTokens: 100,
           outputTokens: 50,
           tokensSaved: 30,
-          avgSavingsPct: 30,
         }),
       }) as unknown as {
         eventStreamSender: {

packages/agent/src/server/agent-server.ts

@@ -3387,13 +3387,16 @@ ${signedCommitInstructions}
    *
    * Gauge semantics: the `cumulative_*` properties are counter READS of the
    * host's machine-global rtk tally, not per-run deltas. Consumers must group
-   * by `counter_id` and difference readings (argMax - argMin per window,
-   * treating a drop as a counter reset à la `rate()` — `rtk gain --reset`
-   * exists), never sum event values. This makes the numbers correct even when
-   * several sessions share one rtk database: concurrent reads of the shared
-   * counter dedupe under max() instead of double-counting. In the ephemeral
-   * cloud sandbox the counter starts at zero, so a single reading is also this
-   * run's savings.
+   * by `counter_id` and difference consecutive readings per counter, with an
+   * implicit 0 before a counter's first reading (a single reading therefore
+   * counts in full) and a value drop treated as a reset starting a new
+   * segment à la `rate()` — `rtk gain --reset` exists. Never sum event
+   * values. This makes the numbers correct even when several sessions share
+   * one rtk database: concurrent reads of the shared counter dedupe under
+   * max() instead of double-counting. A savings ratio is derivable as
+   * cumulative_tokens_saved / cumulative_input_tokens; rtk's per-command
+   * average is deliberately not emitted since an average cannot be
+   * differenced under this contract.
    *
    * Best-effort and cloud-only for now (no-op when the event stream isn't
    * configured; a desktop emit through the analytics pipeline can reuse the
@@ -3426,14 +3429,16 @@ ${signedCommitInstructions}
             run_id: this.config.runId,
             team_id: this.config.projectId,
             // The identity of the rtk database this reading came from — the
-            // group-by key for differencing. The cloud sandbox is fresh per
-            // run, so the run owns its counter.
-            counter_id: this.config.runId,
+            // group-by key for differencing. Keyed to the task, not the run:
+            // a warm snapshot-resume restarts the sandbox with its filesystem
+            // (and rtk tally) intact under a new run_id, so the task tracks
+            // the database's lifetime. A cold resume gets a fresh sandbox and
+            // reads a dropped value, which the reset rule already handles.
+            counter_id: this.config.taskId,
             cumulative_commands: savings.totalCommands,
             cumulative_input_tokens: savings.inputTokens,
             cumulative_output_tokens: savings.outputTokens,
             cumulative_tokens_saved: savings.tokensSaved,
-            avg_savings_pct: savings.avgSavingsPct,
           },
         },
       });

packages/agent/src/server/rtk-savings.test.ts

@@ -32,7 +32,6 @@ describe("resolveRtkSavings", () => {
       inputTokens: 502691,
       outputTokens: 5835,
       tokensSaved: 496856,
-      avgSavingsPct: 98.8392471717218,
     });
   });
 
@@ -93,7 +92,6 @@ describe("resolveRtkSavings", () => {
       inputTokens: 0,
       outputTokens: 0,
       tokensSaved: 0,
-      avgSavingsPct: 0,
     });
   });
 });

packages/agent/src/server/rtk-savings.ts

@@ -15,7 +15,6 @@ export interface RtkSavingsSummary {
   inputTokens: number;
   outputTokens: number;
   tokensSaved: number;
-  avgSavingsPct: number;
 }
 
 interface ResolveRtkSavingsOptions {
@@ -41,7 +40,6 @@ function parseGainSummary(stdout: string): RtkSavingsSummary | null {
     inputTokens: toFiniteNumber(summary.total_input),
     outputTokens: toFiniteNumber(summary.total_output),
     tokensSaved: toFiniteNumber(summary.total_saved),
-    avgSavingsPct: toFiniteNumber(summary.avg_savings_pct),
   };
 }