Skip to content

Commit 2b0cd75

Browse files
ryoppippiigorovh
andcommitted
fix(all): skip Claude Agent rows of every session Claude counted
Claude dedups a turn repeated across sessions, such as a resumed or forked transcript, down to one surviving entry, so the counted set held only the survivor's session. An OpenCode row linked to the other copy's session was kept and its turn counted twice. The push functions now hand back the entry they discard, and the loaders keep main-thread copies from other sessions, so every session of a counted dedup group matches. Session reports matched per session day, but the Claude session row holds all of that session's usage, including days outside the Claude window. They now skip every row whose Claude session the report includes, which also covers turns that cross midnight; daily-family reports keep matching per day in the Claude source's timezone. load_entries is no longer used outside the OpenCode crate, which the hawk check flagged, so it is crate-private now. The pair type it returned is exported as LinkedEntry, which the unified loader names. Refs #2004 Co-authored-by: igorovh <[email protected]>
1 parent 48f26c1 commit 2b0cd75

6 files changed

Lines changed: 287 additions & 74 deletions

File tree

‎rust/adapters/claude/src/daily.rs‎

Lines changed: 39 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ pub(super) fn load_daily_summaries_inner(
3232
shared: &SharedArgs,
3333
project_filter: Option<&str>,
3434
group_by_project: bool,
35-
session_days: impl FnOnce(&[DailyLoadedEntry]) -> SessionDays,
35+
session_days: impl FnOnce(&DedupedDailyEntries) -> SessionDays,
3636
) -> Result<DailySummaries> {
3737
let paths = claude_paths()?;
3838
let SinceFiles { kept, pruned } =
@@ -58,7 +58,7 @@ pub(super) fn load_daily_summaries_inner(
5858
let deduped =
5959
load_deduped_daily_entries(&kept, shared, project_filter, tz.as_ref(), pricing.as_ref());
6060
let session_days = session_days(&deduped);
61-
let summaries = summarize_daily_entries(&deduped, group_by_project);
61+
let summaries = summarize_daily_entries(&deduped.entries, group_by_project);
6262
// Skipped sessions still hold Claude usage, so they keep Claude detected
6363
// exactly as an unbounded load would. The first file with an entry settles it.
6464
let detected = !summaries.is_empty()
@@ -75,10 +75,21 @@ pub(super) fn load_daily_summaries_inner(
7575
})
7676
}
7777

