fix(checkpoint): carry subagent tokens through to committed checkpoints

Soph · claude · Soph · commit a5cf26df89b4 · 2026-08-10T18:04:07.000+02:00
Committed checkpoints reported "subagent_tokens": null even for sessions that
ran many subagents — 0 of 30 sampled real checkpoints carried one. Two
independent drops:

1. Condensation recomputes token usage from the transcript with
   subagentsDir="", which by contract leaves SubagentTokens nil, and that
   recomputed value replaced what SaveStep had produced. The session-wide
   cumulative survived on state.TokenUsage (so `entire status` still showed
   subagent usage), but the value written to checkpoint metadata lost it.

2. The store's aggregateTokenUsage, which sums a checkpoint's sessions into the
   root metadata.json, copied only the five scalar fields — so even a
   per-session metadata carrying SubagentTokens produced a null total at the
   root.

For (1), fill from state.CheckpointTokenUsage.SubagentTokens: SaveStep already
rescoped it to this window (cumulative minus SubagentTokensBaseline), so
checkpoints stay summable instead of each re-reporting the session total, and
we avoid re-reading subagent transcripts that may already be cleaned up. The
fill copies rather than mutates — state.TokenUsage can alias that struct after
applyBackfilledSessionTokenUsage adopts it (Copilot CLI), and mutating would
overwrite the cumulative with a window delta, making resetCheckpointWindow
snapshot a too-small baseline. It also runs after that helper, which must see
the recomputed usage without the fill.

For (2), recurse into SubagentTokens. Summing is correct at that level: it
aggregates across the sessions of one checkpoint, and each session's value is
already checkpoint-scoped. (The replace-don't-add rule applies to accumulating
steps within a session, where each step re-reports a cumulative snapshot.)

Replaces the two `//TODO: why do we not use here subagents dir?` markers with
the actual reason. Known gap, now documented: a mid-turn commit that condenses
before any SaveStep in the window has no CheckpointTokenUsage to draw on and
still records no subagent tokens.

Co-Authored-By: Claude Opus 5 (1M context) &lt;noreply@anthropic.com&gt;
Entire-Checkpoint: 01KZP6NJ9ZC864YR854AQ84Q29
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -676,7 +676,7 @@ The manual-commit strategy (`manual_commit*.go`) does not modify the active bran
 - Builds git trees in-memory using go-git plumbing APIs
 - Rewind restores files from shadow branch commit tree (does not use `git reset`)
 - **Location-independent transcript resolution** - transcript paths are always computed dynamically from the current repo location (via `agent.GetSessionDir` + `agent.ResolveSessionFile`), never stored in checkpoint metadata. This ensures restore/rewind works after repo relocation or across machines.
