v0.2.0 (#10)

Author: husayn-hasanov

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "worko-ai-usage"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.86"
 license = "MIT"

Cargo.toml

@@ -65,7 +65,7 @@ worko-ai-usage logout
   then exchanges a single-use token for a scoped Worko HR access token. The
   single-use token and your account password are never stored.
 - `status` prints locally detected counters and does not contact Worko.
-- `sync` uploads at most the latest 48 hourly snapshots.
+- `sync` uploads session-level snapshots from the latest 48 hours (up to 500 rows).
 - `logout` deletes the local Worko token and does not affect Claude or Codex login.
 
 ## Data collected
@@ -74,11 +74,18 @@ worko-ai-usage logout
 |---|---|
 | Provider (`claude`/`codex`) | Separate agent reporting |
 | Anonymous machine hash | Avoid duplicate hourly snapshots |
+| Anonymous session hash | Keep concurrent agent sessions separate without uploading paths |
 | UTC hour | Hourly reporting |
 | Input/cached/output token counts | Usage KPI |
 | Usage event count | Activity indicator |
 | Provider-reported 5-hour percentage | Included only when present in local provider logs |
 
+Five-hour utilization is never inferred from token counts. It remains unknown when
+the provider log does not expose a limit signal. Session separation improves
+attribution, but a provider may report an account-wide window value rather than a
+session-specific quota; the HR dashboard shows signal coverage so this limitation
+stays visible.
+
 ## Development and releases
 
 ```bash

README.md

@@ -54,12 +54,14 @@ struct Config {
 struct Snapshot {
     provider: String,
     machine_id: String,
+    session_hash: String,
     observed_at: String,
     input_tokens: u64,
     cached_input_tokens: u64,
     output_tokens: u64,
     sessions: u32,
     five_hour_percent: Option<f64>,
+    limit_source: Option<String>,
     collector_version: String,
     ide: String,
 }
@@ -190,14 +192,24 @@ fn sync() -> Result<()> {
         println!("No Claude Code or Codex usage events found.");
         return Ok(());
     }
-    let start = snapshots.len().saturating_sub(48);
+    let recent_cutoff = Utc::now() - chrono::Duration::hours(48);
+    let recent: Vec<&Snapshot> = snapshots
+        .iter()
+        .filter(|snapshot| {
+            DateTime::parse_from_rfc3339(&snapshot.observed_at)
+                .map(|time| time >= recent_cutoff)
+                .unwrap_or(false)
+        })
+        .rev()
+        .take(500)
+        .collect();
     let response = client()
         .post(format!(
             "{}/api/v1/ai-agent-usage/snapshots",
             config.base_url
         ))
         .bearer_auth(config.token)
-        .json(&json!({"snapshots": &snapshots[start..]}))
+        .json(&json!({"snapshots": recent.into_iter().rev().collect::<Vec<_>>()}))
         .send()?;
     if !response.status().is_success() {
         bail!("sync failed ({})", response.status());
@@ -220,13 +232,13 @@ fn collect() -> Result<Vec<Snapshot>> {
     ];
     let machine_id = machine_id(&home);
     let cutoff = SystemTime::now() - Duration::from_secs(7 * 86_400);
-    let mut buckets: BTreeMap<(String, String), Snapshot> = BTreeMap::new();
+    let mut buckets: BTreeMap<(String, String, String), Snapshot> = BTreeMap::new();
 
     for (provider, root) in sources {
         if !root.is_dir() {
             continue;
         }
-        for entry in WalkDir::new(root)
+        for entry in WalkDir::new(&root)
             .into_iter()
             .filter_map(|entry| entry.ok())
         {
@@ -240,6 +252,7 @@ fn collect() -> Result<Vec<Snapshot>> {
                 continue;
             }
             let fallback = DateTime::<Utc>::from(fs::metadata(path)?.modified()?);
+            let session_hash = session_hash(&machine_id, provider, path, &root);
             for line in io::BufReader::new(fs::File::open(path)?)
                 .lines()
                 .map_while(|line| line.ok())
@@ -262,16 +275,18 @@ fn collect() -> Result<Vec<Snapshot>> {
                     .with_nanosecond(0)
                     .unwrap()
                     .to_rfc3339();
-                let key = (provider.to_owned(), hour.clone());
+                let key = (provider.to_owned(), session_hash.clone(), hour.clone());
                 let bucket = buckets.entry(key).or_insert_with(|| Snapshot {
                     provider: provider.to_owned(),
                     machine_id: machine_id.clone(),
+                    session_hash: session_hash.clone(),
                     observed_at: hour,
                     input_tokens: 0,
                     cached_input_tokens: 0,
                     output_tokens: 0,
                     sessions: 0,
                     five_hour_percent: None,
+                    limit_source: None,
                     collector_version: VERSION.to_owned(),
                     ide: std::env::var("WORKO_IDE").unwrap_or_else(|_| "terminal".to_owned()),
                 });
@@ -282,13 +297,23 @@ fn collect() -> Result<Vec<Snapshot>> {
                 bucket.sessions += 1;
                 if let Some(percent) = find_percent(&event) {
                     bucket.five_hour_percent = Some(percent.clamp(0.0, 100.0));
+                    bucket.limit_source = Some("provider_log".to_owned());
                 }
             }
         }
     }
     Ok(buckets.into_values().collect())
 }
 
+fn session_hash(machine_id: &str, provider: &str, path: &Path, root: &Path) -> String {
+    let relative = path.strip_prefix(root).unwrap_or(path);
+    let mut hash = Sha256::new();
+    hash.update(machine_id.as_bytes());
+    hash.update(provider.as_bytes());
+    hash.update(relative.to_string_lossy().as_bytes());
+    hex::encode(hash.finalize())
+}
+
 fn find_usage(value: &Value) -> Option<&Value> {
     if let Value::Object(map) = value {
         for key in ["usage", "token_usage", "last_token_usage"] {