Reason Network: your team's coding agents, talking to each other. The engine behind `reason network`.
Rust agent-to-agentai-agentsclaude-codecodexcoding-agentscursorgrokirohmcpmcp-servermulti-agentpeer-to-peerreason
//! Sessions running on this machine: registered by `reason network mcp` (a connection), or by hooks (no connection,
//! kept alive by hook events and the agent's process).
use super::{Daemon, Inner, Live, log};
use crate::{
agent,
config::{BUSY_OFF, OFF_HERE},
git::GitInfo,
proto::*,
render,
store::Remembered,
util,
};
use crate::{net::Remote, team::TeamState};
use anyhow::{Result, anyhow, bail};
use iroh::EndpointId;
use std::{
collections::{HashMap, HashSet},
sync::Arc,
time::Instant,
};
/// A hook-only session that hasn't fired a hook for this long is considered gone.
const HOOK_TTL_MS: i64 = 6 * 3_600_000;
/// A session gone this long isn't coming back: it is forgotten, with the mail it never read.
pub(super) const FORGET_MS: i64 = 24 * 3_600_000;
/// A session in a folder that is off counts as mid-turn this long after its last prompt or tool call.
const OFF_TURN_MS: i64 = 10 * 60_000;
impl Daemon {
/// How fast hooks let us reach an agent's session (`push_failed`: its push channel didn't work).
fn hook_tier(&self, agent: &str, push_failed: bool) -> Tier {
match agent {
// Native Hermes queues push events, otherwise its explicit inbox tool is the reader.
"hermes" => Tier::Pull,
"codex" if !push_failed && agent::find_bin("codex").is_some() => Tier::Push,
// Their plugin or extension delivers into idle sessions; Reason's CLI sends into its sessions.
"opencode" | "pi" | "reason" => Tier::Push,
_ => Tier::Turn,
}
}
/// Registers (or refreshes) a session. Returns its mail that is waiting, for the caller to deliver.
pub(super) fn register(self: &Arc<Self>, conn: Option<u64>, reg: SessionReg, git: GitInfo) -> Result<Registered> {
let (registered, pending) = self.register_quiet(conn, reg, git)?;
let key = pending.0;
if !pending.1.is_empty() {
let mut g = self.inner.lock().unwrap();
self.deliver(&mut g, &key, pending.1, true);
}
Ok(registered)
}
fn register_quiet(
&self,
conn: Option<u64>,
mut reg: SessionReg,
git: GitInfo,
) -> Result<(Registered, (String, Vec<Message>))> {
// Every session comes in here: one in a folder that is off never does.
if self.cfg.off_in(®.cwd) {
bail!(OFF_HERE);
}
let now = util::now_ms();
let others = self.my_names_elsewhere(now);
let mut g = self.inner.lock().unwrap();
let g = &mut *g;
let key = reg.key.clone();
if reg.agent == "antigravity" && conn.is_some() && reg.tier == Tier::Push {
let allowed =
g.store.native_app_roots(&key)?.is_some_and(|roots| roots.iter().all(|root| !self.cfg.off_in(root)));
if !allowed {
bail!("Antigravity App binding is unavailable or includes a disabled workspace");
}
}
// Its hooks said its folder is off (an MCP server several sessions share can't know its folder).
if g.off.contains_key(&key) {
bail!(OFF_HERE);
}
// An agent with an MCP server per session is in one conversation at a time: the one its server registers now
// ends any other it served (Claude Code's `/clear`, which runs no new server). Also when the new one is known
// already, from its hooks or Claude Code's registry.
if conn.is_some() && !agent::multiplexed(®.agent) {
let before: Vec<String> = g
.live
.iter()
.filter(|(k, l)| l.conn == conn && l.reg.agent == reg.agent && **k != key)
.map(|(k, _)| k.clone())
.collect();
self.moved_on(g, before, now);
}
// A Gemini window is in one conversation at a time: its hooks starting another (`/clear`, `/new`) end the one
// before, which its MCP server, outliving it, may still have. Never one registered by process (an older MCP
// server's).
if conn.is_none() && agent::session_from_hooks(®.agent) && reg.pid.is_some() && !g.live.contains_key(&key) {
let before: Vec<String> = g
.live
.iter()
.filter(|(k, l)| l.reg.agent == reg.agent && l.reg.pid == reg.pid && !k.starts_with("proc:"))
.map(|(k, _)| k.clone())
.collect();
self.moved_on(g, before, now);
}
if let Some(l) = g.live.get_mut(&key) {
// Known already (e.g. from a hook, now the MCP server connects, or a reconnect).
if conn.is_some() {
l.conn = conn;
l.attached = true;
l.mcp_push = reg.tier == Tier::Push;
}
l.reg.tier = if l.push_failed { l.reg.tier.max(Tier::Turn) } else { l.reg.tier.min(reg.tier) };
l.attached |= l.reg.tier == Tier::Push;
if l.last_hook.is_none() {
l.reg.cwd = reg.cwd;
l.git = git;
}
l.reg.pid = reg.pid.or(l.reg.pid);
} else {
if conn.is_none() {
reg.tier = reg.tier.min(self.hook_tier(®.agent, false));
}
let name = pick_name(g, ®, &git, &others, &self.person, |r| self.holds(r, now))?;
self.take_over(g, &name, &key)?;
let attached = conn.is_some() || reg.tier == Tier::Push || reg.agent == "cli";
let mcp_push = conn.is_some() && reg.tier == Tier::Push;
self.usage.count(
"registered",
crate::usage::Dimensions { source: crate::usage::family(®.agent), ..Default::default() },
1,
);
g.live.insert(
key.clone(),
Live {
through_reason: Some(conn.is_none() && reg.agent == "reason"),
reg,
name,
conn,
git,
doing: None,
since: now,
status: None,
last_hook: None,
push_failed: false,
transcript: None,
retry: None,
stop_gen: 0,
attached,
mcp_push,
mailbox: key == TERMINAL,
},
);
self.presence_changed();
}
let l = &g.live[&key];
g.store.upsert_session(&remembered(l, now), &self.person)?;
let name = l.name.clone();
let address = self.addr(&name);
let pending: Vec<Message> = g.pending(&address)?;
let wake: Vec<Message> = pending.iter().filter(|m| m.wake).cloned().collect();
log(&format!("session {address} registered"));
Ok((Registered { name, address, unread: pending.len() as u32 }, (key, wake)))
}
/// My session names on my other machines, so my addresses stay unique across them (see [`names_elsewhere`]).
fn my_names_elsewhere(&self, now: i64) -> Elsewhere {
let (Some(net), Some(team)) = (self.net(), self.team_state()) else { return Elsewhere::default() };
names_elsewhere(&net.remotes(), &team, &self.person, &self.key.public(), now)
}
/// This machine's terminal took a name another of my machines' terminal has too, while every engine in the team
/// could tell two apart in a reply. Once one that can't is in the team, it takes the next free name, as it would if
/// it registered now. (Checked as the terminal is used: each command from it comes through here.) A rename that
/// fails (another session took the name meanwhile) is logged, and the command goes on: it is tried again next time.
fn recheck_terminal(&self, others: &Elsewhere) {
self.recheck_terminal_with(others, |name| self.set_status(TERMINAL, None, Some(name)).map(drop));
}
/// `recheck_terminal`, renaming with `rename`.
fn recheck_terminal_with(&self, others: &Elsewhere, rename_to: impl FnOnce(String) -> Result<()>) {
let now = util::now_ms();
let rename = || -> Result<()> {
let name = {
let g = self.inner.lock().unwrap();
let Some(l) = g.live.get(TERMINAL) else { return Ok(()) };
if others.terminals || !others.live.contains(&l.name) {
return Ok(());
}
pick_name(&g, &l.reg, &l.git, others, &self.person, |r| self.holds(r, now))?
};
log(&format!(
"{} is on another machine too, and an older engine is in the team: now {name}",
self.addr("terminal")
));
rename_to(name)
};
if let Err(e) = rename() {
log(&format!("renaming {}: {e:#}", self.addr("terminal")));
}
}
/// Whether a session remembered here still keeps its name from every other session: one that can come back to it
/// (see [`Remembered::kept`]), until it would be forgotten. The person's own mailboxes are never forgotten.
pub(super) fn holds(&self, r: &Remembered, now: i64) -> bool {
r.kept() && (r.mailbox || now - r.last_seen <= FORGET_MS || !self.forgetting(now))
}
/// Whether sessions gone a day are forgotten yet: not just after a start, while sessions that are still up haven't
/// registered again (each gets the time a hook-only session has to show it is there).
fn forgetting(&self, now: i64) -> bool {
now - self.started > HOOK_TTL_MS
}
/// A live session turned out reachable (mail went to it or came from it): from now on its name is kept for it.
pub(super) fn reached(&self, g: &mut Inner, key: &str) {
if let Some(l) = g.live.get_mut(key)
&& !l.attached
{
l.attached = true;
let r = remembered(l, util::now_ms());
if let Err(e) = g.store.upsert_session(&r, &self.person) {
log(&format!("remembering {}: {e:#}", self.addr(&r.name)));
}
}
}
/// Ends sessions whose agent is in another conversation now: they are offline from here on, their names kept for
/// them. (The log names them by address: agents' session ids stay out of it.)
pub(super) fn moved_on(&self, g: &mut Inner, keys: Vec<String>, now: i64) {
for k in keys {
if let Some(l) = g.live.remove(&k) {
let _ = g.store.touch_session(&l.name, now);
log(&format!("session {} ended: its agent went on to another conversation", self.addr(&l.name)));
self.presence_changed();
}
}
}
/// Marks a live session as one of the person's own mailboxes, kept for good.
fn mailbox(&self, key: &str, now: i64) -> Result<()> {
let mut g = self.inner.lock().unwrap();
let g = &mut *g;
if let Some(l) = g.live.get_mut(key)
&& !l.mailbox
{
l.mailbox = true;
g.store.upsert_session(&remembered(l, now), &self.person)?;
}
Ok(())
}
/// Before `key` takes `name`: a session that kept the name until it lapsed is forgotten, with the mail it never
/// read, which is never another session's. A session known only by its process leaves its mail to the name.
fn take_over(&self, g: &mut Inner, name: &str, key: &str) -> Result<()> {
if let Some(r) = g.store.session_by_name(name)?
&& r.key != key
&& r.kept()
{
log(&format!("{} lapsed: a new session takes the name", self.addr(name)));
g.store.forget_session(&r, &self.person)?;
}
Ok(())
}
pub(super) fn set_status(&self, key: &str, doing: Option<String>, name: Option<String>) -> Result<Registered> {
let now = util::now_ms();
let others = self.my_names_elsewhere(now);
let mut g = self.inner.lock().unwrap();
let g = &mut *g;
let new_name = name.as_deref().map(util::slug);
if let Some(n) = new_name.as_deref() {
if n.is_empty() {
bail!("a name needs letters or digits");
}
if g.live.iter().any(|(k, l)| l.name == n && k != key) || others.live.contains(n) {
bail!("'{n}' is taken by a live session");
}
if n == self.person {
bail!("'{n}' is your person name; pick another session name");
}
// A name kept for a session that is offline stays its own, with its mail: never renamed into.
if let Some(r) = g.store.session_by_name(n)?.filter(|r| r.key != key && self.holds(r, now)) {
bail!(
"'{n}' belongs to a session that is offline (last seen {} ago); pick another name",
util::ago(r.last_seen, now)
);
}
if others.kept.contains(n) {
bail!("'{n}' belongs to a session on another of your machines that is offline; pick another name");
}
}
if let Some(n) = new_name.as_deref()
&& g.live.get(key).is_some_and(|l| l.name != n)
{
self.take_over(g, n, key)?;
}
let live = g.live.get_mut(key).ok_or_else(|| anyhow!("this session is not registered"))?;
if let Some(d) = doing {
let d = crate::team::without_tickets(d.trim());
live.doing = (!d.is_empty()).then(|| d.chars().take(200).collect());
}
if let Some(n) = new_name
&& n != live.name
{
g.store.rename(
&live.name,
&n,
&format!("{}/{}", self.person, live.name),
&format!("{}/{n}", self.person),
)?;
live.name = n;
}
g.store.upsert_session(&remembered(live, now), &self.person)?;
let address = self.addr(&live.name);
Ok(Registered { name: live.name.clone(), unread: g.store.unread_count(&address)?, address })
}
pub(super) fn unread(&self, key: &str) -> Result<Unread> {
let mut g = self.inner.lock().unwrap();
let Some(l) = g.live.get(key) else { return Ok(Unread { count: 0, from: Vec::new() }) };
let address = self.addr(&l.name);
let msgs = g.pending(&address)?;
let mut from: Vec<String> = Vec::new();
for m in &msgs {
if !from.contains(&m.from) {
from.push(m.from.clone());
}
}
Ok(Unread { count: msgs.len() as u32, from })
}
/// A hook fired in an agent: keep its session alive, track busy/idle, hand back mail to inject.
pub(super) async fn hook(self: &Arc<Self>, h: HookCall) -> Result<HookReply> {
let HookCall { agent, event, session_id, cwd, pid, mail, transcript, doing, name, dirs, keep, through_reason } =
h;
let (agent, event) = (agent.as_str(), event.as_str());
let key = format!("{agent}:{session_id}");
let now = util::now_ms();
let mut native_dirs: Vec<String> = cwd.iter().chain(&dirs).cloned().collect();
// In a folder that is off, by any folder the agent names: never a session here, only noted as off.
if cwd.iter().chain(&dirs).any(|d| self.cfg.off_in(d)) {
let mut g = self.inner.lock().unwrap();
if agent == "antigravity" {
g.store.remember_native_app(&key, None, &[])?;
}
if let Some(l) = g.live.remove(&key) {
let _ = g.store.touch_session(&l.name, now);
self.presence_changed();
}
match event {
"end" => {
g.off.remove(&key);
}
"doing" => {}
_ => {
g.off.insert(key, (matches!(event, "prompt" | "tool"), now));
}
}
// Hooks print nothing either way; `listen --as` says why.
bail!(OFF_HERE);
}
// Only in folders that are on (again): it left the one that is off.
self.inner.lock().unwrap().off.remove(&key);
if event == "end" {
let mut g = self.inner.lock().unwrap();
if agent == "antigravity" {
g.store.remember_native_app(&key, None, &[])?;
}
// Gemini's MCP server outlives a conversation (`/clear`): its hooks say when one ends.
if g.live
.get(&key)
.is_some_and(|l| l.conn.is_none() || agent::session_from_hooks(agent) || agent == "antigravity")
&& let Some(l) = g.live.remove(&key)
{
let _ = g.store.touch_session(&l.name, now);
log(&format!("session {} ended", self.addr(&l.name)));
self.presence_changed();
}
return Ok(HookReply::default());
}
let known = self.inner.lock().unwrap().live.contains_key(&key);
if known && key == TERMINAL {
self.recheck_terminal(&self.my_names_elsewhere(now));
}
if !known {
let remembered_cwd = self.inner.lock().unwrap().store.session_by_key(&key)?.map(|r| r.cwd);
let cwd = cwd.or(remembered_cwd).unwrap_or_else(|| "/".into());
let git = self.git(&cwd).await;
let reg = SessionReg {
key: key.clone(),
agent: agent.to_string(),
cwd,
agent_session_id: Some(session_id.clone()),
pid,
tier: Tier::Pull,
name,
};
self.register_quiet(None, reg, git)?;
}
// A name the person gave with `listen --as`: one of their own mailboxes from now on.
if keep && agent == "cli" {
self.mailbox(&key, now)?;
}
// Read a Codex rollout that is new here now, not later while holding the lock (see `deliver`).
if agent == "codex"
&& let Some(t) = &transcript
{
crate::codex::turn_running(std::path::Path::new(t));
}
let mut g = self.inner.lock().unwrap();
let g = &mut *g;
let Some(l) = g.live.get_mut(&key) else { return Ok(HookReply::default()) };
if let Some(t) = transcript {
l.transcript = Some(t.into());
}
// Only a report: it says nothing about the session's activity or how to reach it.
if event == "doing" {
if let Some(d) = doing {
let d = crate::team::without_tickets(d.trim());
l.doing = Some(d.chars().take(200).collect::<String>()).filter(|d| !d.is_empty());
}
return Ok(HookReply::default());
}
l.through_reason = through_reason;
l.last_hook = Some(now);
l.reg.tier = l.reg.tier.min(self.hook_tier(agent, l.push_failed));
if pid.is_some() {
l.reg.pid = pid;
}
let status = if matches!(event, "prompt" | "tool") { "busy" } else { "idle" };
if l.status.as_ref().is_none_or(|(s, _)| s != status) {
l.status = Some((status.to_string(), now));
}
let address = self.addr(&l.name);
let agent_kind = l.reg.agent.clone();
let native_app = agent == "antigravity"
&& l.transcript.as_ref().is_some_and(|p| crate::antigravity::app_transcript(&p.to_string_lossy()));
if native_app {
l.reg.pid = None;
if !native_dirs.contains(&l.reg.cwd) {
native_dirs.push(l.reg.cwd.clone());
}
g.store.remember_native_app(&key, Some(now), &native_dirs)?;
}
// Mid-turn, only what should interrupt; at a pause, everything.
let msgs: Vec<Message> = if mail {
g.pending(&address)?.into_iter().filter(|m| event != "tool" || m.wake).collect()
} else {
Vec::new()
};
// Not marked read here: the hook confirms with `Delivered` once it has printed them. Until then they are in
// flight, so a hook asking at the same moment (opencode 2.x can run two plugin instances) doesn't get them too.
let ids: Vec<String> = msgs.iter().map(|m| m.id.clone()).collect();
for id in &ids {
g.in_flight.insert(id.clone(), Instant::now());
}
// Its hooks hand it mail: it can be reached, and its name stays its own.
if !ids.is_empty() {
self.reached(g, &key);
}
let text = (!msgs.is_empty()).then(|| render::for_agent(&msgs, Some(&agent_kind), false));
Ok(HookReply { address: Some(address), text, ids })
}
/// The hook-known session of `agent` that is calling a tool right now, when that is unambiguous: the only
/// busy one in `cwd` (the caller is mid-turn), else the only busy one at all. None while a session of `agent` in a
/// folder that is off is mid-turn: the caller may be that one, which must never get another session's key.
pub(super) fn attach(&self, agent: &str, cwd: &str) -> Result<Option<String>> {
let mut g = self.inner.lock().unwrap();
self.prune(&mut g);
let now = util::now_ms();
let prefix = format!("{agent}:");
if g.off.iter().any(|(k, (busy, at))| *busy && now - at < OFF_TURN_MS && k.starts_with(&prefix)) {
bail!(BUSY_OFF);
}
let busy: Vec<(&String, &Live)> = g
.live
.iter()
.filter(|(_, l)| {
l.reg.agent == agent && l.last_hook.is_some() && l.status.as_ref().is_some_and(|(s, _)| s == "busy")
})
.collect();
let here: Vec<&(&String, &Live)> = busy.iter().filter(|(_, l)| l.reg.cwd == cwd).collect();
let key = match (here.as_slice(), busy.as_slice()) {
([(k, _)], _) => Some((*k).clone()),
([], [(k, _)]) => Some((*k).clone()),
_ => None,
};
// Its agent's MCP server answers for it now.
if let Some(l) = key.as_ref().and_then(|k| g.live.get_mut(k))
&& !l.attached
{
l.attached = true;
let r = remembered(l, now);
g.store.upsert_session(&r, &self.person)?;
}
Ok(key)
}
/// The session id `agent`'s live process `pid` is in, as its hooks registered it: for its MCP server, which the
/// agent gives no session id (Gemini). None unless exactly one session is its process's.
pub(super) fn linked(&self, agent: &str, pid: u32) -> Option<String> {
if !agent::session_from_hooks(agent) || !util::pid_alive(pid) {
return None;
}
let mut g = self.inner.lock().unwrap();
self.prune(&mut g);
let mut ids = g
.live
.values()
.filter(|l| l.reg.agent == agent && l.reg.pid == Some(pid) && !l.reg.key.starts_with("proc:"))
.map(|l| l.reg.agent_session_id.clone());
match (ids.next(), ids.next()) {
(Some(id), None) => id,
_ => None,
}
}
pub(super) fn drop_conn(&self, conn: u64) {
let now = util::now_ms();
let mut g = self.inner.lock().unwrap();
g.conns.remove(&conn);
if g.antigravity_conn == Some(conn) {
g.antigravity_conn = None;
}
let mine: Vec<String> = g.live.iter().filter(|(_, l)| l.conn == Some(conn)).map(|(k, _)| k.clone()).collect();
for key in mine {
let l = g.live.get_mut(&key).expect("listed above");
// Hooks still vouch for it: keep it, reachable through them.
if l.last_hook.is_some()
&& (l.reg.pid.is_some_and(util::pid_alive)
|| l.reg.agent == "antigravity"
&& l.reg.pid.is_none()
&& l.last_hook.is_some_and(|at| now - at < HOOK_TTL_MS))
{
l.conn = None;
if l.reg.agent == "antigravity" {
l.reg.tier = Tier::Turn;
l.mcp_push = false;
}
continue;
}
if let Some(l) = g.live.remove(&key) {
let _ = g.store.touch_session(&l.name, now);
log(&format!("session {} left", self.addr(&l.name)));
self.presence_changed();
}
}
}
/// Forgets hook-only sessions whose agent is gone or has been silent too long.
pub(super) fn prune(&self, g: &mut Inner) {
let now = util::now_ms();
let dead: Vec<String> = g
.live
.iter()
.filter(|(_, l)| {
l.conn.is_none()
&& (l.reg.pid.is_some_and(|p| !util::pid_alive(p))
|| l.last_hook.is_none_or(|t| now - t > HOOK_TTL_MS))
})
.map(|(k, _)| k.clone())
.collect();
for key in dead {
if let Some(l) = g.live.remove(&key) {
let _ = g.store.touch_session(&l.name, now);
}
}
g.off.retain(|_, (_, at)| now - *at <= HOOK_TTL_MS);
if self.forgetting(now) {
let live: HashSet<&str> = g.live.values().map(|l| l.name.as_str()).collect();
let _ = g.store.forget_sessions(now - FORGET_MS, &live, &self.person);
}
// Files of messages that are gone, or were read a day ago.
if now - g.swept > 10 * 60_000 {
g.swept = now;
// Live sessions are seen now: if this daemon stops without seeing them go, their names are kept from then.
for l in g.live.values() {
let _ = g.store.touch_session(&l.name, now);
}
if let Err(e) = g.store.sweep_files(now) {
log(&format!("sweeping the inbox folder: {e:#}"));
}
}
}
}
fn remembered(l: &Live, now: i64) -> Remembered {
Remembered {
name: l.name.clone(),
key: l.reg.key.clone(),
agent: l.reg.agent.clone(),
cwd: l.reg.cwd.clone(),
repo: l.git.repo.clone(),
branch: l.git.branch.clone(),
doing: l.doing.clone(),
tier: l.reg.tier,
last_seen: now,
attached: l.attached,
mailbox: l.mailbox,
}
}
/// The key of a machine's own terminal mailbox (`<you>/terminal`).
const TERMINAL: &str = "cli:terminal";
/// What a machine's presence says when its engine shows a message from another machine's terminal as from
/// `<person>/terminal@<machine>`, so its agents' replies reach the one it came from.
pub(super) const TERMINALS: &str = "terminals";
/// My session names on my other machines.
#[derive(Default, Debug, PartialEq)]
struct Elsewhere {
live: HashSet<String>,
kept: HashSet<String>,
/// Every teammate machine heard from routes replies to a terminal by machine (`TERMINALS`).
terminals: bool,
}
/// The session names on `person`'s other machines, from their presence: live sessions', and those kept there for
/// sessions that are offline (older engines don't say which). Kept names count while that machine is online or was
/// in the last day: one off longer can't still be keeping them, and its last presence, loaded from disk, would
/// otherwise hold them for good.
fn names_elsewhere(
remotes: &HashMap<EndpointId, Remote>,
team: &TeamState,
person: &str,
me: &EndpointId,
now: i64,
) -> Elsewhere {
let mut out = Elsewhere { terminals: true, ..Default::default() };
for m in team.active().filter(|m| m.endpoint != *me) {
// A machine not heard from yet (offline since before this one joined) may be of an older engine.
let r = remotes.get(&m.endpoint);
out.terminals &= r.is_some_and(|r| r.presence.has(TERMINALS));
let Some(r) = r else { continue };
if m.person != person {
continue;
}
out.live.extend(r.presence.sessions.iter().map(|s| s.name.clone()));
if r.online || now - r.last_seen <= FORGET_MS {
out.kept.extend(r.presence.kept.iter().cloned());
}
}
out
}
/// The name of a session registering here. Its own from before (and the mail waiting for it), unless a live session
/// has that now; else the name it asks for or `<repo>-<agent>`, or the first `-2`, `-3`, … that is free: that no live
/// session has, here or on my other machines, and that isn't kept for another session that is offline (`holds`). One of
/// the person's own mailboxes (`listen --as`) takes the name it asks for whenever that is free.
fn pick_name(
g: &Inner,
reg: &SessionReg,
git: &GitInfo,
elsewhere: &Elsewhere,
person: &str,
holds: impl Fn(&Remembered) -> bool,
) -> Result<String> {
// A machine's own `terminal` is its own: another machine's never makes it take a suffix, once every engine in the
// team shows which machine a terminal's message came from. (An older one couldn't tell two apart in a reply.)
let none = Elsewhere::default();
let elsewhere = if reg.key == TERMINAL && elsewhere.terminals { &none } else { elsewhere };
// The person's own name is never a session's (`<person>/<person>` would read as the person), as for a rename.
let live =
|n: &str| n == person || g.live.iter().any(|(k, l)| l.name == n && *k != reg.key) || elsewhere.live.contains(n);
let free = |n: &str| -> Result<bool> {
let kept_here = g.store.session_by_name(n)?.is_some_and(|r| r.key != reg.key && holds(&r));
Ok(!live(n) && !kept_here && !elsewhere.kept.contains(n))
};
let asked = reg.name.as_deref().map(util::slug).filter(|s| !s.is_empty());
// One of the person's own mailboxes is the name it asks for: once that is free again, it goes back to it (its mail
// from the suffixed name comes along).
if reg.key.starts_with("cli:")
&& let Some(n) = asked.as_deref()
&& free(n)?
{
return Ok(n.to_string());
}
if let Some(r) = g.store.session_by_key(®.key)?
&& !live(&r.name)
{
return Ok(r.name);
}
let base = asked.unwrap_or_else(|| agent::default_name(®.agent, ®.cwd, git));
if free(&base)? {
return Ok(base);
}
for i in 2.. {
let n = util::joined(&base, &i.to_string());
if free(&n)? {
return Ok(n);
}
}
unreachable!("some suffix is free")
}
#[cfg(test)]
mod tests {
use super::*;
const DAY: i64 = 24 * 3_600_000;
fn claude(id: &str) -> SessionReg {
SessionReg {
key: format!("claude-code:{id}"),
agent: agent::CLAUDE_CODE.into(),
cwd: "/work/api".into(),
agent_session_id: Some(id.into()),
pid: None,
tier: Tier::Push,
name: None,
}
}
fn named(key: &str, agent: &str, name: Option<&str>) -> SessionReg {
SessionReg {
key: key.into(),
agent: agent.into(),
cwd: "/work/api".into(),
agent_session_id: None,
pid: None,
tier: Tier::Pull,
name: name.map(str::to_string),
}
}
/// Registers a session through an MCP server of its own, as Claude Code runs one per session; a `cli` one as
/// `listen --as` does, as one of the person's own mailboxes.
fn join(d: &Daemon, reg: SessionReg) -> Registered {
let (conn, key, cli) = (conn_of(®.key), reg.key.clone(), reg.agent == "cli");
let r = d.register_quiet(Some(conn), reg, GitInfo::default()).unwrap().0;
if cli {
d.mailbox(&key, util::now_ms()).unwrap();
}
r
}
/// The connection of the MCP server `join` registers a session through.
fn conn_of(key: &str) -> u64 {
key.bytes().fold(7, |h: u64, b| h.wrapping_mul(31).wrapping_add(b.into()))
}
/// Takes a session here offline, last seen `ago` before now.
fn leave(d: &Daemon, key: &str, ago: i64) {
let mut g = d.inner.lock().unwrap();
let name = g.live.remove(key).unwrap().name;
g.store.touch_session(&name, util::now_ms() - ago).unwrap();
}
/// The daemon restarts: nothing is live until sessions register again.
fn restart(d: &Daemon) {
d.inner.lock().unwrap().live.clear();
}
/// Long enough after a start that sessions gone a day are forgotten.
fn settled(d: &mut Daemon) {
d.started -= HOOK_TTL_MS + 1;
}
fn mail(d: &Daemon, id: &str, name: &str) {
let mut m = Message {
id: id.into(),
from: "sven/web-codex".into(),
from_agent: None,
from_repo: None,
to: d.addr(name),
via: None,
reply_to: None,
body: format!("for {name}"),
wake: true,
notify: false,
sent_at: 0,
approval: None,
files: Vec::new(),
};
d.inner.lock().unwrap().store.insert(&mut m, false).unwrap();
}
#[test]
fn a_conversation_gets_its_name_and_mail_back_after_a_restart_whoever_registers_first() {
let d = super::super::test_daemon(Default::default());
assert_eq!(join(&d, claude("a")).name, "api-claude");
assert_eq!(join(&d, claude("b")).name, "api-claude-2");
restart(&d);
mail(&d, "m1", "api-claude");
mail(&d, "m2", "api-claude-2");
// A new conversation in the same folder comes back first: both names are kept, and it gets none of their mail.
let new = join(&d, claude("c"));
assert_eq!((new.name.as_str(), new.unread), ("api-claude-3", 0));
// Then the two others, in the other order.
let b = join(&d, claude("b"));
assert_eq!((b.name.as_str(), b.unread), ("api-claude-2", 1));
let a = join(&d, claude("a"));
assert_eq!((a.name.as_str(), a.unread), ("api-claude", 1));
}
#[test]
fn a_new_conversation_never_takes_the_name_or_mail_of_one_that_is_offline() {
let d = super::super::test_daemon(Default::default());
join(&d, claude("a"));
leave(&d, "claude-code:a", 3 * 3_600_000);
mail(&d, "m1", "api-claude");
// Asking for the name doesn't get it either.
let new = join(&d, named("cli:api-claude", "cli", Some("api-claude")));
assert_eq!((new.name.as_str(), new.unread), ("api-claude-2", 0));
let other = join(&d, claude("c"));
assert_eq!((other.name.as_str(), other.unread), ("api-claude-3", 0));
// Resumed hours later, the conversation is still api-claude, with its mail.
let a = join(&d, claude("a"));
assert_eq!((a.name.as_str(), a.unread), ("api-claude", 1));
}
#[tokio::test]
async fn a_pasted_invite_line_never_reaches_teammates_through_what_a_session_is_doing() {
let cfg = crate::config::Config { person: Some("alex".into()), ..Default::default() };
let d = Arc::new(super::super::test_daemon(cfg));
let mut team = crate::team::TeamState::found("acme", &d.person, &d.machine, &d.key);
team.new_link(&d.key);
let secret = team.link_secret().expect("a team link").to_string();
d.inner.lock().unwrap().team = Some(team);
let l = d.link(false).await.unwrap();
let line = crate::invite_line(&l.url);
// `status <doing>` from an agent's shell; a `doing` hook; a session kept by a build that stored the line.
join(&d, claude("a"));
d.set_status("claude-code:a", Some(format!("{line} then fix CI")), None).unwrap();
join(&d, claude("b"));
let doing = HookCall {
through_reason: Some(false),
agent: "claude-code".into(),
event: "doing".into(),
session_id: "b".into(),
cwd: Some("/work/api".into()),
pid: None,
mail: false,
transcript: None,
doing: Some(line.clone()),
name: None,
dirs: Vec::new(),
keep: false,
};
d.hook(doing).await.unwrap();
let old = Remembered {
name: "old".into(),
key: "claude-code:old".into(),
agent: "claude-code".into(),
cwd: "/work/api".into(),
repo: None,
branch: None,
doing: Some(line.clone()),
tier: Tier::Push,
last_seen: util::now_ms() - 60_000,
attached: true,
mailbox: false,
};
d.inner.lock().unwrap().store.upsert_session(&old, &d.person).unwrap();
let dir = d.who(None, None, true).await.unwrap();
let presence = serde_json::to_string(&d.presence().await).unwrap();
let stored = format!("{:?}", d.inner.lock().unwrap().store.session_by_name("api-claude").unwrap());
let agent = crate::render::directory_for_agent(&dir);
for out in [&serde_json::to_string(&dir).unwrap(), &agent, &presence, &stored] {
assert!(!out.contains("rn1-") && !out.contains(&l.ticket) && !out.contains(&secret), "{out}");
}
let doings: Vec<_> = dir.sessions.iter().filter_map(|s| s.doing.as_deref()).collect();
assert_eq!(
doings.iter().filter(|d| d.starts_with("Join the Reason Network: (team link)")).count(),
3,
"{doings:?}"
);
assert!(agent.contains("doing: Join the Reason Network: (team link) then fix CI"), "{agent}");
}
#[tokio::test]
async fn a_conversation_coming_back_through_its_hooks_gets_its_name_too() {
let d = Arc::new(super::super::test_daemon(Default::default()));
let call = |id: &str| HookCall {
through_reason: Some(false),
agent: "claude-code".into(),
event: "start".into(),
session_id: id.into(),
cwd: Some("/work/api".into()),
pid: None,
mail: true,
transcript: None,
doing: None,
name: None,
dirs: Vec::new(),
keep: false,
};
// Its MCP server registered it; then it ends.
assert_eq!(join(&d, claude("a")).name, "api-claude");
d.hook(call("a")).await.unwrap();
d.drop_conn(conn_of("claude-code:a"));
d.hook(HookCall { event: "end".into(), ..call("a") }).await.unwrap();
mail(&d, "m1", "api-claude");
assert_eq!(d.hook(call("b")).await.unwrap().address, Some(d.addr("api-claude-2")));
let back = d.hook(call("a")).await.unwrap();
assert_eq!(back.address, Some(d.addr("api-claude")));
assert!(back.text.is_some_and(|t| t.contains("for api-claude")));
}
#[tokio::test]
async fn a_hermes_conversations_hooks_never_promise_delivery_at_its_next_turn() {
let d = Arc::new(super::super::test_daemon(Default::default()));
// Its plugin registers it pull (wake off), and calls hooks only for activity: they never carry mail.
join(&d, named("hermes:p:1", "hermes", None));
for event in ["prompt", "tool", "stop"] {
d.hook(HookCall {
through_reason: Some(false),
agent: "hermes".into(),
event: event.into(),
session_id: "p:1".into(),
cwd: Some("/work/api".into()),
pid: None,
mail: false,
transcript: None,
doing: None,
name: None,
dirs: Vec::new(),
keep: false,
})
.await
.unwrap();
assert_eq!(d.inner.lock().unwrap().live["hermes:p:1"].reg.tier, Tier::Pull, "after {event}");
}
}
#[test]
fn a_name_is_kept_until_its_conversation_would_be_forgotten_and_then_comes_without_its_mail() {
let mut d = super::super::test_daemon(Default::default());
join(&d, claude("a"));
leave(&d, "claude-code:a", DAY + 60_000);
mail(&d, "m1", "api-claude");
// Just after a start, sessions still up may not have registered again: nothing has lapsed yet.
assert_eq!(join(&d, claude("b")).name, "api-claude-2");
settled(&mut d);
// A day on, the name is free again, but the mail stays the forgotten conversation's: it is dropped.
let c = join(&d, claude("c"));
assert_eq!((c.name.as_str(), c.unread), ("api-claude", 0));
assert_eq!(d.inner.lock().unwrap().store.unread_count(&d.addr("api-claude")).unwrap(), 0);
// Back after that, the conversation is a new session.
assert_eq!(join(&d, claude("a")).name, "api-claude-3");
}
#[test]
fn live_sessions_are_seen_as_they_run_so_a_restart_after_days_up_keeps_their_names() {
let mut d = super::super::test_daemon(Default::default());
settled(&mut d);
join(&d, claude("a"));
// Registered days ago, and still up.
d.inner.lock().unwrap().store.touch_session("api-claude", util::now_ms() - 3 * DAY).unwrap();
let mut g = d.inner.lock().unwrap();
d.prune(&mut g);
let r = g.store.session_by_name("api-claude").unwrap().unwrap();
assert!(util::now_ms() - r.last_seen < 60_000);
}
#[test]
fn renaming_into_a_name_kept_for_an_offline_session_is_refused() {
let mut d = super::super::test_daemon(Default::default());
join(&d, claude("a"));
leave(&d, "claude-code:a", 3 * 3_600_000);
mail(&d, "m1", "api-claude");
join(&d, claude("b"));
let e = d.set_status("claude-code:b", None, Some("API Claude".into())).unwrap_err();
assert_eq!(
e.to_string(),
"'api-claude' belongs to a session that is offline (last seen 3h ago); pick another name"
);
// A name of its own is fine, and its own mail comes along.
mail(&d, "m2", "api-claude-2");
let r = d.set_status("claude-code:b", None, Some("auth".into())).unwrap();
assert_eq!((r.name.as_str(), r.unread), ("auth", 1));
// Once the offline one has lapsed, the name can be taken, without that session's mail.
leave(&d, "claude-code:b", 0);
join(&d, claude("b"));
d.inner.lock().unwrap().store.touch_session("api-claude", util::now_ms() - 2 * DAY).unwrap();
settled(&mut d);
let r = d.set_status("claude-code:b", None, Some("api-claude".into())).unwrap();
assert_eq!(r.name, "api-claude");
let unread = d.inner.lock().unwrap().store.unread(&r.address).unwrap();
assert_eq!(unread.iter().map(|m| m.id.as_str()).collect::<Vec<_>>(), ["m2"]);
}
#[test]
fn the_persons_own_mailboxes_keep_their_names_for_good() {
let mut d = super::super::test_daemon(Default::default());
settled(&mut d);
join(&d, named("cli:review", "cli", Some("review")));
leave(&d, "cli:review", 30 * DAY);
mail(&d, "m1", "review");
// A Claude Code session someone named "review" can't have that mailbox.
let c = join(&d, SessionReg { name: Some("Review".into()), ..claude("c") });
assert_eq!((c.name.as_str(), c.unread), ("review-2", 0));
let r = join(&d, named("cli:review", "cli", Some("review")));
assert_eq!((r.name.as_str(), r.unread), ("review", 1));
}
#[tokio::test]
async fn the_reason_clis_one_off_ask_sessions_are_sessions_like_any_other() {
let mut d = super::super::test_daemon(Default::default());
settled(&mut d);
let d = Arc::new(d);
let cli = |id: &str, keep: bool| HookCall {
through_reason: Some(false),
agent: "cli".into(),
event: "stop".into(),
session_id: id.into(),
cwd: Some("/work/api".into()),
pid: None,
mail: false,
transcript: None,
doing: None,
name: Some(id.into()),
dirs: Vec::new(),
keep,
};
// `reason network <who> "…"` waits for its answer at a session of its own; `listen --as review` is a mailbox.
d.hook(cli("ask-1a2b3c", false)).await.unwrap();
d.hook(cli("review", true)).await.unwrap();
for key in ["cli:ask-1a2b3c", "cli:review"] {
leave(&d, key, 2 * DAY);
}
mail(&d, "m1", "ask-1a2b3c");
mail(&d, "m2", "review");
// Neither is named to the person's other machines (each machine has its own).
assert!(d.presence_of(Vec::new()).kept.is_empty());
// A day on, the ask session is forgotten with its mail, as any session is; the mailbox stays, mail and all.
{
let mut g = d.inner.lock().unwrap();
d.prune(&mut g);
assert!(g.store.session_by_key("cli:ask-1a2b3c").unwrap().is_none());
assert_eq!(g.store.unread_count(&d.addr("ask-1a2b3c")).unwrap(), 0);
assert!(g.store.session_by_key("cli:review").unwrap().is_some_and(|r| r.mailbox));
assert_eq!(g.store.unread_count(&d.addr("review")).unwrap(), 1);
}
// The terminal is always one of the person's own mailboxes, whoever registers it.
d.hook(cli("terminal", false)).await.unwrap();
assert!(d.inner.lock().unwrap().store.session_by_key(TERMINAL).unwrap().is_some_and(|r| r.mailbox));
}
#[test]
fn a_session_known_only_by_its_process_leaves_its_name_and_mail_to_the_next_in_its_place() {
let d = super::super::test_daemon(Default::default());
assert_eq!(join(&d, named("proc:11", "zed", None)).name, "api-zed");
leave(&d, "proc:11", 3 * 3_600_000);
mail(&d, "m1", "api-zed");
// As before: nothing could come back for it, so "tell the api agent" reaches the one there now.
let next = join(&d, named("proc:12", "zed", None));
assert_eq!((next.name.as_str(), next.unread), ("api-zed", 1));
// But it can't take a name kept for a conversation.
join(&d, claude("a"));
leave(&d, "claude-code:a", 0);
assert_eq!(join(&d, named("proc:13", "zed", Some("api-claude"))).name, "api-claude-2");
}
#[test]
fn rows_an_older_engine_left_are_kept_for_their_sessions_and_others_work_as_before() {
let d = super::super::test_daemon(Default::default());
let row = |name: &str, key: &str| Remembered {
name: name.into(),
key: key.into(),
agent: agent::CLAUDE_CODE.into(),
cwd: "/work/api".into(),
repo: None,
branch: None,
doing: None,
tier: Tier::Push,
last_seen: util::now_ms() - 3_600_000,
attached: true,
mailbox: false,
};
{
let g = d.inner.lock().unwrap();
for (name, key) in
[("api-claude", "claude-code:a"), ("api-claude-2", "claude-code:b"), ("api-claude-3", "proc:5")]
{
g.store.upsert_session(&row(name, key), &d.person).unwrap();
}
}
for (id, name) in [("m1", "api-claude"), ("m2", "api-claude-2"), ("m3", "api-claude-3")] {
mail(&d, id, name);
}
// Rows with an agent's id are kept for it from the start; one known by its process is taken, mail and all.
let new = join(&d, claude("d"));
assert_eq!((new.name.as_str(), new.unread), ("api-claude-3", 1));
let b = join(&d, claude("b"));
assert_eq!((b.name.as_str(), b.unread), ("api-claude-2", 1));
let a = join(&d, claude("a"));
assert_eq!((a.name.as_str(), a.unread), ("api-claude", 1));
}
#[test]
fn a_session_whose_name_went_elsewhere_takes_its_mail_to_its_new_one() {
let d = super::super::test_daemon(Default::default());
join(&d, claude("a"));
leave(&d, "claude-code:a", 3_600_000);
mail(&d, "m1", "api-claude");
// An older engine on another of my machines gave the name to a live session there.
let elsewhere =
Elsewhere { live: HashSet::from(["api-claude".to_string()]), kept: HashSet::new(), terminals: true };
let mut g = d.inner.lock().unwrap();
let g = &mut *g;
let name = pick_name(g, &claude("a"), &GitInfo::default(), &elsewhere, &d.person, |_| true).unwrap();
assert_eq!(name, "api-claude-2");
let r = Remembered {
name: name.clone(),
key: "claude-code:a".into(),
agent: agent::CLAUDE_CODE.into(),
cwd: "/work/api".into(),
repo: None,
branch: None,
doing: None,
tier: Tier::Push,
last_seen: util::now_ms(),
attached: true,
mailbox: false,
};
g.store.upsert_session(&r, &d.person).unwrap();
assert!(g.store.session_by_name("api-claude").unwrap().is_none());
assert_eq!(g.store.unread_count(&d.addr("api-claude-2")).unwrap(), 1);
}
#[test]
fn names_kept_on_my_other_machines_go_to_no_new_session_here() {
let d = super::super::test_daemon(Default::default());
let elsewhere = Elsewhere {
live: HashSet::from(["api-claude".to_string()]),
kept: HashSet::from(["api-claude-2".to_string()]),
terminals: true,
};
let g = d.inner.lock().unwrap();
assert_eq!(
pick_name(&g, &claude("c"), &GitInfo::default(), &elsewhere, &d.person, |_| true).unwrap(),
"api-claude-3"
);
}
#[test]
fn presence_tells_my_other_machines_which_names_are_kept() {
let mut d = super::super::test_daemon(Default::default());
settled(&mut d);
join(&d, claude("a"));
join(&d, named("cli:terminal", "cli", Some("terminal")));
join(&d, named("proc:9", "zed", None));
join(&d, claude("old"));
join(&d, claude("up"));
leave(&d, "claude-code:a", 3_600_000);
leave(&d, "cli:terminal", 3 * DAY);
leave(&d, "proc:9", 3_600_000);
leave(&d, "claude-code:old", 2 * DAY);
let p = d.presence_of(Vec::new());
let mut known = p.known.clone();
known.sort();
assert_eq!(known, ["api-claude", "api-claude-2", "api-zed", "terminal"]);
// Not each machine's own `terminal`, nor a session that can't come back, nor one that has lapsed.
assert_eq!(p.kept, ["api-claude"]);
}
#[tokio::test]
async fn a_run_only_its_hooks_ever_saw_keeps_no_name() {
let d = Arc::new(super::super::test_daemon(Default::default()));
let call = |id: &str, event: &str| HookCall {
through_reason: Some(false),
agent: "claude-code".into(),
event: event.into(),
session_id: id.into(),
cwd: Some("/work/api".into()),
pid: None,
mail: true,
transcript: None,
doing: None,
name: None,
dirs: Vec::new(),
keep: false,
};
// A headless run: hooks only, never an MCP server, a push channel or a listen.
assert_eq!(d.hook(call("p", "start")).await.unwrap().address, Some(d.addr("api-claude")));
d.hook(call("p", "end")).await.unwrap();
mail(&d, "m1", "api-claude");
let r = d.inner.lock().unwrap().store.session_by_name("api-claude").unwrap().unwrap();
assert!(!r.kept());
// As for a session without an id: the next one in its place takes the name, mail and all.
let next = join(&d, claude("q"));
assert_eq!((next.name.as_str(), next.unread), ("api-claude", 1));
// A run whose MCP server answers for it is reachable, so its name is kept from then on.
assert_eq!(d.hook(call("r", "prompt")).await.unwrap().address, Some(d.addr("api-claude-2")));
let mut cursor = call("r", "prompt");
cursor.agent = "cursor".into();
d.hook(cursor).await.unwrap();
assert_eq!(d.attach("cursor", "/work/api").unwrap().as_deref(), Some("cursor:r"));
assert!(d.inner.lock().unwrap().store.session_by_key("cursor:r").unwrap().unwrap().kept());
}
fn gemini(id: &str, event: &str) -> HookCall {
HookCall {
through_reason: Some(false),
agent: "gemini".into(),
event: event.into(),
session_id: id.into(),
cwd: Some("/work/api".into()),
pid: None,
mail: true,
transcript: None,
doing: None,
name: None,
dirs: Vec::new(),
keep: false,
}
}
/// A Gemini hook from process `pid`, and its MCP server registering `key` over its connection `conn`.
fn gemini_hook(id: &str, event: &str, pid: u32) -> HookCall {
HookCall { pid: Some(pid), ..gemini(id, event) }
}
fn gemini_mcp(d: &Daemon, conn: u64, key: &str, pid: u32) {
let id = key.strip_prefix("gemini:").map(str::to_string);
let reg = SessionReg { agent_session_id: id, pid: Some(pid), ..named(key, "gemini", None) };
d.register_quiet(Some(conn), reg, GitInfo::default()).unwrap();
}
fn live_sessions(d: &Daemon) -> Vec<(String, String, Tier)> {
let g = d.inner.lock().unwrap();
let mut v: Vec<_> = g.live.iter().map(|(k, l)| (k.clone(), l.name.clone(), l.reg.tier)).collect();
v.sort();
v
}
/// A process that has exited.
fn gone_pid() -> u32 {
let mut child = std::process::Command::new(std::env::current_exe().unwrap())
.arg("--list")
.stdout(std::process::Stdio::null())
.spawn()
.unwrap();
child.wait().unwrap();
child.id()
}
#[tokio::test]
async fn geminis_mcp_server_goes_by_the_session_its_hooks_registered() {
// Gemini gives its MCP servers no session id, only its hooks: its MCP server asks for the session the hooks of
// its own process registered, and registers that, which keeps its hooks' tier.
let d = Arc::new(super::super::test_daemon(Default::default()));
let (me, other) = (std::process::id(), util::parent_pid());
d.hook(gemini_hook("g1", "start", me)).await.unwrap();
assert_eq!(d.linked("gemini", me).as_deref(), Some("g1"));
assert_eq!(d.linked("gemini", other), None);
gemini_mcp(&d, 1, "gemini:g1", me);
assert_eq!(live_sessions(&d), [("gemini:g1".into(), "api-gemini".into(), Tier::Turn)]);
// Only Gemini's: agents whose MCP calls name the session, or that share one MCP server, never ask.
let mut cursor = gemini_hook("c1", "start", me);
cursor.agent = "cursor".into();
d.hook(cursor).await.unwrap();
assert_eq!((d.linked("cursor", me), d.linked("claude-code", me), d.linked("codex", me)), (None, None, None));
}
#[tokio::test]
async fn an_older_gemini_mcp_server_keeps_the_session_it_registered_by_process() {
// An MCP server from before (or one whose hooks were late) registered by its process: its hooks coming never
// take that key away, so it keeps working across an upgrade.
let d = Arc::new(super::super::test_daemon(Default::default()));
let me = std::process::id();
gemini_mcp(&d, 7, "proc:7", me);
d.hook(gemini_hook("g2", "start", me)).await.unwrap();
let keys: Vec<String> = live_sessions(&d).into_iter().map(|(k, ..)| k).collect();
assert_eq!(keys, ["gemini:g2", "proc:7"]);
// A current one goes by its hooks' session from then on: over the same connection, that ends its own.
gemini_mcp(&d, 7, "gemini:g2", me);
assert_eq!(live_sessions(&d), [("gemini:g2".into(), "api-gemini-2".into(), Tier::Turn)]);
}
#[tokio::test]
async fn a_new_conversation_in_a_gemini_window_ends_the_one_before() {
let d = Arc::new(super::super::test_daemon(Default::default()));
let me = std::process::id();
d.hook(gemini_hook("g1", "start", me)).await.unwrap();
gemini_mcp(&d, 3, "gemini:g1", me);
// `/clear`: SessionEnd, then SessionStart with a new id, the same MCP server throughout.
d.hook(gemini_hook("g1", "end", me)).await.unwrap();
assert_eq!(live_sessions(&d), []);
d.hook(gemini_hook("g2", "start", me)).await.unwrap();
assert_eq!(d.linked("gemini", me).as_deref(), Some("g2"));
gemini_mcp(&d, 3, "gemini:g2", me);
assert_eq!(live_sessions(&d).len(), 1);
// A SessionEnd that never came: the next conversation's start ends this one all the same. An older MCP
// server's session, registered by process, stays.
gemini_mcp(&d, 9, "proc:9", me);
d.hook(gemini_hook("g3", "start", me)).await.unwrap();
let keys: Vec<String> = live_sessions(&d).into_iter().map(|(k, ..)| k).collect();
assert_eq!(keys, ["gemini:g3", "proc:9"]);
}
#[tokio::test]
async fn no_session_is_linked_when_it_is_unclear_or_its_process_is_gone() {
let d = Arc::new(super::super::test_daemon(Default::default()));
let me = std::process::id();
// Two of its process's sessions: neither is taken for the other.
d.hook(gemini_hook("g1", "start", me)).await.unwrap();
gemini_mcp(&d, 5, "gemini:g9", me);
assert_eq!(d.linked("gemini", me), None);
// A process that has exited (its id may be some other process's soon).
let gone = gone_pid();
d.hook(gemini_hook("g4", "start", gone)).await.unwrap();
assert_eq!(d.linked("gemini", gone), None);
}
#[tokio::test]
async fn a_session_its_hooks_hand_mail_to_keeps_its_name() {
// Gemini is reached through its hooks only: no MCP connection or push channel ever.
let d = Arc::new(super::super::test_daemon(Default::default()));
assert_eq!(d.hook(gemini("g1", "start")).await.unwrap().address, Some(d.addr("api-gemini")));
mail(&d, "m1", "api-gemini");
let got = d.hook(gemini("g1", "stop")).await.unwrap();
assert!(got.text.is_some_and(|t| t.contains("for api-gemini")));
d.hook(gemini("g1", "end")).await.unwrap();
mail(&d, "m2", "api-gemini");
// A new conversation gets the next name, and none of g1's mail.
let g2 = d.hook(gemini("g2", "start")).await.unwrap();
assert_eq!((g2.address, g2.text.is_some()), (Some(d.addr("api-gemini-2")), false));
// g1, resumed, is api-gemini again, with what came meanwhile.
let back = d.hook(gemini("g1", "start")).await.unwrap();
assert_eq!(back.address, Some(d.addr("api-gemini")));
assert!(back.text.is_some_and(|t| t.contains("for api-gemini")));
}
#[tokio::test]
async fn a_session_that_sends_or_is_sent_mail_keeps_its_name() {
let d = Arc::new(super::super::test_daemon(Default::default()));
d.hook(gemini("s", "start")).await.unwrap();
let mut copilot = gemini("r", "start");
copilot.agent = "copilot".into();
d.hook(copilot.clone()).await.unwrap();
// s writes to r, whose hooks haven't shown it yet.
d.send("gemini:s".into(), &d.addr("api-copilot"), "hi", None, true, false, None, Vec::new()).await.unwrap();
let g = d.inner.lock().unwrap();
for key in ["gemini:s", "copilot:r"] {
assert!(g.store.session_by_key(key).unwrap().unwrap().kept(), "{key}");
}
}
#[tokio::test]
async fn a_session_stays_reachable_once_it_has_been() {
let d = Arc::new(super::super::test_daemon(Default::default()));
d.hook(gemini("g1", "start")).await.unwrap();
mail(&d, "m1", "api-gemini");
d.hook(gemini("g1", "stop")).await.unwrap();
d.hook(gemini("g1", "end")).await.unwrap();
// Back through its hooks, with no mail this time, then gone again: still kept.
d.hook(gemini("g1", "start")).await.unwrap();
d.hook(gemini("g1", "end")).await.unwrap();
assert!(d.inner.lock().unwrap().store.session_by_key("gemini:g1").unwrap().unwrap().kept());
assert_eq!(d.hook(gemini("g2", "start")).await.unwrap().address, Some(d.addr("api-gemini-2")));
}
#[test]
fn a_listen_mailbox_goes_back_to_the_name_it_asks_for_once_free() {
let mut d = super::super::test_daemon(Default::default());
join(&d, named("cli:review-x", "cli", Some("x")));
join(&d, SessionReg { name: Some("review".into()), ..claude("a") });
leave(&d, "claude-code:a", 3_600_000);
// `listen --as review` while the name is kept for the conversation: the next free one.
assert_eq!(join(&d, named("cli:review", "cli", Some("review"))).name, "review-2");
leave(&d, "cli:review", 0);
mail(&d, "m1", "review-2");
assert_eq!(join(&d, named("cli:review", "cli", Some("review"))).name, "review-2");
leave(&d, "cli:review", 0);
// Once the conversation's name lapses, the mailbox takes it, and its mail comes along.
d.inner.lock().unwrap().store.touch_session("review", util::now_ms() - 2 * DAY).unwrap();
settled(&mut d);
let r = join(&d, named("cli:review", "cli", Some("review")));
assert_eq!((r.name.as_str(), r.unread), ("review", 1));
assert!(d.inner.lock().unwrap().store.session_by_name("review-2").unwrap().is_none());
}
#[tokio::test]
async fn mail_held_for_a_conversation_goes_with_it_and_never_to_the_next_session() {
let cfg = crate::config::Config {
person: Some("alex".into()),
inbound: crate::config::Inbound { default: crate::config::Policy::Hold, ..Default::default() },
..Default::default()
};
let mut d = super::super::test_daemon(cfg);
let bob = iroh::SecretKey::generate();
let mut team = TeamState::found("acme", &d.person, &d.machine, &d.key);
team.put_member(&d.key, bob.public(), "bob", "xps", true);
d.inner.lock().unwrap().team = Some(team);
let d = {
join(&d, claude("a"));
join(&d, named("proc:5", "zed", None));
leave(&d, "claude-code:a", 0);
leave(&d, "proc:5", 0);
settled(&mut d);
Arc::new(d)
};
let (h1, h2) = (ulid::Ulid::generate().to_string(), ulid::Ulid::generate().to_string());
let from_bob = |id: &str, to: &str| Message {
id: id.into(),
from: "bob/web".into(),
from_agent: None,
from_repo: None,
to: d.addr(to),
via: None,
reply_to: None,
body: "hi".into(),
wake: true,
notify: false,
sent_at: 0,
approval: None,
files: Vec::new(),
};
let (state, note) = d.receive(bob.public(), from_bob(&h1, "api-claude")).unwrap();
assert_eq!(state, "held");
assert_eq!(note, "held until alex approves it; dropped if that session is gone for a day first");
// Held for a session without an id, it stays the person's to settle, for whoever has the name, as before.
assert_eq!(d.receive(bob.public(), from_bob(&h2, "api-zed")).unwrap().1, "held until alex approves it");
// A day on, both names lapse: the conversation's held mail goes with it.
{
let g = d.inner.lock().unwrap();
g.store.touch_session("api-claude", util::now_ms() - 2 * DAY).unwrap();
g.store.touch_session("api-zed", util::now_ms() - 2 * DAY).unwrap();
}
let next = join(&d, claude("b"));
assert_eq!(next.name, "api-claude");
let held: Vec<String> = d.inner.lock().unwrap().store.held().unwrap().into_iter().map(|m| m.id).collect();
assert_eq!(held, [h2]);
assert_eq!(d.settle(&[], true).unwrap(), 1);
assert_eq!(d.inner.lock().unwrap().store.unread_count(&d.addr("api-claude")).unwrap(), 0);
}
#[test]
fn names_elsewhere_are_my_other_machines_and_kept_ones_only_while_they_could_still_be_kept() {
let d = super::super::test_daemon(crate::config::Config { person: Some("alex".into()), ..Default::default() });
let (desk, old, bob) = (iroh::SecretKey::generate(), iroh::SecretKey::generate(), iroh::SecretKey::generate());
let mut team = TeamState::found("acme", &d.person, &d.machine, &d.key);
team.put_member(&d.key, desk.public(), "alex", "desk", true);
team.put_member(&d.key, old.public(), "alex", "old", true);
team.put_member(&d.key, bob.public(), "bob", "xps", true);
let now = util::now_ms();
let remote = |live: &str, kept: &str, online: bool, last_seen: i64| Remote {
presence: crate::net::Presence {
sessions: vec![SessionInfo {
address: String::new(),
name: live.into(),
person: String::new(),
machine: String::new(),
agent: "codex".into(),
cwd: String::new(),
repo: None,
branch: None,
status: "idle".into(),
since: None,
doing: None,
tier: Tier::Pull,
unread: 0,
is_me: false,
}],
known: vec![kept.into()],
kept: vec![kept.into()],
..Default::default()
},
last_seen,
online,
};
let remotes = HashMap::from([
(desk.public(), remote("desk-live", "desk-kept", false, now - 3_600_000)),
// Off for two days: what it kept then has lapsed by now.
(old.public(), remote("old-live", "old-kept", false, now - 2 * DAY)),
// Another person's names are theirs.
(bob.public(), remote("bob-live", "bob-kept", true, now)),
]);
let e = names_elsewhere(&remotes, &team, "alex", &d.key.public(), now);
let set = |v: &[&str]| v.iter().map(|s| s.to_string()).collect::<HashSet<_>>();
assert_eq!(e.live, set(&["desk-live", "old-live"]));
assert_eq!(e.kept, set(&["desk-kept"]));
// None of those engines said it tells terminals apart by machine.
assert!(!e.terminals);
}
#[test]
fn terminals_go_by_machine_only_once_every_machine_in_the_team_says_it_can() {
let d = super::super::test_daemon(crate::config::Config { person: Some("alex".into()), ..Default::default() });
let (desk, olga) = (iroh::SecretKey::generate(), iroh::SecretKey::generate());
let mut team = TeamState::found("acme", &d.person, &d.machine, &d.key);
team.put_member(&d.key, desk.public(), "alex", "desk", true);
team.put_member(&d.key, olga.public(), "olga", "oldbox", true);
let now = util::now_ms();
let new = Remote {
presence: crate::net::Presence { features: vec![TERMINALS.into()], ..Default::default() },
last_seen: now,
online: true,
};
let me = d.key.public();
// olga's machine hasn't been heard from (it was off when this one joined): it may be an older engine.
let remotes = HashMap::from([(desk.public(), new.clone())]);
assert!(!names_elsewhere(&remotes, &team, "alex", &me, now).terminals);
// Heard from, and an older engine.
let old = Remote { presence: Default::default(), ..new.clone() };
let remotes = HashMap::from([(desk.public(), new.clone()), (olga.public(), old)]);
assert!(!names_elsewhere(&remotes, &team, "alex", &me, now).terminals);
// Every other machine says it can (this one isn't asked).
let remotes = HashMap::from([(desk.public(), new.clone()), (olga.public(), new)]);
assert!(names_elsewhere(&remotes, &team, "alex", &me, now).terminals);
}
#[tokio::test]
async fn a_terminal_takes_a_suffix_once_an_older_engine_turns_up() {
let d = Arc::new(super::super::test_daemon(Default::default()));
assert_eq!(join(&d, named(TERMINAL, "cli", Some("terminal"))).name, "terminal");
mail(&d, "m1", "terminal");
let mut others =
Elsewhere { live: HashSet::from(["terminal".to_string()]), terminals: true, ..Default::default() };
// Every engine tells two apart: it stays `terminal`.
d.recheck_terminal(&others);
assert_eq!(d.inner.lock().unwrap().live[TERMINAL].name, "terminal");
// An older one is in the team now: the next free name, with its mail.
others.terminals = false;
d.recheck_terminal(&others);
let g = d.inner.lock().unwrap();
assert_eq!(g.live[TERMINAL].name, "terminal-2");
assert_eq!(g.store.unread_count(&d.addr("terminal-2")).unwrap(), 1);
}
#[tokio::test]
async fn a_terminal_rename_that_fails_never_fails_the_command() {
let d = Arc::new(super::super::test_daemon(Default::default()));
assert_eq!(join(&d, named(TERMINAL, "cli", Some("terminal"))).name, "terminal");
let others =
Elsewhere { live: HashSet::from(["terminal".to_string()]), terminals: false, ..Default::default() };
// The rename loses a race: another session took the name it picked meanwhile.
d.recheck_terminal_with(&others, |name| bail!("'{name}' is taken by a live session"));
assert_eq!(d.inner.lock().unwrap().live[TERMINAL].name, "terminal");
// The terminal's commands go on as before.
let call = HookCall {
through_reason: Some(false),
agent: "cli".into(),
event: "stop".into(),
session_id: "terminal".into(),
cwd: Some("/".into()),
pid: None,
mail: false,
transcript: None,
doing: None,
name: Some("terminal".into()),
dirs: Vec::new(),
keep: false,
};
assert_eq!(d.hook(call).await.unwrap().address, Some(d.addr("terminal")));
}
#[test]
fn no_session_is_named_after_its_person() {
let d = super::super::test_daemon(crate::config::Config { person: Some("lars".into()), ..Default::default() });
// `listen --as lars`, and a Claude Code session someone named Lars.
assert_eq!(join(&d, named("cli:lars", "cli", Some("lars"))).name, "lars-2");
assert_eq!(join(&d, SessionReg { name: Some("Lars".into()), ..claude("a") }).name, "lars-3");
// Nor a session coming back to such a name an older engine gave it.
let r = Remembered {
name: "lars".into(),
key: "claude-code:old".into(),
agent: agent::CLAUDE_CODE.into(),
cwd: "/work/api".into(),
repo: None,
branch: None,
doing: None,
tier: Tier::Push,
last_seen: util::now_ms(),
attached: true,
mailbox: false,
};
d.inner.lock().unwrap().store.upsert_session(&r, &d.person).unwrap();
assert_eq!(join(&d, claude("old")).name, "api-claude");
}
#[test]
fn each_machine_has_its_own_terminal() {
let d = super::super::test_daemon(Default::default());
let mut elsewhere = Elsewhere {
live: HashSet::from(["terminal".to_string()]),
kept: HashSet::from(["review".to_string()]),
terminals: false,
};
let g = d.inner.lock().unwrap();
let terminal = named(TERMINAL, "cli", Some("terminal"));
// While an older engine in the team couldn't tell two apart in a reply, the second one on is `terminal-2`.
assert_eq!(
pick_name(&g, &terminal, &GitInfo::default(), &elsewhere, &d.person, |_| true).unwrap(),
"terminal-2"
);
elsewhere.terminals = true;
assert_eq!(pick_name(&g, &terminal, &GitInfo::default(), &elsewhere, &d.person, |_| true).unwrap(), "terminal");
// Any other session asking for it, or for a name kept elsewhere, still gets the next free one.
let other = named("cli:t2", "cli", Some("terminal"));
assert_eq!(pick_name(&g, &other, &GitInfo::default(), &elsewhere, &d.person, |_| true).unwrap(), "terminal-2");
let review = named("cli:review", "cli", Some("review"));
assert_eq!(pick_name(&g, &review, &GitInfo::default(), &elsewhere, &d.person, |_| true).unwrap(), "review-2");
}
#[test]
fn presence_names_the_most_recent_kept_names_when_there_are_too_many() {
let d = super::super::test_daemon(Default::default());
let now = util::now_ms();
{
let g = d.inner.lock().unwrap();
for i in 0..120 {
let r = Remembered {
name: format!("s{i}"),
key: format!("codex:{i}"),
agent: "codex".into(),
cwd: "/work/api".into(),
repo: None,
branch: None,
doing: None,
tier: Tier::Pull,
last_seen: now - 1_000 * (120 - i),
attached: true,
mailbox: false,
};
g.store.upsert_session(&r, &d.person).unwrap();
}
}
let p = d.presence_of(Vec::new());
assert_eq!(p.kept.len(), 100);
assert_eq!(
(p.kept.first().map(String::as_str), p.kept.last().map(String::as_str)),
(Some("s119"), Some("s20"))
);
assert_eq!(p.known, p.kept);
}
#[test]
fn a_session_in_a_folder_that_is_off_never_registers() {
let cfg = crate::config::Config {
folders: [("/work/private".to_string(), "off".to_string())].into(),
..Default::default()
};
let d = super::super::test_daemon(cfg);
let reg = |key: &str, cwd: &str| SessionReg {
key: key.into(),
agent: "codex".into(),
cwd: cwd.into(),
agent_session_id: None,
pid: None,
tier: Tier::Pull,
name: None,
};
let err = d.register_quiet(None, reg("codex:1", "/work/private/notes"), GitInfo::default()).unwrap_err();
assert_eq!(err.to_string(), OFF_HERE);
let (r, _) = d.register_quiet(Some(1), reg("codex:2", "/work/private-api"), GitInfo::default()).unwrap();
assert_eq!(r.name, "private-api-codex");
let g = d.inner.lock().unwrap();
assert_eq!(g.live.keys().collect::<Vec<_>>(), ["codex:2"]);
assert!(g.store.session_by_key("codex:1").unwrap().is_none());
}
#[test]
fn a_new_conversation_from_the_same_mcp_server_ends_the_one_before() {
let d = super::super::test_daemon(Default::default());
let reg = |key: &str, agent: &str| SessionReg {
key: key.into(),
agent: agent.into(),
cwd: "/work/api".into(),
agent_session_id: None,
pid: None,
tier: Tier::Pull,
name: None,
};
// Claude Code's `/clear`: its MCP server now registers the new conversation.
assert_eq!(
d.register_quiet(Some(1), reg("claude-code:a", "claude-code"), GitInfo::default()).unwrap().0.name,
"api-claude"
);
d.register_quiet(Some(2), reg("claude-code:other", "claude-code"), GitInfo::default()).unwrap();
let (r, _) = d.register_quiet(Some(1), reg("claude-code:b", "claude-code"), GitInfo::default()).unwrap();
// The cleared conversation keeps its name: `/resume` can bring it back.
assert_eq!(r.name, "api-claude-3");
assert!(d.inner.lock().unwrap().store.session_by_name("api-claude").unwrap().unwrap().kept());
let live = |d: &Daemon| {
let mut k: Vec<String> = d.inner.lock().unwrap().live.keys().cloned().collect();
k.sort();
k
};
assert_eq!(live(&d), ["claude-code:b", "claude-code:other"]);
// The registry scan can register the new conversation before the server's next call does: its call then still
// ends the one before.
d.register_quiet(
None,
SessionReg { tier: Tier::Push, ..reg("claude-code:c", "claude-code") },
GitInfo::default(),
)
.unwrap();
d.register_quiet(Some(1), reg("claude-code:c", "claude-code"), GitInfo::default()).unwrap();
assert_eq!(live(&d), ["claude-code:c", "claude-code:other"]);
let g = d.inner.lock().unwrap();
assert_eq!(g.live["claude-code:c"].conn, Some(1));
drop(g);
// One shared MCP server serves many sessions at once.
d.register_quiet(Some(3), reg("codex:1", "codex"), GitInfo::default()).unwrap();
d.register_quiet(Some(3), reg("codex:2", "codex"), GitInfo::default()).unwrap();
assert_eq!(live(&d), ["claude-code:c", "claude-code:other", "codex:1", "codex:2"]);
}
#[tokio::test]
async fn a_session_its_hooks_put_in_a_folder_that_is_off_never_gets_a_key() {
let cfg = crate::config::Config {
folders: [("/work/private".to_string(), "off".to_string())].into(),
..Default::default()
};
let d = Arc::new(super::super::test_daemon(cfg));
let call = |id: &str, event: &str, dirs: &[&str]| HookCall {
through_reason: Some(false),
agent: "cursor".into(),
event: event.into(),
session_id: id.into(),
cwd: Some("/work/api".into()),
pid: None,
mail: true,
transcript: None,
doing: None,
name: None,
dirs: dirs.iter().map(|d| d.to_string()).collect(),
keep: false,
};
// Working in /work/api, with /work/private open too.
let e = d.hook(call("c1", "prompt", &["/work/private"])).await.unwrap_err();
assert_eq!(e.to_string(), OFF_HERE);
assert!(!d.inner.lock().unwrap().live.contains_key("cursor:c1"));
// Its MCP server (shared, in another folder) can't register it either.
let reg = SessionReg {
key: "cursor:c1".into(),
agent: "cursor".into(),
cwd: "/work/api".into(),
agent_session_id: None,
pid: None,
tier: Tier::Pull,
name: None,
};
assert_eq!(d.register_quiet(Some(1), reg, GitInfo::default()).unwrap_err().to_string(), OFF_HERE);
// Another session, mid-turn: while c1 is mid-turn too, a call naming no session can't be handed its key.
assert!(d.hook(call("c2", "prompt", &[])).await.unwrap().address.is_some());
assert_eq!(d.attach("cursor", "/work/api").unwrap_err().to_string(), BUSY_OFF);
assert!(d.hook(call("c1", "stop", &["/work/private"])).await.is_err());
assert_eq!(d.attach("cursor", "/work/api").unwrap().as_deref(), Some("cursor:c2"));
// Once its folders are all on again, it is a session like any other.
assert!(d.hook(call("c1", "prompt", &[])).await.unwrap().address.is_some());
assert!(d.inner.lock().unwrap().live.contains_key("cursor:c1"));
}
}