-- **Token usage scoping** - `SessionState.TokenUsage` is the session-wide total used by `entire status`; `SessionState.CheckpointTokenUsage` is the pending checkpoint delta since the last condensation. Checkpoint metadata must stay scoped to `CheckpointTranscriptStart` or the pending checkpoint delta. Cursor tokens come only from stop-hook payloads, while Copilot CLI can also backfill full-session totals from `session.shutdown`.
+- **Token usage scoping** - `SessionState.TokenUsage` is the session-wide total used by `entire status`; `SessionState.CheckpointTokenUsage` is the pending checkpoint delta since the last condensation. Checkpoint metadata must stay scoped to `CheckpointTranscriptStart` or the pending checkpoint delta. Cursor tokens come only from stop-hook payloads, while Copilot CLI can also backfill full-session totals from `session.shutdown`. Subagent tokens need two extra steps to reach a committed checkpoint, because condensation recomputes usage with `subagentsDir=""` (which leaves `SubagentTokens` nil by contract): `withCheckpointSubagentTokens` fills the already-rescoped window total from `state.CheckpointTokenUsage` onto the metadata value — copying, not mutating, since `state.TokenUsage` can alias it for Copilot CLI, and running *after* `applyBackfilledSessionTokenUsage`, which must see the recomputed usage without it — and the store's `aggregateTokenUsage` sums `SubagentTokens` across a checkpoint's sessions for the root `metadata.json`. Summing is right there (each session's value is already checkpoint-scoped), unlike the replace-don't-add rule for steps *within* a session. Remaining gap: a mid-turn commit that condenses before any `SaveStep` in the window has no `CheckpointTokenUsage` to draw on and records no subagent tokens.
 - Tracks session state in `.git/entire-sessions/` (shared across worktrees)
 - **Shadow branch migration** - if user does stash/pull/rebase (HEAD changes without commit), shadow branch is automatically moved to new base commit
 - **Orphaned branch cleanup** - if a shadow branch exists without a corresponding session state file, it is automatically reset when a new session starts
diff --git a/cmd/entire/cli/checkpoint/aggregate_token_usage_test.go b/cmd/entire/cli/checkpoint/aggregate_token_usage_test.go
@@ -0,0 +1,73 @@
+package checkpoint
+
+import (
+	"testing"
+
+	"github.com/entireio/cli/cmd/entire/cli/agent"
+	"github.com/stretchr/testify/require"
+)
+
+// TestAggregateTokenUsage_SumsSubagentTokens pins the nested SubagentTokens into
+// the root CheckpointSummary. The aggregation copied only the five scalar fields,
+// so a checkpoint's root metadata.json reported "subagent_tokens": null even when
+// its per-session metadata carried one.
+//
+// Summing is correct here: this aggregates across the *sessions* of one checkpoint,
+// and each session's SubagentTokens is already that session's checkpoint-scoped
+// total. (The replace-don't-add rule applies to accumulating steps within a
+// session, where each step re-reports a cumulative snapshot.)
+func TestAggregateTokenUsage_SumsSubagentTokens(t *testing.T) {
+	t.Parallel()
+
+	t.Run("single session", func(t *testing.T) {
+		t.Parallel()
+		got := aggregateTokenUsage(nil, &agent.TokenUsage{
+			InputTokens: 300, OutputTokens: 150, APICallCount: 2,
+			SubagentTokens: &agent.TokenUsage{InputTokens: 500, OutputTokens: 250, APICallCount: 5},
+		})
+		require.NotNil(t, got.SubagentTokens)
+		require.Equal(t, 500, got.SubagentTokens.InputTokens)
+		require.Equal(t, 250, got.SubagentTokens.OutputTokens)
+		require.Equal(t, 5, got.SubagentTokens.APICallCount)
+	})
+
+	t.Run("two sessions both with subagents", func(t *testing.T) {
+		t.Parallel()
+		a := &agent.TokenUsage{
+			InputTokens: 300, OutputTokens: 150,
+			SubagentTokens: &agent.TokenUsage{InputTokens: 500, OutputTokens: 250, APICallCount: 5},
+		}
+		b := &agent.TokenUsage{
+			InputTokens: 100, OutputTokens: 40,
+			SubagentTokens: &agent.TokenUsage{InputTokens: 20, OutputTokens: 10, APICallCount: 1},
+		}
+		got := aggregateTokenUsage(a, b)
+		require.Equal(t, 400, got.InputTokens)
+		require.Equal(t, 190, got.OutputTokens)
+		require.NotNil(t, got.SubagentTokens)
+		require.Equal(t, 520, got.SubagentTokens.InputTokens)
+		require.Equal(t, 260, got.SubagentTokens.OutputTokens)
+		require.Equal(t, 6, got.SubagentTokens.APICallCount)
+	})
+
+	t.Run("only one session has subagents", func(t *testing.T) {
+		t.Parallel()
+		got := aggregateTokenUsage(
+			&agent.TokenUsage{InputTokens: 300},
+			&agent.TokenUsage{InputTokens: 100, SubagentTokens: &agent.TokenUsage{InputTokens: 20}},
+		)
+		require.NotNil(t, got.SubagentTokens)
+		require.Equal(t, 20, got.SubagentTokens.InputTokens)
+	})
+
+	t.Run("no subagents stays nil", func(t *testing.T) {
+		t.Parallel()
+		got := aggregateTokenUsage(&agent.TokenUsage{InputTokens: 300}, &agent.TokenUsage{InputTokens: 100})
+		require.Nil(t, got.SubagentTokens, "must not synthesize an empty subagent total")
+	})
+
+	t.Run("both nil", func(t *testing.T) {
+		t.Parallel()
+		require.Nil(t, aggregateTokenUsage(nil, nil))
+	})
+}
diff --git a/cmd/entire/cli/checkpoint/persistent.go b/cmd/entire/cli/checkpoint/persistent.go
@@ -1002,8 +1002,17 @@ func (s *treeWriter) readSummaryFromBlob(hash plumbing.Hash) (*CheckpointSummary
 	return readJSONFromBlob[CheckpointSummary](s.repo, hash)
 }
 
-// aggregateTokenUsage sums two TokenUsage structs.
-// Returns nil if both inputs are nil.
+// aggregateTokenUsage sums two TokenUsage structs, including their nested
+// SubagentTokens. Returns nil if both inputs are nil.
+//
+// This sums across the *sessions* of one checkpoint, where each session's
+// SubagentTokens is that session's checkpoint-scoped total, so adding them is
+// correct. (The replace-don't-add rule for SubagentTokens applies to accumulating
+// steps *within* a session, where each step re-reports a cumulative snapshot —
+// see accumulateTokenUsage in the strategy package.)
+//
+// Dropping the nested total here left the root metadata.json reporting
+// "subagent_tokens": null even when the per-session metadata carried one.
 func aggregateTokenUsage(a, b *agent.TokenUsage) *agent.TokenUsage {
 	if a == nil && b == nil {
 		return nil
@@ -1023,9 +1032,17 @@ func aggregateTokenUsage(a, b *agent.TokenUsage) *agent.TokenUsage {
 		result.OutputTokens += b.OutputTokens
 		result.APICallCount += b.APICallCount
 	}
+	result.SubagentTokens = aggregateTokenUsage(subagentTokensOf(a), subagentTokensOf(b))
 	return result
 }
 
+func subagentTokensOf(usage *agent.TokenUsage) *agent.TokenUsage {
+	if usage == nil {
+		return nil
+	}
+	return usage.SubagentTokens
+}
+
 // SanitizeTranscriptForAgentType strips non-portable agent state from a transcript
 // about to be stored (see agent.TranscriptSanitizer). It exists for callers that work
 // from a types.AgentType rather than a live agent.Agent: the store itself, as a
diff --git a/cmd/entire/cli/strategy/condensation_subagent_tokens_test.go b/cmd/entire/cli/strategy/condensation_subagent_tokens_test.go
@@ -0,0 +1,184 @@
+package strategy
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/entireio/cli/cmd/entire/cli/agent"
+	"github.com/entireio/cli/cmd/entire/cli/checkpoint"
+	"github.com/entireio/cli/cmd/entire/cli/checkpoint/id"
+	"github.com/entireio/cli/cmd/entire/cli/paths"
+	"github.com/go-git/go-git/v6"
+	"github.com/go-git/go-git/v6/plumbing"
+	"github.com/stretchr/testify/require"
+)
+
+// TestCondenseSession_CommittedCheckpointCarriesSubagentTokens pins the
+// checkpoint-scoped subagent total onto the committed checkpoint's metadata.
+//
+// Condensation recomputes token usage from the transcript with subagentsDir="",
+// which by contract leaves SubagentTokens nil, and that recomputed value overwrote
+// the checkpoint-scoped total SaveStep had already rescoped into
+// state.CheckpointTokenUsage. Result: committed checkpoints reported
+// "subagent_tokens": null even for sessions that ran many subagents (0 of 30
+// sampled real checkpoints carried one).
+func TestCondenseSession_CommittedCheckpointCarriesSubagentTokens(t *testing.T) {
+	dir := setupGitRepo(t)
+	t.Chdir(dir)
+
+	repo, err := git.PlainOpen(dir)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	s := &ManualCommitStrategy{}
+	sessionID := "2026-08-10-condense-subagent-tokens"
+
+	metadataDir := ".entire/metadata/" + sessionID
+	metadataDirAbs := filepath.Join(dir, metadataDir)
+	require.NoError(t, os.MkdirAll(metadataDirAbs, 0o755))
+
+	// The assistant line carries real usage, so the transcript recompute fires and
+	// produces main-agent tokens with no SubagentTokens — the overwrite this test
+	// guards against.
+	transcript := `{"type":"human","message":{"content":"delegate to a subagent"}}
+{"type":"assistant","uuid":"a1","message":{"id":"m1","usage":{"input_tokens":300,"output_tokens":150}}}
+`
+	require.NoError(t, os.WriteFile(filepath.Join(metadataDirAbs, paths.TranscriptFileName), []byte(transcript), 0o644))
+	require.NoError(t, os.WriteFile(filepath.Join(dir, "test.txt"), []byte("agent-modified"), 0o644))
+
+	require.NoError(t, s.SaveStep(ctx, StepContext{
+		SessionID:      sessionID,
+		MetadataDir:    metadataDir,
+		MetadataDirAbs: metadataDirAbs,
+		ModifiedFiles:  []string{"test.txt"},
+		CommitMessage:  "checkpoint 1",
+		AuthorName:     "Test",
+		AuthorEmail:    "test@test.com",
+		AgentType:      agent.AgentTypeClaudeCode,
+		TokenUsage: &agent.TokenUsage{
+			InputTokens: 100, OutputTokens: 50, APICallCount: 1,
+			SubagentTokens: &agent.TokenUsage{InputTokens: 500, OutputTokens: 250, APICallCount: 5},
+		},
+	}))
+
+	state, err := s.loadSessionState(ctx, sessionID)
+	require.NoError(t, err)
+	require.NotNil(t, state.CheckpointTokenUsage.SubagentTokens,
+		"precondition: SaveStep records the checkpoint-scoped subagent total")
+
+	checkpointID := id.MustCheckpointID("aabbccdd3344")
+	result, err := s.CondenseSession(ctx, repo, checkpointID, state, nil)
+	require.NoError(t, err)
+	require.False(t, result.Skipped, "condensation must not skip when files are touched")
+
+	summary := readCheckpointSummary(t, repo, checkpointID)
+	require.NotNil(t, summary.TokenUsage, "committed checkpoint must carry token usage")
+	require.NotNil(t, summary.TokenUsage.SubagentTokens,
+		"committed checkpoint must carry the checkpoint-scoped subagent total")
+	require.Equal(t, 500, summary.TokenUsage.SubagentTokens.InputTokens)
+	require.Equal(t, 250, summary.TokenUsage.SubagentTokens.OutputTokens)
+	require.Equal(t, 5, summary.TokenUsage.SubagentTokens.APICallCount)
+
+	// The session-wide cumulative must survive the fill untouched. The fill copies
+	// rather than mutates precisely because state.TokenUsage can alias the
+	// checkpoint usage (applyBackfilledSessionTokenUsage adopts it for Copilot CLI);
+	// mutating in place would overwrite the cumulative with this window's delta and
+	// make resetCheckpointWindow snapshot a too-small baseline for the next window.
+	require.NotNil(t, state.TokenUsage.SubagentTokens,
+		"session-wide cumulative subagent total must survive condensation")
+	require.Equal(t, 500, state.TokenUsage.SubagentTokens.InputTokens)
+	require.Equal(t, 250, state.TokenUsage.SubagentTokens.OutputTokens)
+}
+
+// TestCondenseSession_SubagentTokensStayScopedToCheckpointWindow covers the second
+// checkpoint of a session: the committed value must be that window's delta, not the
+// session-wide cumulative, so summing checkpoints does not over-count.
+func TestCondenseSession_SubagentTokensStayScopedToCheckpointWindow(t *testing.T) {
+	dir := setupGitRepo(t)
+	t.Chdir(dir)
+
+	repo, err := git.PlainOpen(dir)
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	s := &ManualCommitStrategy{}
+	sessionID := "2026-08-10-condense-subagent-window"
+
+	metadataDir := ".entire/metadata/" + sessionID
+	metadataDirAbs := filepath.Join(dir, metadataDir)
+	require.NoError(t, os.MkdirAll(metadataDirAbs, 0o755))
+	transcript := `{"type":"human","message":{"content":"delegate again"}}
+{"type":"assistant","uuid":"a1","message":{"id":"m1","usage":{"input_tokens":300,"output_tokens":150}}}
+`
+	require.NoError(t, os.WriteFile(filepath.Join(metadataDirAbs, paths.TranscriptFileName), []byte(transcript), 0o644))
+
+	saveStep := func(commitMsg, content string, subagent *agent.TokenUsage) {
+		require.NoError(t, os.WriteFile(filepath.Join(dir, "test.txt"), []byte(content), 0o644))
+		require.NoError(t, s.SaveStep(ctx, StepContext{
+			SessionID:      sessionID,
+			MetadataDir:    metadataDir,
+			MetadataDirAbs: metadataDirAbs,
+			ModifiedFiles:  []string{"test.txt"},
+			CommitMessage:  commitMsg,
+			AuthorName:     "Test",
+			AuthorEmail:    "test@test.com",
+			AgentType:      agent.AgentTypeClaudeCode,
+			TokenUsage: &agent.TokenUsage{
+				InputTokens: 100, OutputTokens: 50, APICallCount: 1,
+				SubagentTokens: subagent,
+			},
+		}))
+	}
+
+	// Checkpoint 1: subagent cumulative 500/250. Condense through
+	// CondenseSessionByID so the real reset path runs and snapshots the baseline —
+	// CondenseSession alone does not reset the window (its callers do).
+	saveStep("checkpoint 1", "v2", &agent.TokenUsage{InputTokens: 500, OutputTokens: 250, APICallCount: 5})
+	require.NoError(t, s.CondenseSessionByID(ctx, sessionID))
+
+	stateReset, err := s.loadSessionState(ctx, sessionID)
+	require.NoError(t, err)
+	require.NotNil(t, stateReset.SubagentTokensBaseline, "precondition: reset snapshots the baseline")
+	require.Equal(t, 500, stateReset.SubagentTokensBaseline.InputTokens)
+
+	// Checkpoint 2: the subagent grew to 620/310 cumulative — a 120/60 delta.
+	saveStep("checkpoint 2", "v3", &agent.TokenUsage{InputTokens: 620, OutputTokens: 310, APICallCount: 6})
+	state2, err := s.loadSessionState(ctx, sessionID)
+	require.NoError(t, err)
+	secondID := id.MustCheckpointID("aabbccdd7788")
+	_, err = s.CondenseSession(ctx, repo, secondID, state2, nil)
+	require.NoError(t, err)
+
+	summary := readCheckpointSummary(t, repo, secondID)
+	require.NotNil(t, summary.TokenUsage)
+	require.NotNil(t, summary.TokenUsage.SubagentTokens)
+	require.Equal(t, 120, summary.TokenUsage.SubagentTokens.InputTokens,
+		"second checkpoint must carry its window's delta, not the session cumulative")
+	require.Equal(t, 60, summary.TokenUsage.SubagentTokens.OutputTokens)
+}
+
+// readCheckpointSummary reads a committed checkpoint's root CheckpointSummary off
+// the metadata branch.
+func readCheckpointSummary(t *testing.T, repo *git.Repository, checkpointID id.CheckpointID) checkpoint.CheckpointSummary {
+	t.Helper()
+
+	ref, err := repo.Reference(plumbing.NewBranchReferenceName(paths.MetadataBranchName), true)
+	require.NoError(t, err)
+	commit, err := repo.CommitObject(ref.Hash())
+	require.NoError(t, err)
+	tree, err := commit.Tree()
+	require.NoError(t, err)
+	checkpointTree, err := tree.Tree(checkpointID.Path())
+	require.NoError(t, err)
+	rootMeta, err := checkpointTree.File(paths.MetadataFileName)
+	require.NoError(t, err)
+	rootBytes, err := rootMeta.Contents()
+	require.NoError(t, err)
+
+	var summary checkpoint.CheckpointSummary
+	require.NoError(t, json.Unmarshal([]byte(rootBytes), &summary))
+	return summary
+}
diff --git a/cmd/entire/cli/strategy/manual_commit_condensation.go b/cmd/entire/cli/strategy/manual_commit_condensation.go
@@ -306,6 +306,11 @@ func (s *ManualCommitStrategy) CondenseSession(ctx context.Context, repo *git.Re
 		sessionData.TokenUsage = accumulateTokenUsage(nil, state.CheckpointTokenUsage)
 	}
 
+	// Restore the checkpoint-scoped subagent total onto the value written to
+	// metadata. This must run after applyBackfilledSessionTokenUsage, which needs
+	// to see the recomputed usage without it (see that function).
+	sessionData.TokenUsage = withCheckpointSubagentTokens(sessionData.TokenUsage, state.CheckpointTokenUsage)
+
 	// Backfill the model from the transcript for agents that don't report it via
 	// hooks (e.g., Pi records message.model but its hook events carry no model
 	// field). Only fills when the model is otherwise unknown — hook-reported
@@ -764,6 +769,44 @@ func hasTokenUsageData(usage *agent.TokenUsage) bool {
 	return hasTokenUsageData(usage.SubagentTokens)
 }
 
+// withCheckpointSubagentTokens returns usage carrying the checkpoint-scoped
+// subagent total from checkpointUsage, filling it in only when usage has none of
+// its own.
+//
+// Condensation recomputes token usage from the transcript with subagentsDir=""
+// (see extractSessionData), which by contract leaves SubagentTokens nil, and that
+// recomputed value replaces what SaveStep produced. Without this fill, committed
+// checkpoints reported "subagent_tokens": null even for sessions that ran many
+// subagents, while `entire status` still showed them — the session-wide cumulative
+// survives on state.TokenUsage via applyBackfilledSessionTokenUsage.
+//
+// state.CheckpointTokenUsage.SubagentTokens is the right source: SaveStep already
+// rescoped it to this window (cumulative minus SubagentTokensBaseline), so
+// checkpoints stay summable instead of each re-reporting the session total. That
+// also avoids re-reading subagent transcripts here, which would return a cumulative
+// snapshot needing the same rescoping — and would fail outright once the agent has
+// cleaned the transcripts up.
+//
+// Returns a copy and never mutates either input: applyBackfilledSessionTokenUsage
+// can adopt the checkpoint usage as state.TokenUsage (Copilot CLI), so mutating in
+// place would overwrite the session-wide cumulative with a window delta and make
+// resetCheckpointWindow snapshot a too-small baseline.
+//
+// Known gap: a mid-turn commit that condenses before any SaveStep in the window has
+// no state.CheckpointTokenUsage to draw on, so that checkpoint still records no
+// subagent tokens.
+func withCheckpointSubagentTokens(usage, checkpointUsage *agent.TokenUsage) *agent.TokenUsage {
+	if usage == nil || usage.SubagentTokens != nil {
+		return usage
+	}
+	if checkpointUsage == nil || checkpointUsage.SubagentTokens == nil {
+		return usage
+	}
+	filled := *usage
+	filled.SubagentTokens = checkpointUsage.SubagentTokens
+	return &filled
+}
+
 // applyBackfilledSessionTokenUsage overwrites state.TokenUsage with the
 // transcript-recomputed session total (see sessionStateBackfillTokenUsage) when
 // one is available, preserving the cumulative subagent total across the backfill.
@@ -1082,7 +1125,12 @@ func (s *ManualCommitStrategy) extractSessionData(ctx context.Context, repo *git
 	// extract them from offset 0; consumers can filter by checkpoint_transcript_start
 	// if they only render the checkpoint-scoped slice.
 	if len(data.Transcript) > 0 {
-		data.TokenUsage = agent.CalculateTokenUsage(ctx, ag, data.Transcript, checkpointTranscriptStart, "") //TODO: why do we not use here subagents dir?
+		// subagentsDir="" on purpose: re-reading subagent transcripts here yields a
+		// cumulative-since-session-start snapshot that would still need rescoping
+		// against SubagentTokensBaseline, and it finds nothing once the agent has
+		// cleaned them up. CondenseSession fills the already-rescoped window total
+		// in instead — see withCheckpointSubagentTokens.
+		data.TokenUsage = agent.CalculateTokenUsage(ctx, ag, data.Transcript, checkpointTranscriptStart, "")
 		data.SkillEvents = agent.ExtractSkillEvents(ctx, ag, data.Transcript, 0)
 	}
 
@@ -1124,7 +1172,8 @@ func (s *ManualCommitStrategy) extractSessionDataFromLiveTranscript(ctx context.
 	// extract them from offset 0; consumers can filter by checkpoint_transcript_start
 	// if they only render the checkpoint-scoped slice.
 	if len(data.Transcript) > 0 {
-		data.TokenUsage = agent.CalculateTokenUsage(ctx, ag, data.Transcript, state.CheckpointTranscriptStart, "") //TODO: why do we not use here subagents dir?
+		// subagentsDir="" for the same reason as extractSessionData above.
+		data.TokenUsage = agent.CalculateTokenUsage(ctx, ag, data.Transcript, state.CheckpointTranscriptStart, "")
 		data.SkillEvents = agent.ExtractSkillEvents(ctx, ag, data.Transcript, 0)
 	}
 
