chore(#1474): add reason= to remaining bare clippy allows outside dashboard

hive-c0re/src/actions.rs

@@ -423,7 +423,11 @@ fn finish_approval(
 /// and reset the working tree back to the last known-good main. main
 /// never advances on a failed build, so a crash-and-recover doesn't
 /// leave the agent pointing at a tree it can't evaluate.
-#[allow(clippy::too_many_lines)] // sequential build/tag/notify pipeline; splitting would obscure the flow
+#[allow(
+    clippy::too_many_lines,
+    reason = "one sequential build/tag/notify pipeline; splitting the steps \
+              across helpers would obscure the linear flow without shrinking it"
+)]
 async fn run_apply_commit(
     coord: &Arc<Coordinator>,
     approval: &hive_sh4re::Approval,

hive-c0re/src/agent_server.rs

@@ -113,7 +113,11 @@ pub(crate) fn recv_timeout(wait_seconds: Option<u64>) -> std::time::Duration {
     }
 }
 
-#[allow(clippy::too_many_lines)]
+#[allow(
+    clippy::too_many_lines,
+    reason = "flat dispatch table: one match arm per shared request variant; \
+              splitting it would scatter the routing logic without shrinking it"
+)]
 /// Handle the subset of `Request` variants that are identical on both
 /// the agent socket and the manager socket. Returns `Some(response)` for
 /// every variant it handles; returns `None` for variants with socket-specific
@@ -301,7 +305,11 @@ pub(crate) async fn dispatch_shared(
     })
 }
 
-#[allow(clippy::too_many_lines)]
+#[allow(
+    clippy::too_many_lines,
+    reason = "flat dispatch table: one match arm per agent-socket request \
+              variant; splitting it would scatter the routing logic"
+)]
 async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) -> AgentResponse {
     if let Some(resp) = dispatch_shared(req, agent, coord).await {
         return resp;
@@ -553,7 +561,11 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
 ///
 /// The manager is not exempt - grant `read_host_journal` in
 /// `meta/capabilities.json` to enable it for any agent including the manager.
-#[allow(clippy::too_many_arguments)]
+#[allow(
+    clippy::too_many_arguments,
+    reason = "args mirror the GetHostJournal wire variant 1:1 at this single \
+              call site; a params struct would just relabel the same fields"
+)]
 pub async fn dispatch_host_journal(
     agent: &str,
     unit: &Option<String>,

hive-c0re/src/coordinator.rs

@@ -652,7 +652,11 @@ impl Coordinator {
     /// already have an authoritative timestamp from the db update,
     /// the tiny skew between "row updated" and "event emitted" is
     /// presentation-only and doesn't matter to clients.
-    #[allow(clippy::too_many_arguments)]
+    #[allow(
+        clippy::too_many_arguments,
+        reason = "args mirror the approval-resolved event payload fields; \
+                  bundling them into a struct used only here adds no clarity"
+    )]
     pub fn emit_approval_resolved(
         &self,
         id: i64,
@@ -685,7 +689,11 @@ impl Coordinator {
     /// both operator-targeted (`target = None`) and peer-to-peer
     /// (`target = Some(agent)`) threads — the dashboard surfaces
     /// both, distinguishing visually + offering operator override.
-    #[allow(clippy::too_many_arguments)]
+    #[allow(
+        clippy::too_many_arguments,
+        reason = "args mirror the question-added event payload fields; \
+                  bundling them into a struct used only here adds no clarity"
+    )]
     pub fn emit_question_added(
         &self,
         id: i64,

hive-c0re/src/lifecycle.rs

@@ -1128,7 +1128,11 @@ fn bind_child_agent_dirs(child: &str, binds: &mut Vec<BindMount>) {
     });
 }
 
-#[allow(clippy::too_many_lines)]
+#[allow(
+    clippy::too_many_lines,
+    reason = "one contiguous nspawn-flag assembly block; the length is the flag \
+              surface itself, splitting it would just hide the shape"
+)]
 async fn set_nspawn_flags(
     container: &str,
     runtime_dir: &Path,

hive-c0re/src/manager_server.rs

@@ -74,7 +74,11 @@ async fn serve(stream: UnixStream, coord: Arc<Coordinator>) -> Result<()> {
     }
 }
 
-#[allow(clippy::too_many_lines)]
+#[allow(
+    clippy::too_many_lines,
+    reason = "flat dispatch table: one match arm per manager-socket request \
+              variant; splitting it would scatter the routing logic"
+)]
 async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResponse {
     // Delegate all variants shared with the agent socket to the common handler.
     if let Some(resp) = crate::agent_server::dispatch_shared(req, MANAGER_AGENT, coord).await {
@@ -664,7 +668,11 @@ async fn handle_fire_schedule_now(
 /// zero-interval validation. Returns `Ok` on a clean update;
 /// `Err` with the underlying message on any auth / validation
 /// failure so the dashboard can surface it verbatim.
-#[allow(clippy::too_many_arguments)]
+#[allow(
+    clippy::too_many_arguments,
+    reason = "args mirror the edit-schedule PATCH fields 1:1; bundling them into \
+              a struct used only here adds no clarity"
+)]
 #[allow(
     clippy::option_option,
     reason = "double-Option carries three-state PATCH semantics: outer None = \

hive-c0re/src/rebuild_queue.rs

@@ -366,7 +366,11 @@ impl RebuildQueue {
     // four kind-specific payload fields (inputs, approval_id, perm_payload,
     // depends_on). A builder struct would obscure the call sites; the
     // shorter wrappers already cover all common cases.
-    #[allow(clippy::too_many_arguments)]
+    #[allow(
+        clippy::too_many_arguments,
+        reason = "args mirror the queue-entry fields the row is built from; the \
+                  thinner enqueue helpers wrap this for the common cases"
+    )]
     pub fn enqueue_full(
         &self,
         kind: QueueKind,

hive-c0re/src/server.rs

@@ -73,7 +73,11 @@ async fn handle(stream: UnixStream, coord: Arc<Coordinator>) -> Result<()> {
     }
 }
 
-#[allow(clippy::too_many_lines)]
+#[allow(
+    clippy::too_many_lines,
+    reason = "flat dispatch table: one match arm per host-socket request \
+              variant; splitting it would scatter the routing logic"
+)]
 async fn dispatch(req: &HostRequest, coord: Arc<Coordinator>) -> HostResponse {
     let result: anyhow::Result<HostResponse> = async {
         Ok(match req {