78-
pub(super) fn session_days(entries: &[DailyLoadedEntry]) -> SessionDays {
78+
/// Deduplicated daily entries plus the copies dedup merged into them from
79+
/// other sessions, such as a resumed or forked transcript repeating a turn.
80+
pub(super) struct DedupedDailyEntries {
81+
entries: Vec<DailyLoadedEntry>,
82+
copies: Vec<DailyLoadedEntry>,
83+
}
84+
85+
/// Counts a copy's session too: a tool wrapping Claude Code can link its row
86+
/// to the session it ran in even when dedup kept another session's copy.
87+
pub(super) fn session_days(deduped: &DedupedDailyEntries) -> SessionDays {
7988
main_thread_session_days(
80-
entries
89+
deduped
90+
.entries
8191
.iter()
92+
.chain(&deduped.copies)
8293
.map(|entry| (&entry.session_id, entry.date.as_str(), entry.is_sidechain)),
8394
)
8495
}
@@ -89,9 +100,12 @@ fn load_deduped_daily_entries(
89100
project_filter: Option<&str>,
90101
tz: Option<&JiffTimeZone>,
91102
pricing: Option<&PricingMap>,
92-
) -> Vec<DailyLoadedEntry> {
103+
) -> DedupedDailyEntries {
93104
if files.is_empty() {
94-
return Vec::new();
105+
return DedupedDailyEntries {
106+
entries: Vec::new(),
107+
copies: Vec::new(),
108+
};
95109
}
96110
let mode = shared.mode;
97111
let loaded_files = if shared.single_thread {
@@ -105,17 +119,26 @@ fn load_deduped_daily_entries(
105119

106120
let mut deduped_indexes: FxHashMap<u64, DedupeIndexVec> = FxHashMap::default();
107121
let mut deduped = Vec::with_capacity(loaded_files.iter().map(|file| file.entries.len()).sum());
122+
let mut copies = Vec::new();
108123
for loaded_file in loaded_files {
109124
for entry in loaded_file.entries {
110125
if let Some(filter) = project_filter
111126
&& entry.project.as_ref() != filter
112127
{
113128
continue;
114129
}
115-
push_deduped_daily_entry(entry, &mut deduped_indexes, &mut deduped);
130+
if let Some((index, discarded)) =
131+
push_deduped_daily_entry(entry, &mut deduped_indexes, &mut deduped)
132+
&& discarded.session_id != deduped[index].session_id
133+
{
134+
copies.push(discarded);
135+
}
116136
}
117137
}
118-
deduped
138+
DedupedDailyEntries {
139+
entries: deduped,
140+
copies,
141+
}
119142
}
120143

121144
fn summarize_daily_entries(
@@ -467,7 +490,7 @@ fn push_deduped_daily_entry(
467490
entry: DailyLoadedEntry,
468491
deduped_indexes: &mut FxHashMap<u64, DedupeIndexVec>,
469492
deduped: &mut Vec<DailyLoadedEntry>,
470-
) {
493+
) -> Option<(usize, DailyLoadedEntry)> {
471494
let dedupe_lookup = entry.message_id.as_deref().map(|message_id| {
472495
let request_id = entry.request_id.as_deref();
473496
let exact_hash = usage_dedupe_hash(
@@ -532,7 +555,7 @@ fn push_deduped_daily_entry(
532555
}
533556
}
534557
}
535-
if should_replace_deduped_daily_entry(&entry, &deduped[index]) {
558+
let discarded = if should_replace_deduped_daily_entry(&entry, &deduped[index]) {
536559
let previous = std::mem::replace(&mut deduped[index], entry);
537560
// The survivor is already indexed under its previous keys. Only register the keys
538561
// that changed, so repeated same-timestamp rewrites do not rescan large buckets.
@@ -557,8 +580,11 @@ fn push_deduped_daily_entry(
557580
);
558581
}
559582
}
560-
}
561-
return;
583+
previous
584+
} else {
585+
entry
586+
};
587+
return Some((index, discarded));
562588
}
563589

564590
let index = deduped.len();
@@ -582,6 +608,7 @@ fn push_deduped_daily_entry(
582608
}
583609
}
584610
}
611+
None
585612
}
586613

