refactor: single now_unix in hive_sh4re::wire_time

replaces 15 per-module copies (now_unix/now_secs) across hive-c0re and
hive-ag3nt; wire_time already owns the epoch-seconds convention

hive-c0re/src/approvals.rs

@@ -4,11 +4,11 @@
 
 use std::path::Path;
 use std::sync::Mutex;
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context, Result, bail};
 use hive_sh4re::{Approval, ApprovalKind, ApprovalStatus};
 use rusqlite::{Connection, OptionalExtension, params};
+use hive_sh4re::wire_time::now_unix;
 
 const SCHEMA: &str = r"
 CREATE TABLE IF NOT EXISTS approvals (
@@ -380,13 +380,6 @@ fn kind_from_str(s: &str) -> Result<ApprovalKind> {
     })
 }
 
-fn now_unix() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {

hive-c0re/src/audit_log.rs

@@ -21,13 +21,13 @@
 
 use std::path::Path;
 use std::sync::{Arc, Mutex, OnceLock};
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context, Result};
 
 use chrono::{DateTime, Utc};
 use rusqlite::{Connection, params};
 use serde::Serialize;
+use hive_sh4re::wire_time::now_unix;
 
 /// Process-singleton handle, set once at coordinator startup. Mirrors
 /// `build_logs::GLOBAL` — lets recording sites write without threading an
