fix(acp): de-duplicate post-cancel orphan-update warnings (#457)

## Summary
🤖 Generated with [Nori](https://noriagentic.com/)

- After a cancel, in-flight `session/update` events still hit the
reducer with no active request and currently produce one "Received
request-owned content update while no request is active" yellow warning
cell per event — flooding the history.
- The reducer now tracks an `orphan_update_warning_emitted` flag on
`SessionRuntime`. The warning fires only on the first orphan update in a
burst; subsequent orphans in the same idle window skip the warning. The
normalizer still runs on every update, so well-formed `session/update`
events continue to render as tool / message history cells.
- The flag resets when a new prompt or load begins (`start_prompt`,
`reduce_load_submit`), so a fresh burst on a future request will warn
again.

## Test Plan
- [x] `cargo test -p nori-acp` (494 tests pass)
- [x] New unit tests in
`nori-rs/acp/src/backend/session_reducer/tests.rs`:
- `orphan_warning_is_emitted_only_once_per_burst` — three orphan
`ToolCallUpdate`s produce exactly one warning and three `ToolSnapshot`s.
- `orphan_warning_resets_when_a_new_prompt_starts` — burst → new prompt
→ new burst produces two warnings total.
- [x] Existing
`test_out_of_phase_tool_call_update_still_emits_normalized_tool_snapshot`
still passes (single update still gets the warning + snapshot).
- [x] `just fmt` and `just fix -p nori-acp -p nori-protocol` clean.

Share Nori with your team: https://www.npmjs.com/package/nori-skillsets

Co-authored-by: Cliff <clifford@tilework.tech>
Co-authored-by: Nori <contact@tilework.tech>

Author: 3 people

nori-rs/acp/src/backend/session_reducer.rs

@@ -177,6 +177,7 @@ fn start_prompt(runtime: &mut SessionRuntime, prompt: QueuedPrompt, out: &mut Re
         request_id.clone(),
         prompt.clone(),
     ));
+    runtime.orphan_update_warning_emitted = false;
 
     // Add user message to transcript.
     if let Some(display_text) = &prompt.display_text
@@ -372,6 +373,7 @@ fn reduce_load_submit(runtime: &mut SessionRuntime, request_id: String, out: &mu
         request_id,
         ActiveRequestKind::Loading,
     ));
+    runtime.orphan_update_warning_emitted = false;
     out.events
         .push(ClientEvent::SessionPhaseChanged(runtime.phase_view()));
 }
@@ -422,9 +424,13 @@ fn reduce_notification(
 
     // Request-owned content requires an active request.
     if runtime.active.is_none() {
-        out.events.push(ClientEvent::Warning(WarningInfo {
-            message: "Received request-owned content update while no request is active".to_string(),
-        }));
+        if !runtime.orphan_update_warning_emitted {
+            out.events.push(ClientEvent::Warning(WarningInfo {
+                message: "Received request-owned content update while no request is active"
+                    .to_string(),
+            }));
+            runtime.orphan_update_warning_emitted = true;
+        }
         let client_events = normalizer.push_session_update(&update);
         out.events.extend(client_events);
         return;

nori-rs/acp/src/backend/session_reducer/tests.rs

@@ -803,3 +803,129 @@ fn usage_update_is_accepted_while_idle_and_emits_info_event() {
             if info.kind == nori_protocol::SessionUpdateKind::Usage
     )));
 }