587614
fn daily_entry_exact_hash(entry: &DailyLoadedEntry) -> Option<u64> {

‎rust/adapters/claude/src/lib.rs‎

Lines changed: 64 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -50,11 +50,46 @@ type DedupeIndexVec = SmallVec<[DedupeIndex; 1]>;
5050
/// Use this when a report reads history before the `--since` window, such as
5151
/// billing blocks anchored on earlier entries or whole-session totals.
5252
pub fn load_entries(shared: &SharedArgs, project_filter: Option<&str>) -> Result<Vec<LoadedEntry>> {
53+
load_deduped_entries(shared, project_filter).map(|deduped| deduped.entries)
54+
}
55+
56+
/// Loads every deduplicated Claude usage entry like [`load_entries`], keeping
57+
/// the sessions of the copies dedup merged into them.
58+
pub fn load_deduped_entries(
59+
shared: &SharedArgs,
60+
project_filter: Option<&str>,
61+
) -> Result<DedupedEntries> {
5362
progress::track_usage_load(progress::UsageLoadAgent("Claude"), shared.json, || {
5463
load_entries_inner(shared, project_filter, false)
5564
})
5665
}
5766

67+
/// Deduplicated Claude entries plus the main-thread copies dedup merged into
68+
/// them from other sessions, such as a resumed or forked transcript repeating
69+
/// a turn.
70+
#[derive(Default)]
71+
pub struct DedupedEntries {
72+
pub entries: Vec<LoadedEntry>,
73+
/// `(session the usage is counted under, session of the copy)` pairs.
74+
copies: Vec<(Arc<str>, Arc<str>)>,
75+
}
76+
77+
impl DedupedEntries {
78+
/// Sessions holding main-thread usage counted under a session `is_counted`
79+
/// accepts, copies included, because a tool wrapping Claude Code links its
80+
/// row to the session it ran in, which need not be the one dedup kept.
81+
pub fn main_thread_sessions(&self, is_counted: impl Fn(&str) -> bool) -> HashSet<Arc<str>> {
82+
self.entries
83+
.iter()
84+
.filter(|entry| entry.data.is_sidechain != Some(true))
85+
.map(|entry| (&entry.session_id, &entry.session_id))
86+
.chain(self.copies.iter().map(|(counted, copy)| (counted, copy)))
87+
.filter(|(counted, _)| is_counted(counted))
88+
.map(|(_, session_id)| Arc::clone(session_id))
89+
.collect()
90+
}
91+
}
92+
5893
/// Loads Claude usage entries for a report that keeps only entries dated
5994
/// inside the `--since` window.
6095
///
@@ -72,6 +107,7 @@ pub fn load_entries_since(
72107
progress::track_usage_load(progress::UsageLoadAgent("Claude"), shared.json, || {
73108
load_entries_inner(shared, project_filter, true)
74109
})
110+
.map(|deduped| deduped.entries)
75111
}
76112

77113
/// Loads daily Claude summaries. Summaries dated before `since` may be
@@ -94,19 +130,8 @@ pub fn load_daily_summaries(
94130
/// copy of the turns this source counts.
95131
pub type SessionDays = HashSet<(Arc<str>, String)>;
96132

97-
/// The session days of `entries`, leaving out sidechain (subagent) usage that
98-
/// a wrapping tool does not record.
99-
pub fn session_days<'a>(entries: impl IntoIterator<Item = &'a LoadedEntry>) -> SessionDays {
100-
main_thread_session_days(entries.into_iter().map(|entry| {
101-
(
102-
&entry.session_id,
103-
entry.date.as_str(),
104-
entry.data.is_sidechain,
105-
)
106-
}))
107-
}
108-
109-
/// Takes `(session ID, date, is_sidechain)` per entry and dedups the borrowed
133+
/// Takes `(session ID, date, is_sidechain)` per entry and leaves out sidechain
134+
/// (subagent) usage, which a wrapping tool does not record. Dedups the borrowed
110135
/// pairs before owning them, so the date is cloned once per session day.
111136
fn main_thread_session_days<'a>(
112137
entries: impl Iterator<Item = (&'a Arc<str>, &'a str, Option<bool>)>,
@@ -154,7 +179,7 @@ fn load_entries_inner(
154179
shared: &SharedArgs,
155180
project_filter: Option<&str>,
156181
skip_files_before_since: bool,
157-
) -> Result<Vec<LoadedEntry>> {
182+
) -> Result<DedupedEntries> {
158183
let paths = claude_paths()?;
159184
debug_log(
160185
shared,
@@ -184,7 +209,7 @@ fn load_entries_inner(
184209
);
185210
}
186211
if files.is_empty() {
187-
return Ok(Vec::new());
212+
return Ok(DedupedEntries::default());
188213
}
189214

190215
let pricing = if shared.mode == CostMode::Display {
@@ -216,21 +241,35 @@ fn load_entries_inner(
216241
let mut deduped_indexes: FxHashMap<u64, DedupeIndexVec> = FxHashMap::default();
217242
let mut deduped: Vec<LoadedEntry> =
218243
Vec::with_capacity(loaded_files.iter().map(|file| file.entries.len()).sum());
244+
let mut copies = Vec::new();
219245
for loaded_file in loaded_files {
220246
for entry in loaded_file.entries {
221247
if let Some(filter) = project_filter
222248
&& entry.project.as_ref() != filter
223249
{
224250
continue;
225251
}
226-
push_deduped_entry(entry, &mut deduped_indexes, &mut deduped);
252+
if let Some((index, discarded)) =
253+
push_deduped_entry(entry, &mut deduped_indexes, &mut deduped)
254+
&& discarded.session_id != deduped[index].session_id
255+
&& discarded.data.is_sidechain != Some(true)
256+
{
257+
copies.push((index, discarded.session_id));
258+
}
227259
}
228260
}
229261
debug_log(
230262
shared,
231263
format!("Kept {} usage entries after deduplication", deduped.len()),
232264
);
233-
Ok(deduped)
265+
let copies = copies
266+
.into_iter()
267+
.map(|(index, session_id)| (Arc::clone(&deduped[index].session_id), session_id))
268+
.collect();
269+
Ok(DedupedEntries {
270+
entries: deduped,
271+
copies,
272+
})
234273
}
235274

236275
fn usage_token_total(data: &UsageEntry) -> u64 {
@@ -261,7 +300,7 @@ fn push_deduped_entry(
261300
entry: LoadedEntry,
262301
deduped_indexes: &mut FxHashMap<u64, DedupeIndexVec>,
263302
deduped: &mut Vec<LoadedEntry>,
264-
) {
303+
) -> Option<(usize, LoadedEntry)> {
265304
let dedupe_lookup = entry.data.message.id.as_deref().map(|message_id| {
266305
let request_id = entry.data.request_id.as_deref();
267306
let session_id = loaded_entry_session_id(&entry);
@@ -330,7 +369,7 @@ fn push_deduped_entry(
330369
}
331370
}
332371
}
333-
if should_replace_deduped_entry(&entry.data, &deduped[index].data) {
372+
let discarded = if should_replace_deduped_entry(&entry.data, &deduped[index].data) {
334373
let previous = std::mem::replace(&mut deduped[index], entry);
335374
// The survivor is already indexed under its previous keys. Only register the keys
336375
// that changed, so repeated same-timestamp rewrites do not rescan large buckets.
@@ -359,8 +398,11 @@ fn push_deduped_entry(
359398
);
360399
}
361400
}
362-
}
363-
return;
401+
previous
402+
} else {
403+
entry
404+
};
405+
return Some((index, discarded));
364406
}
365407

366408
let index = deduped.len();
@@ -384,6 +426,7 @@ fn push_deduped_entry(
384426
}
385427
}
386428
}
429+
None
387430
}
388431

