fix(usage): bill cancelled terminal usage and preserve terminal telemetry

crates/aether-usage-runtime/src/record.rs

@@ -136,7 +136,7 @@ fn lifecycle_status_and_billing(event_type: UsageEventType) -> (&'static str, &'
         UsageEventType::Streaming => ("streaming", "pending"),
         UsageEventType::Completed => ("completed", "pending"),
         UsageEventType::Failed => ("failed", "void"),
-        UsageEventType::Cancelled => ("cancelled", "void"),
+        UsageEventType::Cancelled => ("cancelled", "pending"),
     }
 }
 
@@ -181,6 +181,38 @@ mod tests {
         assert_eq!(record.finalized_at_unix_secs, Some(1_700_000_000));
     }
 
+    #[test]
+    fn cancelled_terminal_record_stays_pending_for_settlement() {
+        let record = build_upsert_usage_record_from_event(&UsageEvent {
+            event_type: UsageEventType::Cancelled,
+            request_id: "req-cancelled".to_string(),
+            timestamp_ms: 1_700_000_000_000,
+            data: UsageEventData {
+                provider_name: "OpenAI".to_string(),
+                model: "gpt-5".to_string(),
+                input_tokens: Some(10),
+                output_tokens: Some(20),
+                total_tokens: Some(30),
+                total_cost_usd: Some(0.03),
+                actual_total_cost_usd: Some(0.02),
+                status_code: Some(499),
+                response_time_ms: Some(200),
+                first_byte_time_ms: Some(50),
+                ..UsageEventData::default()
+            },
+        })
+        .expect("record should build");
+
+        assert_eq!(record.status, "cancelled");
+        assert_eq!(record.billing_status, "pending");
+        assert_eq!(record.total_tokens, Some(30));
+        assert_eq!(record.total_cost_usd, Some(0.03));
+        assert_eq!(record.actual_total_cost_usd, Some(0.02));
+        assert_eq!(record.status_code, Some(499));
+        assert_eq!(record.response_time_ms, Some(200));
+        assert_eq!(record.first_byte_time_ms, Some(50));
+    }
+
     #[test]
     fn sanitizes_request_metadata_before_building_upsert_record() {
         let record = build_upsert_usage_record_from_event(&UsageEvent {

crates/aether-usage-runtime/src/settlement.rs

@@ -164,6 +164,29 @@ mod tests {
         assert!(!inputs[0].api_key_is_standalone);
     }
 
+    #[tokio::test]
+    async fn settles_pending_cancelled_usage() {
+        let writer = TestSettlementWriter {
+            has_writer: true,
+            ..Default::default()
+        };
+        let mut usage = sample_usage();
+        usage.status = "cancelled".to_string();
+        usage.status_code = Some(499);
+
+        settle_usage_if_needed(&writer, &usage)
+            .await
+            .expect("settlement should succeed");
+
+        let inputs = writer.inputs.lock().expect("settlement inputs lock");
+        assert_eq!(inputs.len(), 1);
+        assert_eq!(inputs[0].request_id, "req-1");
+        assert_eq!(inputs[0].status, "cancelled");
+        assert_eq!(inputs[0].billing_status, "pending");
+        assert_eq!(inputs[0].total_cost_usd, 1.25);
+        assert_eq!(inputs[0].actual_total_cost_usd, 0.75);
+    }
+
     #[tokio::test]
     async fn propagates_standalone_key_flag_from_usage_metadata() {
         let writer = TestSettlementWriter {