fix(hooks): retain completion-only observers

Always run turn_end observers for TurnComplete events that have no matching TurnStarted, including manual compaction, purge, and shell-only lifecycle completions. Give those records a unique lifecycle id, observed timestamp, and no route so they remain visible without inheriting stale model provenance or cost.

Validation: CI-equivalent workspace/all-features clippy; completion-only and TurnStarted metadata regressions; turn_end payload regression.

Author: nightt5879

CHANGELOG.md

@@ -15,7 +15,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   unpriced, and route-scoped cache and recorded-time pricing replace model-only
   guesses. StepFun PAYG and Step Plan usage now stay distinct without persisting
   raw endpoint URLs, so subscription quota is never reported as token spend
-  (#4335). This builds on the scorecard introduced by @findshan in #3388.
+  (#4335). Completion-only shell, manual-compaction, and purge events remain
+  visible to `turn_end` observers as explicitly non-model lifecycle records.
+  This builds on the scorecard introduced by @findshan in #3388.
 
 ## [0.8.68] - 2026-07-12
 

crates/tui/CHANGELOG.md

@@ -15,7 +15,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   unpriced, and route-scoped cache and recorded-time pricing replace model-only
   guesses. StepFun PAYG and Step Plan usage now stay distinct without persisting
   raw endpoint URLs, so subscription quota is never reported as token spend
-  (#4335). This builds on the scorecard introduced by @findshan in #3388.
+  (#4335). Completion-only shell, manual-compaction, and purge events remain
+  visible to `turn_end` observers as explicitly non-model lifecycle records.
+  This builds on the scorecard introduced by @findshan in #3388.
 
 ## [0.8.68] - 2026-07-12
 

crates/tui/src/tui/ui.rs

@@ -1222,7 +1222,7 @@ fn execute_subagent_observer_hook(
 
 fn execute_turn_end_observer_hook(
     app: &App,
-    turn: &ActiveTurnMetadata,
+    turn: Option<&ActiveTurnMetadata>,
     usage: &Usage,
     billing_surface: Option<&str>,
     duration: Duration,
@@ -1232,15 +1232,16 @@ fn execute_turn_end_observer_hook(
         return;
     }
 
+    let metadata = turn_end_observer_metadata(turn);
     let context = app.base_hook_context();
     let payload = crate::hooks::turn_end_payload(TurnEndPayloadInput {
         context: &context,
-        created_at: turn.created_at,
-        model_backed: turn.route.is_some(),
-        provider: turn.route.as_ref().map(|route| route.provider.as_str()),
-        billing_surface,
-        model: turn.route.as_ref().map(|route| route.model.as_str()),
-        turn_id: &turn.turn_id,
+        created_at: metadata.created_at,
+        model_backed: metadata.route.is_some(),
+        provider: metadata.route.map(|route| route.provider.as_str()),
+        billing_surface: metadata.route.and(billing_surface),
+        model: metadata.route.map(|route| route.model.as_str()),
+        turn_id: metadata.turn_id.as_ref(),
         status: app.runtime_turn_status.as_deref().unwrap_or("unknown"),
         error,
         duration,
@@ -1262,6 +1263,31 @@ fn execute_turn_end_observer_hook(
         });
 }
 
+struct TurnEndObserverMetadata<'a> {
+    turn_id: std::borrow::Cow<'a, str>,
+    created_at: chrono::DateTime<chrono::Utc>,
+    route: Option<&'a crate::core::events::TurnRoute>,
+}
+
+fn turn_end_observer_metadata(turn: Option<&ActiveTurnMetadata>) -> TurnEndObserverMetadata<'_> {
+    turn.map_or_else(
+        || TurnEndObserverMetadata {
+            // Manual compaction, purge, and shell-only completions predate the
+            // TurnStarted lifecycle event. Preserve their observer contract
+            // with a distinct non-model identity instead of borrowing a stale
+            // model turn id.
+            turn_id: std::borrow::Cow::Owned(format!("lifecycle_{}", uuid::Uuid::new_v4())),
+            created_at: chrono::Utc::now(),
+            route: None,
+        },
+        |turn| TurnEndObserverMetadata {
+            turn_id: std::borrow::Cow::Borrowed(&turn.turn_id),
+            created_at: turn.created_at,
+            route: turn.route.as_ref(),
+        },
+    )
+}
+
 fn bounded_subagent_hook_preview(text: &str) -> (String, bool) {
     if text.len() <= SUBAGENT_HOOK_PREVIEW_LIMIT {
         return (text.to_string(), false);
@@ -2950,16 +2976,14 @@ async fn run_event_loop(
                             }
                         }
 
-                        if let Some(completed_turn) = completed_turn.as_ref() {
-                            execute_turn_end_observer_hook(
-                                app,
-                                completed_turn,
-                                &usage,
-                                billing_surface,
-                                turn_elapsed,
-                                error.as_deref(),
-                            );
-                        }
+                        execute_turn_end_observer_hook(
+                            app,
+                            completed_turn.as_ref(),
+                            &usage,
+                            billing_surface,
+                            turn_elapsed,
+                            error.as_deref(),
+                        );
 
                         if queued_to_send.is_none() {
                             queued_to_send = app.pop_queued_message();

crates/tui/src/tui/ui/tests.rs

@@ -6718,6 +6718,25 @@ fn turn_started_route_is_captured_before_cancel_suppression() {
     assert!(route.auto_model);
     assert!(app.pending_turn_route.is_none());
     assert!(app.ocean_completion_started_at.is_none());
+
+    let observer = turn_end_observer_metadata(Some(active_turn));
+    assert_eq!(observer.turn_id.as_ref(), "turn_cancel_race");
+    assert_eq!(observer.created_at, created_at);
+    assert_eq!(observer.route, Some(route));
+}
+
+#[test]
+fn completion_only_hook_metadata_is_synthetic_and_non_model() {
+    let observed_after = chrono::Utc::now();
+    let first = turn_end_observer_metadata(None);
+    let second = turn_end_observer_metadata(None);
+
+    assert!(first.turn_id.starts_with("lifecycle_"));
+    assert!(second.turn_id.starts_with("lifecycle_"));
+    assert_ne!(first.turn_id, second.turn_id);
+    assert!(first.created_at >= observed_after);
+    assert!(first.route.is_none());
+    assert!(second.route.is_none());
 }
 
 #[test]

docs/CONFIGURATION.md

@@ -1017,7 +1017,9 @@ usage. Unrecognized and custom endpoints remain `null` and unpriced.
 
 Shell-only lifecycle completions set `model_backed` to `false` and may report a
 `null` provider; offline scorecards exclude those records from model token and
-cost totals.
+cost totals. Completion-only shell, manual-compaction, and purge events that do
+not have a matching `TurnStarted` retain the observer notification with a
+synthetic `lifecycle_<uuid>` turn id and the time the completion was observed.
 
 For `interrupted` or `failed` turns, `status` reflects that terminal
 state and `error` carries the engine error string when one is available.