389432
/// Exact-match dedupe key shared by the entry and daily loaders.

‎rust/adapters/opencode/src/lib.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ mod parser;
88
mod paths;
99
mod report;
1010

11-
pub use loader::{load_entries, load_entries_with_native_sessions};
11+
pub use loader::{LinkedEntry, load_entries_with_native_sessions};
1212
pub use report::{report_json, summarize_entries};
1313

1414
use crate::{

‎rust/adapters/opencode/src/loader.rs‎

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,17 +20,20 @@ use crate::{
2020
collect_files_with_extension, date_range_bounds_ms, debug_log, parse_tz, read_files_parallel,
2121
};
2222

23-
pub fn load_entries(shared: &SharedArgs, report_kind: AgentReportKind) -> Result<Vec<LoadedEntry>> {
23+
pub(crate) fn load_entries(
24+
shared: &SharedArgs,
25+
report_kind: AgentReportKind,
26+
) -> Result<Vec<LoadedEntry>> {
2427
load_entries_with_native_sessions(shared, report_kind)
2528
.map(|entries| entries.into_iter().map(|(entry, _)| entry).collect())
2629
}
2730

2831
/// An entry and the Claude Code session its `claude-agent` row ran in.
29-
type LinkedEntry = (LoadedEntry, Option<Arc<str>>);
32+
pub type LinkedEntry = (LoadedEntry, Option<Arc<str>>);
3033

31-
/// Loads entries like [`load_entries`], each paired with the Claude Code
32-
/// session its `claude-agent` row ran in, so a unified report can skip the
33-
/// turns the Claude source already counts.
34+
/// Loads OpenCode usage entries, each paired with the Claude Code session its
35+
/// `claude-agent` row ran in, so a unified report can skip the turns the
36+
/// Claude source already counts.
3437
pub fn load_entries_with_native_sessions(
3538
shared: &SharedArgs,
3639
report_kind: AgentReportKind,

0 commit comments

Comments
 (0)