Function classify_and_mark

src/daemon/git_watch.rs:456–496

Translates a raw notify event into dirty-set marks. Does NOT re-derive git state — it only records *what kind of path changed* so the debounce drain can resolve the actual git state once, after quiescence.

(state: &Arc<WatchState>, event: &notify::Event)

/// state — it only records *what kind of path changed* so the debounce drain
/// can resolve the actual git state once, after quiescence.
fn classify_and_mark(state: &Arc<WatchState>, event: &notify::Event) {
    let is_remove = matches!(event.kind, EventKind::Remove(_));
    let is_create = matches!(event.kind, EventKind::Create(_));

    // Cheap synchronous classification into the dirty set. We use `try_lock` to
    // stay non-blocking in the notify thread; on contention we still wake the
    // loop, which rechecks git state anyway, so no event is lost.
    if let Ok(mut dirty) = state.dirty.try_lock() {
        let now = Instant::now();
        dirty.dirty = true;
        if dirty.first_event.is_none() {
            dirty.first_event = Some(now);
        }
        dirty.last_event = Some(now);

        for path in &event.paths {
            let s = path.to_string_lossy();
            if let Some(idx) = s.find("/refs/heads/") {
                let branch = &s[idx + "/refs/heads/".len()..];
                if !branch.is_empty() {
                    dirty.branches.insert(branch.to_string());
                }
                if is_remove {
                    dirty.gc_eligible = true;
                }
            } else if let Some(idx) = s.find("/worktrees/") {
                let rest = &s[idx + "/worktrees/".len()..];
                let name = rest.split('/').next().unwrap_or("");
                if !name.is_empty() {
                    if is_create {
                        dirty.new_worktrees.insert(name.to_string());
                    }
                    if is_remove {
                        dirty.gc_eligible = true;
                    }
                }
            }
        }
    }
    state.wake.notify_one();
}

/// The debounce state machine for a healthy watcher. Wakes on events, sleeps
/// until the quiet deadline or the hard cap (whichever comes first), then