feat(maestro): server-side prompt queue for structured sessions
Prompts sent while a turn is active are queued on the daemon instead of in the browser's React state. The queue is persisted in the session sidecar and drained as the next turn when the current one completes. Fixes the bug where queued messages were delivered to the wrong session when switching focus in the UI: the client-side queue captured the new sessionId in its drain closure. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 4.6
parent
cd5bbcfcb1
commit
ebe25a1a55
@@ -483,13 +483,12 @@ async fn structured_prompt(
|
||||
Json(body): Json<StructuredPromptRequest>,
|
||||
) -> Response {
|
||||
match s.manager.queue_acp_prompt(id, body.prompt).await {
|
||||
Ok(QueueAcpPrompt::Queued) | Ok(QueueAcpPrompt::Pending) => {
|
||||
StatusCode::NO_CONTENT.into_response()
|
||||
}
|
||||
Ok(QueueAcpPrompt::InFlight) => error_response(
|
||||
StatusCode::CONFLICT,
|
||||
"turn_in_flight",
|
||||
"the structured session already has an active turn",
|
||||
Ok(QueueAcpPrompt::Dispatched) => StatusCode::NO_CONTENT.into_response(),
|
||||
Ok(QueueAcpPrompt::Queued) => StatusCode::ACCEPTED.into_response(),
|
||||
Ok(QueueAcpPrompt::Full) => error_response(
|
||||
StatusCode::TOO_MANY_REQUESTS,
|
||||
"queue_full",
|
||||
"the prompt queue has reached its capacity",
|
||||
),
|
||||
Ok(QueueAcpPrompt::Unavailable) => error_response(
|
||||
StatusCode::CONFLICT,
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
//! single point through which the API handlers and the per-session WS
|
||||
//! handler interact with tmux.
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::collections::{HashMap, HashSet, VecDeque};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Weak};
|
||||
@@ -15,8 +15,8 @@ use chrono::Utc;
|
||||
use maestro_acp::{AcpAdapter, AcpSession, PermissionRequest, SpawnConfig};
|
||||
use maestro_protocol::display::command_tool;
|
||||
use maestro_protocol::{
|
||||
ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, NameSource, Session,
|
||||
SessionStatus, SessionView, StructuredReplayEvent, TranscriptDelta, TranscriptRow,
|
||||
ActivityState, CatalogEvent, CreateSessionRequest, ErrorInfo, NameSource, ReducedState,
|
||||
Session, SessionStatus, SessionView, StructuredReplayEvent, TranscriptDelta, TranscriptRow,
|
||||
TranscriptRowKind, WorktreeSpec, NAME_KEY, NAME_SOURCE_KEY,
|
||||
};
|
||||
use tokio::sync::{broadcast, oneshot, watch, Mutex, Notify};
|
||||
@@ -122,9 +122,6 @@ pub struct SessionRecord {
|
||||
/// When `true`, the permission pump auto-responds `AllowAlways` to every
|
||||
/// ACP permission request without surfacing it to clients.
|
||||
pub auto_approve: bool,
|
||||
/// A prompt submitted while the adapter was still booting (`Starting`).
|
||||
/// The background handshake task drains this on success.
|
||||
pub pending_prompt: Option<String>,
|
||||
}
|
||||
|
||||
impl SessionRecord {
|
||||
@@ -149,6 +146,9 @@ struct StructuredActivityWatermark {
|
||||
sequence: u64,
|
||||
}
|
||||
|
||||
/// Maximum number of prompts that can be queued while a turn is in flight.
|
||||
const PROMPT_QUEUE_CAP: usize = 20;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct AcpEventStream {
|
||||
log: EventLog,
|
||||
@@ -160,6 +160,10 @@ struct AcpEventStream {
|
||||
/// claimed: it is queued onto ACP before another operation can proceed.
|
||||
operation: Arc<Mutex<()>>,
|
||||
dispatch: AcpDispatchState,
|
||||
/// Server-side FIFO of prompts accepted while a turn was in flight or the
|
||||
/// adapter was still booting. Drained as a single concatenated prompt when
|
||||
/// the current turn completes. Persisted to the session sidecar.
|
||||
prompt_queue: VecDeque<String>,
|
||||
activity_sequence: u64,
|
||||
}
|
||||
|
||||
@@ -168,6 +172,23 @@ impl AcpEventStream {
|
||||
self.activity_sequence += 1;
|
||||
(self.activity_sequence, self.projection.activity())
|
||||
}
|
||||
|
||||
/// The reduced state with the prompt queue overlaid. Every broadcast and
|
||||
/// snapshot should use this instead of `projection.state()` directly so
|
||||
/// clients always see the current queue.
|
||||
fn state_with_queue(&self) -> ReducedState {
|
||||
let mut state = self.projection.state();
|
||||
state.queued_prompts = self.prompt_queue.iter().cloned().collect();
|
||||
state
|
||||
}
|
||||
|
||||
/// Broadcast a projection update with the prompt queue overlaid into the
|
||||
/// state. Every `projected_live.send` should go through this so clients
|
||||
/// never see a stale queue.
|
||||
fn broadcast(&self, mut update: ProjectionUpdate) {
|
||||
update.state.queued_prompts = self.prompt_queue.iter().cloned().collect();
|
||||
let _ = self.projected_live.send(update);
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
@@ -235,11 +256,14 @@ pub enum BeginAcpTurn {
|
||||
/// Result of serializing a projected turn claim with its ACP prompt enqueue.
|
||||
#[derive(Debug)]
|
||||
pub enum QueueAcpPrompt {
|
||||
/// The prompt was dispatched to ACP immediately (no turn was in flight).
|
||||
Dispatched,
|
||||
/// The prompt was accepted into the server-side queue and will be
|
||||
/// dispatched when the current turn completes.
|
||||
Queued,
|
||||
/// The adapter is still booting; the prompt is held until it is ready.
|
||||
Pending,
|
||||
InFlight,
|
||||
Unavailable,
|
||||
/// The prompt queue has reached its capacity.
|
||||
Full,
|
||||
Failed(String),
|
||||
}
|
||||
|
||||
@@ -662,7 +686,7 @@ impl SessionManager {
|
||||
let live = stream.projected_live.subscribe();
|
||||
Ok(Some((
|
||||
stream.projection.snapshot(stream.log.last_seq()),
|
||||
stream.projection.state(),
|
||||
stream.state_with_queue(),
|
||||
live,
|
||||
)))
|
||||
}
|
||||
@@ -692,7 +716,7 @@ impl SessionManager {
|
||||
return Ok(false);
|
||||
};
|
||||
let projected = persist_turn_update(&mut stream, projected);
|
||||
let _ = stream.projected_live.send(projected);
|
||||
stream.broadcast(projected);
|
||||
drop(stream);
|
||||
sync_structured_activity(&self.inner, id).await;
|
||||
Ok(true)
|
||||
@@ -717,7 +741,7 @@ impl SessionManager {
|
||||
return Ok(BeginAcpTurn::InFlight);
|
||||
}
|
||||
let (turn, update) = stream.projection.begin_turn();
|
||||
let _ = stream.projected_live.send(update);
|
||||
stream.broadcast(update);
|
||||
drop(stream);
|
||||
sync_structured_activity(&self.inner, id).await;
|
||||
Ok(BeginAcpTurn::Started(acp, turn))
|
||||
@@ -735,13 +759,28 @@ impl SessionManager {
|
||||
text: String,
|
||||
) -> Result<QueueAcpPrompt, SessionError> {
|
||||
let (acp, stream) = {
|
||||
let mut sessions = self.inner.sessions.lock().await;
|
||||
let record = sessions.get_mut(&id).ok_or(SessionError::NotFound(id))?;
|
||||
// While the adapter is booting, stash the prompt for the
|
||||
// background handshake task to drain on success.
|
||||
let sessions = self.inner.sessions.lock().await;
|
||||
let record = sessions.get(&id).ok_or(SessionError::NotFound(id))?;
|
||||
if record.is_starting_structured() {
|
||||
record.pending_prompt = Some(text);
|
||||
return Ok(QueueAcpPrompt::Pending);
|
||||
// Adapter still booting — queue the prompt for drain on boot
|
||||
// success. The AcpEventStream exists, just no ACP handle yet.
|
||||
let stream = record
|
||||
.acp_events
|
||||
.clone()
|
||||
.expect("structured session has events at Starting");
|
||||
let mut stream = stream.lock().await;
|
||||
if stream.prompt_queue.len() >= PROMPT_QUEUE_CAP {
|
||||
return Ok(QueueAcpPrompt::Full);
|
||||
}
|
||||
stream.prompt_queue.push_back(text);
|
||||
let update = ProjectionUpdate {
|
||||
transcript: None,
|
||||
state: stream.projection.state(),
|
||||
};
|
||||
stream.broadcast(update);
|
||||
drop(stream);
|
||||
self.persist_prompt_queue(id).await;
|
||||
return Ok(QueueAcpPrompt::Queued);
|
||||
}
|
||||
if !record.is_live_structured() {
|
||||
return Ok(QueueAcpPrompt::Unavailable);
|
||||
@@ -762,12 +801,37 @@ impl SessionManager {
|
||||
}
|
||||
if let Some(turn) = stream.dispatch.queued_turn {
|
||||
if stream.dispatch.cancelled_turn != Some(turn) {
|
||||
return Ok(QueueAcpPrompt::InFlight);
|
||||
// Turn is in flight — queue instead of rejecting.
|
||||
if stream.prompt_queue.len() >= PROMPT_QUEUE_CAP {
|
||||
return Ok(QueueAcpPrompt::Full);
|
||||
}
|
||||
stream.prompt_queue.push_back(text);
|
||||
let update = ProjectionUpdate {
|
||||
transcript: None,
|
||||
state: stream.projection.state(),
|
||||
};
|
||||
stream.broadcast(update);
|
||||
drop(stream);
|
||||
self.persist_prompt_queue(id).await;
|
||||
return Ok(QueueAcpPrompt::Queued);
|
||||
}
|
||||
Some((turn, stream.dispatch.settled.clone()))
|
||||
} else {
|
||||
if stream.projection.turn_active() {
|
||||
return Ok(QueueAcpPrompt::InFlight);
|
||||
// Projection says active but dispatch says idle —
|
||||
// queue rather than rejecting.
|
||||
if stream.prompt_queue.len() >= PROMPT_QUEUE_CAP {
|
||||
return Ok(QueueAcpPrompt::Full);
|
||||
}
|
||||
stream.prompt_queue.push_back(text);
|
||||
let update = ProjectionUpdate {
|
||||
transcript: None,
|
||||
state: stream.projection.state(),
|
||||
};
|
||||
stream.broadcast(update);
|
||||
drop(stream);
|
||||
self.persist_prompt_queue(id).await;
|
||||
return Ok(QueueAcpPrompt::Queued);
|
||||
}
|
||||
let row = TranscriptRow {
|
||||
id: format!("user:{}", Uuid::new_v4()),
|
||||
@@ -789,9 +853,9 @@ impl SessionManager {
|
||||
let logged = LoggedEvent { seq, event };
|
||||
let projected = stream.projection.restore_row(row);
|
||||
let _ = stream.live.send(logged);
|
||||
let _ = stream.projected_live.send(projected);
|
||||
stream.broadcast(projected);
|
||||
let (turn, update) = stream.projection.begin_turn();
|
||||
let _ = stream.projected_live.send(update);
|
||||
stream.broadcast(update);
|
||||
match acp.prompt(text.clone(), turn) {
|
||||
Ok(done) => {
|
||||
stream.dispatch.queued_turn = Some(turn);
|
||||
@@ -809,7 +873,7 @@ impl SessionManager {
|
||||
if let Ok(true) = self.claim_autoname(id).await {
|
||||
crate::autoname::spawn_naming(self.clone(), id, text);
|
||||
}
|
||||
return Ok(QueueAcpPrompt::Queued);
|
||||
return Ok(QueueAcpPrompt::Dispatched);
|
||||
}
|
||||
Err(message) => {
|
||||
cancel_pending_approvals(&mut stream);
|
||||
@@ -820,7 +884,7 @@ impl SessionManager {
|
||||
"newly claimed turn remains current while stream is locked",
|
||||
);
|
||||
let projected = persist_turn_update(&mut stream, projected);
|
||||
let _ = stream.projected_live.send(projected);
|
||||
stream.broadcast(projected);
|
||||
drop(stream);
|
||||
sync_structured_activity(&self.inner, id).await;
|
||||
return Ok(QueueAcpPrompt::Failed(message));
|
||||
@@ -840,6 +904,27 @@ impl SessionManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// Persist the current prompt queue to the session sidecar.
|
||||
async fn persist_prompt_queue(&self, id: Uuid) {
|
||||
let stream_arc = {
|
||||
let sessions = self.inner.sessions.lock().await;
|
||||
sessions.get(&id).and_then(|r| r.acp_events.clone())
|
||||
};
|
||||
let Some(stream_arc) = stream_arc else { return };
|
||||
let queue: Vec<String> = stream_arc
|
||||
.lock()
|
||||
.await
|
||||
.prompt_queue
|
||||
.iter()
|
||||
.cloned()
|
||||
.collect();
|
||||
let mut sessions = self.inner.sessions.lock().await;
|
||||
if let Some(record) = sessions.get_mut(&id) {
|
||||
record.session.queued_prompts = queue;
|
||||
let _ = self.inner.sidecar.write(&record.session);
|
||||
}
|
||||
}
|
||||
|
||||
async fn finish_queued_acp_turn(&self, id: Uuid, turn: u64, lifecycle: TurnLifecycle) {
|
||||
let stream = self
|
||||
.inner
|
||||
@@ -860,16 +945,33 @@ impl SessionManager {
|
||||
stream.dispatch.cancelled_turn = None;
|
||||
}
|
||||
stream.dispatch.settled.notify_waiters();
|
||||
if stream.projection.active_turn() != Some(turn) {
|
||||
return;
|
||||
}
|
||||
cancel_pending_approvals(&mut stream);
|
||||
if let Some(projected) = stream.projection.turn_lifecycle(lifecycle, turn) {
|
||||
let projected = persist_turn_update(&mut stream, projected);
|
||||
let _ = stream.projected_live.send(projected);
|
||||
if stream.projection.active_turn() == Some(turn) {
|
||||
cancel_pending_approvals(&mut stream);
|
||||
if let Some(projected) = stream.projection.turn_lifecycle(lifecycle, turn) {
|
||||
let projected = persist_turn_update(&mut stream, projected);
|
||||
stream.broadcast(projected);
|
||||
}
|
||||
}
|
||||
// Drain the prompt queue: concatenate all queued prompts into a single
|
||||
// prompt and dispatch as the next turn. This must run even when the
|
||||
// projection already ended the turn (e.g. cancel settled via the event
|
||||
// stream before this function ran).
|
||||
let queued_text = if stream.prompt_queue.is_empty() {
|
||||
None
|
||||
} else {
|
||||
let texts: Vec<String> = stream.prompt_queue.drain(..).collect();
|
||||
Some(texts.join("\n\n"))
|
||||
};
|
||||
drop(stream);
|
||||
sync_structured_activity(&self.inner, id).await;
|
||||
if let Some(text) = queued_text {
|
||||
self.persist_prompt_queue(id).await;
|
||||
// Cannot call queue_acp_prompt here (async cycle via the spawn
|
||||
// inside queue_acp_prompt → finish_queued_acp_turn → here).
|
||||
// Spawn an independent task instead.
|
||||
let manager = self.clone();
|
||||
drain_prompt_queue(manager, id, text);
|
||||
}
|
||||
}
|
||||
|
||||
async fn fail_cancelled_acp_turn(
|
||||
@@ -983,7 +1085,7 @@ impl SessionManager {
|
||||
.turn_lifecycle(TurnLifecycle::Cancel, turn)
|
||||
.expect("active turn remains current while stream is locked");
|
||||
let projected = persist_turn_update(&mut stream, projected);
|
||||
let _ = stream.projected_live.send(projected);
|
||||
stream.broadcast(projected);
|
||||
drop(stream);
|
||||
sync_structured_activity(&self.inner, id).await;
|
||||
if let Some(turn) = cancelled_queued_turn {
|
||||
@@ -1032,7 +1134,7 @@ impl SessionManager {
|
||||
let outcome = permission_outcome(decision, &pending.options);
|
||||
let _ = pending.response.send(outcome);
|
||||
if let Some(update) = stream.projection.resolve_approval(nonce) {
|
||||
let _ = stream.projected_live.send(update);
|
||||
stream.broadcast(update);
|
||||
}
|
||||
drop(stream);
|
||||
sync_structured_activity(&self.inner, id).await;
|
||||
@@ -1340,6 +1442,7 @@ impl SessionManager {
|
||||
pending_approvals: HashMap::new(),
|
||||
operation: Arc::new(Mutex::new(())),
|
||||
dispatch: AcpDispatchState::default(),
|
||||
prompt_queue: VecDeque::new(),
|
||||
activity_sequence: 0,
|
||||
}))
|
||||
}
|
||||
@@ -1405,6 +1508,7 @@ impl SessionManager {
|
||||
acp_session_id: None,
|
||||
view: req.view,
|
||||
auto_approve: req.auto_approve,
|
||||
queued_prompts: Vec::new(),
|
||||
};
|
||||
|
||||
if let Err(e) = self.inner.sidecar.write(&session) {
|
||||
@@ -1436,7 +1540,6 @@ impl SessionManager {
|
||||
structured_activity_watermark: None,
|
||||
acp_event_pump: None,
|
||||
auto_approve: req.auto_approve,
|
||||
pending_prompt: None,
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -1490,8 +1593,8 @@ impl SessionManager {
|
||||
let acp = Arc::new(acp_session);
|
||||
let done = start_acp_event_pump(&inner, id, &acp, events.clone());
|
||||
start_acp_permission_pump(&inner, id, &acp, events.clone(), auto_approve);
|
||||
// Drain any prompt submitted while Starting.
|
||||
let pending_prompt = {
|
||||
// Drain any prompts queued while the adapter was Starting.
|
||||
let queued_text = {
|
||||
let mut sessions = inner.sessions.lock().await;
|
||||
let Some(record) = sessions.get_mut(&id) else {
|
||||
// Session was killed while we were booting.
|
||||
@@ -1505,17 +1608,30 @@ impl SessionManager {
|
||||
record.session.acp_session_id = Some(acp.session_id().to_string());
|
||||
record.session.activity = ActivityState::Idle;
|
||||
record.session.activity_since = Utc::now();
|
||||
let queued = if let Some(ref stream) = record.acp_events {
|
||||
let mut stream = stream.lock().await;
|
||||
if stream.prompt_queue.is_empty() {
|
||||
None
|
||||
} else {
|
||||
let texts: Vec<String> =
|
||||
stream.prompt_queue.drain(..).collect();
|
||||
Some(texts.join("\n\n"))
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
record.session.queued_prompts.clear();
|
||||
let _ = inner.sidecar.write(&record.session);
|
||||
let _ = inner.events.send(CatalogEvent::SessionUpdated {
|
||||
session: record.session.clone(),
|
||||
});
|
||||
record.pending_prompt.take()
|
||||
queued
|
||||
};
|
||||
if let Some(prompt) = pending_prompt {
|
||||
if let Some(text) = queued_text {
|
||||
let manager = SessionManager {
|
||||
inner: inner.clone(),
|
||||
};
|
||||
let _ = manager.queue_acp_prompt(id, prompt).await;
|
||||
let _ = manager.queue_acp_prompt(id, text).await;
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -1680,6 +1796,7 @@ impl SessionManager {
|
||||
// other field's forward-compat default.
|
||||
view: maestro_protocol::SessionView::Terminal,
|
||||
auto_approve: false,
|
||||
queued_prompts: Vec::new(),
|
||||
},
|
||||
};
|
||||
let fifo_path = self.inner.fifo_dir.join(format!("{id}.fifo"));
|
||||
@@ -1718,7 +1835,6 @@ impl SessionManager {
|
||||
structured_activity_watermark: None,
|
||||
acp_event_pump: None,
|
||||
auto_approve: session.auto_approve,
|
||||
pending_prompt: None,
|
||||
},
|
||||
);
|
||||
let _ = self
|
||||
@@ -1846,6 +1962,7 @@ impl SessionManager {
|
||||
pending_approvals: HashMap::new(),
|
||||
operation: Arc::new(Mutex::new(())),
|
||||
dispatch: AcpDispatchState::default(),
|
||||
prompt_queue: session.queued_prompts.drain(..).collect(),
|
||||
activity_sequence: 0,
|
||||
})))
|
||||
}
|
||||
@@ -1893,11 +2010,10 @@ impl SessionManager {
|
||||
focused_since: None,
|
||||
awaiting_suppressed: false,
|
||||
acp,
|
||||
acp_events,
|
||||
acp_events: acp_events.clone(),
|
||||
structured_activity_watermark: None,
|
||||
acp_event_pump: None,
|
||||
auto_approve: session.auto_approve,
|
||||
pending_prompt: None,
|
||||
},
|
||||
);
|
||||
if let Some((acp, events)) = event_pump {
|
||||
@@ -1906,6 +2022,23 @@ impl SessionManager {
|
||||
if let Some(record) = self.inner.sessions.lock().await.get_mut(&id) {
|
||||
record.acp_event_pump = Some(done);
|
||||
}
|
||||
// Drain any prompts that were queued before the daemon restarted.
|
||||
let queued_text = {
|
||||
let stream = acp_events
|
||||
.as_ref()
|
||||
.expect("recovery with acp implies acp_events");
|
||||
let mut stream = stream.lock().await;
|
||||
if stream.prompt_queue.is_empty() {
|
||||
None
|
||||
} else {
|
||||
let texts: Vec<String> = stream.prompt_queue.drain(..).collect();
|
||||
Some(texts.join("\n\n"))
|
||||
}
|
||||
};
|
||||
if let Some(text) = queued_text {
|
||||
self.persist_prompt_queue(id).await;
|
||||
let _ = self.queue_acp_prompt(id, text).await;
|
||||
}
|
||||
}
|
||||
let _ = self
|
||||
.inner
|
||||
@@ -2264,7 +2397,7 @@ fn start_acp_event_pump(
|
||||
};
|
||||
let projected = apply_persisted_event(&mut events.projection, &logged);
|
||||
let _ = events.live.send(logged);
|
||||
let _ = events.projected_live.send(projected);
|
||||
events.broadcast(projected);
|
||||
None
|
||||
}
|
||||
Err(error) => Some(error),
|
||||
@@ -2434,7 +2567,7 @@ fn start_acp_permission_pump(
|
||||
let outcome = record_permission_request(&mut events, request, response);
|
||||
let fatal = matches!(outcome, RecordOutcome::Fatal);
|
||||
if let RecordOutcome::Live(update) = outcome {
|
||||
let _ = events.projected_live.send(*update);
|
||||
events.broadcast(*update);
|
||||
}
|
||||
drop(events);
|
||||
if fatal {
|
||||
@@ -2527,7 +2660,7 @@ fn cancel_pending_approvals(events: &mut AcpEventStream) {
|
||||
.send(maestro_acp::schema::RequestPermissionOutcome::Cancelled);
|
||||
}
|
||||
if let Some(update) = events.projection.clear_approval() {
|
||||
let _ = events.projected_live.send(update);
|
||||
events.broadcast(update);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2877,6 +3010,18 @@ async fn run_blocked_work_pass(inner: &Arc<Inner>) {
|
||||
/// Terminal sessions that die naturally do not survive a daemon restart:
|
||||
/// [`SessionManager::recover`] adopts only what tmux still holds. Structured
|
||||
/// sessions stopped for daemon shutdown retain their sidecars for ACP recovery.
|
||||
/// Spawn an independent task to dispatch the next prompt from the drained
|
||||
/// queue. Free function with an explicit `Box::pin` future to break the
|
||||
/// compiler's async-cycle check: `queue_acp_prompt` → spawn →
|
||||
/// `finish_queued_acp_turn` → here → `queue_acp_prompt`.
|
||||
fn drain_prompt_queue(manager: SessionManager, id: Uuid, text: String) {
|
||||
let fut: std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>> =
|
||||
Box::pin(async move {
|
||||
let _ = manager.queue_acp_prompt(id, text).await;
|
||||
});
|
||||
tokio::spawn(fut);
|
||||
}
|
||||
|
||||
async fn mark_session_dead(inner: &Arc<Inner>, id: Uuid) {
|
||||
if inner.shutting_down.load(Ordering::Acquire) {
|
||||
return;
|
||||
@@ -2930,7 +3075,9 @@ async fn mark_session_dead_with_worktree_settlement(
|
||||
.get(&id)
|
||||
.and_then(|record| record.acp_events.clone());
|
||||
if let Some(stream) = stream {
|
||||
cancel_pending_approvals(&mut *stream.lock().await);
|
||||
let mut stream = stream.lock().await;
|
||||
cancel_pending_approvals(&mut stream);
|
||||
stream.prompt_queue.clear();
|
||||
}
|
||||
tracing::info!(%id, "session process gone — marking dead");
|
||||
|
||||
@@ -2957,6 +3104,7 @@ async fn mark_session_dead_with_worktree_settlement(
|
||||
return false;
|
||||
};
|
||||
record.settled = true;
|
||||
record.session.queued_prompts.clear();
|
||||
record.session.clone()
|
||||
};
|
||||
|
||||
@@ -3120,6 +3268,7 @@ mod tests {
|
||||
pending_approvals: std::collections::HashMap::new(),
|
||||
operation: std::sync::Arc::new(tokio::sync::Mutex::new(())),
|
||||
dispatch: AcpDispatchState::default(),
|
||||
prompt_queue: std::collections::VecDeque::new(),
|
||||
activity_sequence: 0,
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user