Skip to content

A tiny friend in your Mac's notch and on your iPhone that keeps an eye on your AI coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more. Approve from the notch or your Lock Screen.

Windows/Linux: record a weekly recap history from hook events

Claude8d47969f5119
diff --git a/windows/src-tauri/src/lib.rs b/windows/src-tauri/src/lib.rs
index d9ec3353..69520e5a 100644
--- a/windows/src-tauri/src/lib.rs
+++ b/windows/src-tauri/src/lib.rs
@@ -8,6 +8,7 @@ mod island;
mod log;
mod pipe;
mod platform;
+mod recap;
mod secrets;
mod settings;
mod tray;
@@ -215,6 +216,7 @@ fn hooks_apply(
#[tauri::command]
fn approval_decision(app: AppHandle, request_id: String, decision: String) {
+ recap::record_decision(&app, &request_id, &decision);
pipe::answer(&app, &request_id, &decision);
}
@@ -230,6 +232,7 @@ fn approval_ack(app: AppHandle, request_id: String) {
/// already up. Claude Code falls back to asking in the terminal immediately.
#[tauri::command]
fn approval_decline(app: AppHandle, request_id: String) {
+ recap::forget_request(&app, &request_id);
pipe::decline(&app, &request_id);
}
@@ -376,6 +379,7 @@ pub fn run() {
})
.manage(Pending::default())
.manage(Chat::default())
+ .manage(recap::load())
.invoke_handler(tauri::generate_handler![
boot,
save_settings,
@@ -403,6 +407,14 @@ pub fn run() {
open_n8n,
open_settings_window,
set_paused,
+ recap::recap_history,
+ recap::recap_prefs,
+ recap::recap_set_enabled,
+ recap::recap_set_hide_projects,
+ recap::recap_mark_shown,
+ recap::recap_clear,
+ recap::recap_save_png,
+ recap::recap_reveal_saved,
])
.setup(move |app| {
let handle = app.handle().clone();
diff --git a/windows/src-tauri/src/pipe.rs b/windows/src-tauri/src/pipe.rs
index 36b6316c..b8c60d39 100644
--- a/windows/src-tauri/src/pipe.rs
+++ b/windows/src-tauri/src/pipe.rs
@@ -195,6 +195,9 @@ async fn handle(app: AppHandle, mut pipe: impl Relay) {
.unwrap_or_default()
.to_string();
+ // Counts for the weekly recap — never the command, path or prompt itself.
+ crate::recap::observe(&app, &payload);
+
if event != "PermissionRequest" {
log::line(format!("hook {event}"));
let _ = app.emit_to(WINDOW_LABEL, "hook", payload);
@@ -208,6 +211,7 @@ async fn handle(app: AppHandle, mut pipe: impl Relay) {
let pending = app.state::<Pending>();
pending.0.lock().unwrap().insert(id.clone(), tx);
}
+ crate::recap::note_request(&app, &id, &payload);
payload["request_id"] = json!(id);
log::line(format!("hook PermissionRequest id={id}"));
let _ = app.emit_to(WINDOW_LABEL, "hook", payload);
diff --git a/windows/src-tauri/src/platform/linux.rs b/windows/src-tauri/src/platform/linux.rs
index e748a336..eb44860c 100644
--- a/windows/src-tauri/src/platform/linux.rs
+++ b/windows/src-tauri/src/platform/linux.rs
@@ -51,6 +51,38 @@ pub fn local_dir() -> PathBuf {
xdg("XDG_DATA_HOME", ".local/share").join("coucou")
}
+/// Where a saved image goes, best first: the XDG pictures folder named in
+/// ~/.config/user-dirs.dirs, then ~/Pictures, ~/Downloads and the home folder.
+/// The caller takes the first one that exists.
+pub fn picture_dirs() -> Vec<PathBuf> {
+ let home = home_dir();
+ let mut dirs = Vec::new();
+ let user_dirs = xdg("XDG_CONFIG_HOME", ".config").join("user-dirs.dirs");
+ if let Ok(text) = std::fs::read_to_string(user_dirs) {
+ if let Some(dir) = xdg_user_dir(&text, "XDG_PICTURES_DIR", &home) {
+ dirs.push(dir);
+ }
+ }
+ dirs.push(home.join("Pictures"));
+ dirs.push(home.join("Downloads"));
+ dirs.push(home);
+ dirs
+}
+
+/// `XDG_PICTURES_DIR="$HOME/Pictures"` → /home/me/Pictures. Only the two forms
+/// xdg-user-dirs writes are understood: "$HOME/…" and an absolute path.
+fn xdg_user_dir(text: &str, key: &str, home: &Path) -> Option<PathBuf> {
+ let line = text.lines().map(str::trim).find(|l| l.starts_with(key))?;
+ let value = line.strip_prefix(key)?.trim_start().strip_prefix('=')?.trim();
+ let value = value.strip_prefix('"')?.strip_suffix('"')?;
+ let path = match value.strip_prefix("$HOME") {
+ Some(rest) => home.join(rest.trim_start_matches('/')),
+ None => PathBuf::from(value),
+ };
+ // "$HOME/" alone means "no pictures folder", by the spec.
+ (path.is_absolute() && path != home).then_some(path)
+}
+
/// Environment the webview must inherit, set before any thread or process
/// starts.
///
@@ -344,4 +376,17 @@ mod tests {
assert_eq!(std::fs::metadata(&dir).unwrap().mode() & 0o777, 0o700);
let _ = std::fs::remove_dir_all(&dir);
}
+
+ #[test]
+ fn the_pictures_folder_comes_from_user_dirs() {
+ let home = Path::new("/home/me");
+ let text = "# written by xdg-user-dirs-update\nXDG_DESKTOP_DIR=\"$HOME/Desktop\"\nXDG_PICTURES_DIR=\"$HOME/Images\"\n";
+ assert_eq!(xdg_user_dir(text, "XDG_PICTURES_DIR", home), Some(PathBuf::from("/home/me/Images")));
+ let absolute = "XDG_PICTURES_DIR=\"/data/pics\"";
+ assert_eq!(xdg_user_dir(absolute, "XDG_PICTURES_DIR", home), Some(PathBuf::from("/data/pics")));
+ // "$HOME/" means the folder is disabled; relative paths are not paths.
+ assert_eq!(xdg_user_dir("XDG_PICTURES_DIR=\"$HOME/\"", "XDG_PICTURES_DIR", home), None);
+ assert_eq!(xdg_user_dir("XDG_PICTURES_DIR=\"pics\"", "XDG_PICTURES_DIR", home), None);
+ assert_eq!(xdg_user_dir("", "XDG_PICTURES_DIR", home), None);
+ }
}
diff --git a/windows/src-tauri/src/platform/windows.rs b/windows/src-tauri/src/platform/windows.rs
index 6e1200a8..4eaf0c43 100644
--- a/windows/src-tauri/src/platform/windows.rs
+++ b/windows/src-tauri/src/platform/windows.rs
@@ -49,6 +49,26 @@ pub fn local_dir() -> PathBuf {
base.join("Coucou")
}
+/// Where a saved image goes, best first: Pictures (also where OneDrive moves
+/// it), then Downloads and the profile folder. The caller takes the first one
+/// that exists. Read from the environment rather than the Known Folders API: a
+/// relocated Pictures folder falls back to Downloads, which is fine for a PNG.
+pub fn picture_dirs() -> Vec<PathBuf> {
+ let mut dirs = Vec::new();
+ let home = std::env::var_os("USERPROFILE").map(PathBuf::from);
+ if let Some(home) = &home {
+ dirs.push(home.join("Pictures"));
+ }
+ if let Some(onedrive) = std::env::var_os("OneDrive").map(PathBuf::from) {
+ dirs.push(onedrive.join("Pictures"));
+ }
+ if let Some(home) = home {
+ dirs.push(home.join("Downloads"));
+ dirs.push(home);
+ }
+ dirs
+}
+
/// %APPDATA% and %LOCALAPPDATA% are already private to the user.
pub fn ensure_private_dir(dir: &std::path::Path) -> std::io::Result<()> {
std::fs::create_dir_all(dir)
diff --git a/windows/src-tauri/src/recap.rs b/windows/src-tauri/src/recap.rs
new file mode 100644
index 00000000..e6b0d7cd
--- /dev/null
+++ b/windows/src-tauri/src/recap.rs
@@ -0,0 +1,1024 @@
+// Weekly recap history — port of RecapStore.swift.
+//
+// Every hook event the relay forwards also passes through here. A "turn" runs
+// from a prompt (or the first tool call) to Stop, and only its counts and two
+// names are kept: the agent's pill ID and the project folder's last path
+// component. Never a command, a file path, file contents or a prompt.
+//
+// The history lives in recap.json under platform::local_dir()
+// (%LOCALAPPDATA%\Coucou on Windows, ~/.local/share/coucou on Linux), keeps a
+// 12-week rolling window and a hard cap on its length, and is written whole to
+// a temporary file then renamed over the old one, so a crash never leaves half
+// a file. Nothing in it ever leaves the machine.
+//
+// Aggregation (weeks, top agent, busiest day…) happens in the island
+// (src/recap/summary.ts): it needs the user's time zone, which JavaScript has
+// and plain Rust does not.
+
+use std::collections::{HashMap, HashSet};
+use std::io::{ErrorKind, Write};
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, MutexGuard, PoisonError};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use tauri::{AppHandle, Emitter, Manager, State};
+
+use crate::island::WINDOW_LABEL;
+use crate::platform;
+
+/// 12 weeks, like the Mac.
+pub const WINDOW_SECS: i64 = 12 * 7 * 86_400;
+/// A turn with no event for two hours is closed at its last event (agent
+/// crashed, or never sent Stop) — RecapStore.pruneStale.
+const STALE_SECS: i64 = 2 * 3600;
+/// Hard caps, whatever the window holds: about 2 MB of JSON at most.
+const MAX_TURNS: usize = 10_000;
+const MAX_DECISIONS: usize = 10_000;
+const MAX_DRAFTS: usize = 256;
+const MAX_REQUESTS: usize = 64;
+const MAX_NAME_CHARS: usize = 64;
+/// A recap.json larger than this was not written by us: set it aside.
+const MAX_FILE_BYTES: u64 = 16 << 20;
+/// A 1080 × 1920 PNG is ~1 MB; anything far larger is not our image.
+const MAX_PNG_BYTES: usize = 24 << 20;
+
+/// Same limits as DiffEngine.swift: beyond them, lines are counted, not diffed.
+const DIFF_MAX_BYTES: usize = 200 * 1024;
+const DIFF_MAX_LINES: usize = 4000;
+const DIFF_MAX_CELLS: usize = 1_000_000;
+
+/// Tool names that run a shell command, across the agents the relay serves.
+const COMMAND_TOOLS: &[&str] = &[
+ "Bash",
+ "PowerShell",
+ "Execute",
+ "mcp__ide__executeCode",
+ "run_shell_command",
+ "shell",
+ "local_shell",
+ "exec_command",
+];
+
+// ── Persisted model ───────────────────────────────────────────────────────────
+
+/// One finished turn. Times are Unix seconds.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Turn {
+ pub agent: String,
+ pub project: String,
+ pub start: i64,
+ pub end: i64,
+ pub files_changed: u32,
+ pub lines_added: u32,
+ pub lines_removed: u32,
+ pub commands_run: u32,
+ pub questions: u32,
+}
+
+/// A click on Allow or Deny in the island.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Decision {
+ pub agent: String,
+ pub date: i64,
+ /// "allow" or "deny".
+ pub decision: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", default)]
+pub struct Prefs {
+ /// "Keep a history of my coding sessions" — on by default, like the Mac.
+ pub enabled: bool,
+ /// Leave the project name out of the shared image.
+ pub hide_projects: bool,
+ /// Monday (YYYY-MM-DD) of the week the recap was last shown on its own.
+ pub last_shown_week: String,
+}
+
+impl Default for Prefs {
+ fn default() -> Self {
+ Self { enabled: true, hide_projects: false, last_shown_week: String::new() }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", default)]
+struct History {
+ schema_version: u32,
+ turns: Vec<Turn>,
+ decisions: Vec<Decision>,
+ prefs: Prefs,
+}
+
+impl Default for History {
+ fn default() -> Self {
+ Self { schema_version: 1, turns: Vec::new(), decisions: Vec::new(), prefs: Prefs::default() }
+ }
+}
+
+/// What the island reads: the part of the history it asked for.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HistoryView {
+ pub turns: Vec<Turn>,
+ pub decisions: Vec<Decision>,
+ pub prefs: Prefs,
+}
+
+/// A turn in progress, in memory only. The paths are only there to count
+/// distinct files and are never written anywhere.
+#[derive(Debug)]
+struct Draft {
+ agent: String,
+ project: String,
+ start: i64,
+ last_event: i64,
+ paths: HashSet<String>,
+ lines_added: u32,
+ lines_removed: u32,
+ commands_run: u32,
+ questions: u32,
+}
+
+impl Draft {
+ fn into_turn(self, end: i64) -> Turn {
+ Turn {
+ agent: self.agent,
+ project: self.project,
+ start: self.start,
+ end: end.max(self.start),
+ files_changed: self.paths.len().min(u32::MAX as usize) as u32,
+ lines_added: self.lines_added,
+ lines_removed: self.lines_removed,
+ commands_run: self.commands_run,
+ questions: self.questions,
+ }
+ }
+}
+
+// ── Store ─────────────────────────────────────────────────────────────────────
+
+pub struct Recap {
+ path: PathBuf,
+ history: History,
+ drafts: HashMap<String, Draft>,
+ /// Permission request ID → agent, until the island answers it.
+ requests: HashMap<String, String>,
+ /// The last image saved, so "Show in folder" never takes a path from the page.
+ last_saved: Option<PathBuf>,
+}
+
+impl Recap {
+ /// Reads `path`. A file that cannot be used is renamed aside, never lost.
+ pub fn load(path: PathBuf, now: i64) -> Self {
+ let history = read_history(&path);
+ let mut recap = Self {
+ path,
+ history,
+ drafts: HashMap::new(),
+ requests: HashMap::new(),
+ last_saved: None,
+ };
+ recap.prune(now);
+ recap
+ }
+
+ /// One hook event, as the relay delivered it.
+ pub fn observe(&mut self, payload: &Value, now: i64) {
+ if !self.history.prefs.enabled {
+ return;
+ }
+ self.close_stale(now);
+ let event = text(payload, "hook_event_name");
+ let agent = agent_id(payload);
+ let key = session_key(payload, &agent);
+
+ match event {
+ "UserPromptSubmit" => {
+ self.draft(&key, &agent, payload, now);
+ }
+ "PreToolUse" => {
+ let tool = text(payload, "tool_name");
+ let draft = self.draft(&key, &agent, payload, now);
+ if COMMAND_TOOLS.contains(&tool) {
+ draft.commands_run = draft.commands_run.saturating_add(1);
+ }
+ if tool == "AskUserQuestion" {
+ draft.questions = draft.questions.saturating_add(1);
+ }
+ }
+ "PostToolUse" => {
+ let tool = text(payload, "tool_name");
+ let input = payload.get("tool_input").unwrap_or(&Value::Null);
+ let change = file_change(tool, input);
+ let draft = self.draft(&key, &agent, payload, now);
+ if let Some((path, added, removed)) = change {
+ draft.paths.insert(path);
+ draft.lines_added = draft.lines_added.saturating_add(added);
+ draft.lines_removed = draft.lines_removed.saturating_add(removed);
+ }
+ }
+ // Unlike the Mac, SessionEnd closes the turn instead of dropping it:
+ // a session quit mid-turn still worked.
+ "Stop" | "StopFailure" | "Interrupt" | "SessionEnd" => {
+ if let Some(draft) = self.drafts.remove(&key) {
+ self.history.turns.push(draft.into_turn(now));
+ self.prune(now);
+ self.save();
+ }
+ }
+ _ => {}
+ }
+ }
+
+ /// The draft for `key`, created on the first event of a turn.
+ fn draft(&mut self, key: &str, agent: &str, payload: &Value, now: i64) -> &mut Draft {
+ if !self.drafts.contains_key(key) && self.drafts.len() >= MAX_DRAFTS {
+ self.close_oldest_draft();
+ }
+ let draft = self.drafts.entry(key.to_string()).or_insert_with(|| Draft {
+ agent: agent.to_string(),
+ project: project_name(text(payload, "cwd")),
+ start: now,
+ last_event: now,
+ paths: HashSet::new(),
+ lines_added: 0,
+ lines_removed: 0,
+ commands_run: 0,
+ questions: 0,
+ });
+ draft.last_event = now;
+ draft
+ }
+
+ fn close_oldest_draft(&mut self) {
+ let Some(key) = self
+ .drafts
+ .iter()
+ .min_by_key(|(_, d)| d.last_event)
+ .map(|(k, _)| k.clone())
+ else {
+ return;
+ };
+ if let Some(draft) = self.drafts.remove(&key) {
+ let end = draft.last_event;
+ self.history.turns.push(draft.into_turn(end));
+ }
+ }
+
+ /// RecapStore.pruneStale: turns silent for two hours count up to their
+ /// last event instead of being lost.
+ fn close_stale(&mut self, now: i64) {
+ let stale: Vec<String> = self
+ .drafts
+ .iter()
+ .filter(|(_, d)| d.last_event < now - STALE_SECS)
+ .map(|(k, _)| k.clone())
+ .collect();
+ if stale.is_empty() {
+ return;
+ }
+ for key in stale {
+ if let Some(draft) = self.drafts.remove(&key) {
+ let end = draft.last_event;
+ self.history.turns.push(draft.into_turn(end));
+ }
+ }
+ self.prune(now);
+ self.save();
+ }
+
+ /// A permission request reached the island: remember whose it is.
+ pub fn note_request(&mut self, request_id: &str, payload: &Value) {
+ if self.requests.len() >= MAX_REQUESTS {
+ self.requests.clear();
+ }
+ self.requests.insert(request_id.to_string(), agent_id(payload));
+ }
+
+ /// The request was handed back to the terminal: nothing to record.
+ pub fn forget_request(&mut self, request_id: &str) {
+ self.requests.remove(request_id);
+ }
+
+ /// A click on Allow or Deny.
+ pub fn record_decision(&mut self, request_id: &str, decision: &str, now: i64) {
+ let agent = self
+ .requests
+ .remove(request_id)
+ .unwrap_or_else(|| "integration_claude".to_string());
+ if !self.history.prefs.enabled {
+ return;
+ }
+ let word = match decision {
+ "allow" | "always" => "allow",
+ "deny" => "deny",
+ _ => return,
+ };
+ self.history.decisions.push(Decision { agent, date: now, decision: word.to_string() });
+ self.prune(now);
+ self.save();
+ }
+
+ /// Everything from `since` on (Unix seconds).
+ pub fn view(&self, since: i64) -> HistoryView {
+ HistoryView {
+ turns: self.history.turns.iter().filter(|t| t.start >= since).cloned().collect(),
+ decisions: self.history.decisions.iter().filter(|d| d.date >= since).cloned().collect(),
+ prefs: self.history.prefs.clone(),
+ }
+ }
+
+ pub fn prefs(&self) -> &Prefs {
+ &self.history.prefs
+ }
+
+ pub fn set_enabled(&mut self, enabled: bool) {
+ self.history.prefs.enabled = enabled;
+ if !enabled {
+ self.drafts.clear();
+ self.requests.clear();
+ }
+ self.save();
+ }
+
+ pub fn set_hide_projects(&mut self, hide: bool) {
+ self.history.prefs.hide_projects = hide;
+ self.save();
+ }
+
+ /// `week` is the Monday the recap was shown for, as YYYY-MM-DD.
+ pub fn mark_shown(&mut self, week: &str) {
+ if !is_week_key(week) {
+ return;
+ }
+ self.history.prefs.last_shown_week = week.to_string();
+ self.save();
+ }
+
+ /// Settings → General → Clear history. The preferences stay.
+ pub fn clear(&mut self) {
+ self.history.turns.clear();
+ self.history.decisions.clear();
+ self.drafts.clear();
+ self.save();
+ }
+
+ /// 12-week window, then the hard caps (oldest first out).
+ fn prune(&mut self, now: i64) {
+ let cutoff = now - WINDOW_SECS;
+ self.history.turns.retain(|t| t.start >= cutoff);
+ self.history.decisions.retain(|d| d.date >= cutoff);
+ if self.history.turns.len() > MAX_TURNS {
+ self.history.turns.sort_by_key(|t| t.start);
+ let excess = self.history.turns.len() - MAX_TURNS;
+ self.history.turns.drain(..excess);
+ }
+ if self.history.decisions.len() > MAX_DECISIONS {
+ self.history.decisions.sort_by_key(|d| d.date);
+ let excess = self.history.decisions.len() - MAX_DECISIONS;
+ self.history.decisions.drain(..excess);
+ }
+ }
+
+ fn save(&self) {
+ if let Err(err) = write_history(&self.path, &self.history) {
+ note(format!("could not save the weekly recap history: {err}"));
+ }
+ }
+}
+
+// ── Reading and writing recap.json ────────────────────────────────────────────
+
+fn read_history(path: &Path) -> History {
+ let too_big = std::fs::metadata(path).is_ok_and(|m| m.len() > MAX_FILE_BYTES);
+ let bytes = if too_big {
+ None
+ } else {
+ match std::fs::read(path) {
+ Ok(bytes) => Some(bytes),
+ Err(err) if err.kind() == ErrorKind::NotFound => return History::default(),
+ Err(err) => {
+ note(format!("can't read {}: {err}", path.display()));
+ // Unreadable is not corrupt: leave it, and start over in memory.
+ // The first save will replace it, which only costs old counts.
+ return History::default();
+ }
+ }
+ };
+ if let Some(history) = bytes.and_then(|b| serde_json::from_slice::<History>(&b).ok()) {
+ return history;
+ }
+ // Keep the file as recap.json.corrupt-YYYYMMDD-HHMMSS, like the Mac.
+ let t = platform::local_time();
+ let aside = path.with_extension(format!(
+ "json.corrupt-{:04}{:02}{:02}-{:02}{:02}{:02}",
+ t.year, t.month, t.day, t.hour, t.minute, t.second
+ ));
+ match std::fs::rename(path, &aside) {
+ Ok(()) => note(format!("{} was not usable — kept as {}", path.display(), aside.display())),
+ Err(err) => note(format!("{} was not usable and could not be set aside: {err}", path.display())),
+ }
+ History::default()
+}
+
+/// Whole file to a temporary sibling, flushed, then renamed over the old one.
+fn write_history(path: &Path, history: &History) -> std::io::Result<()> {
+ if let Some(dir) = path.parent() {
+ platform::ensure_private_dir(dir)?;
+ }
+ let json = serde_json::to_vec(history)
+ .map_err(|e| std::io::Error::new(ErrorKind::InvalidData, e))?;
+ let temp = path.with_extension(format!("json.coucou-{}", std::process::id()));
+ let mut options = std::fs::OpenOptions::new();
+ options.write(true).create(true).truncate(true);
+ #[cfg(unix)]
+ std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
+ let written = options
+ .open(&temp)
+ .and_then(|mut file| {
+ file.write_all(&json)?;
+ file.sync_all()
+ })
+ .and_then(|()| std::fs::rename(&temp, path));
+ if written.is_err() {
+ let _ = std::fs::remove_file(&temp);
+ }
+ written
+}
+
+/// One line in coucou.log. Tests must never write to the real one.
+fn note(message: String) {
+ #[cfg(not(test))]
+ crate::log::line(message);
+ #[cfg(test)]
+ eprintln!("{message}");
+}
+
+// ── Reading a hook payload ────────────────────────────────────────────────────
+
+fn text<'a>(payload: &'a Value, key: &str) -> &'a str {
+ payload.get(key).and_then(Value::as_str).unwrap_or_default()
+}
+
+/// Same routing as hooks.ts: a valid `coucou_agent` → `agent_<name>`, anything
+/// else → the Claude Code pill. "claude" is reserved.
+fn agent_id(payload: &Value) -> String {
+ let raw = text(payload, "coucou_agent");
+ let valid = !raw.is_empty()
+ && raw.len() <= 24
+ && raw != "claude"
+ && raw.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'-');
+ if valid { format!("agent_{raw}") } else { "integration_claude".to_string() }
+}
+
+/// Concurrent sessions are tracked apart; one without an ID is keyed by its
+/// agent and folder, as HookServer.swift does.
+fn session_key(payload: &Value, agent: &str) -> String {
+ let id = text(payload, "session_id");
+ if id.is_empty() || id == "unknown" {
+ format!("{agent}+{}", text(payload, "cwd"))
+ } else {
+ id.to_string()
+ }
+}
+
+/// The working folder's last component — the only part of a path ever kept.
+fn project_name(cwd: &str) -> String {
+ let trimmed = cwd.trim_end_matches(['/', '\\']);
+ let last = trimmed.rsplit(['/', '\\']).next().unwrap_or_default();
+ clean_name(last)
+}
+
+fn clean_name(raw: &str) -> String {
+ raw.chars().filter(|c| !c.is_control()).take(MAX_NAME_CHARS).collect()
+}
+
+/// The file an Edit, MultiEdit or Write touched, with lines added and removed.
+fn file_change(tool: &str, input: &Value) -> Option<(String, u32, u32)> {
+ let path = input.get("file_path").and_then(Value::as_str)?;
+ let (added, removed) = match tool {
+ "Edit" => {
+ let old = input.get("old_string").and_then(Value::as_str)?;
+ let new = input.get("new_string").and_then(Value::as_str)?;
+ line_diff(old, new)
+ }
+ "MultiEdit" => {
+ let edits = input.get("edits").and_then(Value::as_array)?;
+ edits.iter().fold((0u32, 0u32), |(a, r), edit| {
+ let old = edit.get("old_string").and_then(Value::as_str).unwrap_or_default();
+ let new = edit.get("new_string").and_then(Value::as_str).unwrap_or_default();
+ let (da, dr) = line_diff(old, new);
+ (a.saturating_add(da), r.saturating_add(dr))
+ })
+ }
+ "Write" => {
+ let content = input.get("content").and_then(Value::as_str)?;
+ (count(split_lines(content).len()), 0)
+ }
+ _ => return None,
+ };
+ (added > 0 || removed > 0).then(|| (path.to_string(), added, removed))
+}
+
+fn count(n: usize) -> u32 {
+ n.min(u32::MAX as usize) as u32
+}
+
+/// DiffEngine.splitLines: CRLF → LF, no trailing empty line.
+fn split_lines(text: &str) -> Vec<&str> {
+ if text.is_empty() {
+ return Vec::new();
+ }
+ let mut lines: Vec<&str> = text.split('\n').map(|l| l.strip_suffix('\r').unwrap_or(l)).collect();
+ if lines.last() == Some(&"") {
+ lines.pop();
+ }
+ lines
+}
+
+/// Lines added and removed between `old` and `new`, from their longest common
+/// subsequence — the counts DiffEngine.fromEdit gives. Past its size limits
+/// every old line counts as removed and every new one as added.
+pub fn line_diff(old: &str, new: &str) -> (u32, u32) {
+ let a = split_lines(old);
+ let b = split_lines(new);
+ let fallback = (count(b.len()), count(a.len()));
+ if old.len() + new.len() > DIFF_MAX_BYTES
+ || a.len() + b.len() > DIFF_MAX_LINES
+ || a.len().saturating_mul(b.len()) > DIFF_MAX_CELLS
+ {
+ return fallback;
+ }
+ let mut prev = vec![0usize; b.len() + 1];
+ let mut row = vec![0usize; b.len() + 1];
+ for x in &a {
+ for (j, y) in b.iter().enumerate() {
+ row[j + 1] = if x == y { prev[j] + 1 } else { prev[j + 1].max(row[j]) };
+ }
+ std::mem::swap(&mut prev, &mut row);
+ }
+ let lcs = prev[b.len()];
+ (count(b.len() - lcs), count(a.len() - lcs))
+}
+
+fn is_week_key(week: &str) -> bool {
+ week.len() == 10
+ && week.bytes().enumerate().all(|(i, b)| if i == 4 || i == 7 { b == b'-' } else { b.is_ascii_digit() })
+}
+
+// ── Saving the shared image ───────────────────────────────────────────────────
+
+/// Standard base64, with or without a `data:…;base64,` prefix.
+fn decode_base64(data: &str) -> Option<Vec<u8>> {
+ let body = match data.split_once(',') {
+ Some((head, rest)) if head.starts_with("data:") => rest,
+ _ => data,
+ };
+ let mut out = Vec::with_capacity(body.len() / 4 * 3);
+ let mut acc = 0u32;
+ let mut bits = 0u32;
+ let mut padding = false;
+ for b in body.bytes() {
+ let v = match b {
+ b'A'..=b'Z' => b - b'A',
+ b'a'..=b'z' => b - b'a' + 26,
+ b'0'..=b'9' => b - b'0' + 52,
+ b'+' => 62,
+ b'/' => 63,
+ b'=' => {
+ padding = true;
+ continue;
+ }
+ b'\r' | b'\n' => continue,
+ _ => return None,
+ };
+ if padding {
+ return None;
+ }
+ acc = (acc << 6) | u32::from(v);
+ bits += 6;
+ if bits >= 8 {
+ bits -= 8;
+ out.push((acc >> bits) as u8);
+ acc &= (1 << bits) - 1;
+ }
+ }
+ Some(out)
+}
+
+const PNG_SIGNATURE: &[u8] = &[0x89, b'P', b'N', b'G', b'\r', b'\n', 0x1A, b'\n'];
+
+/// Writes `bytes` as `<stem>.png` in `dir`, or `<stem> (2).png`… when that name
+/// is taken. An existing file is never replaced.
+fn write_unique(dir: &Path, stem: &str, bytes: &[u8]) -> std::io::Result<PathBuf> {
+ for n in 1..1000 {
+ let name = if n == 1 { format!("{stem}.png") } else { format!("{stem} ({n}).png") };
+ let path = dir.join(name);
+ match std::fs::OpenOptions::new().write(true).create_new(true).open(&path) {
+ Ok(mut file) => {
+ let written = file.write_all(bytes).and_then(|()| file.sync_all());
+ drop(file);
+ if let Err(err) = written {
+ let _ = std::fs::remove_file(&path);
+ return Err(err);
+ }
+ return Ok(path);
+ }
+ Err(err) if err.kind() == ErrorKind::AlreadyExists => continue,
+ Err(err) => return Err(err),
+ }
+ }
+ Err(std::io::Error::new(ErrorKind::AlreadyExists, "too many recap images with this name"))
+}
+
+/// The PNG the page rendered, checked and written to the first pictures folder
+/// that exists.
+fn save_png(dirs: &[PathBuf], data: &str, week: &str) -> Result<PathBuf, String> {
+ if data.len() > MAX_PNG_BYTES / 3 * 4 + 64 {
+ return Err("The image is too large.".into());
+ }
+ let bytes = decode_base64(data).ok_or("The image could not be read.")?;
+ if !bytes.starts_with(PNG_SIGNATURE) {
+ return Err("The image could not be read.".into());
+ }
+ let dir = dirs.iter().find(|d| d.is_dir()).ok_or("No Pictures or Downloads folder to save into.")?;
+ let stem = if is_week_key(week) {
+ format!("Coucou weekly recap {week}")
+ } else {
+ "Coucou weekly recap".to_string()
+ };
+ write_unique(dir, &stem, &bytes).map_err(|err| format!("Could not save the image: {err}"))
+}
+
+// ── Tauri glue ────────────────────────────────────────────────────────────────
+
+pub struct Store(Mutex<Recap>);
+
+impl Store {
+ fn lock(&self) -> MutexGuard<'_, Recap> {
+ self.0.lock().unwrap_or_else(PoisonError::into_inner)
+ }
+}
+
+fn now() -> i64 {
+ SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
+}
+
+pub fn load() -> Store {
+ Store(Mutex::new(Recap::load(platform::local_dir().join("recap.json"), now())))
+}
+
+/// Called by the relay server for every hook event. An agent starting work is
+/// also one of the moments the Monday recap may show up.
+pub fn observe(app: &AppHandle, payload: &Value) {
+ if let Some(store) = app.try_state::<Store>() {
+ store.lock().observe(payload, now());
+ }
+ if matches!(text(payload, "hook_event_name"), "SessionStart" | "UserPromptSubmit") {
+ let _ = app.emit_to(WINDOW_LABEL, "recap-check", ());
+ }
+}
+
+pub fn note_request(app: &AppHandle, request_id: &str, payload: &Value) {
+ if let Some(store) = app.try_state::<Store>() {
+ store.lock().note_request(request_id, payload);
+ }
+}
+
+pub fn forget_request(app: &AppHandle, request_id: &str) {
+ if let Some(store) = app.try_state::<Store>() {
+ store.lock().forget_request(request_id);
+ }
+}
+
+pub fn record_decision(app: &AppHandle, request_id: &str, decision: &str) {
+ if let Some(store) = app.try_state::<Store>() {
+ store.lock().record_decision(request_id, decision, now());
+ }
+}
+
+#[tauri::command]
+pub fn recap_history(store: State<Store>, since: i64) -> HistoryView {
+ store.lock().view(since)
+}
+
+#[tauri::command]
+pub fn recap_prefs(store: State<Store>) -> Prefs {
+ store.lock().prefs().clone()
+}
+
+#[tauri::command]
+pub fn recap_set_enabled(store: State<Store>, enabled: bool) {
+ store.lock().set_enabled(enabled);
+}
+
+#[tauri::command]
+pub fn recap_set_hide_projects(store: State<Store>, hide: bool) {
+ store.lock().set_hide_projects(hide);
+}
+
+#[tauri::command]
+pub fn recap_mark_shown(store: State<Store>, week: String) {
+ store.lock().mark_shown(&week);
+}
+
+#[tauri::command]
+pub fn recap_clear(store: State<Store>) {
+ store.lock().clear();
+}
+
+/// `data` is the canvas's PNG as a data URL. Returns where it was written.
+#[tauri::command]
+pub fn recap_save_png(store: State<Store>, data: String, week: String) -> Result<String, String> {
+ let path = save_png(&platform::picture_dirs(), &data, &week)?;
+ let shown = path.to_string_lossy().to_string();
+ store.lock().last_saved = Some(path);
+ Ok(shown)
+}
+
+/// Opens the folder of the image saved last — never a path from the page.
+#[tauri::command]
+pub fn recap_reveal_saved(store: State<Store>) {
+ let dir = store.lock().last_saved.as_ref().and_then(|p| p.parent().map(Path::to_path_buf));
+ if let Some(dir) = dir {
+ platform::reveal_folder(&dir.to_string_lossy());
+ }
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ const HOUR: i64 = 3600;
+ /// Monday 5 October 2026, 00:00 UTC — the exact zone does not matter here.
+ const T0: i64 = 1_791_158_400;
+
+ fn scratch(name: &str) -> PathBuf {
+ let dir = std::env::temp_dir().join(format!("coucou-recap-{name}-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ std::fs::create_dir_all(&dir).unwrap();
+ dir
+ }
+
+ fn event(name: &str, session: &str, extra: Value) -> Value {
+ let mut v = json!({ "hook_event_name": name, "session_id": session, "cwd": "/home/me/code/coucou" });
+ if let (Some(obj), Value::Object(more)) = (v.as_object_mut(), extra) {
+ obj.extend(more);
+ }
+ v
+ }
+
+ fn on_disk(path: &Path) -> Value {
+ serde_json::from_slice(&std::fs::read(path).unwrap()).unwrap()
+ }
+
+ #[test]
+ fn a_turn_is_counted_from_prompt_to_stop() {
+ let dir = scratch("turn");
+ let file = dir.join("recap.json");
+ let mut r = Recap::load(file.clone(), T0);
+ r.observe(&event("UserPromptSubmit", "s1", json!({ "prompt": "secret plan" })), T0);
+ r.observe(&event("PreToolUse", "s1", json!({ "tool_name": "Bash", "tool_input": { "command": "rm -rf /tmp/x" } })), T0 + 10);
+ r.observe(&event("PreToolUse", "s1", json!({ "tool_name": "Read" })), T0 + 20);
+ r.observe(&event("PreToolUse", "s1", json!({ "tool_name": "AskUserQuestion" })), T0 + 25);
+ r.observe(&event("PostToolUse", "s1", json!({ "tool_name": "Edit", "tool_input": {
+ "file_path": "/home/me/code/coucou/a.rs", "old_string": "a\nb\nc", "new_string": "a\nB\nc\nd" } })), T0 + 30);
+ r.observe(&event("PostToolUse", "s1", json!({ "tool_name": "Write", "tool_input": {
+ "file_path": "/home/me/code/coucou/b.rs", "content": "one\ntwo\nthree\n" } })), T0 + 40);
+ r.observe(&event("PostToolUse", "s1", json!({ "tool_name": "Edit", "tool_input": {
+ "file_path": "/home/me/code/coucou/a.rs", "old_string": "x", "new_string": "y" } })), T0 + 50);
+ r.observe(&event("Stop", "s1", json!({})), T0 + HOUR);
+
+ let view = r.view(0);
+ assert_eq!(view.turns, vec![Turn {
+ agent: "integration_claude".into(),
+ project: "coucou".into(),
+ start: T0,
+ end: T0 + HOUR,
+ files_changed: 2,
+ lines_added: 2 + 3 + 1,
+ lines_removed: 1 + 1,
+ commands_run: 1,
+ questions: 1,
+ }]);
+
+ // Only counts and names reach the disk.
+ let written = std::fs::read_to_string(&file).unwrap();
+ for secret in ["secret plan", "rm -rf", "a.rs", "/home/me", "one\\ntwo"] {
+ assert!(!written.contains(secret), "{secret} must not be stored");
+ }
+ assert_eq!(on_disk(&file)["turns"][0]["project"], "coucou");
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn concurrent_sessions_and_agents_are_kept_apart() {
+ let dir = scratch("sessions");
+ let mut r = Recap::load(dir.join("recap.json"), T0);
+ r.observe(&event("UserPromptSubmit", "a", json!({})), T0);
+ r.observe(&event("UserPromptSubmit", "b", json!({ "coucou_agent": "gemini", "cwd": "C:\\Users\\me\\side-project\\" })), T0 + 60);
+ r.observe(&event("PreToolUse", "b", json!({ "coucou_agent": "gemini", "tool_name": "run_shell_command" })), T0 + 70);
+ r.observe(&event("Stop", "a", json!({})), T0 + 120);
+ r.observe(&event("Stop", "b", json!({ "coucou_agent": "gemini" })), T0 + 180);
+ let turns = r.view(0).turns;
+ assert_eq!(turns.len(), 2);
+ assert_eq!((turns[0].agent.as_str(), turns[0].commands_run), ("integration_claude", 0));
+ assert_eq!(turns[1].agent, "agent_gemini");
+ assert_eq!(turns[1].project, "side-project");
+ assert_eq!(turns[1].commands_run, 1);
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn invalid_or_reserved_agent_tags_fall_back_to_claude_code() {
+ for tag in ["claude", "Gemini", "has space", "a-very-long-agent-name-over-24"] {
+ assert_eq!(agent_id(&json!({ "coucou_agent": tag })), "integration_claude", "{tag}");
+ }
+ assert_eq!(agent_id(&json!({ "coucou_agent": "codex" })), "agent_codex");
+ }
+
+ #[test]
+ fn a_turn_silent_for_two_hours_ends_at_its_last_event() {
+ let dir = scratch("stale");
+ let mut r = Recap::load(dir.join("recap.json"), T0);
+ r.observe(&event("UserPromptSubmit", "s1", json!({})), T0);
+ r.observe(&event("PreToolUse", "s1", json!({ "tool_name": "Bash" })), T0 + 600);
+ // Next event, from another session, three hours later.
+ r.observe(&event("UserPromptSubmit", "s2", json!({})), T0 + 3 * HOUR);
+ let turns = r.view(0).turns;
+ assert_eq!(turns.len(), 1);
+ assert_eq!((turns[0].start, turns[0].end), (T0, T0 + 600));
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn decisions_are_recorded_with_the_agent_that_asked() {
+ let dir = scratch("decisions");
+ let mut r = Recap::load(dir.join("recap.json"), T0);
+ r.note_request("r1", &json!({ "coucou_agent": "codex" }));
+ r.record_decision("r1", "always", T0);
+ r.record_decision("unknown", "deny", T0 + 1);
+ r.record_decision("r3", "maybe", T0 + 2);
+ r.note_request("r4", &json!({}));
+ r.forget_request("r4");
+ let d = r.view(0).decisions;
+ assert_eq!(d.len(), 2);
+ assert_eq!((d[0].agent.as_str(), d[0].decision.as_str()), ("agent_codex", "allow"));
+ assert_eq!((d[1].agent.as_str(), d[1].decision.as_str()), ("integration_claude", "deny"));
+ assert!(r.requests.is_empty());
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn twelve_weeks_are_kept_and_older_entries_pruned() {
+ let dir = scratch("prune");
+ let file = dir.join("recap.json");
+ let mut r = Recap::load(file.clone(), T0);
+ let old = T0 - WINDOW_SECS - 1;
+ let edge = T0 - WINDOW_SECS;
+ for start in [old, edge, T0 - HOUR] {
+ r.history.turns.push(Turn {
+ agent: "integration_claude".into(), project: "p".into(), start, end: start + 60,
+ files_changed: 0, lines_added: 0, lines_removed: 0, commands_run: 0, questions: 0,
+ });
+ }
+ r.history.decisions.push(Decision { agent: "integration_claude".into(), date: old, decision: "allow".into() });
+ r.prune(T0);
+ r.save();
+ assert_eq!(r.view(0).turns.iter().map(|t| t.start).collect::<Vec<_>>(), [edge, T0 - HOUR]);
+ assert!(r.view(0).decisions.is_empty());
+ // Loading later prunes again.
+ let later = Recap::load(file, T0 + 2 * HOUR);
+ assert_eq!(later.view(0).turns.len(), 1);
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn the_history_never_grows_past_its_cap() {
+ let dir = scratch("cap");
+ let mut r = Recap::load(dir.join("recap.json"), T0);
+ for i in 0..(MAX_TURNS as i64 + 5) {
+ r.history.turns.push(Turn {
+ agent: "a".into(), project: "p".into(), start: T0 - i, end: T0,
+ files_changed: 0, lines_added: 0, lines_removed: 0, commands_run: 0, questions: 0,
+ });
+ }
+ r.prune(T0);
+ assert_eq!(r.history.turns.len(), MAX_TURNS);
+ // The oldest went.
+ assert_eq!(r.history.turns.first().unwrap().start, T0 - MAX_TURNS as i64 + 1);
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn names_are_cut_short_and_cleaned() {
+ let long = "x".repeat(200);
+ assert_eq!(project_name(&format!("/a/{long}")).chars().count(), MAX_NAME_CHARS);
+ assert_eq!(project_name("/a/b\u{7}c/"), "bc");
+ assert_eq!(project_name(""), "");
+ assert_eq!(project_name("C:\\work\\korus"), "korus");
+ }
+
+ #[test]
+ fn line_counts_match_the_diff_engine() {
+ assert_eq!(line_diff("a\nb\nc", "a\nb\nc"), (0, 0));
+ assert_eq!(line_diff("a\nb\nc", "a\nx\nc"), (1, 1));
+ assert_eq!(line_diff("", "a\nb\n"), (2, 0));
+ assert_eq!(line_diff("a\r\nb\r\n", "a\nb\nc\n"), (1, 0));
+ // Too big to diff: everything counts.
+ let big_old = "l\n".repeat(3000);
+ let big_new = "l\n".repeat(1500);
+ assert_eq!(line_diff(&big_old, &big_new), (1500, 3000));
+ assert_eq!(file_change("Read", &json!({ "file_path": "/x" })), None);
+ assert_eq!(file_change("Edit", &json!({ "file_path": "/x", "old_string": "a", "new_string": "a" })), None);
+ let multi = json!({ "file_path": "/x", "edits": [
+ { "old_string": "a", "new_string": "b" }, { "old_string": "", "new_string": "c\nd" } ] });
+ assert_eq!(file_change("MultiEdit", &multi), Some(("/x".into(), 3, 1)));
+ }
+
+ #[test]
+ fn a_disabled_history_records_nothing_and_clear_keeps_the_prefs() {
+ let dir = scratch("disabled");
+ let file = dir.join("recap.json");
+ let mut r = Recap::load(file.clone(), T0);
+ r.observe(&event("UserPromptSubmit", "s", json!({})), T0);
+ r.observe(&event("Stop", "s", json!({})), T0 + 60);
+ r.set_hide_projects(true);
+ r.mark_shown("2026-10-05");
+ r.mark_shown("not a week");
+ r.clear();
+ assert!(r.view(0).turns.is_empty());
+ let reloaded = Recap::load(file.clone(), T0);
+ assert_eq!(reloaded.prefs(), &Prefs { enabled: true, hide_projects: true, last_shown_week: "2026-10-05".into() });
+
+ r.set_enabled(false);
+ r.observe(&event("UserPromptSubmit", "s", json!({})), T0);
+ r.observe(&event("Stop", "s", json!({})), T0 + 60);
+ r.note_request("r", &json!({}));
+ r.record_decision("r", "allow", T0);
+ assert!(r.view(0).turns.is_empty() && r.view(0).decisions.is_empty());
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn a_corrupt_file_is_set_aside_and_writes_leave_nothing_behind() {
+ let dir = scratch("corrupt");
+ let file = dir.join("recap.json");
+ std::fs::write(&file, b"{ not json").unwrap();
+ let mut r = Recap::load(file.clone(), T0);
+ assert!(r.view(0).turns.is_empty());
+ let names = |d: &Path| -> Vec<String> {
+ let mut n: Vec<String> = std::fs::read_dir(d).unwrap()
+ .map(|e| e.unwrap().file_name().to_string_lossy().to_string()).collect();
+ n.sort();
+ n
+ };
+ let aside = names(&dir);
+ assert_eq!(aside.len(), 1);
+ assert!(aside[0].starts_with("recap.json.corrupt-"), "{aside:?}");
+ assert_eq!(std::fs::read(dir.join(&aside[0])).unwrap(), b"{ not json");
+
+ r.observe(&event("UserPromptSubmit", "s", json!({})), T0);
+ r.observe(&event("Stop", "s", json!({})), T0 + 60);
+ let mut expected = vec!["recap.json".to_string(), aside[0].clone()];
+ expected.sort();
+ assert_eq!(names(&dir), expected);
+ assert_eq!(on_disk(&file)["schemaVersion"], 1);
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn base64_round_trips_and_rejects_junk() {
+ assert_eq!(decode_base64("data:image/png;base64,aGVsbG8=").unwrap(), b"hello");
+ assert_eq!(decode_base64("aGk=").unwrap(), b"hi");
+ assert_eq!(decode_base64("YWJj").unwrap(), b"abc");
+ assert!(decode_base64("a$b").is_none());
+ assert!(decode_base64("aGk=aGk=").is_none());
+ }
+
+ #[test]
+ fn a_saved_image_never_replaces_an_existing_file() {
+ let dir = scratch("png");
+ let missing = dir.join("missing");
+ let png = "data:image/png;base64,iVBORw0KGgo=";
+ let first = save_png(&[missing.clone(), dir.clone()], png, "2026-10-05").unwrap();
+ let second = save_png(&[dir.clone()], png, "2026-10-05").unwrap();
+ assert_eq!(first, dir.join("Coucou weekly recap 2026-10-05.png"));
+ assert_eq!(second, dir.join("Coucou weekly recap 2026-10-05 (2).png"));
+ // The week is a date or nothing: no path tricks through it.
+ let third = save_png(&[dir.clone()], png, "../../x").unwrap();
+ assert_eq!(third, dir.join("Coucou weekly recap.png"));
+ // Not a PNG: refused.
+ assert!(save_png(&[dir.clone()], "data:image/png;base64,aGVsbG8=", "").is_err());
+ assert!(save_png(&[missing], png, "").is_err());
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+}
diff --git a/windows/src-tauri/src/tray.rs b/windows/src-tauri/src/tray.rs
index f6aa0c8f..5be80b18 100644
--- a/windows/src-tauri/src/tray.rs
+++ b/windows/src-tauri/src/tray.rs
@@ -1,4 +1,4 @@
-// Notification-area icon: Open, Settings, Pause, Quit.
+// Notification-area icon: Open, Weekly recap, Settings, Pause, Quit.
use tauri::menu::{Menu, MenuItem, PredefinedMenuItem};
use tauri::tray::TrayIconBuilder;
@@ -8,13 +8,14 @@ use crate::island::WINDOW_LABEL;
pub fn build(app: &AppHandle) -> tauri::Result<()> {
let open = MenuItem::with_id(app, "open", "Open Coucou", true, None::<&str>)?;
+ let recap = MenuItem::with_id(app, "recap", "Weekly recap", true, None::<&str>)?;
let settings = MenuItem::with_id(app, "settings", "Settings…", true, None::<&str>)?;
let pause = MenuItem::with_id(app, "pause", "Pause", true, None::<&str>)?;
let quit = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
let sep1 = PredefinedMenuItem::separator(app)?;
let sep2 = PredefinedMenuItem::separator(app)?;
- let menu = Menu::with_items(app, &[&open, &sep1, &settings, &pause, &sep2, &quit])?;
+ let menu = Menu::with_items(app, &[&open, &recap, &sep1, &settings, &pause, &sep2, &quit])?;
let mut builder = TrayIconBuilder::with_id("coucou")
.tooltip("Coucou")