test(daemon): cover projection lifecycle

crates/maestro-daemon/tests/acp.rs

@@ -12,6 +12,7 @@ use std::time::{Duration, Instant};
 use common::{init_bare_repo, init_repo, push_all_to_origin, wait_for_async, DaemonFixture};
 use maestro_acp::schema::{ContentBlock, SessionUpdate};
 use maestro_acp::{ADAPTER_BIN, INSTALL_COMMAND};
+use maestro_daemon::projection::TurnLifecycle;
 use maestro_daemon::sidecar::{EventCursor, SidecarStore};
 use maestro_daemon::worktree::WorktreeManager;
 use maestro_daemon::SessionManager;
@@ -229,23 +230,49 @@ async fn projection_snapshot_and_live_stream_share_one_fold() {
     assert_eq!(snapshot.cursor, 1);
     assert_eq!(snapshot.rows.len(), 1);
     assert_eq!(snapshot.rows[0].kind, TranscriptRowKind::AgentText);
-    assert!(state.turn.responding);
+    assert_eq!(state.turn, Default::default());
+
+    assert!(fx
+        .manager
+        .apply_acp_turn_lifecycle(session.id, TurnLifecycle::Begin)
+        .await
+        .expect("begin lifecycle"));
+    let begin = tokio::time::timeout(Duration::from_secs(5), live.recv())
+        .await
+        .expect("begin lifecycle broadcast")
+        .expect("projection broadcast");
+    assert_eq!(begin.transcript, None);
+    assert!(begin.state.turn.responding);
+    assert!(begin.state.turn.thinking);
 
     unsafe {
         libc::kill(fake.pid() as libc::pid_t, libc::SIGUSR1);
     }
-    let live = tokio::time::timeout(Duration::from_secs(5), live.recv())
+    let agent_update = tokio::time::timeout(Duration::from_secs(5), live.recv())
         .await
         .expect("live projection")
         .expect("projection broadcast");
-    match live.transcript {
+    match agent_update.transcript {
         Some(TranscriptDelta::Append { row }) => {
             assert_eq!(row.kind, TranscriptRowKind::AgentText);
             assert_eq!(row.data["content"]["text"], "tick 1");
         }
         other => panic!("expected one appended transcript row, got {other:?}"),
     }
-    assert!(live.state.turn.responding);
+    assert!(agent_update.state.turn.responding);
+    assert!(!agent_update.state.turn.thinking);
+
+    assert!(fx
+        .manager
+        .apply_acp_turn_lifecycle(session.id, TurnLifecycle::Finish)
+        .await
+        .expect("finish lifecycle"));
+    let finish = tokio::time::timeout(Duration::from_secs(5), live.recv())
+        .await
+        .expect("finish lifecycle broadcast")
+        .expect("projection broadcast");
+    assert_eq!(finish.transcript, None);
+    assert_eq!(finish.state.turn, Default::default());
 
     fx.manager.kill(session.id, false).await.expect("kill");
 }