feat(ticket): decouple audited lifecycle decisions from MR integration

T-718: unify state, completion, close and reopen with explicit CAS and operation receipts; keep MR integration proofs independent. Queue only the explicitly selected Ticket and fence target edits against active Worker grants. Align REST, Worker/WIP, evidence projection and generated contracts.

Validation: root cargo check; full ticket, merge-request, client, worker, yoi-workspace-server and server-api tests; server-api typescript feature; OpenAPI and six generated API checkers; Svelte check and 36 narrow Web tests; fmt and diff checks.

crates/merge-request/src/lib.rs

@@ -598,16 +598,8 @@ pub struct CompleteMergeRequest {
     pub auth: MergeRequestAuth,
     pub now: DateTime<Utc>,
 }
-#[derive(Debug, Clone)]
-pub struct CompleteTicket {
-    pub ticket_id: String,
-    pub operation_id: String,
-    pub item_revision: String,
-    pub merge_request_ids: Vec<String>,
-    pub requirement_approval_event_id: String,
-    pub auth: MergeRequestAuth,
-    pub now: DateTime<Utc>,
-}
+/// Historical MR-owned Ticket completion payload, retained for reading existing events.
+/// Canonical Ticket completion is owned by the Ticket domain.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
 pub struct TicketCompletionEvent {
     pub operation_id: String,
@@ -1332,164 +1324,6 @@ impl MergeRequestStore {
         Ok(event)
     }
 
-    pub fn complete_ticket(
-        &self,
-        mut input: CompleteTicket,
-    ) -> Result<TicketCompletionEvent, MergeRequestError> {
-        nonempty("operation_id", &input.operation_id)?;
-        nonempty("item_revision", &input.item_revision)?;
-        nonempty(
-            "requirement_approval_event_id",
-            &input.requirement_approval_event_id,
-        )?;
-        if input.merge_request_ids.is_empty() {
-            return Err(MergeRequestError::NotReady(
-                "Ticket completion requires at least one linked Merge Request result".into(),
-            ));
-        }
-        input.merge_request_ids.sort();
-        if input
-            .merge_request_ids
-            .windows(2)
-            .any(|ids| ids[0] == ids[1])
-        {
-            return Err(MergeRequestError::Validation(
-                "merge_request_ids must not contain duplicates".into(),
-            ));
-        }
-        let mut connection = self.lock()?;
-        let transaction = connection.transaction()?;
-        let existing: Option<String> = transaction
-            .query_row(
-                "SELECT payload.value
-                   FROM typed_ticket_event_attributes operation
-                   JOIN typed_ticket_event_attributes payload
-                     ON payload.workspace_id=operation.workspace_id
-                    AND payload.ticket_id=operation.ticket_id
-                    AND payload.event_index=operation.event_index
-                    AND payload.key='ticket_completion'
-                  WHERE operation.workspace_id=?1 AND operation.ticket_id=?2
-                    AND operation.key='operation_id' AND operation.value=?3",
-                params![input.auth.workspace_id, input.ticket_id, input.operation_id],
-                |row| row.get(0),
-            )
-            .optional()?;
-        if let Some(payload) = existing {
-            let event: TicketCompletionEvent = json(&payload)?;
-            if event.item_revision == input.item_revision
-                && event.merge_request_ids == input.merge_request_ids
-                && event.requirement_approval_event_id == input.requirement_approval_event_id
-                && event.completed_by == input.auth.actor()
-            {
-                return Ok(event);
-            }
-            return Err(MergeRequestError::Conflict(
-                "Ticket completion operation fingerprint mismatch".into(),
-            ));
-        }
-        let current_revision =
-            current_ticket_revision(&transaction, &input.auth.workspace_id, &input.ticket_id)?
-                .ok_or(MergeRequestError::NotFound)?;
-        if current_revision != input.item_revision {
-            return Err(MergeRequestError::Conflict(format!(
-                "Ticket item revision changed from `{}` to `{current_revision}`; repeat requirement review before completion",
-                input.item_revision
-            )));
-        }
-        let state: String = transaction.query_row(
-            "SELECT workflow_state FROM typed_tickets WHERE workspace_id=?1 AND ticket_id=?2",
-            params![input.auth.workspace_id, input.ticket_id],
-            |row| row.get(0),
-        )?;
-        if state != "inprogress" {
-            return Err(MergeRequestError::Conflict(
-                "Ticket must be inprogress".into(),
-            ));
-        }
-        let assignment_is_current: bool = transaction.query_row(
-            "SELECT EXISTS(
-                SELECT 1 FROM ticket_active_worker_assignments
-                 WHERE workspace_id=?1 AND ticket_id=?2 AND assignment_id=?3
-             )",
-            params![
-                input.auth.workspace_id,
-                input.ticket_id,
-                input.auth.assignment_id
-            ],
-            |row| row.get(0),
-        )?;
-        if !assignment_is_current {
-            return Err(MergeRequestError::Unauthorized(
-                "Ticket completion assignment changed before commit".into(),
-            ));
-        }
-        let actual_ids =
-            linked_merge_request_ids(&transaction, &input.auth.workspace_id, &input.ticket_id)?;
-        if actual_ids != input.merge_request_ids {
-            return Err(MergeRequestError::Conflict(
-                "linked Merge Request set changed; refresh Ticket completion evidence".into(),
-            ));
-        }
-        let mut requests = Vec::with_capacity(actual_ids.len());
-        let mut merged_subjects = Vec::with_capacity(actual_ids.len());
-        for merge_request_id in &actual_ids {
-            let request = load_mr(&transaction, &input.auth.workspace_id, merge_request_id)?
-                .ok_or(MergeRequestError::NotFound)?;
-            request.integration_approval().map_err(|error| {
-                let message = format!("Merge Request `{merge_request_id}`: {}", error.as_str());
-                if error == MergeRequestEvidenceError::MergeResultMissing {
-                    MergeRequestError::Corrupt(message)
-                } else {
-                    MergeRequestError::NotReady(message)
-                }
-            })?;
-            let merge = request
-                .merged_result()
-                .map_err(|error| MergeRequestError::Corrupt(error.as_str().into()))?;
-            merged_subjects.push(MergeRequestReviewSubject {
-                merge_request_id: merge_request_id.clone(),
-                subject_ref: merge.approved_source_ref.clone(),
-            });
-            requests.push(request);
-        }
-        requirement_approval(
-            &requests,
-            &input.item_revision,
-            &merged_subjects,
-            Some(&input.requirement_approval_event_id),
-        )
-        .map_err(|error| MergeRequestError::NotReady(error.as_str().into()))?;
-        let updated = transaction.execute(
-            "UPDATE typed_tickets
-                SET workflow_state='done',workflow_state_explicit=1,updated_at=?3
-              WHERE workspace_id=?1 AND ticket_id=?2 AND workflow_state='inprogress'",
-            params![
-                input.auth.workspace_id,
-                input.ticket_id,
-                input.now.to_rfc3339()
-            ],
-        )?;
-        if updated != 1 {
-            return Err(MergeRequestError::Conflict(
-                "Ticket state changed during completion".into(),
-            ));
-        }
-        // Terminal state ends unfinished work through the Workspace authority's
-        // lifecycle trigger. Keep the responsibility identity and its history.
-        let event = TicketCompletionEvent {
-            operation_id: input.operation_id,
-            ticket_id: input.ticket_id.clone(),
-            item_revision: input.item_revision,
-            merge_request_ids: input.merge_request_ids,
-            requirement_approval_event_id: input.requirement_approval_event_id,
-            completed_by: input.auth.actor(),
-            created_at: input.now,
-        };
-        ticket_completion_event(&transaction, &input.auth.workspace_id, &event)?;
-        transaction.commit()?;
-        Ok(event)
-    }
-
     pub fn repair_selector_from(
         &self,
         i: RepairSelectorFrom,
@@ -1935,62 +1769,6 @@ fn ticket_event(
     Ok(())
 }
 
-fn ticket_completion_event(
-    transaction: &Transaction<'_>,
-    workspace_id: &str,
-    event: &TicketCompletionEvent,
-) -> Result<(), MergeRequestError> {
-    let event_index: i64 = transaction.query_row(
-        "SELECT COALESCE(MAX(event_index),-1)+1 FROM typed_ticket_events WHERE workspace_id=?1 AND ticket_id=?2",
-        params![workspace_id, event.ticket_id],
-        |row| row.get(0),
-    )?;
-    transaction.execute(
-        "INSERT INTO typed_ticket_events(workspace_id,ticket_id,event_index,kind,author,at,from_state,to_state,heading,body)
-         VALUES(?1,?2,?3,'state_changed',?4,?5,'inprogress','done','Ticket requirements completed',?6)",
-        params![
-            workspace_id,
-            event.ticket_id,
-            event_index,
-            format!(
-                "worker:{}:{}",
-                event.completed_by.runtime_id, event.completed_by.worker_id
-            ),
-            event.created_at.to_rfc3339(),
-            format!(
-                "Current Ticket revision `{}` was approved by Review `{}` and completed with Merge Requests: {}.",
-                event.item_revision,
-                event.requirement_approval_event_id,
-                event.merge_request_ids.join(", ")
-            )
-        ],
-    )?;
-    for (key, value) in [
-        ("operation_id", event.operation_id.clone()),
-        ("item_revision", event.item_revision.clone()),
-        (
-            "requirement_approval_event_id",
-            event.requirement_approval_event_id.clone(),
-        ),
-        (
-            "merge_request_ids",
-            serde_json::to_string(&event.merge_request_ids)
-                .map_err(|error| MergeRequestError::Operation(error.to_string()))?,
-        ),
-        (
-            "ticket_completion",
-            serde_json::to_string(event)
-                .map_err(|error| MergeRequestError::Operation(error.to_string()))?,
-        ),
-    ] {
-        transaction.execute(
-            "INSERT INTO typed_ticket_event_attributes VALUES(?1,?2,?3,?4,?5)",
-            params![workspace_id, event.ticket_id, event_index, key, value],
-        )?;
-    }
-    Ok(())
-}
-
 pub fn migrate(c: &Connection) -> Result<(), MergeRequestError> {
     match schema_state(c)? {
         SchemaState::Fresh => fresh(c),

crates/merge-request/tests/store.rs

@@ -166,7 +166,7 @@ fn review_submission_authorization_rejects_invalid_grants_before_side_effects()
 }
 
 #[test]
-fn selectors_thread_and_completion_have_no_revision_or_commit_api() {
+fn integration_preserves_selectors_ticket_state_and_assignment_and_replays_its_merge() {
     let (d, s) = fixture();
     open(&s);
     let review = approve(&s, "opaque-source-ref", "token");
@@ -226,45 +226,14 @@ fn selectors_thread_and_completion_have_no_revision_or_commit_api() {
         })
         .unwrap();
     assert_eq!(replayed, merged);
-    let completed = s
-        .complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-op".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR".into()],
-            requirement_approval_event_id: merged.approval_event_id.clone(),
-            auth: auth(),
-            now: at(7),
-        })
-        .unwrap();
-    assert_eq!(completed.merge_request_ids, vec!["MR"]);
     let connection = Connection::open(d.path().join("db")).unwrap();
