The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
fix(codex): preserve attribution through filtered reports
shukieshah755d737cf085
diff --git a/cli/beacon/cmd/token_usage.go b/cli/beacon/cmd/token_usage.goindex 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.goindex 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 thatdiff --git a/cli/beacon/internal/endpoint/dashboard/events.go b/cli/beacon/internal/endpoint/dashboard/events.goindex 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, errorreturn 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 — ReadEventsdiff --git a/cli/beacon/internal/endpoint/dashboard/server.go b/cli/beacon/internal/endpoint/dashboard/server.goindex 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.goindex 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 boolmetricName stringrawSource string+ sourceStart time.TimeseriesField stringseriesValue 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.goindex 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 *testingif 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.goindex 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 ptraif 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.goindex 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) {