feat: atomic wrapup, movie, integration writes

Ride writes: WrapUpRequested/Completed (wrapup create/set_complete),
MovieDiscovered (resolve upsert, new+ext id only), PosterSynced (poster
handler upsert), MovieDeleted (delete_movie), WatchEventIngested (save).
Deps drop event_publisher: wrapup, ingest, delete_review, watchlist add,
review logger.

Remaining .publish( sites:
announce-only: users/delete_account UserDeleted, person/get +
get_credits PersonEnrichmentRequested, jobs/enrichment_staleness,
http-axum search, movies/sync_poster + poster_sync_handler +
image-converter backfill + users/update_profile ImageStored (object
storage), activitypub federation_event_bridge (reacting to events).
rides write, deferred: social/execute (see report),
activitypub review_handler MovieEnrichmentRequested (after
save_remote_review).

crates/application/tests/wrapup/handle_requested_test.rs

@@ -1,7 +1,7 @@
 use chrono::{NaiveDate, Utc};
 use domain::models::wrapup::{WrapUpRecord, WrapUpStatus};
 use domain::ports::WrapUpRepository;
-use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, NoopEventPublisher};
+use domain::testing::{InMemoryWrapUpRepository, InMemoryWrapUpStatsQuery, RefusingWrapUpWrites};
 use domain::value_objects::WrapUpId;
 
 use application::wrapup::{deps::HandleWrapUpRequestedDeps, handle_requested};
@@ -22,11 +22,10 @@ async fn skips_if_already_ready() {
         created_at: Utc::now().naive_utc(),
         completed_at: None,
     };
-    repo.create(&record).await.unwrap();
+    repo.create(&record, &[]).await.unwrap();
 
     let deps = HandleWrapUpRequestedDeps {
         wrapup_repo: repo.clone(),
-        event_publisher: NoopEventPublisher::new(),
         wrapup_stats: InMemoryWrapUpStatsQuery::new(),
     };
 
@@ -46,7 +45,6 @@ async fn skips_if_already_ready() {
 async fn generates_wrapup_and_marks_complete() {
     let repo = InMemoryWrapUpRepository::new();
     let stats = InMemoryWrapUpStatsQuery::new();
-    let events = NoopEventPublisher::new();
     let wrapup_id = WrapUpId::generate();
     let uid = uuid::Uuid::new_v4();
 
@@ -61,11 +59,10 @@ async fn generates_wrapup_and_marks_complete() {
         created_at: Utc::now().naive_utc(),
         completed_at: None,
     };
-    repo.create(&record).await.unwrap();
+    repo.create(&record, &[]).await.unwrap();
 
     let deps = HandleWrapUpRequestedDeps {
         wrapup_repo: repo.clone(),
-        event_publisher: events.clone(),
         wrapup_stats: stats.clone(),
     };
 
@@ -85,13 +82,13 @@ async fn generates_wrapup_and_marks_complete() {
     assert_eq!(final_rec.status, WrapUpStatus::Ready);
     assert!(final_rec.report.is_some());
 
-    // Verify event was published
-    let published = events.published();
-    assert!(
-        published
-            .iter()
-            .any(|e| matches!(e, domain::events::DomainEvent::WrapUpCompleted { .. }))
-    );
+    // The completion event is recorded together with the completed row.
+    let recorded = repo.recorded_events();
+    assert_eq!(recorded.len(), 1);
+    assert!(matches!(
+        &recorded[0],
+        domain::events::DomainEvent::WrapUpCompleted { wrapup_id: id } if *id == wrapup_id
+    ));
 }
 
 #[tokio::test]
@@ -110,11 +107,10 @@ async fn skips_if_already_generating() {
         created_at: Utc::now().naive_utc(),
         completed_at: None,
     };
-    repo.create(&record).await.unwrap();
+    repo.create(&record, &[]).await.unwrap();
 
     let deps = HandleWrapUpRequestedDeps {
         wrapup_repo: repo.clone(),
-        event_publisher: NoopEventPublisher::new(),
         wrapup_stats: InMemoryWrapUpStatsQuery::new(),
     };
 
@@ -132,4 +128,42 @@ async fn skips_if_already_generating() {
     // Status should still be Generating (not changed to Ready)
     let final_rec = repo.get_by_id(&wrapup_id).await.unwrap().unwrap();
     assert_eq!(final_rec.status, WrapUpStatus::Generating);
+    assert!(repo.recorded_events().is_empty());
+}
+
+#[tokio::test]
+async fn a_refused_completion_propagates_and_records_nothing() {
+    let inner = InMemoryWrapUpRepository::new();
+    let wrapup_id = WrapUpId::generate();
+    let record = WrapUpRecord {
+        id: wrapup_id.clone(),
+        user_id: None,
+        start_date: NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
+        end_date: NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+        status: WrapUpStatus::Pending,
+        report: None,
+        error_message: None,
+        created_at: Utc::now().naive_utc(),
+        completed_at: None,
+    };
+    inner.create(&record, &[]).await.unwrap();
+    let deps = HandleWrapUpRequestedDeps {
+        wrapup_repo: RefusingWrapUpWrites::new(inner.clone()),
+        wrapup_stats: InMemoryWrapUpStatsQuery::new(),
+    };
+
+    let result = handle_requested::execute(
+        &deps,
+        wrapup_id.clone(),
+        None,
+        NaiveDate::from_ymd_opt(2024, 1, 1).unwrap(),
+        NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+    )
+    .await;
+
+    assert!(result.is_err());
+    let rec = inner.get_by_id(&wrapup_id).await.unwrap().unwrap();
+    assert_ne!(rec.status, WrapUpStatus::Ready);
+    assert!(rec.report.is_none());
+    assert!(inner.recorded_events().is_empty());
 }