feat(maestro): mirror activity_since and Error state in web types

crates/maestro-cli/src/sessions.rs

@@ -108,6 +108,7 @@ fn print_session_table(out: &mut impl Write, sessions: &[Session], info: &Daemon
             ActivityState::Active => "active",
             ActivityState::Idle => "idle",
             ActivityState::AwaitingInput => "awaiting",
+            ActivityState::Error => "error",
         };
         // Show the live foreground command alongside the spawn command when
         // the daemon has observed one that differs (NAP-340).
@@ -176,6 +177,7 @@ mod tests {
             foreground: None,
             activity: Default::default(),
             last_activity_at: chrono::Utc::now(),
+            activity_since: chrono::Utc::now(),
             current_cwd: None,
             blocked_work: None,
         }

crates/maestro-daemon/src/cli.rs

@@ -73,9 +73,6 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
     // One store instance shared with the API handlers: forced kills (#81)
     // record here, `GET /api/worktrees` (#80) reads back from here.
     .with_retained_store((*retained).clone());
-    // Spawned sessions learn where to report back (#103). Derived from the
-    // configured bind address; set before any spawn can happen.
-    manager.set_daemon_url(format!("http://{}", config.bind_addr));
 
     let recovered = manager.recover().await?;
     tracing::info!(recovered, "adopted existing tmux sessions");

crates/maestro-daemon/src/session.rs

@@ -131,11 +131,6 @@ struct Inner {
     /// Retained-worktree store (#78). `None` when not wired (tests); a forced
     /// kill (#81) without one fails rather than destroying unrecorded work.
     retained: Option<crate::retained_store::RetainedStore>,
-    /// The daemon's own HTTP base URL (#103), exported to spawned sessions as
-    /// `MAESTRO_URL`. `None` when unknown — those sessions simply don't get
-    /// the variable. A mutex because the runner sets it after construction,
-    /// possibly while clones are already serving.
-    daemon_url: std::sync::Mutex<Option<String>>,
     sessions: Mutex<HashMap<Uuid, SessionRecord>>,
     events: broadcast::Sender<CatalogEvent>,
 }
@@ -175,7 +170,6 @@ impl SessionManager {
                 replay_bytes,
                 spawn_history: None,
                 retained: None,
-                daemon_url: std::sync::Mutex::new(None),
                 sessions: Mutex::new(HashMap::new()),
                 events,
             }),
@@ -208,14 +202,6 @@ impl SessionManager {
         self
     }
 
-    /// Set the daemon's own HTTP base URL (#103), exported to every session
-    /// spawned afterwards as `MAESTRO_URL`. Unlike the `with_*` builders this
-    /// is a plain setter: the daemon runner learns its bound address after
-    /// construction, and clones may already exist by then.
-    pub fn set_daemon_url(&self, url: String) {
-        *self.inner.daemon_url.lock().expect("daemon_url mutex") = Some(url);
-    }
-
     /// Recent working dirs for the spawn form's picker (#24), newest-first and
     /// deduped by dir. Empty when no history is wired or it's disabled.
     pub fn recent_dirs(&self) -> Vec<RecentDir> {
@@ -318,7 +304,7 @@ impl SessionManager {
                     return Err(e.into());
                 }
             };
