fix(daemon): recover stale serial locks

crates/fbuild-build/tests/cache_survives_tar_extract.rs

@@ -172,9 +172,10 @@ fn compiler_signature_survives_toolchain_path_change() {
     let flags = vec!["-O2".to_string(), "-DFOO=1".to_string()];
     let pre_flags = vec!["-Wall".to_string()];
     let extra_flags = vec!["-I/some/include".to_string()];
+    let build_unflags: Vec<String> = Vec::new();
 
-    let sig_a = build_rebuild_signature(&path_a, &flags, &pre_flags, &extra_flags);
-    let sig_b = build_rebuild_signature(&path_b, &flags, &pre_flags, &extra_flags);
+    let sig_a = build_rebuild_signature(&path_a, &flags, &pre_flags, &extra_flags, &build_unflags);
+    let sig_b = build_rebuild_signature(&path_b, &flags, &pre_flags, &extra_flags, &build_unflags);
 
     assert_eq!(
         sig_a, sig_b,
@@ -184,7 +185,7 @@ fn compiler_signature_survives_toolchain_path_change() {
 
     let alt_filename = if cfg!(windows) { "clang.exe" } else { "clang" };
     let path_c = toolchain_a.path().join(alt_filename);
-    let sig_c = build_rebuild_signature(&path_c, &flags, &pre_flags, &extra_flags);
+    let sig_c = build_rebuild_signature(&path_c, &flags, &pre_flags, &extra_flags, &build_unflags);
     assert_ne!(
         sig_a, sig_c,
         "build_rebuild_signature collapsed two different compilers to the same signature; \

crates/fbuild-cli/src/cli/args.rs

@@ -729,7 +729,23 @@ pub enum DaemonAction {
     /// Show lock status (project locks, serial sessions)
     Locks,
     /// Clear stale locks
-    ClearLocks,
+    ClearLocks {
+        /// Include serial sessions in stale lock cleanup
+        #[arg(long)]
+        serial: bool,
+        /// Close only sessions that the daemon can classify as stale
+        #[arg(long)]
+        stale: bool,
+        /// Target a serial session by port (for example COM11 or /dev/ttyUSB0)
+        #[arg(long)]
+        port: Option<String>,
+        /// Target a serial session by client id
+        #[arg(long = "client-id")]
+        client_id: Option<String>,
+        /// Close a targeted live serial session; requires --port or --client-id
+        #[arg(long)]
+        force: bool,
+    },
     /// Show disk cache statistics
     CacheStats,
     /// Run disk cache garbage collection

crates/fbuild-cli/src/cli/daemon_cmd.rs

@@ -111,8 +111,21 @@ pub async fn run_daemon(action: DaemonAction) -> fbuild_core::Result<()> {
         DaemonAction::Locks => {
             run_daemon_locks(&client).await?;
         }
-        DaemonAction::ClearLocks => {
-            run_daemon_clear_locks(&client).await?;
+        DaemonAction::ClearLocks {
+            serial,
+            stale,
+            port,
+            client_id,
+            force,
+        } => {
+            let request = daemon_client::ClearLocksRequest {
+                serial,
+                stale,
+                port,
+                client_id,
+                force,
+            };
+            run_daemon_clear_locks(&client, request).await?;
         }
         DaemonAction::CacheStats => {
             run_daemon_cache_stats(&client).await?;
@@ -347,9 +360,64 @@ pub async fn run_daemon_locks(client: &DaemonClient) -> fbuild_core::Result<()>
         for lock in &status.port_locks {
             let state = if lock.is_held { "HELD" } else { "FREE" };
             let writer = lock.writer_client_id.as_deref().unwrap_or("none");
+            let owner = lock.owner_client_id.as_deref().unwrap_or("none");
             output::result(format!(
-                "  {} [{}] open={} writer={} readers={}",
-                lock.port, state, lock.is_open, writer, lock.reader_count
+                "  {} [{}] open={} baud={} owner={} writer={} readers={} age={} last_activity={} rx={} tx={}",
+                lock.port,
+                state,
+                lock.is_open,
+                lock.baud_rate,
+                owner,
+                writer,
+                lock.reader_count,
+                format_age_seconds(lock.session_age_seconds),
+                format_age_seconds(lock.last_activity_age_seconds),
+                lock.total_bytes_read,
+                lock.total_bytes_written
+            ));
+            if let Some(age) = lock.last_read_age_seconds {
+                output::result(format!("    last_read: {}", format_age_seconds(age)));
+            }
+            if let Some(age) = lock.last_write_age_seconds {
+                output::result(format!("    last_write: {}", format_age_seconds(age)));
+            }
+            for client in &lock.clients {
+                let pid = client
+                    .pid
+                    .map(|pid| pid.to_string())
+                    .unwrap_or_else(|| "unknown".to_string());
+                let alive = client
+                    .process_alive
+                    .map(|alive| if alive { "alive" } else { "dead" })
+                    .unwrap_or("unknown");
+                output::result(format!(
+                    "    client {} pid={} ({})",
+                    client.client_id, pid, alive
+                ));
+                if let Some(exe) = &client.exe {
+                    output::result(format!("      exe: {}", exe));
+                }
+                if let Some(cwd) = &client.cwd {
+                    output::result(format!("      cwd: {}", cwd));
+                }
+                if let Some(argv) = &client.argv {
+                    if !argv.is_empty() {
+                        output::result(format!("      argv: {}", argv.join(" ")));
+                    }
+                }
+            }
+        }
+    }
+
+    if !status.pending_serial_attaches.is_empty() {
+        output::result("Pending Serial Attaches:");
+        for pending in &status.pending_serial_attaches {
+            output::result(format!(
+                "  #{} port={} client={} age={}",
+                pending.id,
+                pending.port.as_deref().unwrap_or("unknown"),
+                pending.client_id.as_deref().unwrap_or("unknown"),
+                format_age_seconds(pending.age_seconds)
             ));
         }
     }
@@ -375,17 +443,35 @@ pub async fn run_daemon_locks(client: &DaemonClient) -> fbuild_core::Result<()>
     Ok(())
 }
 
-pub async fn run_daemon_clear_locks(client: &DaemonClient) -> fbuild_core::Result<()> {
+pub async fn run_daemon_clear_locks(
+    client: &DaemonClient,
+    request: daemon_client::ClearLocksRequest,
+) -> fbuild_core::Result<()> {
     if !client.health().await {
         output::result("daemon is not running");
         return Ok(());
     }
 
-    let result = client.clear_locks().await?;
+    let result = client.clear_locks_with(&request).await?;
     output::result(&result.message);
     if result.cleared_count > 0 {
         output::result(format!("Cleared {} lock(s)", result.cleared_count));
     }
+    if result.cleared_project_count > 0 {
+        output::result(format!(
+            "Cleared {} project lock(s)",
+            result.cleared_project_count
+        ));
+    }
+    if result.cleared_serial_count > 0 {
+        output::result(format!(
+            "Cleared serial sessions: {}",
+            result.cleared_serial_sessions.join(", ")
+        ));
+    }
+    for refusal in result.refused {
+        output::warn(refusal);
+    }
     Ok(())
 }
 
@@ -688,3 +774,7 @@ pub fn format_uptime(seconds: f64) -> String {
         format!("{}h {}m", secs / 3600, (secs % 3600) / 60)
     }
 }
+
+fn format_age_seconds(seconds: f64) -> String {
+    format_uptime(seconds.max(0.0))
+}

crates/fbuild-cli/src/daemon_client.rs

@@ -546,9 +546,18 @@ impl DaemonClient {
 
     /// Clear stale locks on the daemon.
     pub async fn clear_locks(&self) -> fbuild_core::Result<ClearLocksResponse> {
+        self.clear_locks_with(&ClearLocksRequest::default()).await
+    }
+
+    /// Clear stale locks on the daemon with targeting options.
+    pub async fn clear_locks_with(
+        &self,
+        request: &ClearLocksRequest,
+    ) -> fbuild_core::Result<ClearLocksResponse> {
         let resp = self
             .client
             .post(format!("{}/api/locks/clear", self.base_url))
+            .json(request)
             .timeout(fbuild_core::time::MEDIUM_HTTP_TIMEOUT)
             .send()
             .await

crates/fbuild-cli/src/daemon_client/types.rs

@@ -227,6 +227,8 @@ pub struct LockStatusResponse {
     pub success: bool,
     pub port_locks: Vec<PortLockInfo>,
     pub project_locks: Vec<ProjectLockInfo>,
+    #[serde(default)]
+    pub pending_serial_attaches: Vec<PendingSerialAttachInfo>,
     pub stale_locks: Vec<String>,
 }
 
@@ -237,8 +239,70 @@ pub struct PortLockInfo {
     #[allow(dead_code)]
     pub holder_description: Option<String>,
     pub is_open: bool,
+    #[serde(default)]
+    pub owner_client_id: Option<String>,
     pub writer_client_id: Option<String>,
     pub reader_count: usize,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub reader_client_ids: Vec<String>,
+    #[serde(default)]
+    pub baud_rate: u32,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub started_at: f64,
+    #[serde(default)]
+    pub session_age_seconds: f64,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub last_activity_at: f64,
+    #[serde(default)]
+    pub last_activity_age_seconds: f64,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub last_read_at: Option<f64>,
+    #[serde(default)]
+    pub last_read_age_seconds: Option<f64>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub last_write_at: Option<f64>,
+    #[serde(default)]
+    pub last_write_age_seconds: Option<f64>,
+    #[serde(default)]
+    pub total_bytes_read: u64,
+    #[serde(default)]
+    pub total_bytes_written: u64,
+    #[serde(default)]
+    pub clients: Vec<SerialClientLockInfo>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct SerialClientLockInfo {
+    pub client_id: String,
+    #[serde(default)]
+    pub pid: Option<u32>,
+    #[serde(default)]
+    pub process_alive: Option<bool>,
+    #[serde(default)]
+    pub exe: Option<String>,
+    #[serde(default)]
+    pub cwd: Option<String>,
+    #[serde(default)]
+    pub argv: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct PendingSerialAttachInfo {
+    pub id: u64,
+    #[serde(default)]
+    pub client_id: Option<String>,
+    #[serde(default)]
+    pub port: Option<String>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    pub started_at: f64,
+    #[serde(default)]
+    pub age_seconds: f64,
 }
 
 #[derive(Debug, Deserialize)]
@@ -247,11 +311,33 @@ pub struct ProjectLockInfo {
     pub is_held: bool,
 }
 
+#[derive(Debug, Default, Serialize)]
+pub struct ClearLocksRequest {
+    #[serde(default)]
+    pub serial: bool,
+    #[serde(default)]
+    pub stale: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub port: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default)]
+    pub force: bool,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct ClearLocksResponse {
     #[allow(dead_code)]
     pub success: bool,
     pub cleared_count: usize,
+    #[serde(default)]
+    pub cleared_project_count: usize,
+    #[serde(default)]
+    pub cleared_serial_count: usize,
+    #[serde(default)]
+    pub cleared_serial_sessions: Vec<String>,
+    #[serde(default)]
+    pub refused: Vec<String>,
     pub message: String,
 }