set_status: consolidate whoami into get_agent_meta with optional name

docs/turn-loop.md

@@ -214,8 +214,17 @@ it as a stdio child via `--mcp-config`. The hyperhive socket name is
   short pointer. Each agent's pending-reminder count is capped
   (default 50, override via `HIVE_REMIND_MAX_PENDING_PER_AGENT`);
   scheduling a new one fails if the cap is already hit.
-- `whoami()` — `{ name, role, pronouns, hyperhive_rev }` for
+- `set_status(text)` — set a free-text status string visible on
-  self-identification without scraping the system prompt.
+  the operator dashboard. Persisted to
+  `{state_dir}/hyperhive-status`; survives harness restarts. Pass
+  an empty string to clear.
+- `get_agent_meta(name?)` — fetch identity + status metadata for
+  an agent: `{ name, role, hyperhive_rev, status_text,
+  status_set_at }`. Pass `name` to query a peer (e.g. check
+  whether a sub-agent is idle before sending it work). Omit
+  `name` to get your own identity stamp — replaces the previous
+  `whoami` tool. Status fields are `None` when the target has
+  never called `set_status` or has cleared it.
 - `request_next_turn()` — ask the harness to start another turn
   immediately after this one ends, even if the inbox is empty. Use for
   multi-turn tasks (long builds, sequential steps) where you want to
@@ -314,10 +323,11 @@ meta's.
   startup crashes, etc.). Pass the plain logical agent name;
   hive-c0re resolves the machine name (`h-<name>`, manager
   `hm1nd`). `lines` defaults to 50, host-capped at 500.
-- `remind` / `get_loose_ends` / `cancel_loose_end` / `whoami` —
+- `remind` / `get_loose_ends` / `cancel_loose_end` / `set_status`
-  same as the sub-agent tools above. `get_loose_ends` scopes to
+  / `get_agent_meta` — same as the sub-agent tools above.
-  the manager's own items by default; pass `agent: "*"` for a
+  `get_loose_ends` scopes to the manager's own items by default;
-  hive-wide view, or `agent: "<name>"` to inspect one agent.
+  pass `agent: "*"` for a hive-wide view, or `agent: "<name>"`
+  to inspect one agent.
   `cancel_loose_end` may cancel any agent's row.
 
 The boundary: lifecycle ops on *existing* sub-agents

hive-ag3nt/prompts/agent.md

@@ -10,7 +10,8 @@ Tools (hyperhive surface):
 - `mcp__hyperhive__get_loose_ends()` — list your loose ends: unanswered questions where you're asker (waiting on someone) or target (owing a reply), plus reminders you've scheduled that haven't fired. No args, cheap server-side sweep. Useful at turn start to remember what's outstanding without scanning inbox archaeology.
 - `mcp__hyperhive__cancel_loose_end(kind, id)` — cancel one of your own open threads. `kind` is `"question"` (the asker — you, in this case — gets a `[cancelled by <you>]` answer so the waiter unblocks) or `"reminder"` (hard-deleted before it fires). `id` from the matching `get_loose_ends` row or the original submission reply.
 - `mcp__hyperhive__remind(message, delay_seconds? | at_unix_timestamp?, file_path?)` — schedule a message to land in your *own* inbox at a future time (sender shows as `reminder`). Set exactly one of `delay_seconds` (relative) or `at_unix_timestamp` (absolute). Use for self-paced follow-ups instead of blocking a whole turn on a long `recv` wait. A large `message` auto-spills to a file under `/agents/{label}/state/reminders/`; pass `file_path` to point at one yourself. Each agent's pending-reminder count is capped (default 50) — the tool will error if the cap is already reached.
