feat: add project working copies (clone agents)

src-tauri/src/lib.rs

@@ -222,6 +222,7 @@ pub fn run() {
             codex::codex_doctor,
             workspaces::list_workspaces,
             workspaces::add_workspace,
+            workspaces::add_clone,
             workspaces::add_worktree,
             workspaces::remove_workspace,
             workspaces::remove_worktree,

src-tauri/src/local_usage.rs

@@ -234,6 +234,14 @@ fn scan_file(
                 output: (output - prev.output).max(0),
             };
             previous_totals = Some(UsageTotals { input, cached, output });
+        } else {
+            // Some streams emit `last_token_usage` deltas between `total_token_usage` snapshots.
+            // Treat those as already-counted to avoid double-counting when the next total arrives.
+            let mut next = previous_totals.unwrap_or_default();
+            next.input += delta.input;
+            next.cached += delta.cached;
+            next.output += delta.output;
+            previous_totals = Some(next);
         }
 
         if delta.input == 0 && delta.cached == 0 && delta.output == 0 {
@@ -344,3 +352,75 @@ fn day_dir_for_key(root: &Path, day_key: &str) -> PathBuf {
     let day = parts.next().unwrap_or("01");
     root.join(year).join(month).join(day)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use uuid::Uuid;
+
+    fn write_temp_jsonl(lines: &[&str]) -> PathBuf {
+        let mut path = std::env::temp_dir();
+        path.push(format!(
+            "codexmonitor-local-usage-test-{}.jsonl",
+            Uuid::new_v4()
+        ));
+        let mut file = File::create(&path).expect("create temp jsonl");
+        for line in lines {
+            writeln!(file, "{line}").expect("write jsonl line");
+        }
+        path
+    }
+
+    #[test]
+    fn scan_file_does_not_double_count_last_and_total_usage() {
+        let day_key = "2026-01-19";
+        let path = write_temp_jsonl(&[
+            r#"{"payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":10,"cached_input_tokens":0,"output_tokens":5}}}}"#,
+            r#"{"payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":10,"cached_input_tokens":0,"output_tokens":5}}}}"#,
+        ]);
+
+        let mut daily: HashMap<String, DailyTotals> = HashMap::new();
+        let mut model_totals: HashMap<String, i64> = HashMap::new();
+        scan_file(&path, day_key, &mut daily, &mut model_totals).expect("scan file");
+
+        let totals = daily.get(day_key).copied().unwrap_or_default();
+        assert_eq!(totals.input, 10);
+        assert_eq!(totals.output, 5);
+    }
+
+    #[test]
+    fn scan_file_counts_last_deltas_before_total_snapshot_once() {
+        let day_key = "2026-01-19";
+        let path = write_temp_jsonl(&[
+            r#"{"payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":10,"cached_input_tokens":0,"output_tokens":5}}}}"#,
+            r#"{"payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":20,"cached_input_tokens":0,"output_tokens":10}}}}"#,
+        ]);
+
+        let mut daily: HashMap<String, DailyTotals> = HashMap::new();
+        let mut model_totals: HashMap<String, i64> = HashMap::new();
+        scan_file(&path, day_key, &mut daily, &mut model_totals).expect("scan file");
+
+        let totals = daily.get(day_key).copied().unwrap_or_default();
+        assert_eq!(totals.input, 20);
+        assert_eq!(totals.output, 10);
+    }
+
+    #[test]
+    fn scan_file_does_not_double_count_last_between_total_snapshots() {
+        let day_key = "2026-01-19";
+        let path = write_temp_jsonl(&[
+            r#"{"payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":10,"cached_input_tokens":0,"output_tokens":5}}}}"#,
+            r#"{"payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":2,"cached_input_tokens":0,"output_tokens":1}}}}"#,
+            r#"{"payload":{"type":"token_count","info":{"total_token_usage":{"input_tokens":12,"cached_input_tokens":0,"output_tokens":6}}}}"#,
+        ]);
+
+        let mut daily: HashMap<String, DailyTotals> = HashMap::new();
+        let mut model_totals: HashMap<String, i64> = HashMap::new();
+        scan_file(&path, day_key, &mut daily, &mut model_totals).expect("scan file");
+
+        let totals = daily.get(day_key).copied().unwrap_or_default();
+        assert_eq!(totals.input, 12);
+        assert_eq!(totals.output, 6);
+    }
+}

src-tauri/src/types.rs

@@ -213,6 +213,8 @@ pub(crate) struct WorkspaceGroup {
     pub(crate) name: String,
     #[serde(default, rename = "sortOrder")]
     pub(crate) sort_order: Option<u32>,
+    #[serde(default, rename = "copiesFolder")]
+    pub(crate) copies_folder: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
@@ -396,7 +398,9 @@ impl Default for AppSettings {
 
 #[cfg(test)]
 mod tests {
-    use super::{AppSettings, BackendMode, WorkspaceEntry, WorkspaceKind, WorkspaceSettings};
+    use super::{
+        AppSettings, BackendMode, WorkspaceEntry, WorkspaceGroup, WorkspaceKind, WorkspaceSettings,
+    };
 
     #[test]
     fn app_settings_defaults_from_empty_json() {
@@ -430,6 +434,33 @@ mod tests {
         assert!(settings.workspace_groups.is_empty());
     }
 
+    #[test]
+    fn workspace_group_defaults_from_minimal_json() {
+        let group: WorkspaceGroup =
+            serde_json::from_str(r#"{"id":"g1","name":"Group"}"#).expect("group deserialize");
+        assert!(group.sort_order.is_none());
+        assert!(group.copies_folder.is_none());
+    }
+
+    #[test]
+    fn app_settings_round_trip_preserves_workspace_group_copies_folder() {
+        let mut settings = AppSettings::default();
+        settings.workspace_groups = vec![WorkspaceGroup {
+            id: "g1".to_string(),
+            name: "Group".to_string(),
+            sort_order: Some(2),
+            copies_folder: Some("/tmp/group-copies".to_string()),
+        }];
+
+        let json = serde_json::to_string(&settings).expect("serialize settings");
+        let decoded: AppSettings = serde_json::from_str(&json).expect("deserialize settings");
+        assert_eq!(decoded.workspace_groups.len(), 1);
+        assert_eq!(
+            decoded.workspace_groups[0].copies_folder.as_deref(),
+            Some("/tmp/group-copies")
+        );
+    }
+
     #[test]
     fn workspace_entry_defaults_from_minimal_json() {
         let entry: WorkspaceEntry = serde_json::from_str(