feat(maestro): hold agent-reported activity above inference for a TTL

crates/maestro-daemon/src/session.rs

@@ -57,6 +57,11 @@ pub struct SessionRecord {
     /// fall back to a probe.
     pub worktree_branch: Option<String>,
     pub bridge: PtyBridge,
+    /// Agent-reported activity (#105) still within its TTL. While in force it
+    /// outranks the activity pass's own inference; when it lapses, inference
+    /// resumes and [`Session::activity_detail`] is cleared with it. This
+    /// field is daemon-local bookkeeping only — it never rides the wire.
+    pub reported_activity: Option<crate::activity::ReportedActivity>,
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -136,6 +141,9 @@ struct Inner {
     /// the variable. A mutex because the runner sets it after construction,
     /// possibly while clones are already serving.
     daemon_url: std::sync::Mutex<Option<String>>,
+    /// TTL an agent-reported activity state (#105) stays in force. A const in
+    /// production; overridable for tests that watch the lapse happen.
+    report_ttl: Duration,
     sessions: Mutex<HashMap<Uuid, SessionRecord>>,
     events: broadcast::Sender<CatalogEvent>,
 }
@@ -176,6 +184,7 @@ impl SessionManager {
                 spawn_history: None,
                 retained: None,
                 daemon_url: std::sync::Mutex::new(None),
+                report_ttl: crate::activity::REPORT_TTL,
                 sessions: Mutex::new(HashMap::new()),
                 events,
             }),
@@ -208,6 +217,15 @@ impl SessionManager {
         self
     }
 
+    /// Override the agent-report TTL (#105). Tests pass a short one to watch
+    /// inference resume without waiting out [`crate::activity::REPORT_TTL`].
+    pub fn with_activity_report_ttl(mut self, ttl: Duration) -> Self {
+        let inner = Arc::get_mut(&mut self.inner)
+            .expect("with_activity_report_ttl must be called before the SessionManager is cloned");
+        inner.report_ttl = ttl;
+        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
@@ -410,6 +428,7 @@ impl SessionManager {
                     worktree_base_repo,
                     worktree_branch: req.worktree.as_ref().map(|w| w.branch.clone()),
                     bridge,
+                    reported_activity: None,
                 },
             );
         }
@@ -637,6 +656,7 @@ impl SessionManager {
                     // recovered session probes git for it at retain time.
                     worktree_branch: None,
                     bridge,
+                    reported_activity: None,
                 },
             );
             let _ = self
@@ -677,6 +697,48 @@ impl SessionManager {
             .await
             .map_err(SessionError::Tmux)
     }
+
+    /// Accept an agent-reported activity state (#105), the only path that can
+    /// produce `ActivityState::Error`. The report outranks the activity pass's
+    /// own inference until its TTL lapses — so an agent that dies mid-run
+    /// cannot pin its session at `Error` forever. An unknown session is
+    /// [`SessionError::NotFound`]; the reported `detail` is capped
+    /// server-side.
+    ///
+    /// A report that changes the effective state restarts `activity_since`
+    /// (#104's clock); re-reporting an unchanged state only extends the TTL
+    /// and stays silent on the event stream at steady state.
+    pub async fn report_activity(
+        &self,
+        id: Uuid,
+        state: ActivityState,
+        detail: Option<String>,
+    ) -> Result<(), SessionError> {
+        let now = std::time::Instant::now();
+        let updated = {
+            let mut sessions = self.inner.sessions.lock().await;
+            let rec = sessions.get_mut(&id).ok_or(SessionError::NotFound(id))?;
+            let detail = crate::activity::truncate_detail(detail);
+            let changed = rec.session.activity != state || rec.session.activity_detail != detail;
+            if rec.session.activity != state {
+                rec.session.activity_since = Utc::now();
+            }
+            rec.session.activity = state;
+            rec.session.activity_detail = detail;
+            rec.reported_activity = Some(crate::activity::ReportedActivity::new(
+                state,
+                self.inner.report_ttl,
+            ));
+            changed.then(|| rec.session.clone())
+        };
+        if let Some(session) = updated {
+            let _ = self
+                .inner
+                .events
+                .send(CatalogEvent::SessionUpdated { session });
+        }
+        Ok(())
+    }
 }
 
 /// Run a blocking `tmux` subprocess call on the blocking thread pool so it
@@ -847,8 +909,22 @@ async fn run_activity_pass(inner: &Arc<Inner>) {
             let Some(rec) = sessions.get_mut(&id) else {
                 continue;
             };
+            // #105: an agent report lapses at its TTL — drop it and its
+            // detail so this tick's inference takes over again.
+            if let Some(report) = &rec.reported_activity {
+                if !report.in_force(std::time::Instant::now()) {
+                    rec.reported_activity = None;
+                    rec.session.activity_detail = None;
+                }
+            }
             let idle = rec.bridge.idle_for();
-            let activity = crate::activity::decide(idle, awaiting);
+            // #105: while a report is in force it supplies the state and
+            // nothing here may overwrite it; only an unreported session is
+            // decided by inference.
+            let activity = match &rec.reported_activity {
+                Some(report) => report.state,
+                None => crate::activity::decide(idle, awaiting),
+            };
             let foreground = Some(pane.command.clone());
             // The pane's live cwd, drives the dir-based session tree; empty means
             // tmux reported none.