fix(daemon): eliminate flakiness in daemon and wrapper-daemon test suites

src/authorship/rebase_authorship.rs

@@ -2863,13 +2863,28 @@ pub fn rewrite_authorship_after_commit_amend_with_snapshot(
     let touched_files = working_log.all_touched_files()?;
     pathspecs.extend(touched_files);
 
-    // Check if original commit has an authorship log with prompts or humans
-    let has_existing_log = get_reference_as_authorship_log_v3(repo, original_commit).is_ok();
-    let has_existing_data = if has_existing_log {
-        let original_log = get_reference_as_authorship_log_v3(repo, original_commit).unwrap();
-        !original_log.metadata.prompts.is_empty() || !original_log.metadata.humans.is_empty()
-    } else {
-        false
+    // Check if original commit has an authorship log with prompts or humans.
+    // Under heavy I/O the note written by a prior command's side-effect pipeline
+    // may be transiently unreadable (loose object not yet visible to a new git
+    // subprocess, or notes ref update still in flight).  Retry briefly before
+    // falling back to the no-existing-data path.
+    let (has_existing_log, has_existing_data) = {
+        let mut found_log = false;
+        let mut found_data = false;
+        for attempt in 0..=20 {
+            if let Ok(original_log) =
+                get_reference_as_authorship_log_v3(repo, original_commit)
+            {
+                found_log = true;
+                found_data = !original_log.metadata.prompts.is_empty()
+                    || !original_log.metadata.humans.is_empty();
+                break;
+            }
+            if attempt < 20 {
+                std::thread::sleep(std::time::Duration::from_millis(25));
+            }
+        }
+        (found_log, found_data)
     };
 
     // Phase 1: Load all attributions (committed + uncommitted)

src/commands/daemon.rs

@@ -175,7 +175,18 @@ fn handle_run(args: &[String]) -> Result<(), String> {
             e
         )
     })?;
+    // Ensure at least 4 Tokio worker threads regardless of CPU count.
+    // The daemon runs concurrent tasks (ingest worker, per-family drain
+    // workers, applied-path handlers, control API) that all need async
+    // thread pool access.  On 2-core machines the default of 2 threads
+    // causes starvation when the ingest worker blocks during normalizer
+    // I/O and drain workers compete for the remaining thread.
+    let worker_threads = std::thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(4)
+        .max(4);
     let runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(worker_threads)
         .enable_all()
         .build()
         .map_err(|e| e.to_string())?;

src/commands/git_handlers.rs

@@ -175,9 +175,49 @@ pub fn handle_git(args: &[String]) {
 
         let exit_status = proxy_to_git(args, false, None, Some(&invocation_id));
 
-        let post_state = worktree
+        let mut post_state = worktree
             .as_deref()
             .and_then(crate::git::repo_state::read_head_state_for_worktree);
+        // Under heavy I/O the ref file may be transiently unresolvable.
+        // Retry so the daemon overlay receives a valid HEAD OID.
+        if post_state.as_ref().is_none_or(|s| s.head.is_none()) {
+            for _ in 0..25 {
+                std::thread::sleep(std::time::Duration::from_millis(20));
+                post_state = worktree
+                    .as_deref()
+                    .and_then(crate::git::repo_state::read_head_state_for_worktree);
+                if post_state.as_ref().is_some_and(|s| s.head.is_some()) {
+                    break;
+                }
+            }
+        }
+        // Last resort: use git rev-parse HEAD subprocess.
+        if post_state.as_ref().is_none_or(|s| s.head.is_none()) {
+            if let Some(wt) = worktree.as_deref() {
+                if let Ok(output) = std::process::Command::new("git")
+                    .args(["rev-parse", "HEAD"])
+                    .current_dir(wt)
+                    .stdout(std::process::Stdio::piped())
+                    .stderr(std::process::Stdio::null())
+                    .output()
+                {
+                    let oid = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    if output.status.success()
+                        && crate::git::repo_state::is_valid_git_oid(&oid)
+                    {
+                        let (branch, detached) = post_state
+                            .as_ref()
+                            .map(|s| (s.branch.clone(), s.detached))
+                            .unwrap_or((None, false));
+                        post_state = Some(crate::git::repo_state::HeadState {
+                            head: Some(oid),
+                            branch,
+                            detached,
+                        });
+                    }
+                }
+            }
+        }
 
         send_wrapper_post_state_to_daemon(&invocation_id, worktree.as_deref(), &post_state);