// TODO: start watch once loaded?
    let (fs_watch_tx, fs_watch_rx) = watch::channel(());
    let mut fs_watch = new_debouncer(
        Duration::from_secs(1),
        None,
        move |result: DebounceEventResult| match result {
            Ok(events) => events.iter().for_each(|event| {
                // TODO: distinguish ".pijul" changes
                // dbg!(event);
                if event.kind.is_create()
                    || event.kind.is_modify()
                    || event.kind.is_remove()
                {
                    let _ = fs_watch_tx.send(());
                }
            }),
            Err(errors) => {
                errors.iter().for_each(|error| eprintln!("{error:?}"))
            }
        },
    )
    .unwrap();
    fs_watch
        .watch(&repo_path, RecursiveMode::Recursive)
        .unwrap();
    let fs_watch_rx = WatchStream::from_changes(fs_watch_rx);
    let watch_task = Task::run(fs_watch_rx, |()| {
        Message::ToRepo(repo::MsgIn::RefreshChangedAndUntrackedFiles)
    });

    let repo_path_clone = repo_path.clone();

        repo::manage(repo_path, repo_rx_in, repo_tx_out).await;

        repo::manage(repo_path_clone, repo_rx_in, repo_tx_out).await;

    let tasks = Task::batch([watch_task, repo_task, repo_msg_out_task]);

    let tasks = Task::batch([repo_task, repo_msg_out_task]);

            _fs_watch: fs_watch,

            repo_fs_watch: None,
            repo_path,

    _fs_watch: Debouncer<RecommendedWatcher, RecommendedCache>,

    repo_fs_watch: Option<Debouncer<RecommendedWatcher, RecommendedCache>>,
    repo_path: PathBuf,

            Task::none()

            // Start watching the repo's dir for changes
            let (fs_watch_tx, fs_watch_rx) = watch::channel(());
            let mut fs_watch = new_debouncer(
                Duration::from_secs(1),
                None,
                move |result: DebounceEventResult| match result {
                    Ok(events) => events.iter().for_each(|event| {
                        // TODO: distinguish ".pijul" changes
                        // dbg!(event);
                        if event.kind.is_create()
                            || event.kind.is_modify()
                            || event.kind.is_remove()
                        {
                            let _ = fs_watch_tx.send(());
                        }
                    }),
                    Err(errors) => {
                        errors.iter().for_each(|error| eprintln!("{error:?}"))
                    }
                },
            )
            .unwrap();
            fs_watch
                .watch(&state.repo_path, RecursiveMode::Recursive)
                .unwrap();
            let fs_watch_rx = WatchStream::from_changes(fs_watch_rx);
            let watch_task = Task::run(fs_watch_rx, |()| {
                Message::ToRepo(repo::MsgIn::RefreshChangedAndUntrackedFiles)
            });
            state.repo_fs_watch = Some(fs_watch);
            watch_task