-- `mcp__hyperhive__whoami()` — self-introspection: returns your canonical agent name (from socket identity, not the prompt-substituted label), role, and current hyperhive rev. No args. Use it when you want a trustworthy identity stamp for state files, commit messages, or cross-agent attribution that won't drift across renames.
+- `mcp__hyperhive__set_status(text)` — set a free-text status visible on the operator dashboard. **Call this at the start of every task** to say what you're working on (e.g. `"processing matrix messages"`, `"fixing #319 model priority"`, `"idle"`). Pass an empty string to clear. Persists across harness restarts.
+- `mcp__hyperhive__get_agent_meta(name?)` — fetch identity + status metadata for an agent: canonical `name`, `role` (`agent` / `manager`), current `hyperhive_rev`, plus self-reported `status` text (set via `set_status`) and how long ago it was set. Pass `name` to query a peer (e.g. check whether iris is idle before pinging them). Omit `name` to get your own trustworthy identity stamp — useful for state files, commit messages, cross-agent attribution that won't drift across renames or session-continue boundaries where the system-prompt label could be stale.
 - `mcp__hyperhive__request_next_turn()` — ask the harness to start another turn immediately after this one ends, even if the inbox is empty. Use for multi-turn tasks (long builds, sequential steps) where you want to continue without waiting for an external message. The next turn starts with `from: "self"` and `body: "continue"`. No-op if new inbox messages arrive before this turn ends (the harness already loops immediately on pending messages). No args.
 
 Need new packages, env vars, or other NixOS config for yourself? You can't edit your own config directly — message the manager (recipient `manager`) describing what you need + why. The manager evaluates the request (it doesn't rubber-stamp), edits `/agents/{label}/config/agent.nix` on your behalf, commits, and submits an approval that the operator can accept on the dashboard; on approve hive-c0re rebuilds your container with the new config.

hive-ag3nt/prompts/manager.md

@@ -17,7 +17,8 @@ Tools (hyperhive surface):
 - `mcp__hyperhive__get_loose_ends(agent?)` — loose ends. Omit `agent` for your own: pending approvals you submitted + unanswered questions where you are asker/target + your own pending reminders. Pass `agent: "*"` for a hive-wide sweep — every pending approval, unanswered question, and reminder across the swarm — to find stalled threads (sub-agent A asked B something three days ago and B never answered) before they rot. Pass `agent: "<name>"` to inspect one agent's threads. Cheap server-side query.
 - `mcp__hyperhive__cancel_loose_end(kind, id)` — cancel any question or reminder in the swarm (manager bypasses the owner check used on sub-agents). Use for hive-wide cleanup when a sub-agent is offline / can't withdraw its own ask / reminder.
 - `mcp__hyperhive__remind(message, delay_seconds? | at_unix_timestamp?, file_path?)` — schedule a message to land in your own inbox at a future time (sender shows as `reminder`). Set exactly one of `delay_seconds` (relative) or `at_unix_timestamp` (absolute). Good for deadline follow-ups — "check whether agent X answered the question I relayed". Large payloads auto-spill to a file under `/state/reminders/`; pass `file_path` to control the destination.
-- `mcp__hyperhive__whoami()` — self-introspection: canonical name (`manager`), role, current hyperhive rev. No args. Useful for boot announcements and cross-agent attribution that won't drift across config reloads.
+- `mcp__hyperhive__set_status(text)` — set a free-text status visible on the operator dashboard. **Call this at the start of every task** to say what you're doing (e.g. `"reviewing argus's #341 proposal"`, `"approving lifecycle changes"`, `"idle"`). Pass an empty string to clear. Persists across harness restarts.
+- `mcp__hyperhive__get_agent_meta(name?)` — fetch identity + status metadata for an agent: canonical `name`, `role` (`agent` / `manager`), current `hyperhive_rev`, plus the target's self-reported `status` text (set via `set_status`) and how long ago it was set. Pass `name` to check on a sub-agent (idle? still working on the task you assigned?) without scrolling the dashboard. Omit `name` for your own identity stamp — useful for boot announcements, state-file headers, cross-agent attribution that won't drift across config reloads.
 
 Approval boundary: lifecycle ops on *existing* sub-agents (`kill`, `start`, `restart`) are at your discretion — no operator approval. *Creating* a new agent (two-step: `request_init_config` + `request_apply_commit`) and *changing* any agent's config (`request_apply_commit`) both go through the approval queue. The operator only signs off on changes; you run the day-to-day.
 

hive-ag3nt/src/bin/hive-ag3nt.rs

@@ -194,7 +194,7 @@ async fn serve(
                 | AgentResponse::LooseEnds { .. }
                 | AgentResponse::PendingRemindersCount { .. }
                 | AgentResponse::ReminderRollup { .. }
-                | AgentResponse::Whoami { .. },
+                | AgentResponse::AgentMeta { .. },
             ) => {
                 tracing::warn!("recv produced unexpected response kind");
             }