+
+// =========================================================================
+// Orphan-update warning de-duplication
+// =========================================================================
+
+fn orphan_tool_update(call_id: &'static str) -> acp::SessionUpdate {
+    acp::SessionUpdate::ToolCallUpdate(acp::ToolCallUpdate::new(
+        call_id,
+        acp::ToolCallUpdateFields::new()
+            .title("Read Cargo.toml")
+            .kind(acp::ToolKind::Read)
+            .status(acp::ToolCallStatus::Completed)
+            .raw_input(serde_json::json!({ "path": "Cargo.toml" })),
+    ))
+}
+
+fn count_orphan_warnings(events: &[ClientEvent]) -> usize {
+    events
+        .iter()
+        .filter(|e| match e {
+            ClientEvent::Warning(w) => w
+                .message
+                .contains("Received request-owned content update while no request is active"),
+            _ => false,
+        })
+        .count()
+}
+
+fn count_tool_snapshots(events: &[ClientEvent]) -> usize {
+    events
+        .iter()
+        .filter(|e| matches!(e, ClientEvent::ToolSnapshot(_)))
+        .count()
+}
+
+#[test]
+fn orphan_warning_is_emitted_only_once_per_burst() {
+    let mut rt = new_runtime();
+    let mut norm = new_normalizer();
+
+    let first = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-1")),
+        &mut norm,
+    );
+    let second = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-2")),
+        &mut norm,
+    );
+    let third = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-3")),
+        &mut norm,
+    );
+
+    let warnings = count_orphan_warnings(&first.events)
+        + count_orphan_warnings(&second.events)
+        + count_orphan_warnings(&third.events);
+    assert_eq!(
+        warnings, 1,
+        "expected exactly one orphan warning across the burst"
+    );
+
+    let snapshots = count_tool_snapshots(&first.events)
+        + count_tool_snapshots(&second.events)
+        + count_tool_snapshots(&third.events);
+    assert_eq!(
+        snapshots, 3,
+        "every orphan update should still produce a tool snapshot"
+    );
+}
+
+#[test]
+fn orphan_warning_resets_when_a_new_prompt_starts() {
+    let mut rt = new_runtime();
+    let mut norm = new_normalizer();
+
+    // First burst while idle.
+    let first = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-1")),
+        &mut norm,
+    );
+    let second = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-2")),
+        &mut norm,
+    );
+    assert_eq!(
+        count_orphan_warnings(&first.events) + count_orphan_warnings(&second.events),
+        1
+    );
+
+    // Start a new prompt and finalize it back to idle.
+    reduce(
+        &mut rt,
+        InboundEvent::PromptSubmit(simple_prompt()),
+        &mut norm,
+    );
+    reduce(
+        &mut rt,
+        InboundEvent::PromptResponse {
+            stop_reason: acp::StopReason::EndTurn,
+        },
+        &mut norm,
+    );
+    assert_eq!(rt.phase_view(), SessionPhaseView::Idle);
+
+    // Second burst after the new request — warning should fire again.
+    let third = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-3")),
+        &mut norm,
+    );
+    let fourth = reduce(
+        &mut rt,
+        notification(orphan_tool_update("call-4")),
+        &mut norm,
+    );
+    assert_eq!(
+        count_orphan_warnings(&third.events) + count_orphan_warnings(&fourth.events),
+        1,
+        "a new prompt should reset the burst window so the warning fires again"
+    );
+}

nori-rs/nori-protocol/src/session_runtime.rs

@@ -220,6 +220,11 @@ pub struct SessionRuntime {
     pub persisted: PersistedSessionState,
     pub active: Option<ActiveRequestState>,
     pub queue: VecDeque<QueuedPrompt>,
+    /// Tracks whether we have already emitted the "request-owned content
+    /// update while no request is active" warning since the last time a
+    /// request became active. Reset on each new prompt/load start so that a
+    /// fresh post-cancel burst on a subsequent request can warn again.
+    pub orphan_update_warning_emitted: bool,
 }
 
 impl SessionRuntime {
@@ -229,6 +234,7 @@ impl SessionRuntime {
             persisted: PersistedSessionState::default(),
             active: None,
             queue: VecDeque::new(),
+            orphan_update_warning_emitted: false,
         }
     }
 

spec/agent-turn-state-spec.md

@@ -268,14 +268,18 @@ handle that path anyway, even if only to log and drop it.
 The observable behavior should be:
 
 - if a request-owned content update arrives with `active.is_none()`, emit
-  `UiEvent::Warning`
+  `UiEvent::Warning` once per burst — only the first such update since the
+  last active request emits the warning, subsequent updates in the same
+  idle window do not. The flag resets when a new prompt or load begins.
 - forward the well-formed content to the TUI as standalone between-turn output
+  (every update, regardless of whether the warning fired)
 - do not attribute that content to a prior or future request
 - do not reopen `active`
 - if the update is malformed or unrecognizable, log a warning and drop it
 
 This keeps the protocol handling honest without adding attribution heuristics to
-the core reducer.
+the core reducer, and prevents post-cancel update bursts from spamming the
+history with identical warning cells.
 
 ### 4. Attributed tool updates