feat: pause an agent's turn loop without stopping its container

A paused agent keeps its container, its claude session and its
dashboard/todo servers up, but stops driving turns. Messages queue
unacked and are drained on resume.

The whole protocol is a single marker file, `<harness>/paused`. That
directory is already a bind-mount shared between host and container, so
both sides just stat the same path: the harness reads it to decide
whether to drive a turn, hive-c0re reads it to render the badge and
writes/removes it for `hivectl pause|resume`. No new wire protocol, no
container round-trip, and it is sticky across restarts by construction.

Not calling `recv_next` while paused *is* the queueing semantic, so
there is no fencing to get wrong: reminders buffer in their unbounded
channel, the todo `Notify` permit coalesces, and a `request_next_turn`
that raced the pause survives because the gate sits above
`self_continue.take()`.

Graceful stop is handled host-side rather than in the harness: a paused
agent provably has no turn in flight, so `run_signal` skips the fence
entirely instead of eating the full `GRACEFUL_STOP_TIMEOUT` waiting for
a checkpoint turn that will never run.

`paused` is reported on `ContainerView` / `AgentStatusRow` for the
dashboard, orthogonal to `running` and reported for stopped containers
too.

Closes: hyperhive/hyperhive issue 2271

hive-sh4re/src/lib.rs

@@ -366,6 +366,18 @@ pub struct ContainerInfo {
 /// projection of the dashboard's per-agent `ContainerView`. Carries the
 /// agent's running/health flags plus the technical state an operator
 /// wants in a roster overview (`hivectl agents list`).
+//
+// Four orthogonal, independently-observed facts about one agent, each
+// rendered as its own column/token by `hivectl agents list` and read
+// individually by `--json` consumers. Any combination is meaningful
+// (a stopped agent can be paused and need an update), so folding them
+// into a state machine or nested flag structs would only add
+// `serde(flatten)` indirection to preserve the same flat JSON. Same
+// rationale as `LifecycleScope` in hive-host-sock.
+#[allow(
+    clippy::struct_excessive_bools,
+    reason = "flat wire projection of independent per-agent flags"
+)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AgentStatusRow {
     /// Logical agent name (no `h-` prefix).
@@ -385,6 +397,12 @@ pub struct AgentStatusRow {
     /// Count of this agent's pending reminders.
     #[serde(default)]
     pub pending_reminders: u64,
+    /// The agent's turn loop is parked (pause marker present in its
+    /// harness dir): the container may well be up and serving, it just
+    /// drives no turns. Orthogonal to `running` — an agent can be
+    /// paused while stopped, and pause survives a restart.
+    #[serde(default)]
+    pub paused: bool,
     /// Parent in the topology tree. `None` marks a root-level agent.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub parent: Option<String>,

hive-sh4re/src/paths.rs

@@ -28,3 +28,26 @@ pub fn harness_dir() -> PathBuf {
     let label = std::env::var("HIVE_LABEL").unwrap_or_default();
     PathBuf::from(format!("/agents/{label}/harness"))
 }
+
+/// File name of the pause marker inside the harness dir. Shared so the
+/// in-container resolver below and hive-c0re's host-side one (which
+/// builds the same path from `/var/lib/hyperhive/agents/{name}/harness`)
+/// cannot drift apart.
+pub const PAUSED_MARKER_FILE: &str = "paused";
+
+/// Marker file whose presence means "this agent is paused": the harness
+/// keeps serving its web UI and MCP daemons but drives no turns, so
+/// inbox messages queue up unacked until it's removed.
+///
+/// It lives in the harness dir rather than `state/` because `state/` is
+/// the agent's own scratch space — this is harness control state. The
+/// harness dir is bind-mounted from the host, so the marker is the
+/// single source of truth for both sides: the harness stats it to gate
+/// the turn loop, and hive-c0re stats it to render the paused
+/// indicator and creates/removes it for `hivectl pause|resume`. Being a
+/// plain file, it survives container restarts — pause is sticky by
+/// construction, and works even when the harness isn't running.
+#[must_use]
+pub fn paused_marker() -> PathBuf {
+    harness_dir().join(PAUSED_MARKER_FILE)
+}