hive-ag3nt/src/bin/hive-m1nd.rs

@@ -160,7 +160,7 @@ async fn serve(
                 | ManagerResponse::LooseEnds { .. }
                 | ManagerResponse::PendingRemindersCount { .. }
                 | ManagerResponse::ReminderRollup { .. }
-                | ManagerResponse::Whoami { .. },
+                | ManagerResponse::AgentMeta { .. },
             ) => {
                 tracing::warn!("recv produced unexpected response kind");
             }

hive-ag3nt/src/mcp.rs

@@ -49,10 +49,12 @@ pub enum SocketReply {
     LooseEnds(Vec<hive_sh4re::LooseEnd>),
     PendingRemindersCount(u64),
     ReminderRollup(hive_sh4re::ReminderStats),
-    Whoami {
+    AgentMeta {
         name: String,
         role: String,
         hyperhive_rev: Option<String>,
+        status_text: Option<String>,
+        status_set_at: Option<i64>,
     },
 }
 
@@ -70,14 +72,18 @@ impl From<hive_sh4re::AgentResponse> for SocketReply {
                 Self::PendingRemindersCount(count)
             }
             hive_sh4re::AgentResponse::ReminderRollup(stats) => Self::ReminderRollup(stats),
-            hive_sh4re::AgentResponse::Whoami {
+            hive_sh4re::AgentResponse::AgentMeta {
                 name,
                 role,
                 hyperhive_rev,
-            } => Self::Whoami {
+                status_text,
+                status_set_at,
+            } => Self::AgentMeta {
                 name,
                 role,
                 hyperhive_rev,
+                status_text,
+                status_set_at,
             },
         }
     }
@@ -98,14 +104,18 @@ impl From<hive_sh4re::ManagerResponse> for SocketReply {
                 Self::PendingRemindersCount(count)
             }
             hive_sh4re::ManagerResponse::ReminderRollup(stats) => Self::ReminderRollup(stats),
-            hive_sh4re::ManagerResponse::Whoami {
+            hive_sh4re::ManagerResponse::AgentMeta {
                 name,
                 role,
                 hyperhive_rev,
-            } => Self::Whoami {
+                status_text,
+                status_set_at,
+            } => Self::AgentMeta {
                 name,
                 role,
                 hyperhive_rev,
+                status_text,
+                status_set_at,
             },
         }
     }
@@ -259,23 +269,57 @@ fn loose_end_kind_label(kind: hive_sh4re::CancelLooseEndKind) -> &'static str {
     }
 }
 
-/// Format helper for `whoami`: renders the identity block as a short
+/// Format helper for `get_agent_meta`: renders an agent's identity +
-/// human-readable string. Skips fields that are `None` so the output
+/// current status as a short human-readable block. `name`, `role`, and
-/// doesn't carry dead placeholders.
+/// `hyperhive_rev` are always shown; `status` only appears when one is
+/// set, otherwise the line reads `status: <none>`.
 #[must_use]
