@@ -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.
5252pub 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.
95131pub 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.
111136fn 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
236275fn 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.
0 commit comments