Function execute_plan

src/daemon/git_watch.rs:573–665

Executes one coalesced debounce cycle: proactively track new worktrees, sync affected branches / the current branch, and mark GC eligibility.

(
    inner: &Arc<GitWatcherInner>,
    state: &Arc<WatchState>,
    common: &Path,
    plan: DirtyPlan,
)

/// Executes one coalesced debounce cycle: proactively track new worktrees, sync
/// affected branches / the current branch, and mark GC eligibility.
async fn execute_plan(
    inner: &Arc<GitWatcherInner>,
    state: &Arc<WatchState>,
    common: &Path,
    plan: DirtyPlan,
) {
    let root = &state.project_root;
    let opts = TraceDecayOpenOptions::default();

    // 1. Proactively track newly-created linked worktrees.
    for name in &plan.new_worktrees {
        if let Some((wt_root, branch)) = resolve_worktree(common, name) {
            let _permit = inner.sync_semaphore.acquire().await;
            match track_worktree_branch(wt_root.clone(), branch.clone()).await {
                Some(outcome) => {
                    log_daemon_event(
                        "git_watch_synced",
                        &[
                            ("project", root.display().to_string()),
                            ("action", "worktree_tracked".to_string()),
                            ("worktree", wt_root.display().to_string()),
                            ("branch", branch),
                            ("outcome", outcome),
                        ],
                    );
                }
                None => log_daemon_event(
                    "git_watch_degraded",
                    &[
                        ("project", root.display().to_string()),
                        ("reason", "worktree_track_failed".to_string()),
                    ],
                ),
            }
        }
    }

    // 2. Sync the CURRENT branch's store (HEAD move / general dirtiness).
    //
    //    `sync_project` opens the project root, which resolves to whichever
    //    branch HEAD currently points at, and diffs against the working tree.
    //    It therefore can only refresh the checked-out branch's store — a
    //    ref update to a tracked-but-not-checked-out branch (e.g. `git fetch`
    //    advancing `refs/heads/feature` while on `main`, or a branch moved in
    //    another worktree) has no working tree here to diff against, so its own
    //    store cannot be incrementally synced from this checkout. Those stores
    //    recover on the next on-read sync (when that branch is checked out /
    //    opened) or via the backstop. We only report the branch we actually
    //    refreshed, so the log never claims a sync that did not happen.
    let current_branch = if plan.dirty {
        crate::branch::current_branch(root)
    } else {
        None
    };
    // Non-current tracked branches whose refs changed: recorded but NOT synced
    // here (see above). Kept distinct from `current_branch` for honest logging.
    let other_changed_branches: Vec<String> = plan
        .branches