-pub fn format_whoami(resp: Result<SocketReply, anyhow::Error>) -> String {
+pub fn format_agent_meta(resp: Result<SocketReply, anyhow::Error>) -> String {
     match resp {
-        Ok(SocketReply::Whoami {
+        Ok(SocketReply::AgentMeta {
             name,
             role,
             hyperhive_rev,
+            status_text,
+            status_set_at,
         }) => {
             let rev = hyperhive_rev.as_deref().unwrap_or("<unknown>");
-            format!("name: {name}\nrole: {role}\nhyperhive_rev: {rev}")
+            let mut out = format!("name: {name}\nrole: {role}\nhyperhive_rev: {rev}");
+            match status_text {
+                None => out.push_str("\nstatus: <none>"),
+                Some(s) => {
+                    let age = status_set_at.and_then(|ts| {
+                        let now = std::time::SystemTime::now()
+                            .duration_since(std::time::UNIX_EPOCH)
+                            .ok()?
+                            .as_secs();
+                        let secs = now.saturating_sub(ts as u64);
+                        Some(format_age_secs(secs))
+                    });
+                    match age {
+                        Some(a) => out.push_str(&format!("\nstatus: {s} (set {a} ago)")),
+                        None => out.push_str(&format!("\nstatus: {s}")),
+                    }
+                }
+            }
+            out
         }
-        Ok(SocketReply::Err(m)) => format!("whoami failed: {m}"),
+        Ok(SocketReply::Err(m)) => format!("get_agent_meta failed: {m}"),
-        Ok(other) => format!("whoami unexpected response: {other:?}"),
+        Ok(other) => format!("get_agent_meta unexpected response: {other:?}"),
-        Err(e) => format!("whoami transport error: {e:#}"),
+        Err(e) => format!("get_agent_meta transport error: {e:#}"),
+    }
+}
+
+/// Format a duration in seconds as a human-readable age string.
+fn format_age_secs(secs: u64) -> String {
+    if secs < 60 {
+        format!("{secs}s")
+    } else if secs < 3600 {
+        format!("{}m", secs / 60)
+    } else if secs < 86400 {
+        format!("{}h", secs / 3600)
+    } else {
+        format!("{}d", secs / 86400)
     }
 }
 
@@ -549,17 +593,42 @@ impl AgentServer {
     }
 
     #[tool(
-        description = "Self-introspection: returns your own canonical agent name (the \
+        description = "Set a free-text status string visible on the operator dashboard. \
-        socket-identity name, NOT the prompt-substituted label), role (`agent`), and \
+        Call this at the START of every task to describe what you're working on (e.g. \
-        the current hyperhive rev hive-c0re is running against. No args. Useful when \
+        `\"processing matrix messages\"`, `\"fixing bitburner crash\"`, `\"idle\"`). Pass an empty \
-        you want a trustworthy identity stamp for state files / commit messages / \
+        string to clear. The status is shown on your dashboard card and persists across \
-        cross-agent attribution that won't drift across renames or session-continue \
+        harness restarts."
-        boundaries where the system-prompt label could be stale."
     )]
-    async fn whoami(&self) -> String {
+    async fn set_status(&self, Parameters(args): Parameters<SetStatusArgs>) -> String {
-        run_tool_envelope("whoami", String::new(), async move {
+        run_tool_envelope("set_status", args.text.clone(), async move {
-            let (resp, retries) = self.dispatch(hive_sh4re::AgentRequest::Whoami).await;
+            let (resp, retries) =
-            annotate_retries(format_whoami(resp), retries)
+                self.dispatch(hive_sh4re::AgentRequest::SetStatus { text: args.text }).await;
+            annotate_retries(format_ack(resp, "set_status", "status updated".to_owned()), retries)
+        })
+        .await
+    }
+
+    #[tool(
+        description = "Fetch identity + status metadata for an agent. Returns canonical \
+        `name`, `role` (`agent` / `manager`), the current `hyperhive_rev` hive-c0re is \
+        running against, and the target's self-reported `status` text (set via \
+        `set_status`) plus how long ago it was set. Pass `name` to query a peer (e.g. \
+        check whether iris is idle before pinging them); omit `name` to get your own \
+        identity stamp — handy for state files / commit messages / cross-agent \
+        attribution that won't drift across renames or session-continue boundaries \
+        where the system-prompt label could be stale. Status reads `<none>` when the \
+        target has never called `set_status` or has cleared it."
+    )]
+    async fn get_agent_meta(
+        &self,
+        Parameters(args): Parameters<GetAgentMetaArgs>,
+    ) -> String {
+        let log = args.name.clone().unwrap_or_else(|| "<self>".to_owned());
+        run_tool_envelope("get_agent_meta", log, async move {
+            let (resp, retries) = self
+                .dispatch(hive_sh4re::AgentRequest::GetAgentMeta { name: args.name })
+                .await;
+            annotate_retries(format_agent_meta(resp), retries)
         })
         .await
     }
@@ -724,6 +793,21 @@ pub struct KillArgs {
     pub name: String,
 }
 
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
+pub struct SetStatusArgs {
+    /// Status text to display on the dashboard card. Pass an empty string to clear.
+    pub text: String,
+}
+
+#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
+pub struct GetAgentMetaArgs {
+    /// Logical name of the agent to query (e.g. `"iris"`, `"manager"`).
+    /// Omit to query your own identity + status — replaces the
+    /// previous `whoami` self-introspection tool.
+    #[serde(default)]
+    pub name: Option<String>,
+}
+
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
 pub struct StartArgs {
     /// Sub-agent name (without the `h-` container prefix).
@@ -1245,15 +1329,39 @@ impl ManagerServer {
     }
 
     #[tool(
-        description = "Self-introspection for the manager: returns canonical name \
+        description = "Set a free-text status string visible on the operator dashboard. \
-        (`manager`), role (`manager`), and the current hyperhive rev. Same shape as \
+        Call this at the START of every task to describe what you're working on. \
-        the agent flavour; useful for cross-agent attribution / boot announcements / \
+        Pass an empty string to clear. Persists across harness restarts."
-        state-file headers without trusting prompt substitution."
     )]
