feat(background): livraison auto au propriétaire + projection des tâches de fond dans le work-state (T1+T3)

T1 — Wake automatique du propriétaire à la complétion.
La complétion d'une tâche de fond est désormais livrée à l'agent
propriétaire dès que la session accepte l'envoi (wake.rs :
mark_completion_delivered au send accepté), via un drain de flux dédié
(structured.rs : drain_reply_stream_with_readiness). L'inbox médiée
enfile l'item sans démarrer de tour ni marquer l'agent busy
(input/mod.rs : enqueue FIFO silencieux). Régression couverte
(tests/agent_wake.rs, tests input/mod.rs).

T3 — Tâches de fond projetées dans le read-model du panneau Work.
AgentWorkState porte désormais background_tasks
(VO AgentBackgroundTaskState), alimenté par un builder best-effort
with_background_tasks(store) : union list_open_for_agent + dispatch des
completions non livrées par owner_agent_id, erreur store => Vec vide
(aucune régression live/busy/tickets). DTO Tauri backgroundTasks et
wiring du BackgroundTaskStore côté state.rs. Le frontend, déjà câblé,
affiche Cancel/Retry (mapping queued/waiting -> pending, tri sur
updatedAtMs). Borne V1 : une tâche terminale déjà livrée n'est plus
énumérable (Retry limité à la fenêtre non livrée).

Tests : cargo build --workspace OK ; cargo test -p application /
-p app-tauri / -p infrastructure verts ; frontend build + vitest verts.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

crates/application/src/agent/mod.rs

@@ -19,7 +19,8 @@ pub(crate) use lifecycle::ReattachDecision;
 
 pub use session_limit::{AgentResumer, SessionLimitService, RESUME_PROMPT};
 pub use structured::{
-    drain_with_readiness, drain_with_readiness_outcome, send_blocking, TurnOutcome,
+    drain_reply_stream_with_readiness, drain_with_readiness, drain_with_readiness_outcome,
+    send_blocking, TurnOutcome,
 };
 
 pub use catalogue::{

crates/application/src/agent/structured.rs

@@ -16,7 +16,7 @@ use std::time::Duration;
 
 use domain::ids::AgentId;
 use domain::input::InputMediator;
-use domain::ports::{AgentSession, AgentSessionError, ReplyEvent};
+use domain::ports::{AgentSession, AgentSessionError, ReplyEvent, ReplyStream};
 use domain::readiness::{ReadinessPolicy, ReadinessSignal};
 
 /// Issue d'un tour drainé (ARCHITECTURE §21.2-T4, réconciliation de la limite de
@@ -113,6 +113,36 @@ pub async fn drain_with_readiness(
     }
 }
 
+/// Draine un flux de réponse déjà ouvert, avec la même politique de readiness que
+/// [`drain_with_readiness`].
+///
+/// Ce point d'entrée sert aux appelants qui doivent effectuer une action durable
+/// après `AgentSession::send` réussi mais avant le drain complet du tour.
+pub async fn drain_reply_stream_with_readiness(
+    stream: ReplyStream,
+    mediator: &dyn InputMediator,
+    agent: AgentId,
+) -> Result<String, AgentSessionError> {
+    match drain_stream_to_final(
+        stream,
+        |event| {
+            if !matches!(event, ReplyEvent::Final { .. }) {
+                mediator.mark_alive(agent);
+            }
+        },
+        |signal| {
+            if signal == ReadinessSignal::TurnEnded {
+                mediator.mark_idle(agent);
+            }
+        },
+    )? {
+        TurnOutcome::Completed(content) => Ok(content),
+        TurnOutcome::RateLimited { .. } => Err(AgentSessionError::Io(
+            "le tour s'est clos en limite de session, sans contenu Final".to_string(),
+        )),
+    }
+}
+
 /// Variante **riche** de [`drain_with_readiness`] : même branchement readiness, mais
 /// retourne le [`TurnOutcome`] complet au lieu de réduire la limite à une erreur.
 ///