@@ -148,7 +148,7 @@ impl AuditLog {
         outcome: AuditOutcome,
         detail: Option<&str>,
     ) -> Option<AuditEntry> {
-        let now = now_secs();
+        let now = now_unix();
         let conn = self.conn.lock().unwrap();
         match conn.execute(
             "INSERT INTO audit_log (ts_unix, agent, action, target, outcome, detail)
@@ -215,7 +215,7 @@ impl AuditLog {
     /// # Errors
     /// Returns an error if the `DELETE` query fails.
     pub fn vacuum(&self) -> Result<u64> {
-        let cutoff = now_secs() - KEEP_SECS;
+        let cutoff = now_unix() - KEEP_SECS;
         let conn = self.conn.lock().unwrap();
         let removed = conn.execute("DELETE FROM audit_log WHERE ts_unix < ?1", params![cutoff])?;
         Ok(u64::try_from(removed).unwrap_or(0))
@@ -259,13 +259,6 @@ fn row_to_entry(r: &rusqlite::Row) -> rusqlite::Result<AuditEntry> {
     })
 }
 
-fn now_secs() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {
@@ -326,7 +319,7 @@ mod tests {
             let conn = db.conn.lock().unwrap();
             conn.execute(
                 "UPDATE audit_log SET ts_unix = ?1",
-                params![now_secs() - KEEP_SECS - 60],
+                params![now_unix() - KEEP_SECS - 60],
             )
             .unwrap();
         }

hive-c0re/src/broker.rs

@@ -4,7 +4,6 @@
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
 use std::sync::Mutex;
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context, Result};
 
@@ -13,6 +12,7 @@ use hive_sh4re::{InboxRow, Message};
 use rusqlite::{Connection, OptionalExtension, params};
 use serde::Serialize;
 use tokio::sync::broadcast;
+use hive_sh4re::wire_time::now_unix;
 
 const SCHEMA: &str = r"
 CREATE TABLE IF NOT EXISTS messages (
@@ -1136,13 +1136,6 @@ fn ensure_reminder_columns(conn: &Connection) -> Result<()> {
     )
 }
 
-fn now_unix() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {

hive-c0re/src/build_logs.rs

@@ -5,12 +5,12 @@
 
 use std::path::Path;
 use std::sync::{Arc, Mutex, OnceLock};
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context, Result};
 use rusqlite::{Connection, OptionalExtension, params};
 use serde::Serialize;
 use tokio::sync::broadcast;
+use hive_sh4re::wire_time::now_unix;
 
 /// Process-singleton handle, set once at coordinator startup. Lets
 /// the `lifecycle` module's `run` / `prebuild_toplevel` access the
@@ -169,7 +169,7 @@ impl BuildLogs {
     /// — the caller threads it through `append_stdout` / `append_stderr`
     /// while the child runs and into `finish` once it exits.
     pub fn start(&self, agent: &str, kind: &str, cmdline: &str) -> Result<i64> {
-        let now = now_secs();
+        let now = now_unix();
         let conn = self.conn.lock().unwrap();
         conn.execute(
             "INSERT INTO build_logs (agent, kind, cmdline, started_at) VALUES (?1, ?2, ?3, ?4)",
@@ -219,7 +219,7 @@ impl BuildLogs {
     /// Finalize a build attempt. Sets `finished_at` to now and
     /// `status` to the terminal state. Best-effort.
     pub fn finish(&self, id: i64, status: BuildStatus) {
-        let now = now_secs();
+        let now = now_unix();
         let conn = self.conn.lock().unwrap();
         if let Err(e) = conn.execute(
             "UPDATE build_logs SET finished_at = ?1, status = ?2 WHERE id = ?3",
@@ -374,7 +374,7 @@ impl BuildLogs {
     ///   a long-running build shouldn't disappear from its own log
     ///   viewer mid-stream.
     pub fn vacuum(&self) -> Result<u64> {
-        let now = now_secs();
+        let now = now_unix();
         let conn = self.conn.lock().unwrap();
         let fail_cutoff = now - KEEP_FAIL_SECS;
         let ok_cutoff = now - KEEP_OK_SECS;
@@ -438,13 +438,6 @@ fn row_to_header(r: &rusqlite::Row) -> rusqlite::Result<BuildLogHeader> {
     })
 }
 
-fn now_secs() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {
@@ -533,7 +526,7 @@ mod tests {
         // stays within KEEP_FAIL_SECS so it survives; old_fail goes
         // beyond; old_ok goes past KEEP_OK_SECS but inside
         // KEEP_FAIL_SECS — proves the per-status rule.
-        let now = now_secs();
+        let now = now_unix();
         {
             let conn = db.conn.lock().unwrap();
             conn.execute(

hive-c0re/src/hive_stats.rs

@@ -18,12 +18,13 @@
 
 use std::collections::HashMap;
 use std::path::Path;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::Duration;
 
 use rusqlite::{Connection, OpenFlags};
 use serde::{Deserialize, Serialize};
 
 use crate::coordinator::Coordinator;
+use hive_sh4re::wire_time::now_unix;
 
 /// Window accepted by `/api/stats-hive?window=`. Maps to a lookback
 /// span; the hive view is a flat rollup (no per-bucket trend — the
@@ -225,11 +226,6 @@ struct AgentAgg {
     bash: HashMap<String, u64>,
 }
 
-fn now_secs() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map_or(0, |d| i64::try_from(d.as_secs()).unwrap_or(i64::MAX))
-}
 
 #[allow(
     clippy::cast_sign_loss,
@@ -322,7 +318,7 @@ fn read_bash_heads(conn: &Connection, from: i64) -> HashMap<String, u64> {
 /// per-agent db is skipped (logged), never fatal.
 #[must_use]
 pub fn hive_snapshot(window: Window, prices: &PriceTable) -> HiveStats {
-    let now = now_secs();
+    let now = now_unix();
     // Fixed windows look back a constant span; `all` aggregates every
     // recorded turn (`from == 0`). The hive rollup isn't time-bucketed, so
     // unlike the per-agent snapshot it needs no adaptive bucket sizing.
@@ -426,7 +422,7 @@ mod tests {
         let conn = Connection::open_in_memory().unwrap();
         conn.execute_batch("CREATE TABLE bash_commands (ts INTEGER NOT NULL, head TEXT NOT NULL);")
             .unwrap();
-        let now = now_secs();
+        let now = now_unix();
         for (ts, head) in [
             (now - 100, "cargo"),
             (now - 200, "cargo"),

hive-c0re/src/job_queue/mod.rs

@@ -29,6 +29,7 @@ use std::collections::{HashMap, VecDeque};
 use std::sync::Mutex;
 
 use tokio::sync::Notify;
+use hive_sh4re::wire_time::now_unix;
 
 pub use model::{
     Dag, DagSpec, DagView, DepWhen, Node, NodeId, NodeKind, PermPayload, Source, State, Template,
@@ -566,11 +567,3 @@ impl JobQueue {
     }
 }
 
-/// Current unix timestamp in seconds.
-fn now_unix() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}

hive-c0re/src/loose_ends.rs

@@ -13,12 +13,12 @@
 //! the dashboard uses, so the bottleneck would be json
 //! (de)serialisation, not the read.
 
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::Result;
 use hive_sh4re::LooseEnd;
 
 use crate::coordinator::Coordinator;
+use hive_sh4re::wire_time::now_unix;
 
 /// Open threads pending against `agent`:
 /// - undelivered inbox messages this agent still owes itself a `recv`
@@ -143,13 +143,6 @@ fn saturating_age(now: i64, then: i64) -> u64 {
     u64::try_from(delta).unwrap_or(0)
 }
 
-fn now_unix() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {

hive-c0re/src/operator_questions.rs

@@ -11,13 +11,13 @@
 
 use std::path::Path;
 use std::sync::Mutex;
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::{Context, Result, bail};
 
 use chrono::{DateTime, Utc};
 use rusqlite::{Connection, OptionalExtension, params};
 use serde::Serialize;
+use hive_sh4re::wire_time::now_unix;
 
 const SCHEMA: &str = r"
 CREATE TABLE IF NOT EXISTS operator_questions (
@@ -272,10 +272,3 @@ fn row_to_question(row: &rusqlite::Row<'_>) -> rusqlite::Result<OpQuestion> {
     })
 }
 
-fn now_unix() -> i64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}

hive-c0re/src/power.rs

@@ -19,6 +19,7 @@ use std::sync::Mutex;
 
 use anyhow::{Context, Result};
 use rusqlite::{Connection, OptionalExtension, params};
+use hive_sh4re::wire_time::now_unix;
 
 const SCHEMA: &str = "
 CREATE TABLE IF NOT EXISTS agent_power (
@@ -128,7 +129,7 @@ impl PowerStore {
         conn.execute(
             "INSERT INTO agent_power (agent, wanted, updated_at) VALUES (?1, ?2, ?3)
              ON CONFLICT(agent) DO UPDATE SET wanted = ?2, updated_at = ?3",
-            params![agent, wanted.as_str(), now_secs()],
+            params![agent, wanted.as_str(), now_unix()],
         )
         .context("upsert agent_power")?;
         Ok(())
@@ -157,13 +158,6 @@ impl PowerStore {
     }
 }
 
-fn now_secs() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {

hive-c0re/src/scheduled_prompts.rs

@@ -18,6 +18,7 @@ use std::sync::Mutex;
 use anyhow::{Context, Result, bail};
 use rusqlite::{Connection, OptionalExtension, params};
 use serde::{Deserialize, Serialize};
+use hive_sh4re::wire_time::now_unix;
 
 /// Typed error returned by [`ScheduledPrompts::pause`] and
 /// [`ScheduledPrompts::resume`] when the target row does not exist or
@@ -674,13 +675,6 @@ fn load_targets(conn: &Connection, schedule_id: i64) -> Result<Vec<ScheduleTarge
     Ok(out)
 }
 
-fn now_unix() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 #[cfg(test)]
 mod tests {

hive-c0re/src/scheduled_prompts_worker.rs

@@ -10,6 +10,7 @@ use hive_sh4re::Message;
 
 use crate::coordinator::Coordinator;
 use crate::scheduled_prompts::Schedule;
+use hive_sh4re::wire_time::now_unix;
 
 /// Per-tick cap. Each schedule fires once per tick at most;
 /// 100/tick × 5s tick = sustained throughput cap of ~20/sec,
@@ -236,13 +237,6 @@ fn notify_operator_missing_target(coord: &Coordinator, schedule: &Schedule, targ
     }
 }
 
-fn now_unix() -> i64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .ok()
-        .and_then(|d| i64::try_from(d.as_secs()).ok())
-        .unwrap_or(0)
-}
 
 /// Per-target outcome counts for one `fire_now` invocation.
 /// Returned to the operator so the dashboard can render