-    async fn whoami(&self) -> String {
+    async fn set_status(&self, Parameters(args): Parameters<SetStatusArgs>) -> String {
-        run_tool_envelope("whoami", String::new(), async move {
+        run_tool_envelope("set_status", args.text.clone(), async move {
-            let (resp, retries) = self.dispatch(hive_sh4re::ManagerRequest::Whoami).await;
+            let (resp, retries) =
-            annotate_retries(format_whoami(resp), retries)
+                self.dispatch(hive_sh4re::ManagerRequest::SetStatus { text: args.text }).await;
+            annotate_retries(format_ack(resp, "set_status", "status updated".to_owned()), retries)
+        })
+        .await
+    }
+
+    #[tool(
+        description = "Fetch identity + status metadata for an agent. Returns canonical \
+        `name`, `role` (`agent` / `manager`), the current `hyperhive_rev` hive-c0re is \
+        running against, and the target's self-reported `status` text (set via \
+        `set_status`) plus how long ago it was set. Pass `name` to query a sub-agent or \
+        peer manager; omit `name` for the manager's own identity stamp — useful for \
+        boot announcements, state-file headers, or cross-agent attribution that won't \
+        drift across renames. Status reads `<none>` when the target has never called \
+        `set_status` or has cleared it."
+    )]
+    async fn get_agent_meta(
+        &self,
+        Parameters(args): Parameters<GetAgentMetaArgs>,
+    ) -> String {
+        let log = args.name.clone().unwrap_or_else(|| "<self>".to_owned());
+        run_tool_envelope("get_agent_meta", log, async move {
+            let (resp, retries) = self
+                .dispatch(hive_sh4re::ManagerRequest::GetAgentMeta { name: args.name })
+                .await;
+            annotate_retries(format_agent_meta(resp), retries)
         })
         .await
     }
@@ -1333,8 +1441,9 @@ impl ManagerServer {
         `answer` (respond to a `question_asked` event directed at you), \
         `get_loose_ends` (hive-wide loose ends — pending approvals + unanswered \
         questions + pending reminders across the swarm), `cancel_loose_end` (cancel any \
-        question or reminder row by id), `whoami` (self-introspection — canonical \
+        question or reminder row by id), `set_status` / `get_agent_meta` (publish your \
-        name, role, current hyperhive rev). The manager's own config lives at \
+        own status text + query identity/status of any agent — `get_agent_meta` with \
+        no arg replaces the old `whoami` self-introspection). The manager's own config lives at \
         `/agents/hm1nd/config/agent.nix`."
 )]
 impl ServerHandler for ManagerServer {}
@@ -1376,7 +1485,8 @@ pub fn allowed_mcp_tools(flavor: Flavor) -> Vec<String> {
             "answer",
             "remind",
             "get_loose_ends",
-            "whoami",
+            "set_status",
+            "get_agent_meta",
             "cancel_loose_end",
         ],
         Flavor::Manager => &[
@@ -1394,7 +1504,8 @@ pub fn allowed_mcp_tools(flavor: Flavor) -> Vec<String> {
             "get_logs",
             "get_loose_ends",
             "remind",
-            "whoami",
+            "set_status",
+            "get_agent_meta",
             "cancel_loose_end",
         ],
     };

hive-c0re/assets/app.js

@@ -17,6 +17,8 @@
 
   // ─── helpers ────────────────────────────────────────────────────────────
   const $ = (id) => document.getElementById(id);