@@ -209,6 +239,15 @@ async fn drain_bounded_events(
 async fn drain_to_final(
     session: &dyn AgentSession,
     prompt: &str,
+    on_event: impl FnMut(&ReplyEvent),
+    on_signal: impl FnMut(ReadinessSignal),
+) -> Result<TurnOutcome, AgentSessionError> {
+    let stream = session.send(prompt).await?;
+    drain_stream_to_final(stream, on_event, on_signal)
+}
+
+fn drain_stream_to_final(
+    stream: ReplyStream,
     mut on_event: impl FnMut(&ReplyEvent),
     mut on_signal: impl FnMut(ReadinessSignal),
 ) -> Result<TurnOutcome, AgentSessionError> {
@@ -216,7 +255,6 @@ async fn drain_to_final(
     // `RateLimited` traverse le flux. Sert UNIQUEMENT au cas « clos sans Final » —
     // un `Final` ultérieur l'emporte toujours (le tour a réellement abouti).
     let mut last_rate_limit: Option<Option<i64>> = None;
-    let stream = session.send(prompt).await?;
     for event in stream {
         // Battement de vivacité (lot 2) : notifié pour CHAQUE événement brut, avant le
         // classement readiness. Le sink décide (les non-terminaux prouvent la vivacité).

crates/application/src/background/mod.rs

@@ -193,10 +193,7 @@ impl CancelBackgroundTask {
     ///
     /// # Errors
     /// [`AppError`] if the runner or store fails.
-    pub async fn execute(
-        &self,
-        task_id: TaskId,
-    ) -> Result<CancelBackgroundTaskOutput, AppError> {
+    pub async fn execute(&self, task_id: TaskId) -> Result<CancelBackgroundTaskOutput, AppError> {
         self.runner.cancel(task_id).await.map_err(map_port_err)?;
         let task = self.store.get(task_id).await.map_err(map_port_err)?;
         Ok(CancelBackgroundTaskOutput { task })
@@ -256,10 +253,7 @@ impl RetryBackgroundTask {
     /// # Errors
     /// [`AppError::NotFound`] if the task is unknown, [`AppError::Invalid`] if it
     /// is not a terminal command task or its command is no longer available.
-    pub async fn execute(
-        &self,
-        task_id: TaskId,
-    ) -> Result<SpawnBackgroundCommandOutput, AppError> {
+    pub async fn execute(&self, task_id: TaskId) -> Result<SpawnBackgroundCommandOutput, AppError> {
         let old = self
             .store
             .get(task_id)

crates/application/src/lib.rs

@@ -33,25 +33,27 @@ pub mod window;
 pub mod workstate;
 
 pub use agent::{
-    drain_with_readiness, drain_with_readiness_outcome, reference_profile_id, reference_profiles,
-    selectable_reference_profiles, send_blocking, AgentResumer, ChangeAgentProfile,
-    ChangeAgentProfileInput, ChangeAgentProfileOutput, ConfigureProfiles, ConfigureProfilesInput,
-    ConfigureProfilesOutput, CreateAgentFromScratch, CreateAgentInput, CreateAgentOutput,
-    DeleteAgent, DeleteAgentInput, DeleteProfile, DeleteProfileInput, DetectProfiles,
-    DetectProfilesInput, DetectProfilesOutput, FirstRunState, FirstRunStateOutput, HandoffProvider,
-    InjectedLiveRow, InspectConversation, InspectConversationInput, InspectConversationOutput,
-    LaunchAgent, LaunchAgentInput, LaunchAgentOutput, ListAgents, ListAgentsInput,
-    ListAgentsOutput, ListProfiles, ListProfilesOutput, ListResumableAgents,
-    ListResumableAgentsInput, ListResumableAgentsOutput, LiveStateLeanProvider, McpRuntime,
-    PermissionProjectorRegistry, ProfileAvailability, ProviderSessionProvider, ReadAgentContext,
-    ReadAgentContextInput, ReadAgentContextOutput, ReferenceProfiles, ReferenceProfilesOutput,
-    ResumableAgent, SaveProfile, SaveProfileInput, SaveProfileOutput, SessionLimitService,
-    StructuredSessionDescriptor, TurnOutcome, UpdateAgentContext, UpdateAgentContextInput,
-    AGENT_MEMORY_RECALL_BUDGET, CODEX_SUBMIT_DELAY_MS, LIVE_STATE_INJECT_MAX, RESUME_PROMPT,
+    drain_reply_stream_with_readiness, drain_with_readiness, drain_with_readiness_outcome,
+    reference_profile_id, reference_profiles, selectable_reference_profiles, send_blocking,
+    AgentResumer, ChangeAgentProfile, ChangeAgentProfileInput, ChangeAgentProfileOutput,
+    ConfigureProfiles, ConfigureProfilesInput, ConfigureProfilesOutput, CreateAgentFromScratch,
+    CreateAgentInput, CreateAgentOutput, DeleteAgent, DeleteAgentInput, DeleteProfile,
+    DeleteProfileInput, DetectProfiles, DetectProfilesInput, DetectProfilesOutput, FirstRunState,
+    FirstRunStateOutput, HandoffProvider, InjectedLiveRow, InspectConversation,
+    InspectConversationInput, InspectConversationOutput, LaunchAgent, LaunchAgentInput,
+    LaunchAgentOutput, ListAgents, ListAgentsInput, ListAgentsOutput, ListProfiles,
+    ListProfilesOutput, ListResumableAgents, ListResumableAgentsInput, ListResumableAgentsOutput,
+    LiveStateLeanProvider, McpRuntime, PermissionProjectorRegistry, ProfileAvailability,
+    ProviderSessionProvider, ReadAgentContext, ReadAgentContextInput, ReadAgentContextOutput,
+    ReferenceProfiles, ReferenceProfilesOutput, ResumableAgent, SaveProfile, SaveProfileInput,
+    SaveProfileOutput, SessionLimitService, StructuredSessionDescriptor, TurnOutcome,
+    UpdateAgentContext, UpdateAgentContextInput, AGENT_MEMORY_RECALL_BUDGET, CODEX_SUBMIT_DELAY_MS,
+    LIVE_STATE_INJECT_MAX, RESUME_PROMPT,
 };
 pub use background::{
-    BackgroundCommandArchive, CancelBackgroundTask, CancelBackgroundTaskOutput, RetryBackgroundTask,
-    SpawnBackgroundCommand, SpawnBackgroundCommandInput, SpawnBackgroundCommandOutput,
+    BackgroundCommandArchive, CancelBackgroundTask, CancelBackgroundTaskOutput,
+    RetryBackgroundTask, SpawnBackgroundCommand, SpawnBackgroundCommandInput,
+    SpawnBackgroundCommandOutput,
 };
 pub use conversation::{
     ConversationArchiveProvider, ReadConversationPage, ReadConversationPageInput, RecordTurn,
@@ -140,11 +142,11 @@ pub use terminal::{
 };
 pub use window::{MoveTabToNewWindow, MoveTabToNewWindowInput, MoveTabToNewWindowOutput};
 pub use workstate::{
-    AgentTicketState, AgentWorkState, AttachLiveAgent, AttachLiveAgentInput, AttachLiveAgentOutput,
-    ConversationLogProvider, ConversationPreviewStatus, ConversationTurnWorkPreview,
-    ConversationWorkSummary, GetLiveStateLean, GetProjectWorkState, GetProjectWorkStateInput,
-    LeanLiveEntry, LeanLiveState, LiveWorkSession, ProjectWorkState, ReconcileLiveState,
-    ReconcileLiveStateInput, StopLiveAgent, StopLiveAgentInput, StopLiveAgentOutput,
-    TicketWorkSource, TicketWorkStatus, UpdateLiveState, UpdateLiveStateInput,
-    LIVE_STATE_MAX_ENTRIES, LIVE_STATE_TTL_MS,
+    AgentBackgroundTaskState, AgentTicketState, AgentWorkState, AttachLiveAgent,
+    AttachLiveAgentInput, AttachLiveAgentOutput, BackgroundTaskKindLabel, ConversationLogProvider,
+    ConversationPreviewStatus, ConversationTurnWorkPreview, ConversationWorkSummary,
+    GetLiveStateLean, GetProjectWorkState, GetProjectWorkStateInput, LeanLiveEntry, LeanLiveState,
+    LiveWorkSession, ProjectWorkState, ReconcileLiveState, ReconcileLiveStateInput, StopLiveAgent,
+    StopLiveAgentInput, StopLiveAgentOutput, TicketWorkSource, TicketWorkStatus, UpdateLiveState,
+    UpdateLiveStateInput, LIVE_STATE_MAX_ENTRIES, LIVE_STATE_TTL_MS,
 };

crates/application/src/orchestrator/wake.rs

@@ -19,7 +19,7 @@ use domain::ports::{
 };
 use domain::project::Project;
 
-use crate::agent::drain_with_readiness;
+use crate::agent::drain_reply_stream_with_readiness;
 
 /// Provides a structured/headless session for a wake turn.
 ///
@@ -96,7 +96,7 @@ impl AgentWakeService {
         });
 
         if self.input.busy_state(agent).is_busy() {
-            return Ok(());
+            return Err(WakeError::AgentBusy { agent_id: agent });
         }
 
         let Some(item) = self.inbox.dequeue_next(agent) else {
@@ -117,26 +117,29 @@ impl AgentWakeService {
             agent_id: agent,
         });
         let session = self.sessions.session_for_wake(project, agent).await?;
-        drain_with_readiness(
-            session.as_ref(),
-            &delivery.prompt,
-            None,
-            self.input.as_ref(),
-            agent,
-        )
-        .await
-        .map_err(|err| WakeError::Session(err.to_string()))?;
-
-        self.mailbox.cancel_head(agent, delivery.ticket_id);
-        self.input.mark_idle(agent);
-        guard.disarm();
+        let stream = session
+            .send(&delivery.prompt)
+            .await
+            .map_err(|err| WakeError::Session(err.to_string()))?;
 
         if let Some(task_id) = delivery.delivered_task_id {
             self.tasks
                 .mark_completion_delivered(task_id)
                 .await
                 .map_err(|err| WakeError::Store(err.to_string()))?;
+            self.publish(DomainEvent::BackgroundTaskCompletionDelivered {
+                project_id: project.id,
+                task_id,
+                owner_agent_id: agent,
+            });
         }
+        drain_reply_stream_with_readiness(stream, self.input.as_ref(), agent)
+            .await
+            .map_err(|err| WakeError::Session(err.to_string()))?;
+
+        self.mailbox.cancel_head(agent, delivery.ticket_id);
+        self.input.mark_idle(agent);
+        guard.disarm();
         Ok(())
     }
 

crates/application/src/workstate/mod.rs

@@ -23,11 +23,12 @@ use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 use domain::input::{AgentBusyState, InputSource};
-use domain::ports::AgentContextStore;
+use domain::ports::{AgentContextStore, BackgroundTaskPortError, BackgroundTaskStore};
 use domain::{
-    AgentId, AgentQueueSnapshot, ConversationId, ConversationLog, ConversationTurn, Handoff,
-    HandoffStore, InputMediator, NodeId, ProfileId, Project, ProjectPath, QueuedTicketSnapshot,
-    SessionId, TicketId, TurnId, TurnRole,
+    AgentId, AgentQueueSnapshot, BackgroundTask, BackgroundTaskKind, BackgroundTaskResult,
+    BackgroundTaskState, ConversationId, ConversationLog, ConversationTurn, Handoff, HandoffStore,
+    InputMediator, NodeId, ProfileId, Project, ProjectPath, QueuedTicketSnapshot, SessionId,
+    TaskId, TicketId, TurnId, TurnRole,
 };
 
 use crate::error::AppError;
@@ -150,6 +151,48 @@ pub struct AgentWorkState {
     pub busy: AgentBusyState,
     /// Pending/in-progress delegation tickets, in FIFO order.
     pub tickets: Vec<AgentTicketState>,
+    /// Best-effort first-class background tasks owned by this agent.
+    ///
+    /// V1 bound: terminal tasks already delivered to the owner are no longer
+    /// enumerable by the background-task store, so they disappear from Work;
+    /// retry is available only while the terminal completion is still undelivered.
+    pub background_tasks: Vec<AgentBackgroundTaskState>,
+}
+
+/// Background task projected into an agent's work state.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AgentBackgroundTaskState {
+    /// Stable task id.
+    pub task_id: TaskId,
+    /// Kind discriminant.
+    pub kind: BackgroundTaskKindLabel,
+    /// Current lifecycle state.
+    pub state: BackgroundTaskState,
+    /// Process exit code, when the terminal result carries one.
+    pub exit_code: Option<i32>,
+    /// Human-readable summary / error / reason of the terminal result.
+    pub summary: Option<String>,
+    /// Bounded stdout tail.
+    pub stdout_tail: Option<String>,
+    /// Bounded stderr tail.
+    pub stderr_tail: Option<String>,
+    /// Creation timestamp, epoch milliseconds.
+    pub created_at_ms: u64,
+    /// Last update timestamp, epoch milliseconds.
+    pub updated_at_ms: u64,
+}
+
+/// Background task kind label used by the work-state read model.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BackgroundTaskKindLabel {
+    /// A non-interactive command.
+    Command,
+    /// A headless inter-agent rendezvous.
+    HeadlessRendezvous,
+    /// Resume of a structured agent session.
+    SessionResume,
+    /// Internal maintenance work.
+    Maintenance,
 }
 
 /// One queued delegation ticket, projected for the work-state read model.
@@ -229,6 +272,8 @@ pub struct GetProjectWorkState {
     handoffs: Option<Arc<dyn HandoffProvider>>,
     /// Per-root log source (fallback), wired best-effort; `None` ⇒ no fallback turns.
     logs: Option<Arc<dyn ConversationLogProvider>>,
+    /// Background-task read model source, wired best-effort; `None` ⇒ no tasks.
+    background_tasks: Option<Arc<dyn BackgroundTaskStore>>,
 }
 
 impl GetProjectWorkState {
@@ -250,6 +295,7 @@ impl GetProjectWorkState {
             queue,
             handoffs: None,
             logs: None,
+            background_tasks: None,
         }
     }
 
@@ -267,6 +313,15 @@ impl GetProjectWorkState {
         self
     }
 
+    /// Wires the best-effort background-task source for the Work panel. Builder so
+    /// existing call sites/tests stay unchanged; absent or failing store ⇒ empty
+    /// `background_tasks` without affecting live/busy/tickets.
+    #[must_use]
+    pub fn with_background_tasks(mut self, store: Arc<dyn BackgroundTaskStore>) -> Self {
+        self.background_tasks = Some(store);
+        self
+    }
+
     /// Executes the read-only aggregation.
     ///
     /// # Errors
@@ -278,40 +333,47 @@ impl GetProjectWorkState {
     ) -> Result<ProjectWorkState, AppError> {
         let manifest = self.contexts.load_manifest(&input.project).await?;
         let live_by_agent = live_by_agent(self.live.live_agent_snapshots());
-        let agents = manifest
-            .entries
-            .iter()
-            .map(|entry| {
-                let agent = entry
-                    .to_agent()
-                    .map_err(|err| AppError::Invalid(err.to_string()))?;
-                let live = live_by_agent
-                    .get(&agent.id)
-                    .map(|snapshot| LiveWorkSession {
-                        node_id: snapshot.node_id,
-                        session_id: snapshot.session_id,
-                        kind: snapshot.kind,
-                    });
-                // Tickets are crossed with the busy state: only an agent absent from
-                // the manifest is dropped (this loop only visits manifest entries), so
-                // the manifest boundary is naturally preserved.
-                let busy_ticket = self.input.busy_state(agent.id).ticket();
-                let tickets = self
-                    .queue
-                    .queue_for(agent.id)
-                    .into_iter()
-                    .map(|snapshot| ticket_state(snapshot, busy_ticket))
-                    .collect();
-                Ok(AgentWorkState {
-                    agent_id: agent.id,
-                    name: agent.name,
-                    profile_id: agent.profile_id,
-                    live,
-                    busy: self.input.busy_state(agent.id),
-                    tickets,
-                })
-            })
-            .collect::<Result<Vec<_>, AppError>>()?;
+        let undelivered_completions = match &self.background_tasks {
+            Some(store) => Some(store.list_undelivered_completions().await),
+            None => None,
+        };
+
+        let mut agents = Vec::with_capacity(manifest.entries.len());
+        for entry in &manifest.entries {
+            let agent = entry
+                .to_agent()
+                .map_err(|err| AppError::Invalid(err.to_string()))?;
+            let live = live_by_agent
+                .get(&agent.id)
+                .map(|snapshot| LiveWorkSession {
+                    node_id: snapshot.node_id,
+                    session_id: snapshot.session_id,
+                    kind: snapshot.kind,
+                });
+            // Tickets are crossed with the busy state: only an agent absent from
+            // the manifest is dropped (this loop only visits manifest entries), so
+            // the manifest boundary is naturally preserved.
+            let busy = self.input.busy_state(agent.id);
+            let busy_ticket = busy.ticket();
+            let tickets = self
+                .queue
+                .queue_for(agent.id)
+                .into_iter()
+                .map(|snapshot| ticket_state(snapshot, busy_ticket))
+                .collect();
+            let background_tasks = self
+                .background_tasks_for_agent(&input.project, agent.id, &undelivered_completions)
+                .await;
+            agents.push(AgentWorkState {
+                agent_id: agent.id,
+                name: agent.name,
+                profile_id: agent.profile_id,
+                live,
+                busy,
+                tickets,
+                background_tasks,
+            });
+        }
 
         // Lot C — best-effort conversation summaries. Only the conversations
         // visible through the projected tickets are summarised, deduplicated in
@@ -354,6 +416,106 @@ impl GetProjectWorkState {
         }
         summaries
     }
+
+    async fn background_tasks_for_agent(
+        &self,
+        project: &Project,
+        agent_id: AgentId,
+        undelivered_completions: &Option<Result<Vec<BackgroundTask>, BackgroundTaskPortError>>,
+    ) -> Vec<AgentBackgroundTaskState> {
+        let Some(store) = &self.background_tasks else {
+            return Vec::new();
+        };
+        let Some(Ok(undelivered_completions)) = undelivered_completions.as_ref() else {
+            return Vec::new();
+        };
+        let Ok(open) = store.list_open_for_agent(agent_id).await else {
+            return Vec::new();
+        };
+
+        let mut by_id: HashMap<TaskId, BackgroundTask> = HashMap::new();
+        for task in open {
+            by_id.insert(task.id, task);
+        }
+        for task in undelivered_completions
+            .iter()
+            .filter(|task| task.owner_agent_id == agent_id)
+        {
+            by_id.entry(task.id).or_insert_with(|| task.clone());
+        }
+
+        let mut tasks: Vec<_> = by_id
+            .into_values()
+            .filter(|task| task.project_id == project.id)
+            .map(AgentBackgroundTaskState::from)
+            .collect();
+        tasks.sort_by_key(|task| (task.created_at_ms, task.task_id));
+        tasks
+    }
+}
+
+impl From<BackgroundTask> for AgentBackgroundTaskState {
+    fn from(task: BackgroundTask) -> Self {
+        let (exit_code, summary, stdout_tail, stderr_tail) = flatten_background_result(&task);
+        Self {
+            task_id: task.id,
+            kind: BackgroundTaskKindLabel::from(&task.kind),
+            state: task.state,
+            exit_code,
+            summary,
+            stdout_tail,
+            stderr_tail,
+            created_at_ms: task.created_at_ms,
+            updated_at_ms: task.updated_at_ms,
+        }
+    }
+}
+
+impl From<&BackgroundTaskKind> for BackgroundTaskKindLabel {
+    fn from(kind: &BackgroundTaskKind) -> Self {
+        match kind {
+            BackgroundTaskKind::Command { .. } => Self::Command,
+            BackgroundTaskKind::HeadlessRendezvous { .. } => Self::HeadlessRendezvous,
+            BackgroundTaskKind::SessionResume { .. } => Self::SessionResume,
+            BackgroundTaskKind::Maintenance { .. } => Self::Maintenance,
+        }
+    }
+}
+
+fn flatten_background_result(
+    task: &BackgroundTask,
+) -> (Option<i32>, Option<String>, Option<String>, Option<String>) {
+    match &task.result {
+        Some(BackgroundTaskResult::Success {
+            exit_code,
+            summary,
+            stdout_tail,
+            stderr_tail,
+            ..
+        }) => (
+            *exit_code,
+            Some(summary.clone()),
+            stdout_tail.clone(),
+            stderr_tail.clone(),
+        ),
+        Some(BackgroundTaskResult::Failure {
+            exit_code,
+            error,
+            stdout_tail,
+            stderr_tail,
+            ..
+        }) => (
+            *exit_code,
+            Some(error.clone()),
+            stdout_tail.clone(),
+            stderr_tail.clone(),
+        ),
+        Some(BackgroundTaskResult::Cancelled { reason, .. })
+        | Some(BackgroundTaskResult::Expired { reason, .. }) => {
+            (None, Some(reason.clone()), None, None)
+        }
+        None => (None, None, None, None),
+    }
 }
 
 /// Collects the conversation ids referenced by the agents' tickets, deduplicated in

crates/application/tests/agent_wake.rs

@@ -298,6 +298,16 @@ impl BackgroundTaskStore for FakeTaskStore {
 #[derive(Default)]
 struct FakeSession {
     prompts: Mutex<Vec<String>>,
+    events: Mutex<Option<Vec<ReplyEvent>>>,
+}
+
+impl FakeSession {
+    fn with_events(events: Vec<ReplyEvent>) -> Self {
+        Self {
+            prompts: Mutex::new(Vec::new()),
+            events: Mutex::new(Some(events)),
+        }
+    }
 }
 
 #[async_trait]
@@ -312,12 +322,12 @@ impl AgentSession for FakeSession {
 
     async fn send(&self, prompt: &str) -> Result<ReplyStream, AgentSessionError> {
         self.prompts.lock().unwrap().push(prompt.to_owned());
-        Ok(Box::new(
+        let events = self.events.lock().unwrap().take().unwrap_or_else(|| {
             vec![ReplyEvent::Final {
                 content: "ack".to_owned(),
             }]
-            .into_iter(),
-        ))
+        });
+        Ok(Box::new(events.into_iter()))
     }
 
     async fn shutdown(&self) -> Result<(), AgentSessionError> {
@@ -421,15 +431,16 @@ async fn owner_busy_does_not_start_concurrent_wake_and_keeps_item_queued() {
         .unwrap();
     turns.force_busy(owner, ticket(99));
 
-    service(inbox.clone(), turns, tasks, sessions)
+    let err = service(inbox.clone(), turns, tasks, sessions)
         .wake_agent(
             &project,
             owner,
             WakeReason::BackgroundCompletion { task_id },
         )
         .await
-        .unwrap();
+        .unwrap_err();
 
+    assert_eq!(err, WakeError::AgentBusy { agent_id: owner });
     assert!(session.prompts.lock().unwrap().is_empty());
     assert_eq!(inbox.snapshot(owner).depth, 1);
 }
@@ -489,6 +500,35 @@ async fn completion_is_marked_delivered_after_successful_wake() {
     assert_eq!(tasks.delivered(), vec![task_id]);
 }
 
+#[tokio::test]
+async fn completion_is_marked_delivered_once_send_is_accepted_even_if_drain_fails() {
+    let project = project();
+    let owner = agent(1);
+    let task_id = task_id(10);
+    let inbox = Arc::new(FakeInbox::default());
+    let turns = Arc::new(SharedTurnState::default());
+    let tasks = Arc::new(FakeTaskStore::default());
+    let session = Arc::new(FakeSession::with_events(Vec::new()));
+    let sessions = Arc::new(FakeSessionProvider::with_session(session.clone()));
+    tasks.insert(completed_task(&project, owner, task_id, "done"));
+    inbox
+        .enqueue_message(owner, completion_item(owner, task_id, ticket(20)))
+        .unwrap();
+
+    let err = service(inbox, turns, tasks.clone(), sessions)
+        .wake_agent(
+            &project,
+            owner,
+            WakeReason::BackgroundCompletion { task_id },
+        )
+        .await
+        .unwrap_err();
+
+    assert!(matches!(err, WakeError::Session(_)));
+    assert_eq!(session.prompts.lock().unwrap().len(), 1);
+    assert_eq!(tasks.delivered(), vec![task_id]);
+}
+
 #[tokio::test]
 async fn wake_drains_exactly_one_item_per_turn() {
     let project = project();

crates/application/tests/workstate.rs

@@ -16,13 +16,15 @@ use domain::mailbox::{
     AgentQueueSnapshot, MailboxError, PendingReply, QueuedTicketSnapshot, Ticket, TurnResolution,
 };
 use domain::ports::{
-    AgentContextStore, AgentSession, AgentSessionError, PtyHandle, ReplyStream, StoreError,
+    AgentContextStore, AgentSession, AgentSessionError, BackgroundTaskPortError,
+    BackgroundTaskStore, PtyHandle, ReplyStream, StoreError,
 };
 use domain::{
-    Agent, AgentBusyState, AgentId, AgentManifest, AgentOrigin, ConversationId, ConversationLog,
-    ConversationTurn, Handoff, HandoffStore, InputMediator, InputSource, ManifestEntry,
-    MarkdownDoc, NodeId, ProfileId, Project, ProjectId, ProjectPath, PtySize, RemoteRef, SessionId,
-    SessionKind, TerminalSession, TicketId, TurnId, TurnRole,
+    Agent, AgentBusyState, AgentId, AgentManifest, AgentOrigin, BackgroundTask, BackgroundTaskKind,
+    BackgroundTaskResult, BackgroundTaskState, BackgroundTaskWakePolicy, ConversationId,
+    ConversationLog, ConversationTurn, Handoff, HandoffStore, InputMediator, InputSource,
+    ManifestEntry, MarkdownDoc, NodeId, ProfileId, Project, ProjectId, ProjectPath, PtySize,
+    RemoteRef, SessionId, SessionKind, TaskId, TerminalSession, TicketId, TurnId, TurnRole,
 };
 use uuid::Uuid;
 
@@ -46,6 +48,10 @@ fn ticket_id(n: u128) -> domain::TicketId {
     domain::TicketId::from_uuid(Uuid::from_u128(n))
 }
 
+fn task_id(n: u128) -> TaskId {
+    TaskId::from_uuid(Uuid::from_u128(n))
+}
+
 fn project() -> Project {
     Project::new(
         ProjectId::from_uuid(Uuid::from_u128(1)),
@@ -147,6 +153,106 @@ struct FakeQueue {
     queues: Mutex<HashMap<AgentId, Vec<QueuedTicketSnapshot>>>,
 }
 
+#[derive(Default)]
+struct FakeBackgroundTaskStore {
+    tasks: Mutex<Vec<BackgroundTask>>,
+    fail_open: Mutex<bool>,
+    fail_undelivered: Mutex<bool>,
+}
+
+impl FakeBackgroundTaskStore {
+    fn set_tasks(&self, tasks: Vec<BackgroundTask>) {
+        *self.tasks.lock().unwrap() = tasks;
+    }
+
+    fn fail_open(&self) {
+        *self.fail_open.lock().unwrap() = true;
+    }
+
+    fn fail_undelivered(&self) {
+        *self.fail_undelivered.lock().unwrap() = true;
+    }
+}
+
+#[async_trait]
+impl BackgroundTaskStore for FakeBackgroundTaskStore {
+    async fn create(&self, task: &BackgroundTask) -> Result<(), BackgroundTaskPortError> {
+        self.tasks.lock().unwrap().push(task.clone());
+        Ok(())
+    }
+
+    async fn get(&self, id: TaskId) -> Result<Option<BackgroundTask>, BackgroundTaskPortError> {
+        Ok(self
+            .tasks
+            .lock()
+            .unwrap()
+            .iter()
+            .find(|task| task.id == id)
+            .cloned())
+    }
+
+    async fn save(&self, task: &BackgroundTask) -> Result<(), BackgroundTaskPortError> {
+        let mut tasks = self.tasks.lock().unwrap();
+        if let Some(existing) = tasks.iter_mut().find(|existing| existing.id == task.id) {
+            *existing = task.clone();
+        } else {
+            tasks.push(task.clone());
+        }
+        Ok(())
+    }
+
+    async fn list_open_for_agent(
+        &self,
+        agent_id: AgentId,
+    ) -> Result<Vec<BackgroundTask>, BackgroundTaskPortError> {
+        if *self.fail_open.lock().unwrap() {
+            return Err(BackgroundTaskPortError::Store("open failed".to_owned()));
+        }
+        Ok(self
+            .tasks
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|task| task.owner_agent_id == agent_id && !task.is_terminal())
+            .cloned()
+            .collect())
+    }
+
+    async fn list_undelivered_completions(
+        &self,
+    ) -> Result<Vec<BackgroundTask>, BackgroundTaskPortError> {
+        if *self.fail_undelivered.lock().unwrap() {
+            return Err(BackgroundTaskPortError::Store(
+                "undelivered failed".to_owned(),
+            ));
+        }
+        Ok(self
+            .tasks
+            .lock()
+            .unwrap()
+            .iter()
+            .filter(|task| task.has_pending_completion_delivery())
+            .cloned()
+            .collect())
+    }
+
+    async fn mark_completion_delivered(
+        &self,
+        task_id: TaskId,
+    ) -> Result<(), BackgroundTaskPortError> {
+        if let Some(task) = self
+            .tasks
+            .lock()
+            .unwrap()
+            .iter_mut()
+            .find(|task| task.id == task_id)
+        {
+            task.completion_delivered = true;
+        }
+        Ok(())
+    }
+}
+
 impl FakeQueue {
     fn set(&self, agent: AgentId, tickets: Vec<QueuedTicketSnapshot>) {
         self.queues.lock().unwrap().insert(agent, tickets);
@@ -400,6 +506,106 @@ struct ConvFixture {
     project: Project,
 }
 
+struct BackgroundFixture {
+    usecase: GetProjectWorkState,
+    queue: Arc<FakeQueue>,
+    store: Arc<FakeBackgroundTaskStore>,
+    project: Project,
+}
+
+fn background_fixture(agents: &[Agent]) -> BackgroundFixture {
+    let pty = Arc::new(TerminalSessions::new());
+    let structured = Arc::new(StructuredSessions::new());
+    let live = Arc::new(LiveSessions::new(pty, structured));
+    let input = Arc::new(FakeInput::default());
+    let queue = Arc::new(FakeQueue::default());
+    let store = Arc::new(FakeBackgroundTaskStore::default());
+    let usecase = GetProjectWorkState::new(
+        Arc::new(FakeContexts {
+            manifest: manifest(agents),
+        }),
+        live,
+        input as Arc<dyn InputMediator>,
+        Arc::clone(&queue) as Arc<dyn AgentQueueSnapshot>,
+    )
+    .with_background_tasks(Arc::clone(&store) as Arc<dyn BackgroundTaskStore>);
+    BackgroundFixture {
+        usecase,
+        queue,
+        store,
+        project: project(),
+    }
+}
+
+fn background_task(
+    id: u128,
+    project_id: ProjectId,
+    owner: AgentId,
+    created_at_ms: u64,
+    state: BackgroundTaskState,
+    delivered: bool,
+) -> BackgroundTask {
+    let base = BackgroundTask::new(
+        task_id(id),
+        project_id,
+        owner,
+        BackgroundTaskKind::Command {
+            label: format!("task-{id}"),
+        },
+        BackgroundTaskWakePolicy::WakeOwner,
+        created_at_ms,
+        None,
+    )
+    .unwrap();
+    match state {
+        BackgroundTaskState::Queued => base,
+        BackgroundTaskState::Running | BackgroundTaskState::Waiting => {
+            base.transition(state, created_at_ms + 10).unwrap()
+        }
+        BackgroundTaskState::Completed
+        | BackgroundTaskState::Failed
+        | BackgroundTaskState::Cancelled
+        | BackgroundTaskState::Expired => {
+            let result = match state {
+                BackgroundTaskState::Completed => BackgroundTaskResult::Success {
+                    finished_at_ms: created_at_ms + 20,
+                    exit_code: Some(0),
+                    summary: "done".to_owned(),
+                    stdout_tail: Some("stdout".to_owned()),
+                    stderr_tail: None,
+                },
+                BackgroundTaskState::Failed => BackgroundTaskResult::Failure {
+                    finished_at_ms: created_at_ms + 20,
+                    exit_code: Some(2),
+                    error: "failed".to_owned(),
+                    stdout_tail: Some("out".to_owned()),
+                    stderr_tail: Some("err".to_owned()),
+                },
+                BackgroundTaskState::Cancelled => BackgroundTaskResult::Cancelled {
+                    finished_at_ms: created_at_ms + 20,
+                    reason: "cancelled".to_owned(),
+                },
+                BackgroundTaskState::Expired => BackgroundTaskResult::Expired {
+                    finished_at_ms: created_at_ms + 20,
+                    reason: "expired".to_owned(),
+                },
+                BackgroundTaskState::Queued
+                | BackgroundTaskState::Running
+                | BackgroundTaskState::Waiting => unreachable!(),
+            };
+            let running = base
+                .transition(BackgroundTaskState::Running, created_at_ms + 10)
+                .unwrap();
+            let completed = running.complete(result).unwrap();
+            if delivered {
+                completed.mark_completion_delivered().unwrap()
+            } else {
+                completed
+            }
+        }
+    }
+}
+
 /// Fixture wiring the best-effort conversation sources (handoff + log) onto the
 /// read model, exposing the fake stores so each test configures their outcomes.
 fn conv_fixture(agents: &[Agent]) -> ConvFixture {
@@ -539,6 +745,123 @@ async fn workstate_agent_without_queue_has_no_tickets() {
     assert!(out.agents[0].tickets.is_empty());
 }
 
+#[tokio::test]
+async fn workstate_projects_open_and_undelivered_background_tasks_by_agent() {
+    let a = agent(10, "alpha");
+    let b = agent(20, "beta");
+    let f = background_fixture(&[a.clone(), b.clone()]);
+    let other_project = ProjectId::from_uuid(Uuid::from_u128(999));
+    f.store.set_tasks(vec![
+        background_task(
+            2,
+            f.project.id,
+            a.id,
+            2_000,
+            BackgroundTaskState::Running,
+            false,
+        ),
+        background_task(
+            1,
+            f.project.id,
+            a.id,
+            1_000,
+            BackgroundTaskState::Failed,
+            false,
+        ),
+        background_task(
+            3,
+            f.project.id,
+            a.id,
+            3_000,
+            BackgroundTaskState::Completed,
+            true,
+        ),
+        background_task(
+            4,
+            other_project,
+            a.id,
+            4_000,
+            BackgroundTaskState::Running,
+            false,
+        ),
+    ]);
+
+    let out = f
+        .usecase
+        .execute(GetProjectWorkStateInput { project: f.project })
+        .await
+        .unwrap();
+
+    let alpha_tasks = &out.agents[0].background_tasks;
+    assert_eq!(alpha_tasks.len(), 2);
+    assert_eq!(alpha_tasks[0].task_id, task_id(1));
+    assert_eq!(alpha_tasks[0].state, BackgroundTaskState::Failed);
+    assert_eq!(alpha_tasks[0].exit_code, Some(2));
+    assert_eq!(alpha_tasks[0].summary.as_deref(), Some("failed"));
+    assert_eq!(alpha_tasks[0].stdout_tail.as_deref(), Some("out"));
+    assert_eq!(alpha_tasks[0].stderr_tail.as_deref(), Some("err"));
+    assert_eq!(alpha_tasks[1].task_id, task_id(2));
+    assert_eq!(alpha_tasks[1].state, BackgroundTaskState::Running);
+    assert!(out.agents[1].background_tasks.is_empty());
+}
+
+#[tokio::test]
+async fn workstate_background_task_store_error_degrades_without_dropping_tickets() {
+    let a = agent(10, "alpha");
+    let f = background_fixture(std::slice::from_ref(&a));
+    f.queue.set(
+        a.id,
+        vec![snapshot(1, 0, InputSource::Human, "Human", "queued")],
+    );
+    f.store.set_tasks(vec![background_task(
+        1,
+        f.project.id,
+        a.id,
+        1_000,
+        BackgroundTaskState::Running,
+        false,
+    )]);
+    f.store.fail_open();
+
+    let out = f
+        .usecase
+        .execute(GetProjectWorkStateInput { project: f.project })
+        .await
+        .unwrap();
+
+    assert!(out.agents[0].background_tasks.is_empty());
+    assert_eq!(out.agents[0].tickets.len(), 1);
+    assert_eq!(out.agents[0].tickets[0].ticket_id, ticket_id(1));
+}
+
+#[tokio::test]
+async fn workstate_undelivered_completion_error_degrades_background_tasks_only() {
+    let a = agent(10, "alpha");
+    let f = background_fixture(std::slice::from_ref(&a));
+    f.queue.set(
+        a.id,
+        vec![snapshot(1, 0, InputSource::Human, "Human", "queued")],
+    );
+    f.store.set_tasks(vec![background_task(
+        1,
+        f.project.id,
+        a.id,
+        1_000,
+        BackgroundTaskState::Running,
+        false,
+    )]);
+    f.store.fail_undelivered();
+
+    let out = f
+        .usecase
+        .execute(GetProjectWorkStateInput { project: f.project })
+        .await
+        .unwrap();
+
+    assert!(out.agents[0].background_tasks.is_empty());
+    assert_eq!(out.agents[0].tickets.len(), 1);
+}
+
 #[tokio::test]
 async fn workstate_lists_two_tickets_in_fifo_order() {
     let a = agent(10, "alpha");