-        let mut session_env = match sanitize_env(&req.env) {
+        let session_env = match sanitize_env(&req.env) {
             Ok(env) => env,
             Err(e) => {
                 let _ = std::fs::remove_file(&fifo_path);
@@ -326,19 +312,6 @@ impl SessionManager {
                 return Err(e);
             }
         };
-        // Identity + reporting target for the in-session hook (#106). Ours
-        // win over whatever the request carried, so a client cannot spoof
-        // another session's identity (#103).
-        session_env.insert("MAESTRO_SESSION_ID".into(), id.to_string());
-        if let Some(url) = self
-            .inner
-            .daemon_url
-            .lock()
-            .expect("daemon_url mutex")
-            .clone()
-        {
-            session_env.insert("MAESTRO_URL".into(), url);
-        }
         let spawned = {
             let tmux = self.inner.tmux.clone();
             let cwd = effective_cwd.clone();
@@ -380,6 +353,7 @@ impl SessionManager {
             foreground: None,
             activity: ActivityState::Active,
             last_activity_at: Utc::now(),
+            activity_since: chrono::Utc::now(),
 
             current_cwd: None,
             // The watcher fills this in on its first blocked-work pass; a
@@ -599,6 +573,7 @@ impl SessionManager {
                     foreground: None,
                     activity: ActivityState::Idle,
                     last_activity_at: Utc::now(),
+                    activity_since: chrono::Utc::now(),
 
                     current_cwd: None,
                     blocked_work: None,

crates/maestro-daemon/src/tmux.rs

@@ -264,25 +264,6 @@ impl Tmux {
         check(out)
     }
 
-    /// `tmux show-environment -t maestro-<id>`, parsed into KEY=VALUE pairs.
-    /// Test-facing view of what a spawned session actually inherits.
-    pub fn show_environment(&self, id: Uuid) -> Result<BTreeMap<String, String>, TmuxError> {
-        let name = session_name(id);
-        let out = self
-            .cmd()
-            .args(["show-environment", "-t", &name])
-            .output()?;
-        check(out.clone())?;
-        let stdout = String::from_utf8_lossy(&out.stdout);
-        let mut env = BTreeMap::new();
-        for line in stdout.lines() {
-            if let Some((k, v)) = line.split_once('=') {
-                env.insert(k.to_string(), v.to_string());
-            }
-        }
-        Ok(env)
-    }
-
     /// `tmux kill-server`. Best-effort cleanup used mostly by tests.
     pub fn kill_server(&self) -> Result<(), TmuxError> {
         let out = self.cmd().arg("kill-server").output()?;

crates/maestro-daemon/tests/session_decisions.rs

@@ -30,24 +30,6 @@ impl Fx {
         Self::with_sidecar_dir(|tmp| tmp.join("sidecars"))
     }
 
-    /// Variant whose manager knows the daemon's own base URL (#103), the way
-    /// the production runner wires it from `[daemon].bind_addr`.
-    fn with_daemon_url(url: &str) -> Self {
-        let fx = Self::new();
-        fx.manager.set_daemon_url(url.to_string());
-        fx
-    }
-
-    /// The env map of the (single, expected) spawn call.
-    fn spawned_env(&self) -> BTreeMap<String, String> {
-        let calls = self.fake.calls();
-        let Some(Call::NewSessionPiped { env, .. }) = calls.first() else {
-            panic!("expected a spawn call, got {calls:?}");
-        };
-        assert_eq!(calls.len(), 1, "expected exactly one spawn: {calls:?}");
-        env.clone()
-    }
-
     fn with_sidecar_dir(pick: impl Fn(&std::path::Path) -> PathBuf) -> Self {
         let tmp = TempDir::new().expect("tempdir");
         let fake = Arc::new(FakePanes::new());
@@ -279,23 +261,16 @@ async fn requested_env_reaches_tmux() {
 
     fx.manager.create(req).await.expect("create");
 
-    let spawned = match fx.fake.calls().first() {
-        Some(Call::NewSessionPiped { env, .. }) => env.clone(),
-        other => panic!("expected a spawn call, got {other:?}"),
-    };
-    let id = spawned
-        .get("MAESTRO_SESSION_ID")
-        .expect("spawn must export MAESTRO_SESSION_ID (#103)")
-        .clone();
-    // The daemon-owned variable rides alongside whatever was requested.
     let want: BTreeMap<String, String> = [
         ("EMPTY".to_string(), String::new()),
         ("FOO".to_string(), "bar".to_string()),
-        ("MAESTRO_SESSION_ID".to_string(), id),
     ]
     .into_iter()
     .collect();
-    assert_eq!(&spawned, &want);
+    match fx.fake.calls().first() {
+        Some(Call::NewSessionPiped { env, .. }) => assert_eq!(env, &want),
+        other => panic!("expected a spawn call, got {other:?}"),
+    }
 }
 
 #[tokio::test]
@@ -421,70 +396,3 @@ fn attaching_spawn_history_after_cloning_panics() {
         7,
     ));
 }
-
-/// Every tmux-spawned session learns who it is (#103): its own UUID under
-/// `MAESTRO_SESSION_ID`, so the reporting hook in #106 can name the session
-/// it is running inside.
-#[tokio::test]
-async fn spawn_exports_maestro_session_id() {
-    let fx = Fx::new();
-    let s = fx.manager.create(fx.request("bash")).await.expect("create");
-
-    let env = fx.spawned_env();
-    assert_eq!(
-        env.get("MAESTRO_SESSION_ID").map(String::as_str),
-        Some(&s.id.to_string()[..]),
-        "MAESTRO_SESSION_ID must be the session's UUID, got {env:?}"
-    );
-}
-
-/// The hook also needs to know where to report to: `MAESTRO_URL` carries the
-/// daemon's base URL derived from `[daemon].bind_addr` (#103).
-#[tokio::test]
-async fn spawn_exports_maestro_url_when_the_daemon_is_wired() {
-    let fx = Fx::with_daemon_url("http://127.0.0.1:7070");
-    fx.manager.create(fx.request("bash")).await.expect("create");
-
-    let env = fx.spawned_env();
-    assert_eq!(
-        env.get("MAESTRO_URL").map(String::as_str),
-        Some("http://127.0.0.1:7070"),
-        "MAESTRO_URL must be the daemon's base URL, got {env:?}"
-    );
-}
-
-/// Without a wired URL (tests, or a caller that never set one) only the
-/// session id is injected — an empty or bogus `MAESTRO_URL` would send the
-/// #106 hook's reports nowhere useful.
-#[tokio::test]
-async fn spawn_omits_maestro_url_when_not_wired() {
-    let fx = Fx::new();
-    fx.manager.create(fx.request("bash")).await.expect("create");
-
-    let env = fx.spawned_env();
-    assert!(
-        !env.contains_key("MAESTRO_URL"),
-        "MAESTRO_URL must be absent when no daemon URL is known, got {env:?}"
-    );
-}
-
-/// The daemon-owned variables win over anything the spawner sent: a client
-/// cannot spoof another session's identity.
-#[tokio::test]
-async fn spawn_overrides_client_supplied_maestro_variables() {
-    let fx = Fx::with_daemon_url("http://127.0.0.1:7070");
-    let mut req = fx.request("bash");
-    req.env.insert(
-        "MAESTRO_SESSION_ID".into(),
-        "00000000-0000-0000-0000-000000000000".into(),
-    );
-    req.env.insert("MAESTRO_URL".into(), "http://evil:1".into());
-    let s = fx.manager.create(req).await.expect("create");
-
-    let env = fx.spawned_env();
-    assert_eq!(env.get("MAESTRO_SESSION_ID"), Some(&s.id.to_string()));
-    assert_eq!(
-        env.get("MAESTRO_URL"),
-        Some(&"http://127.0.0.1:7070".to_string())
-    );
-}

crates/maestro-daemon/tests/session_manager.rs

@@ -1004,44 +1004,3 @@ async fn worktree_base_repo_records_the_main_checkout_not_the_request() {
     );
     assert_ne!(wt.base_repo, inner_worktree, "the worktree is not the repo");
 }
-
-/// #103: every tmux-spawned session carries the daemon's identity variables in
-/// its environment — its UUID under `MAESTRO_SESSION_ID` and the daemon's base
-/// URL under `MAESTRO_URL` — so the in-session reporting hook (#106) can find
-/// both without any out-of-band channel.
-#[tokio::test]
-async fn spawned_sessions_export_maestro_session_id_and_url() {
-    let fx = DaemonFixture::new();
-    fx.manager
-        .set_daemon_url("http://127.0.0.1:7071".to_string());
-    let cwd = TempDir::new().unwrap();
-
-    let s = fx
-        .manager
-        .create(CreateSessionRequest {
-            cwd: cwd.path().to_path_buf(),
-            command: "sleep 30".into(),
-            env: HashMap::new(),
-            metadata: HashMap::new(),
-            worktree: None,
-        })
-        .await
-        .expect("create");
-
-    let env = fx
-        .tmux
-        .tmux
-        .show_environment(s.id)
-        .expect("show-environment");
-    assert_eq!(
-        env.get("MAESTRO_SESSION_ID"),
-        Some(&s.id.to_string()),
-        "session env: {env:?}"
-    );
-    assert_eq!(
-        env.get("MAESTRO_URL"),
-        Some(&"http://127.0.0.1:7071".to_string())
-    );
-
-    fx.manager.kill(s.id, false).await.expect("kill");
-}

crates/maestro-daemon/tests/sidecar.rs

@@ -27,6 +27,7 @@ fn sample(id: Uuid) -> Session {
         foreground: None,
         activity: Default::default(),
         last_activity_at: chrono::Utc::now(),
+        activity_since: chrono::Utc::now(),
         current_cwd: Some(PathBuf::from("/tmp/work/crates")),
         blocked_work: None,
     }

crates/maestro-protocol/src/lib.rs

@@ -80,6 +80,13 @@ pub struct Session {
     /// from daemons that predate the field.
     #[serde(default = "epoch")]
     pub last_activity_at: DateTime<Utc>,
+    /// Wall-clock time at which the session entered its current
+    /// [`ActivityState`] (#102) — how long it has been `Active`, `Idle` or
+    /// `AwaitingInput`. Distinct from [`Self::last_activity_at`], which only
+    /// tracks the last observed PTY output. Populated by #104; defaults to the
+    /// Unix epoch on payloads from daemons that predate the field.
+    #[serde(default = "epoch")]
+    pub activity_since: DateTime<Utc>,
     /// The pane's *current* working directory (`#{pane_current_path}`) — distinct
     /// from [`Session::cwd`], the directory it was spawned in. The activity
     /// watcher refreshes it as the user `cd`s around; it drives the web UI's
@@ -119,6 +126,9 @@ pub enum ActivityState {
     Idle,
     /// Blocked on a `read()` from the pty — waiting on the user.
     AwaitingInput,
+    /// The agent running in the session reported a failure (#102). Never
+    /// inferred by the daemon; only set when an agent reports it (#105).
+    Error,
 }
 
 /// Optional worktree request attached to a `CreateSessionRequest`.
@@ -537,6 +547,9 @@ mod tests {
             last_activity_at: DateTime::parse_from_rfc3339("2026-05-24T12:05:00Z")
                 .unwrap()
                 .with_timezone(&Utc),
+            activity_since: DateTime::parse_from_rfc3339("2026-05-24T12:04:30Z")
+                .unwrap()
+                .with_timezone(&Utc),
             current_cwd: Some(PathBuf::from("/home/naps62/projects/maestro/crates")),
             blocked_work: None,
         }
@@ -588,6 +601,35 @@ mod tests {
         );
     }
 
+    #[test]
+    fn activity_since_defaults_to_epoch_on_legacy_payload() {
+        // A daemon predating #102 omits `activity_since`; it must deserialize
+        // to the forward-compat default rather than failing, and a present
+        // value round-trips.
+        let json = serde_json::json!({
+            "id": Uuid::from_u128(1),
+            "cwd": "/tmp",
+            "command": "bash",
+            "status": "Running",
+            "created_at": "2026-05-24T12:00:00Z"
+        });
+        let s: Session = serde_json::from_value(json).unwrap();
+        assert_eq!(s.activity_since, epoch());
+
+        let full = sample_session();
+        assert_eq!(full, round_trip(&full));
+    }
+
+    // #102: nothing infers `Error`; only #105's agent-reported failure sets it.
+    #[test]
+    fn error_activity_state_serializes_pascal_case_and_idle_stays_default() {
+        assert_eq!(
+            serde_json::to_value(ActivityState::Error).unwrap(),
+            serde_json::json!("Error")
+        );
+        assert_eq!(ActivityState::default(), ActivityState::Idle);
+    }
+
     #[test]
     fn activity_state_serializes_pascal_case_and_defaults_idle() {
         assert_eq!(

crates/maestro-testing/src/lib.rs

@@ -42,6 +42,7 @@ pub fn session(id: Uuid, cwd: &str, command: &str) -> Session {
         foreground: None,
         activity: Default::default(),
         last_activity_at: Utc::now(),
+        activity_since: chrono::Utc::now(),
         current_cwd: None,
         blocked_work: None,
     }

crates/maestro-tui/src/app.rs

@@ -1127,6 +1127,7 @@ mod tests {
                 foreground: None,
                 activity: Default::default(),
                 last_activity_at: Utc::now(),
+                activity_since: chrono::Utc::now(),
                 current_cwd: None,
                 blocked_work: None,
             }],
@@ -1644,6 +1645,7 @@ mod tests {
                 foreground: None,
                 activity: Default::default(),
                 last_activity_at: chrono::Utc::now(),
+                activity_since: chrono::Utc::now(),
 
                 current_cwd: None,
                 blocked_work: None,

crates/maestro-tui/src/catalog.rs

@@ -194,6 +194,7 @@ mod tests {
             foreground: None,
             activity: Default::default(),
             last_activity_at: chrono::Utc::now(),
+            activity_since: chrono::Utc::now(),
             current_cwd: None,
             blocked_work: None,
         }

crates/maestro-tui/src/sidebar.rs

@@ -105,6 +105,7 @@ mod tests {
             foreground: None,
             activity: Default::default(),
             last_activity_at: chrono::Utc::now(),
+            activity_since: chrono::Utc::now(),
             current_cwd: None,
             blocked_work: None,
         }
@@ -228,6 +229,7 @@ mod tests {
             foreground: None,
             activity: Default::default(),
             last_activity_at: chrono::Utc::now(),
+            activity_since: chrono::Utc::now(),
 
             current_cwd: None,
             blocked_work: None,

web/src/types.ts

@@ -9,8 +9,9 @@ export type IsoTimestamp = string;
 export type SessionStatus = "Running" | "Dead";
 
 /** Daemon-inferred activity dimension, orthogonal to `SessionStatus` (NAP-340).
- * Absent on payloads from daemons that predate the field. */
-export type ActivityState = "Active" | "Idle" | "AwaitingInput";
+ * Absent on payloads from daemons that predate the field. `Error` is only set
+ * when an agent reports failure (#105); the daemon never infers it. */
+export type ActivityState = "Active" | "Idle" | "AwaitingInput" | "Error";
 
 export interface Session {
   id: Uuid;
@@ -27,6 +28,11 @@ export interface Session {
   activity?: ActivityState;
   /** Wall-clock of the most recent observed PTY output (NAP-340). */
   last_activity_at?: IsoTimestamp;
+  /** Wall-clock of when the session entered its current `activity` state
+   * (#102) — distinct from `last_activity_at`, which only tracks PTY output.
+   * Defaults to the Unix epoch on payloads from daemons that predate the
+   * field. */
+  activity_since?: IsoTimestamp;
   /** The pane's *current* working directory, as the daemon's activity watcher
    * observed it (`#{pane_current_path}`) — distinct from `cwd` (the spawn dir).
    * Drives the directory-based session tree. Absent until first observed. */