+  const fmtAgeSecs = (s) => s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s/60)}m`
+    : s < 86400 ? `${Math.floor(s/3600)}h` : `${Math.floor(s/86400)}d`;
   const esc = (s) => String(s).replace(/[&<>"]/g, (c) =>
     ({ '&':'&amp;', '<':'&lt;', '>':'&gt;', '"':'&quot;' }[c])
   );
@@ -727,6 +729,21 @@
       }
       body.append(head);
 
+      // ── agent status text ─────────────────────────────────────────
+      if (c.status_text) {
+        const nowUnix = Math.floor(Date.now() / 1000);
+        const ageStr = c.status_set_at != null
+          ? ` (set ${fmtAgeSecs(nowUnix - c.status_set_at)} ago)` : '';
+        body.append(el('div', {
+          class: 'agent-status',
+          title: `agent self-reported status${ageStr}`,
+        },
+          el('span', { class: 'status-icon' }, '◈ '),
+          c.status_text,
+          el('span', { class: 'status-age' }, ageStr),
+        ));
+      }
+
       // ── action buttons ───────────────────────────────────────────
       const actions = el('div', { class: 'actions' });
       if (c.running) {

hive-c0re/assets/dashboard.css

@@ -207,6 +207,17 @@ a:hover {
   color: var(--red); border-color: var(--red);
   text-shadow: 0 0 6px rgba(243, 139, 168, 0.5);
 }
+.agent-status {
+  font-size: 0.82em;
+  color: var(--subtext0, #a6adc8);
+  padding: 0.1em 0.3em 0.25em;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.agent-status .status-icon { opacity: 0.65; }
+.agent-status .status-age { opacity: 0.5; font-size: 0.9em; margin-left: 0.2em; }
+
 .container-row.tombstone {
   border-style: dashed;
   background: rgba(24, 24, 37, 0.35);

hive-c0re/src/agent_server.rs

@@ -220,11 +220,48 @@ async fn dispatch(req: &AgentRequest, agent: &str, coord: &Arc<Coordinator>) ->
                 },
             }
         }
-        AgentRequest::Whoami => AgentResponse::Whoami {
+        AgentRequest::SetStatus { text } => {
-            name: agent.to_owned(),
+            let path = crate::coordinator::Coordinator::agent_notes_dir(agent)
-            role: "agent".to_owned(),
+                .join("hyperhive-status");
-            hyperhive_rev: crate::auto_update::current_flake_rev(&coord.hyperhive_flake),
+            let result = if text.trim().is_empty() {
-        },
+                // Empty = clear: remove the file (ignore missing).
+                std::fs::remove_file(&path)
+                    .or_else(|e| if e.kind() == std::io::ErrorKind::NotFound {
+                        Ok(())
+                    } else {
+                        Err(e)
+                    })
+            } else {
+                std::fs::write(&path, format!("{}\n", text.trim()))
+            };
+            match result {
+                Ok(()) => {
+                    // Kick a container rescan so the dashboard updates live.
+                    let coord2 = Arc::clone(coord);
+                    tokio::spawn(async move { coord2.rescan_containers_and_emit().await });
+                    AgentResponse::Ok
+                }
+                Err(e) => AgentResponse::Err { message: format!("set_status write failed: {e}") },
+            }
+        }
+        AgentRequest::GetAgentMeta { name } => {
+            let target = name.as_deref().unwrap_or(agent);
+            let (status_text, status_set_at) =
+                crate::container_view::read_agent_status(target);
+            let role = if target == hive_sh4re::MANAGER_AGENT {
+                "manager"
+            } else {
+                "agent"
+            }
+            .to_owned();
+            AgentResponse::AgentMeta {
+                name: target.to_owned(),
+                role,
+                hyperhive_rev: crate::auto_update::current_flake_rev(&coord.hyperhive_flake),
+                status_text,
+                status_set_at,
+            }
+        }
         AgentRequest::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
             coord, agent, *kind, *id,
         )

hive-c0re/src/container_view.rs

@@ -77,6 +77,16 @@ pub struct ContainerView {
     /// the file is absent or the agent declares no links.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub extra_links: Vec<DashboardLink>,
+    /// Free-text status set by the agent via `mcp__hyperhive__set_status`.
+    /// Persisted to `{state_dir}/hyperhive-status`. `None` when the file
+    /// is absent or empty — the agent hasn't set one yet.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status_text: Option<String>,
+    /// Unix timestamp (seconds since epoch) when the status was last written.
+    /// Derived from the `hyperhive-status` file's mtime. `None` when no
+    /// status is set.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status_set_at: Option<i64>,
 }
 
 /// Build the full container list. Wraps `lifecycle::list()` and
@@ -119,6 +129,7 @@ pub async fn build_all(coord: &Coordinator) -> Vec<ContainerView> {
             .and_then(|(_, model)| resolve_ctx_window(model, &coord.context_window_tokens));
         let rate_limited = is_rate_limited(&logical);
         let extra_links = read_dashboard_links(&logical);
+        let (status_text, status_set_at) = read_status(&logical);
         out.push(ContainerView {
             port: lifecycle::agent_web_port(&logical),
             running: lifecycle::is_running(&logical).await,
@@ -133,6 +144,8 @@ pub async fn build_all(coord: &Coordinator) -> Vec<ContainerView> {
             context_window_tokens,
             rate_limited,
             extra_links,
+            status_text,
+            status_set_at,
         });
     }
     out
@@ -172,6 +185,27 @@ fn is_rate_limited(name: &str) -> bool {
         .exists()
 }
 
+/// Read the agent's free-text status and the Unix timestamp when it was last set
+/// (derived from the file's mtime). Returns `(None, None)` when the file is absent
+/// or empty. `pub` so `agent_server` and `manager_server` can populate `AgentMeta`.
+pub fn read_agent_status(name: &str) -> (Option<String>, Option<i64>) {
+    let path = Coordinator::agent_notes_dir(name).join("hyperhive-status");
+    let meta = std::fs::metadata(&path).ok();
+    let s = std::fs::read_to_string(&path).ok();
+    let text = s.as_deref().map(str::trim).filter(|t| !t.is_empty()).map(str::to_owned);
+    let mtime = meta.and_then(|m| {
+        m.modified().ok().and_then(|t| {
+            t.duration_since(std::time::UNIX_EPOCH).ok()
+                .and_then(|d| i64::try_from(d.as_secs()).ok())
+        })
+    });
+    if text.is_none() { (None, None) } else { (text, mtime) }
+}
+
+fn read_status(name: &str) -> (Option<String>, Option<i64>) {
+    read_agent_status(name)
+}
+
 /// Read the agent's most recent completed turn from its turn-stats
 /// `SQLite`: the context-window size (prompt tokens) and the model name.
 /// Returns `None` when the file is absent or has no rows. Best-effort

hive-c0re/src/manager_server.rs

@@ -480,11 +480,40 @@ async fn dispatch(req: &ManagerRequest, coord: &Arc<Coordinator>) -> ManagerResp
                 },
             }
         }
-        ManagerRequest::Whoami => ManagerResponse::Whoami {
+        ManagerRequest::SetStatus { text } => {
-            name: MANAGER_AGENT.to_owned(),
+            let path = Coordinator::agent_notes_dir(MANAGER_AGENT).join("hyperhive-status");
-            role: "manager".to_owned(),
+            let result = if text.trim().is_empty() {
-            hyperhive_rev: crate::auto_update::current_flake_rev(&coord.hyperhive_flake),
+                std::fs::remove_file(&path)
-        },
+                    .or_else(|e| if e.kind() == std::io::ErrorKind::NotFound {
+                        Ok(())
+                    } else {
+                        Err(e)
+                    })
+            } else {
+                std::fs::write(&path, format!("{}\n", text.trim()))
+            };
+            match result {
+                Ok(()) => {
+                    let coord2 = Arc::clone(coord);
+                    tokio::spawn(async move { coord2.rescan_containers_and_emit().await });
+                    ManagerResponse::Ok
+                }
+                Err(e) => ManagerResponse::Err { message: format!("set_status write failed: {e}") },
+            }
+        }
+        ManagerRequest::GetAgentMeta { name } => {
+            let target = name.as_deref().unwrap_or(MANAGER_AGENT);
+            let (status_text, status_set_at) =
+                crate::container_view::read_agent_status(target);
+            let role = if target == MANAGER_AGENT { "manager" } else { "agent" }.to_owned();
+            ManagerResponse::AgentMeta {
+                name: target.to_owned(),
+                role,
+                hyperhive_rev: crate::auto_update::current_flake_rev(&coord.hyperhive_flake),
+                status_text,
+                status_set_at,
+            }
+        }
         ManagerRequest::CancelLooseEnd { kind, id } => crate::questions::handle_cancel_loose_end(
             coord,
             MANAGER_AGENT,

hive-sh4re/src/lib.rs

@@ -437,12 +437,23 @@ pub enum AgentRequest {
         #[serde(default)]
         since_secs: u64,
     },
-    /// Self-introspection: who am I, what role, what rev. All values
+    /// Set a free-text status string visible on the dashboard. Persisted
-    /// derive from coord state (no env access required); useful for
+    /// to `{state_dir}/hyperhive-status` so it survives harness restarts.
-    /// agents to stamp notes / commits / messages with a trustworthy
+    /// Pass an empty string to clear the status.
-    /// identity after a rename or session-continue boundary where the
+    SetStatus { text: String },
-    /// system-prompt-substituted label is no longer reliable.
+    /// Fetch metadata for an agent: identity (name + role + hyperhive
-    Whoami,
+    /// rev) and current status. When `name` is `None` the caller's own
+    /// identity is returned (self-introspection — replaces the old
+    /// `Whoami` request). When `name` is `Some`, the target agent's
+    /// status fields are populated but `role`/`hyperhive_rev` reflect
+    /// the responding daemon's view (`role` is best-effort: `"manager"`
+    /// for the manager agent, `"agent"` for everyone else).
+    /// `status_text` / `status_set_at` are `None` when the target has
+    /// never set a status or the agent name is unknown.
+    GetAgentMeta {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        name: Option<String>,
+    },
     /// Cancel an open thread the agent owns: a `Question` they asked
     /// (returns `[cancelled by <self>]` as the answer to the asker)
     /// or a `Reminder` they scheduled (hard-deletes the row).
@@ -503,16 +514,23 @@ pub enum AgentResponse {
     PendingRemindersCount { count: u64 },
     /// `ReminderRollup` result: reminder activity stats for the agent.
     ReminderRollup(ReminderStats),
-    /// `Whoami` result: identity + role + the current hyperhive rev
+    /// `GetAgentMeta` result: identity + status metadata for an agent.
-    /// hive-c0re is running against. `role` is `"agent"` for
+    /// `role` is `"agent"` for sub-agents and `"manager"` for the
-    /// sub-agents (the only path that reaches this variant of the
+    /// manager. `hyperhive_rev` is `None` only when the configured
-    /// response). `hyperhive_rev` is `None` only when the configured
+    /// flake URL has no canonical path. `status_text` is the last value
-    /// flake URL has no canonical path.
+    /// written via `SetStatus`, or `None` when none has been set or the
-    Whoami {
+    /// agent name is unknown. `status_set_at` is a Unix timestamp
+    /// (seconds since epoch) of when the status was last written;
+    /// `None` when no status is set.
+    AgentMeta {
         name: String,
         role: String,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         hyperhive_rev: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        status_text: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        status_set_at: Option<i64>,
     },
 }
 
@@ -840,9 +858,15 @@ pub enum ManagerRequest {
         #[serde(default)]
         agent: Option<String>,
     },
-    /// Manager-flavour self-introspection. Same wire shape as
+    /// Mirror of `AgentRequest::SetStatus` on the manager surface.
-    /// `AgentRequest::Whoami`, but `role` is always `"manager"`.
+    SetStatus { text: String },
-    Whoami,
+    /// Mirror of `AgentRequest::GetAgentMeta` on the manager surface.
+    /// `None` returns the manager's own identity (replaces the old
+    /// `Whoami` request).
+    GetAgentMeta {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        name: Option<String>,
+    },
     /// Cancel an open thread (question or reminder). Manager surface
     /// can cancel any row (no owner check) — same dispatch as
     /// `AgentRequest::CancelLooseEnd` but with privileged auth.
@@ -918,12 +942,17 @@ pub enum ManagerResponse {
     },
     /// `ReminderRollup` result: reminder activity stats for the manager.
     ReminderRollup(ReminderStats),
-    /// `Whoami` result: manager identity. `role` is always
+    /// Mirror of `AgentResponse::AgentMeta` on the manager surface.
-    /// `"manager"`. Mirror of `AgentResponse::Whoami`.
+    /// `role` is `"manager"` for the manager and `"agent"` for any
-    Whoami {
+    /// sub-agent looked up by name.
+    AgentMeta {
         name: String,
         role: String,
         #[serde(default, skip_serializing_if = "Option::is_none")]
         hyperhive_rev: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        status_text: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        status_set_at: Option<i64>,
     },
 }