-    let (state, assignment_exists): (String, bool) = connection
-        .query_row(
-            "SELECT workflow_state, EXISTS(
-                SELECT 1 FROM ticket_current_worker_assignments
-                 WHERE workspace_id='W' AND ticket_id='T'
-             ) FROM typed_tickets WHERE workspace_id='W' AND ticket_id='T'",
-            [],
-            |row| Ok((row.get(0)?, row.get(1)?)),
-        )
-        .unwrap();
-    assert_eq!(state, "done");
-    assert!(assignment_exists);
-    let active: bool = connection.query_row("SELECT EXISTS(SELECT 1 FROM ticket_active_worker_assignments WHERE workspace_id='W' AND ticket_id='T')", [], |row| row.get(0)).unwrap();
-    assert!(!active);
-    let replayed_completion = s
-        .complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-op".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR".into()],
-            requirement_approval_event_id: merged.approval_event_id.clone(),
-            auth: auth(),
-            now: at(8),
-        })
-        .unwrap();
-    assert_eq!(replayed_completion, completed);
+    let (state, active): (String, bool) = connection.query_row(
+        "SELECT workflow_state, EXISTS(SELECT 1 FROM ticket_active_worker_assignments WHERE workspace_id='W' AND ticket_id='T') FROM typed_tickets WHERE workspace_id='W' AND ticket_id='T'",
+        [],
+        |row| Ok((row.get(0)?, row.get(1)?)),
+    ).unwrap();
+    assert_eq!(state, "inprogress");
+    assert!(active);
     let json = serde_json::to_string(&mr).unwrap();
     for banned in [
         "revision_id",
@@ -866,12 +835,12 @@ fn ticket_rescope_after_integration_accepts_fresh_requirement_attestation() {
     let (dir, store) = fixture();
     open(&store);
     let integration_approval = approve(&store, "subject", "token-integration");
-    store
+    let merge = store
         .complete(CompleteMergeRequest {
             merge_request_id: "MR".into(),
             ticket_id: "T".into(),
             operation_id: "merge".into(),
-            approval_event_id: integration_approval.event_id,
+            approval_event_id: integration_approval.event_id.clone(),
             current_subject_ref: "subject".into(),
             target_ref_before: "target-before".into(),
             target_ref_after: "target-after".into(),
@@ -896,6 +865,26 @@ fn ticket_rescope_after_integration_accepts_fresh_requirement_attestation() {
         .unwrap();
     drop(connection);
 
+    let snapshot = vec![MergeRequestReviewSubject {
+        merge_request_id: "MR".into(),
+        subject_ref: merge.approved_source_ref.clone(),
+    }];
+    let before_refresh = store.list_for_ticket("W", "T").unwrap();
+    assert_eq!(
+        requirement_approval(
+            &before_refresh,
+            "T:1",
+            &snapshot,
+            Some(&integration_approval.event_id),
+        ),
+        Err(MergeRequestEvidenceError::ItemRevisionMismatch)
+    );
+    assert_eq!(before_refresh[0].merged_result().unwrap(), &merge);
+    assert_eq!(
+        before_refresh[0].integration_approval().unwrap(),
+        &integration_approval
+    );
+
     store
         .register_reviewer_child_session(RegisterReviewerChildSession {
             workspace_id: "W".into(),
@@ -922,7 +911,7 @@ fn ticket_rescope_after_integration_accepts_fresh_requirement_attestation() {
             now: at(7),
         })
         .unwrap();
-    let requirement_approval = store
+    let requirement_review = store
         .submit_review(SubmitMergeRequestReview {
             merge_request_id: "MR".into(),
             ticket_id: "T".into(),
@@ -934,17 +923,33 @@ fn ticket_rescope_after_integration_accepts_fresh_requirement_attestation() {
             now: at(8),
         })
         .unwrap();
-    store
-        .complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete-post-rescope".into(),
-            item_revision: "T:1".into(),
-            merge_request_ids: vec!["MR".into()],
-            requirement_approval_event_id: requirement_approval.event_id,
-            auth: auth(),
-            now: at(9),
-        })
-        .unwrap();
+    let refreshed = store.list_for_ticket("W", "T").unwrap();
+    assert_eq!(
+        requirement_approval(
+            &refreshed,
+            "T:1",
+            &snapshot,
+            Some(&requirement_review.event_id),
+        )
+        .unwrap(),
+        &requirement_review
+    );
+    assert_eq!(
+        requirement_approval(&refreshed, "T:1", &snapshot, None).unwrap(),
+        &requirement_review
+    );
+    assert_eq!(refreshed[0].merged_result().unwrap(), &merge);
+    assert_eq!(
+        refreshed[0].integration_approval().unwrap(),
+        &integration_approval
+    );
+    let connection = Connection::open(dir.path().join("db")).unwrap();
+    let merge_payload: String = connection.query_row(
+        "SELECT payload_json FROM merge_request_thread_events WHERE workspace_id='W' AND merge_request_id='MR' AND kind='merge'",
+        [],
+        |row| row.get(0),
+    ).unwrap();
+    assert_eq!(merge_payload, serde_json::to_string(&merge).unwrap());
 }
 
 #[test]
@@ -980,19 +985,19 @@ fn review_request_rejects_a_snapshot_that_omits_a_linked_merge_request() {
 }
 
 #[test]
-fn partial_integration_retains_ticket_and_assignment_until_guarded_ticket_completion() {
+fn partial_and_full_integration_retain_ticket_state_and_active_assignment() {
     let (dir, store) = fixture();
     open_for(&store, "MR", "R");
     open_for(&store, "MR-2", "R2");
     let first = approve_for(&store, "MR", "R", "subject-one", "token-one");
     let second = approve_for(&store, "MR-2", "R2", "subject-two", "token-two");
 
-    store
+    let first_merge = store
         .complete(CompleteMergeRequest {
             merge_request_id: "MR".into(),
             ticket_id: "T".into(),
             operation_id: "merge-one".into(),
-            approval_event_id: first.event_id,
+            approval_event_id: first.event_id.clone(),
             current_subject_ref: "subject-one".into(),
             target_ref_before: "target-one-before".into(),
             target_ref_after: "target-one-after".into(),
@@ -1002,30 +1007,33 @@ fn partial_integration_retains_ticket_and_assignment_until_guarded_ticket_comple
             now: at(5),
         })
         .unwrap();
-    let connection = Connection::open(dir.path().join("db")).unwrap();
-    let (state, assigned): (String, bool) = connection
-        .query_row(
-            "SELECT workflow_state, EXISTS(SELECT 1 FROM ticket_current_worker_assignments WHERE workspace_id='W' AND ticket_id='T') FROM typed_tickets WHERE workspace_id='W' AND ticket_id='T'",
-            [],
-            |row| Ok((row.get(0)?, row.get(1)?)),
-        )
-        .unwrap();
-    assert_eq!(state, "inprogress");
-    assert!(assigned);
-    assert!(matches!(
-        store.complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR".into(), "MR-2".into()],
-            requirement_approval_event_id: second.event_id.clone(),
-            auth: auth(),
-            now: at(6),
-        }),
-        Err(MergeRequestError::NotReady(_))
-    ));
+    let partial = store.get_by_id("W", "MR-2").unwrap();
+    assert_eq!(
+        partial.integration_approval(),
+        Err(MergeRequestEvidenceError::NotMerged)
+    );
 
-    store
+    let connection = Connection::open(dir.path().join("db")).unwrap();
+    let assert_ticket_unchanged = || {
+        let (state, assigned, active, state_changes): (String, bool, bool, i64) = connection
+            .query_row(
+                "SELECT workflow_state,
+                    EXISTS(SELECT 1 FROM ticket_current_worker_assignments WHERE workspace_id='W' AND ticket_id='T'),
+                    EXISTS(SELECT 1 FROM ticket_active_worker_assignments WHERE workspace_id='W' AND ticket_id='T'),
+                    (SELECT COUNT(*) FROM typed_ticket_events WHERE workspace_id='W' AND ticket_id='T' AND kind='state_changed')
+                 FROM typed_tickets WHERE workspace_id='W' AND ticket_id='T'",
+                [],
+                |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)),
+            )
+            .unwrap();
+        assert_eq!(state, "inprogress");
+        assert!(assigned);
+        assert!(active);
+        assert_eq!(state_changes, 0);
+    };
+    assert_ticket_unchanged();
+
+    let second_merge = store
         .complete(CompleteMergeRequest {
             merge_request_id: "MR-2".into(),
             ticket_id: "T".into(),
@@ -1040,69 +1048,84 @@ fn partial_integration_retains_ticket_and_assignment_until_guarded_ticket_comple
             now: at(7),
         })
         .unwrap();
-    assert!(matches!(
-        store.complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete".into(),
-            item_revision: "stale".into(),
-            merge_request_ids: vec!["MR".into(), "MR-2".into()],
-            requirement_approval_event_id: second.event_id.clone(),
-            auth: auth(),
-            now: at(8),
-        }),
-        Err(MergeRequestError::Conflict(_))
-    ));
-    assert!(matches!(
-        store.complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete-missing-attestation".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR".into(), "MR-2".into()],
-            requirement_approval_event_id: "missing-review".into(),
-            auth: auth(),
-            now: at(8),
-        }),
-        Err(MergeRequestError::NotReady(_))
-    ));
-    assert!(matches!(
-        store.complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR".into()],
-            requirement_approval_event_id: second.event_id.clone(),
-            auth: auth(),
-            now: at(8),
-        }),
-        Err(MergeRequestError::Conflict(_))
-    ));
-    let completed = store
-        .complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR-2".into(), "MR".into()],
-            requirement_approval_event_id: second.event_id.clone(),
-            auth: auth(),
-            now: at(9),
+    assert_ticket_unchanged();
+    let requests = store.list_for_ticket("W", "T").unwrap();
+    let snapshot = requests
+        .iter()
+        .map(|request| MergeRequestReviewSubject {
+            merge_request_id: request.merge_request_id.clone(),
+            subject_ref: request.merged_result().unwrap().approved_source_ref.clone(),
         })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        requirement_approval(&requests, "t", &snapshot, Some(&second.event_id)).unwrap(),
