force fresh session: ↻ new session button + /new-session

bus carries a one-shot AtomicBool armed by POST
/api/new-session (or the /new-session slash command). next
turn drops --continue, starting a fresh claude session; the
flag clears automatically so subsequent turns resume normal
behavior. /compact still always uses --continue — compacting
a non-existent session is a no-op anyway.

per-agent page grows an ↻ new session button next to the
cancel-turn one (always visible, amber, confirms before
posting since dropping --continue context isn't reversible).
slash-command surface picks up /new-session for parity with
the button. note row emitted on the live feed both at arm-
time and again when the turn actually consumes the flag, so
the operator can confirm it landed.

hive-ag3nt/src/events.rs

@@ -9,6 +9,7 @@
 //! showing "connecting…" until the first event arrives.
 
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 
 use rusqlite::{Connection, params};
@@ -189,6 +190,13 @@ pub struct Bus {
     /// Model name passed to `claude --model`. Default `haiku`; the
     /// operator can override at runtime via `POST /api/model`.
     model: Arc<Mutex<String>>,
+    /// One-shot: next `run_claude` call drops `--continue`, starting
+    /// a fresh claude session. Set by `POST /api/new-session` from
+    /// the per-agent web UI; consumed (cleared back to false) by the
+    /// next turn. Subsequent turns resume normal `--continue`
+    /// behavior. Atomic so the consumer can take-and-clear without a
+    /// lock.
+    skip_continue_once: Arc<AtomicBool>,
 }
 
 impl Bus {
@@ -213,9 +221,24 @@ impl Bus {
             store,
             state: Arc::new(Mutex::new((TurnState::Idle, now_unix()))),
             model: Arc::new(Mutex::new(initial_model)),
+            skip_continue_once: Arc::new(AtomicBool::new(false)),
         }
     }
 
+    /// Arm the one-shot: the next claude invocation will run without
+    /// `--continue`, dropping any prior session context. Idempotent
+    /// — calling twice in a row before the next turn still consumes
+    /// to a single fresh-start.
+    pub fn request_new_session(&self) {
+        self.skip_continue_once.store(true, Ordering::SeqCst);
+    }
+
+    /// Take + clear the one-shot. Returns true iff the caller should
+    /// run claude without `--continue` for this turn.
+    pub fn take_skip_continue(&self) -> bool {
+        self.skip_continue_once.swap(false, Ordering::SeqCst)
+    }
+
     /// Currently-selected claude model name. Read on every turn so a
     /// `/model <name>` flip takes effect on the next turn.
     #[must_use]