Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

fix(codex): preserve attribution through filtered reports

shukieshah755d737cf085
diff --git a/cli/beacon/cmd/token_usage.go b/cli/beacon/cmd/token_usage.go
index d401b3bd..1feecb35 100644
--- a/cli/beacon/cmd/token_usage.go
+++ b/cli/beacon/cmd/token_usage.go
@@ -63,7 +63,7 @@ func runTokenUsage(cmd *cobra.Command, args []string) error {
}
query.Until = parsed
}
- events, err := dashboard.ReadEventsAppendOrder(runtimeLog.EffectiveLogPath, query)
+ events, contexts, err := dashboard.ReadTokenEventsAppendOrder(runtimeLog.EffectiveLogPath, query)
if err != nil {
return err
}
@@ -78,7 +78,7 @@ func runTokenUsage(cmd *cobra.Command, args []string) error {
}
opts.BucketSize = parsed
}
- report := tokens.AggregateScoped(events, tokenUsageOpts.runID, opts)
+ report := tokens.AggregateScopedWithContexts(events, contexts, tokenUsageOpts.runID, opts)
out := cmd.OutOrStdout()
if tokenUsageOpts.jsonOutput {
encoder := json.NewEncoder(out)
diff --git a/cli/beacon/cmd/token_usage_test.go b/cli/beacon/cmd/token_usage_test.go
index 9ddd7d9c..a061bf96 100644
--- a/cli/beacon/cmd/token_usage_test.go
+++ b/cli/beacon/cmd/token_usage_test.go
@@ -95,6 +95,25 @@ func TestTokenUsageJSONReport(t *testing.T) {
}
}
+func TestTokenUsageTimeFilterKeepsEarlierUserContext(t *testing.T) {
+ logPath := writeTokensFixtureLog(t)
+ output := runTokenUsageCommand(t,
+ "--log-path", logPath,
+ "--json",
+ "--since", "2026-06-11T10:00:00Z",
+ )
+ var report tokens.Report
+ if err := json.Unmarshal([]byte(output), &report); err != nil {
+ t.Fatalf("unmarshal JSON report: %v\n%s", err, output)
+ }
+ if report.TotalEvents != 3 {
+ t.Fatalf("total events = %d, want only the three time-matched usage events", report.TotalEvents)
+ }
+ if len(report.ByUser) != 1 || report.ByUser[0].Key != "alice [501]" {
+ t.Fatalf("by_user = %#v, want context from before --since", report.ByUser)
+ }
+}
+
func TestTokenUsageRunIDFilterAcceptsBareAndCompositeKeys(t *testing.T) {
logPath := writeTokensFixtureLog(t)
// The BY RUN rollup labels this run "github_actions/777"; both that
diff --git a/cli/beacon/internal/endpoint/dashboard/events.go b/cli/beacon/internal/endpoint/dashboard/events.go
index 72df6d96..96b527ee 100644
--- a/cli/beacon/internal/endpoint/dashboard/events.go
+++ b/cli/beacon/internal/endpoint/dashboard/events.go
@@ -105,6 +105,29 @@ func ReadEventsAppendOrder(path string, query EventQuery) ([]schema.Event, error
return events, nil
}
+// ReadTokenEventsAppendOrder returns query-matched events plus every
+// session.context event in one pass over the log. Session context is kept
+// separate so token totals and TotalEvents still describe only the requested
+// time/model/session slice while user attribution can reach back to SessionStart.
+func ReadTokenEventsAppendOrder(path string, query EventQuery) ([]schema.Event, []schema.Event, error) {
+ result, err := ReadEvents(path, EventQuery{NoLimit: true})
+ if err != nil {
+ return nil, nil, err
+ }
+ SortRecordsAppendOrder(result.Events)
+ events := make([]schema.Event, 0, len(result.Events))
+ contexts := make([]schema.Event, 0)
+ for _, record := range result.Events {
+ if record.Event.Event.Action == "session.context" {
+ contexts = append(contexts, record.Event)
+ }
+ if matchesQuery(record, query) {
+ events = append(events, record.Event)
+ }
+ }
+ return events, contexts, nil
+}
+
// StreamEvents reads every event from the runtime log and its rotated archives in
// chronological (append) order and invokes fn for each, with no limit and no result
// buffering. Rule evaluation (beacon scan) needs the full, ordered stream — ReadEvents
diff --git a/cli/beacon/internal/endpoint/dashboard/server.go b/cli/beacon/internal/endpoint/dashboard/server.go
index ed7eb27a..6551b9e5 100644
--- a/cli/beacon/internal/endpoint/dashboard/server.go
+++ b/cli/beacon/internal/endpoint/dashboard/server.go
@@ -150,15 +150,16 @@ func Handler(opts Options) (http.Handler, error) {
methodNotAllowed(w)
return
}
- // Token rollups need the full matching log in append order, not the
- // latest page. tokenOptions carries the session, so AggregateScoped
- // applies the exact session filter; the dashboard never scopes by run.
- events, err := ReadEventsAppendOrder(opts.LogPath, parseQuery(r, maxEventLimit))
+ // Token rollups need the full matching log in append order, plus
+ // unfiltered SessionStart context for user attribution. tokenOptions
+ // carries the session, so AggregateScopedWithContexts applies the exact
+ // session filter; the dashboard never scopes by run.
+ events, contexts, err := ReadTokenEventsAppendOrder(opts.LogPath, parseQuery(r, maxEventLimit))
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
- writeJSON(w, tokens.AggregateScoped(events, "", tokenOptions(r)))
+ writeJSON(w, tokens.AggregateScopedWithContexts(events, contexts, "", tokenOptions(r)))
})
mux.HandleFunc("/api/detections", func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
diff --git a/cli/beacon/internal/tokens/tokens.go b/cli/beacon/internal/tokens/tokens.go
index faa285f3..f2107040 100644
--- a/cli/beacon/internal/tokens/tokens.go
+++ b/cli/beacon/internal/tokens/tokens.go
@@ -133,6 +133,7 @@ type usageEvent struct {
cumulative bool
metricName string
rawSource string
+ sourceStart time.Time
seriesField string
seriesValue float64
}
@@ -149,11 +150,15 @@ type usageEvent struct {
// slice order to recover the emission sequence. Passing events newest-first
// makes each cumulative step-down look like a counter reset and inflates totals.
func Aggregate(events []schema.Event, opts Options) Report {
+ return aggregate(events, opts, sessionUserContexts(events))
+}
+
+func aggregate(events []schema.Event, opts Options, sessionUsers sessionUserIndex) Report {
if opts.NearLimitRatio <= 0 {
opts.NearLimitRatio = defaultNearLimitRatio
}
report := Report{TotalEvents: len(events)}
- usageEvents := collectUsageEvents(events, sessionUserContexts(events))
+ usageEvents := collectUsageEvents(events, sessionUsers)
usageEvents = preferCodexTurnSpans(usageEvents)
usageEvents = dedupeOverlappingChannels(usageEvents)
resolveCumulativeSeries(usageEvents)
@@ -206,10 +211,19 @@ func Aggregate(events []schema.Event, opts Options) Report {
// filtering. Events should already be in chronological (append) order; see
// Aggregate.
func AggregateScoped(events []schema.Event, runID string, opts Options) Report {
+ return AggregateScopedWithContexts(events, events, runID, opts)
+}
+
+// AggregateScopedWithContexts applies report filters to events while resolving
+// user attribution from an unfiltered set of session context events. Callers
+// that filter by time, model, or session before aggregation should use this
+// form so a SessionStart outside the selected window can still identify usage.
+func AggregateScopedWithContexts(events, contextEvents []schema.Event, runID string, opts Options) Report {
session := strings.TrimSpace(opts.SessionID)
runID = strings.TrimSpace(runID)
+ sessionUsers := sessionUserContexts(contextEvents)
if session == "" && runID == "" {
- return Aggregate(events, opts)
+ return aggregate(events, opts, sessionUsers)
}
filtered := make([]schema.Event, 0, len(events))
for _, event := range events {
@@ -224,7 +238,7 @@ func AggregateScoped(events []schema.Event, runID string, opts Options) Report {
}
filtered = append(filtered, event)
}
- return Aggregate(filtered, opts)
+ return aggregate(filtered, opts, sessionUsers)
}
type sessionContextKey struct {
@@ -405,6 +419,9 @@ func collectUsageEvents(events []schema.Event, sessionUsers sessionUserIndex) []
}
ue.metricName, _ = event.Raw["metric_name"].(string)
ue.rawSource, _ = event.Raw["source"].(string)
+ if rawStart, _ := event.Raw["turn_start_timestamp"].(string); rawStart != "" {
+ ue.sourceStart, _ = schema.ParseTimestamp(rawStart)
+ }
}
out = append(out, ue)
}
@@ -434,8 +451,12 @@ func preferCodexTurnSpans(events []*usageEvent) []*usageEvent {
continue
}
key := keyFor(event)
- if current, ok := cutovers[key]; !ok || event.ts.Before(current) {
- cutovers[key] = event.ts
+ cutover := event.sourceStart
+ if cutover.IsZero() {
+ cutover = event.ts
+ }
+ if current, ok := cutovers[key]; !ok || cutover.Before(current) {
+ cutovers[key] = cutover
}
}
if len(cutovers) == 0 {
diff --git a/cli/beacon/internal/tokens/tokens_test.go b/cli/beacon/internal/tokens/tokens_test.go
index 364f99cf..74881471 100644
--- a/cli/beacon/internal/tokens/tokens_test.go
+++ b/cli/beacon/internal/tokens/tokens_test.go
@@ -143,6 +143,14 @@ func TestAggregateAttributesAuxiliaryCodexSessionToUniqueEndpointUser(t *testing
if len(report.ByUser) != 1 || report.ByUser[0].Key != "shukan [501]" || report.ByUser[0].Usage.InputTokens != 30 {
t.Fatalf("by_user = %#v, want both Codex sessions attributed to the unique endpoint user", report.ByUser)
}
+ scoped := AggregateScoped(
+ []schema.Event{contextEvent, auxiliaryStarted, mainUsage, auxiliaryUsage},
+ "",
+ Options{SessionID: "title-session"},
+ )
+ if len(scoped.ByUser) != 1 || scoped.ByUser[0].Key != "shukan [501]" || scoped.ByUser[0].Usage.InputTokens != 20 {
+ t.Fatalf("scoped by_user = %#v, want auxiliary session attributed from unfiltered context", scoped.ByUser)
+ }
}
func TestAggregateDedupesDualChannelUsage(t *testing.T) {
@@ -218,7 +226,11 @@ func TestAggregatePrefersCodexTurnSpansAfterCutover(t *testing.T) {
turnSpan := usageEventFixture("2026-06-11T10:00:00Z", "codex_cli", "session-1", "gpt-5.6-sol", func(e *schema.Event) {
e.Endpoint = schema.EndpointInfo{Hostname: "host-a", OS: "darwin"}
e.GenAI.Usage.InputTokens = int64Ptr(20)
- e.Raw = map[string]interface{}{"source": "codex_turn_span", "turn_id": "turn-1"}
+ e.Raw = map[string]interface{}{
+ "source": "codex_turn_span",
+ "turn_id": "turn-1",
+ "turn_start_timestamp": "2026-06-11T09:59:55Z",
+ }
})
events := []schema.Event{
// A pre-upgrade metric remains part of historical totals.
@@ -226,7 +238,7 @@ func TestAggregatePrefersCodexTurnSpansAfterCutover(t *testing.T) {
turnSpan,
// The same live turn also flushed through a manually retained metric
// exporter; the turn span wins after cutover.
- codexMetric("2026-06-11T10:00:05Z", 20),
+ codexMetric("2026-06-11T09:59:59Z", 20),
}
report := Aggregate(events, Options{})
diff --git a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go
index df36fda0..aba02408 100644
--- a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go
+++ b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go
@@ -368,6 +368,9 @@ func (c Converter) EventFromSpan(resourceAttrs map[string]interface{}, span ptra
if codexTurnUsage {
rawExtra["source"] = "codex_turn_span"
rawExtra["turn_id"] = FirstString(attrs, "turn.id", "turn_id")
+ if span.StartTimestamp() != 0 {
+ rawExtra["turn_start_timestamp"] = asymptoteobserve.FormatTimestamp(span.StartTimestamp().AsTime())
+ }
NormalizeCodexTurnUsageSpan(&event, attrs)
}
event.Raw = c.RawPayload(attrs, rawExtra)
diff --git a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter_test.go b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter_test.go
index 23426169..e0646225 100644
--- a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter_test.go
+++ b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter_test.go
@@ -248,6 +248,9 @@ func TestEventsFromTracesKeepsAndNormalizesCodexTurnUsage(t *testing.T) {
if event.Raw["source"] != "codex_turn_span" || event.Raw["turn_id"] != "codex-turn" {
t.Fatalf("raw source metadata = %#v", event.Raw)
}
+ if event.Raw["turn_start_timestamp"] != "2023-11-14T22:13:20.000000000Z" {
+ t.Fatalf("turn start metadata = %#v", event.Raw["turn_start_timestamp"])
+ }
}
func TestEventFromSpanCapturesTraceIdentity(t *testing.T) {