+        &second
+    );
+    let first_request = requests
+        .iter()
+        .find(|request| request.merge_request_id == "MR")
         .unwrap();
-    let replay = store
-        .complete_ticket(CompleteTicket {
-            ticket_id: "T".into(),
-            operation_id: "ticket-complete".into(),
-            item_revision: "t".into(),
-            merge_request_ids: vec!["MR".into(), "MR-2".into()],
-            requirement_approval_event_id: second.event_id.clone(),
-            auth: auth(),
-            now: at(10),
-        })
+    let second_request = requests
+        .iter()
+        .find(|request| request.merge_request_id == "MR-2")
         .unwrap();
-    assert_eq!(replay, completed);
+    assert_eq!(first_request.merged_result().unwrap(), &first_merge);
+    assert_eq!(second_request.merged_result().unwrap(), &second_merge);
+    assert_eq!(first_request.integration_approval().unwrap(), &first);
+    assert_eq!(second_request.integration_approval().unwrap(), &second);
 }
 
 #[test]
-fn persisted_merged_result_requires_matching_nonrevoked_requested_approval_before_completion() {
+fn historical_ticket_completion_payload_remains_readable_and_unchanged_on_migration() {
+    let (dir, _store) = fixture();
+    let connection = Connection::open(dir.path().join("db")).unwrap();
+    let payload = r#"{
+        "operation_id": "historical-operation",
+        "ticket_id": "T",
+        "item_revision": "historical-revision",
+        "merge_request_ids": ["MR-2", "MR"],
+        "requirement_approval_event_id": "historical-review",
+        "completed_by": {"runtime_id": "runtime", "worker_id": "coder"},
+        "created_at": "2026-07-26T12:00:07Z"
+    }"#;
+    connection.execute_batch(
+        "UPDATE typed_tickets SET workflow_state='done' WHERE workspace_id='W' AND ticket_id='T';
+         INSERT INTO typed_ticket_events VALUES('W','T',0,'state_changed','worker:runtime:coder','2026-07-26T12:00:07Z','inprogress','done','Ticket requirements completed','historical body');"
+    ).unwrap();
+    connection
+        .execute(
+            "INSERT INTO typed_ticket_event_attributes VALUES('W','T',0,'ticket_completion',?1)",
+            [payload],
+        )
+        .unwrap();
+
+    migrate(&connection).unwrap();
+
+    let (saved_payload, kind, from_state, to_state, heading, body, state): (String, String, String, String, String, String, String) = connection.query_row(
+        "SELECT attribute.value,event.kind,event.from_state,event.to_state,event.heading,event.body,ticket.workflow_state
+           FROM typed_ticket_event_attributes attribute
+           JOIN typed_ticket_events event USING(workspace_id,ticket_id,event_index)
+           JOIN typed_tickets ticket USING(workspace_id,ticket_id)
+          WHERE attribute.workspace_id='W' AND attribute.ticket_id='T' AND attribute.key='ticket_completion'",
+        [],
+        |row| Ok((row.get(0)?,row.get(1)?,row.get(2)?,row.get(3)?,row.get(4)?,row.get(5)?,row.get(6)?)),
+    ).unwrap();
+    assert_eq!(saved_payload, payload);
+    assert_eq!(kind, "state_changed");
+    assert_eq!(from_state, "inprogress");
+    assert_eq!(to_state, "done");
+    assert_eq!(heading, "Ticket requirements completed");
+    assert_eq!(body, "historical body");
+    assert_eq!(state, "done");
+    let historical: TicketCompletionEvent = serde_json::from_str(&saved_payload).unwrap();
+    assert_eq!(
+        serde_json::to_value(&historical).unwrap(),
+        serde_json::from_str::<serde_json::Value>(payload).unwrap()
+    );
+}
+
+#[test]
+fn persisted_integration_evidence_rejects_missing_mismatched_revoked_or_late_approval() {
     for (case, expected) in [
         (
             "merge-missing",
@@ -1207,30 +1230,6 @@ fn persisted_merged_result_requires_matching_nonrevoked_requested_approval_befor
         }
         let reloaded = store.get_by_id("W", "MR").unwrap();
         assert_eq!(reloaded.integration_approval(), Err(expected), "{case}");
-        let rejected = store
-            .complete_ticket(CompleteTicket {
-                ticket_id: "T".into(),
-                operation_id: "complete-ticket".into(),
-                item_revision: "t".into(),
-                merge_request_ids: vec!["MR".into()],
-                requirement_approval_event_id: review.event_id.clone(),
-                auth: auth(),
-                now: at(7),
-            })
-            .unwrap_err();
-        match rejected {
-            MergeRequestError::Corrupt(message)
-                if expected == MergeRequestEvidenceError::MergeResultMissing =>
-            {
-                assert!(message.contains(expected.as_str()), "{case}: {message}");
-            }
-            MergeRequestError::NotReady(message)
-                if expected != MergeRequestEvidenceError::MergeResultMissing =>
-            {
-                assert!(message.contains(expected.as_str()), "{case}: {message}");
-            }
-            other => panic!("{case}: unexpected completion error {other}"),
-        }
         let (state, assigned): (String, bool) = connection.query_row(
             "SELECT workflow_state, EXISTS(SELECT 1 FROM ticket_current_worker_assignments WHERE workspace_id='W' AND ticket_id='T') FROM typed_tickets WHERE workspace_id='W' AND ticket_id='T'",
             [],