chore: merge orchestration into develop

2026-08-17 11:02:47 +09:00
parent 956b453e6a 063f203efe
commit 8c60921c99
27 changed files with 4655 additions and 4106 deletions
@@ -5,10 +5,12 @@ edition.workspace = true
 license.workspace = true

 [dependencies]
+chrono = { version = "0.4", default-features = false, features = ["clock", "serde"] }
 rusqlite.workspace = true
 serde = { workspace = true, features = ["derive"] }
-sha2.workspace = true
+serde_json.workspace = true
 thiserror.workspace = true
+uuid = { workspace = true, features = ["v7"] }

 [dev-dependencies]
 tempfile.workspace = true
@@ -1,297 +1,386 @@
+use chrono::{TimeZone, Utc};
 use merge_request::*;
-use rusqlite::{Connection, params};
-use std::sync::{Arc, Barrier};
-use std::thread;
-use tempfile::TempDir;
-
-fn setup() -> (TempDir, SqliteMergeRequestStore) {
-    let dir = tempfile::tempdir().unwrap();
-    let path = dir.path().join("server.db");
-    let conn = Connection::open(&path).unwrap();
-    conn.execute_batch(r#"
-      PRAGMA foreign_keys=ON;
-      CREATE TABLE repositories(workspace_id TEXT NOT NULL,repository_id TEXT NOT NULL,PRIMARY KEY(workspace_id,repository_id));
-      CREATE TABLE typed_tickets(workspace_id TEXT NOT NULL,ticket_id TEXT NOT NULL,workflow_state TEXT NOT NULL,workflow_state_explicit INTEGER NOT NULL DEFAULT 1,updated_at TEXT NOT NULL,PRIMARY KEY(workspace_id,ticket_id));
-      CREATE TABLE typed_ticket_events(workspace_id TEXT NOT NULL,ticket_id TEXT NOT NULL,event_index INTEGER NOT NULL,kind TEXT NOT NULL,author TEXT,at TEXT,status TEXT,from_state TEXT,to_state TEXT,heading TEXT,body TEXT,PRIMARY KEY(workspace_id,ticket_id,event_index));
-      CREATE TABLE typed_ticket_event_attributes(workspace_id TEXT NOT NULL,ticket_id TEXT NOT NULL,event_index INTEGER NOT NULL,key TEXT NOT NULL,value TEXT NOT NULL,PRIMARY KEY(workspace_id,ticket_id,event_index,key));
-      CREATE TABLE ticket_worker_assignments(workspace_id TEXT NOT NULL,ticket_id TEXT NOT NULL,assignment_id TEXT NOT NULL,runtime_id TEXT NOT NULL,worker_id TEXT NOT NULL,PRIMARY KEY(workspace_id,ticket_id,assignment_id));
-      CREATE TABLE ticket_current_worker_assignments(workspace_id TEXT NOT NULL,ticket_id TEXT NOT NULL,assignment_id TEXT NOT NULL,runtime_id TEXT NOT NULL,worker_id TEXT NOT NULL,PRIMARY KEY(workspace_id,ticket_id));
-    "#).unwrap();
-    for ws in ["ws-a", "ws-b"] {
-        conn.execute("INSERT INTO repositories VALUES(?1,'repo')", params![ws])
-            .unwrap();
-        conn.execute(
-            "INSERT INTO typed_tickets VALUES(?1,'T1','inprogress',1,'t0')",
-            params![ws],
-        )
-        .unwrap();
-        conn.execute(
-            "INSERT INTO ticket_worker_assignments VALUES(?1,'T1','A1','R1','W1')",
-            params![ws],
-        )
-        .unwrap();
-        conn.execute(
-            "INSERT INTO ticket_current_worker_assignments VALUES(?1,'T1','A1','R1','W1')",
-            params![ws],
-        )
-        .unwrap();
-    }
-    drop(conn);
-    let store = SqliteMergeRequestStore::open(&path, "ws-a").unwrap();
-    (dir, store)
-}
-
-fn revision(id: &str, ordinal: u64, head: &str) -> MergeRequestRevision {
-    MergeRequestRevision {
-        revision_id: id.into(),
-        ordinal,
-        base_commit: "base".into(),
-        head_commit: head.into(),
-        changed_paths: vec!["src/lib.rs".into()],
-        summary: format!("revision {id}"),
-        assignment_id: "A1".into(),
-        created_at: format!("t{ordinal}"),
+use rusqlite::Connection;
+use std::sync::{Arc, Mutex};
+#[derive(Clone)]
+struct Assignments(Arc<Mutex<CurrentAssignment>>);
+impl AssignmentSource for Assignments {
+    fn current_assignment(&self, _: &str, _: &str) -> Result<Option<CurrentAssignment>, String> {
+        Ok(Some(self.0.lock().unwrap().clone()))
    }
 }
-
-fn open(store: &SqliteMergeRequestStore) {
-    store
-        .open_merge_request(OpenMergeRequest {
-            merge_request_id: "MR1".into(),
-            ticket_id: "T1".into(),
-            repository_id: "repo".into(),
-            target_ref_selector: "refs/heads/develop".into(),
-            revision: revision("V1", 1, "head"),
-            authenticated_runtime_id: "R1".into(),
-            authenticated_worker_id: "W1".into(),
-            now: "t1".into(),
-        })
-        .unwrap();
-}
-
-fn attempt(store: &SqliteMergeRequestStore, revision: &str, token: &str) {
-    let child = format!("child-{revision}");
-    store
-        .register_reviewer_child_session(RegisterReviewerChildSession {
-            parent_runtime_id: "R1".into(),
-            parent_worker_id: "W1".into(),
-            child_session_id: child.clone(),
-            now: "t2".into(),
-        })
-        .unwrap();
-    store
-        .register_review_attempt(RegisterReviewAttempt {
-            attempt_id: format!("attempt-{revision}"),
-            ticket_id: "T1".into(),
-            revision_id: revision.into(),
-            parent_assignment_id: "A1".into(),
-            parent_runtime_id: "R1".into(),
-            parent_worker_id: "W1".into(),
-            child_session_id: child,
-            capability_token: token.into(),
-            now: "t2".into(),
-        })
-        .unwrap();
-}
-
-fn approve(store: &SqliteMergeRequestStore, revision: &str, token: &str) {
-    attempt(store, revision, token);
-    store
-        .submit_review(SubmitReview {
-            ticket_id: "T1".into(),
-            revision_id: revision.into(),
-            capability_token: token.into(),
-            decision: ReviewDecision::Approve,
-            body: "approved".into(),
-            findings: vec![],
-            now: "t3".into(),
-        })
-        .unwrap();
-}
-
-fn completion(operation_id: &str) -> CompleteMergeRequest {
-    CompleteMergeRequest {
-        operation_id: operation_id.into(),
-        ticket_id: "T1".into(),
-        expected_revision_id: "V1".into(),
-        target_commit: "base".into(),
-        source_commit: "head".into(),
-        result_commit: "head".into(),
-        strategy: MergeStrategy::FastForward,
-        resolution: MergeResolution::None,
-        implementation_assignment_id: "A1".into(),
-        completion_actor_runtime_id: "OR".into(),
-        completion_actor_worker_id: "OW".into(),
-        now: "t4".into(),
+struct Repositories;
+impl RepositorySource for Repositories {
+    fn repository_belongs_to_workspace(&self, w: &str, r: &str) -> Result<bool, String> {
+        Ok(w == "W" && r == "R")
    }
 }
-
-#[test]
-fn target_movement_does_not_invalidate_source_revision_approval() {
-    let (_dir, store) = setup();
-    open(&store);
-    approve(&store, "V1", "token-v1");
-    for target in ["base", "advanced-target"] {
-        let readiness = store
-            .readiness_for_ticket_with_target("T1", Some(target))
-            .unwrap();
-        assert!(
-            readiness.ready,
-            "target movement must not invalidate source approval"
-        );
-        assert_eq!(readiness.review_status, ReviewStatus::Approved);
-        assert_eq!(readiness.observed_target_commit.as_deref(), Some(target));
+fn at(s: u32) -> chrono::DateTime<Utc> {
+    Utc.with_ymd_and_hms(2026, 7, 26, 12, 0, s)
+        .single()
+        .unwrap()
+}
+fn auth() -> MergeRequestAuth {
+    MergeRequestAuth {
+        workspace_id: "W".into(),
+        repository_id: "R".into(),
+        runtime_id: "runtime".into(),
+        worker_id: "coder".into(),
+        assignment_id: "A".into(),
    }
-    store
-        .add_revision(AddRevision {
-            ticket_id: "T1".into(),
-            expected_current_revision_id: "V1".into(),
-            revision: revision("V2", 2, "head2"),
-            authenticated_runtime_id: "R1".into(),
-            authenticated_worker_id: "W1".into(),
-            now: "t5".into(),
-        })
-        .unwrap();
-    assert_eq!(
-        store.readiness_for_ticket("T1").unwrap().review_status,
-        ReviewStatus::Pending
-    );
 }
-
-#[test]
-fn completion_records_one_final_merge_outcome_and_replays_idempotently() {
-    let (_dir, store) = setup();
-    open(&store);
-    approve(&store, "V1", "token-v1");
-    let first = store.complete(completion("OP1")).unwrap();
-    assert!(!first.replayed);
-    assert_eq!(first.ticket_state, "done");
-    let merged = store.show_for_ticket("T1").unwrap().unwrap();
-    assert_eq!(merged.state, MergeRequestState::Merged);
-    assert_eq!(merged.merged_revision_id.as_deref(), Some("V1"));
-    assert_eq!(merged.merged_target_commit.as_deref(), Some("base"));
-    assert_eq!(merged.merged_result_commit.as_deref(), Some("head"));
-    assert_eq!(merged.merge_strategy, Some(MergeStrategy::FastForward));
-    assert_eq!(merged.merge_resolution, Some(MergeResolution::None));
-    assert_eq!(merged.merged_by_runtime_id.as_deref(), Some("OR"));
-    assert_eq!(merged.merged_by_worker_id.as_deref(), Some("OW"));
-    assert!(store.complete(completion("OP1")).unwrap().replayed);
-    let mut conflicting = completion("OP1");
-    conflicting.target_commit = "other".into();
-    assert!(matches!(
-        store.complete(conflicting),
-        Err(MergeRequestError::OperationConflict)
-    ));
+fn fixture() -> (tempfile::TempDir, MergeRequestStore) {
+    let d = tempfile::tempdir().unwrap();
+    let p = d.path().join("db");
+    let c = Connection::open(&p).unwrap();
+    c.execute_batch("CREATE TABLE workspaces(workspace_id TEXT PRIMARY KEY);CREATE TABLE repositories(workspace_id TEXT,repository_id TEXT,PRIMARY KEY(workspace_id,repository_id));CREATE TABLE ticket_current_worker_assignments(workspace_id TEXT,ticket_id TEXT,assignment_id TEXT,runtime_id TEXT,worker_id TEXT,updated_at TEXT,PRIMARY KEY(workspace_id,ticket_id));CREATE TABLE typed_tickets(workspace_id TEXT,ticket_id TEXT,workflow_state TEXT,workflow_state_explicit INTEGER,updated_at TEXT,PRIMARY KEY(workspace_id,ticket_id));CREATE TABLE typed_ticket_events(workspace_id TEXT,ticket_id TEXT,event_index INTEGER,kind TEXT,author TEXT,at TEXT,from_state TEXT,to_state TEXT,heading TEXT,body TEXT,PRIMARY KEY(workspace_id,ticket_id,event_index));CREATE TABLE typed_ticket_event_attributes(workspace_id TEXT,ticket_id TEXT,event_index INTEGER,key TEXT,value TEXT,PRIMARY KEY(workspace_id,ticket_id,event_index,key));INSERT INTO workspaces VALUES('W');INSERT INTO repositories VALUES('W','R');INSERT INTO ticket_current_worker_assignments VALUES('W','T','A','runtime','coder','t');INSERT INTO typed_tickets VALUES('W','T','inprogress',1,'t');").unwrap();
+    drop(c);
+    let a = Assignments(Arc::new(Mutex::new(CurrentAssignment {
+        assignment_id: "A".into(),
+        ticket_id: "T".into(),
+        runtime_id: "runtime".into(),
+        worker_id: "coder".into(),
+    })));
+    let s = MergeRequestStore::open(&p, Arc::new(a), Arc::new(Repositories)).unwrap();
+    (d, s)
 }
-
-#[test]
-fn completion_rejects_invalid_or_non_current_source_outcomes_without_side_effects() {
-    let (_dir, store) = setup();
-    open(&store);
-    approve(&store, "V1", "token-v1");
-    let mut invalid_ff = completion("bad-ff");
-    invalid_ff.result_commit = "different".into();
-    assert!(matches!(
-        store.complete(invalid_ff),
-        Err(MergeRequestError::InvalidMergeOutcome(_))
-    ));
-    let mut invalid_merge = completion("bad-merge");
-    invalid_merge.strategy = MergeStrategy::Merge;
-    assert!(matches!(
-        store.complete(invalid_merge),
-        Err(MergeRequestError::InvalidMergeOutcome(_))
-    ));
-    let mut wrong_source = completion("wrong-source");
-    wrong_source.source_commit = "not-approved".into();
-    wrong_source.result_commit = "not-approved".into();
-    assert!(matches!(
-        store.complete(wrong_source),
-        Err(MergeRequestError::InvalidMergeOutcome(_))
-    ));
-    assert_eq!(
-        store.show_for_ticket("T1").unwrap().unwrap().state,
-        MergeRequestState::Open
-    );
-    let conn = Connection::open(store.db_path()).unwrap();
-    assert_eq!(
-        conn.query_row(
-            "SELECT workflow_state FROM typed_tickets WHERE workspace_id='ws-a' AND ticket_id='T1'",
-            [],
-            |row| row.get::<_, String>(0)
-        )
-        .unwrap(),
-        "inprogress"
-    );
+fn open(s: &MergeRequestStore) {
+    s.open_merge_request(OpenMergeRequest {
+        merge_request_id: "MR".into(),
+        ticket_id: "T".into(),
+        repository_id: "R".into(),
+        selector_from: "work/t".into(),
+        selector_to: "develop".into(),
+        summary: "summary".into(),
+        auth: auth(),
+        now: at(1),
+    })
+    .unwrap();
 }
-
-#[test]
-fn concurrent_completion_converges_on_one_operation() {
-    let (_dir, store) = setup();
-    open(&store);
-    approve(&store, "V1", "token-v1");
-    let path = store.db_path().to_path_buf();
-    let barrier = Arc::new(Barrier::new(3));
-    let mut handles = Vec::new();
-    for _ in 0..2 {
-        let path = path.clone();
-        let barrier = barrier.clone();
-        handles.push(thread::spawn(move || {
-            let store = SqliteMergeRequestStore::open_verified(path, "ws-a").unwrap();
-            barrier.wait();
-            store.complete(completion("OP-concurrent"))
-        }));
-    }
-    barrier.wait();
-    let outcomes: Vec<_> = handles
-        .into_iter()
-        .map(|handle| handle.join().unwrap().unwrap())
-        .collect();
-    assert_eq!(
-        outcomes.iter().filter(|outcome| !outcome.replayed).count(),
-        1
-    );
-    assert_eq!(
-        outcomes.iter().filter(|outcome| outcome.replayed).count(),
-        1
-    );
+fn request(s: &MergeRequestStore, subject: &str, token: &str) -> ReviewRequestedEvent {
+    s.register_reviewer_child_session(RegisterReviewerChildSession {
+        workspace_id: "W".into(),
+        parent_runtime_id: "runtime".into(),
+        parent_worker_id: "coder".into(),
+        child_session_id: format!("child-{token}"),
+        reviewer_profile: "builtin:reviewer".into(),
+        now: at(2),
+    })
+    .unwrap();
+    s.request_review(RequestMergeRequestReview {
+        ticket_id: "T".into(),
+        subject_ref: subject.into(),
+        child_session_id: format!("child-{token}"),
+        capability_token: token.into(),
+        auth: auth(),
+        now: at(3),
+    })
+    .unwrap()
+    .request_event
 }
-
-#[test]
-fn reviewer_attempt_is_bound_to_direct_child_and_current_assignment() {
-    let (_dir, store) = setup();
-    open(&store);
-    store
-        .register_reviewer_child_session(RegisterReviewerChildSession {
-            parent_runtime_id: "R1".into(),
-            parent_worker_id: "W1".into(),
-            child_session_id: "child".into(),
-            now: "t2".into(),
-        })
-        .unwrap();
-    store
-        .register_review_attempt(RegisterReviewAttempt {
-            attempt_id: "attempt".into(),
-            ticket_id: "T1".into(),
-            revision_id: "V1".into(),
-            parent_assignment_id: "A1".into(),
-            parent_runtime_id: "R1".into(),
-            parent_worker_id: "W1".into(),
-            child_session_id: "child".into(),
-            capability_token: "token".into(),
-            now: "t2".into(),
-        })
-        .unwrap();
-    let wrong_token = store.submit_review(SubmitReview {
-        ticket_id: "T1".into(),
-        revision_id: "V1".into(),
-        capability_token: "wrong".into(),
+fn approve(s: &MergeRequestStore, subject: &str, token: &str) -> ReviewEvent {
+    request(s, subject, token);
+    s.submit_review(SubmitMergeRequestReview {
+        ticket_id: "T".into(),
+        current_subject_ref: subject.into(),
+        capability_token: token.into(),
        decision: ReviewDecision::Approve,
        body: "approved".into(),
        findings: vec![],
-        now: "t3".into(),
+        now: at(4),
+    })
+    .unwrap()
+}
+#[test]
+fn selectors_thread_and_completion_have_no_revision_or_commit_api() {
+    let (_d, s) = fixture();
+    open(&s);
+    let review = approve(&s, "opaque-source-ref", "token");
+    let ready = s
+        .readiness(ReadinessCheck {
+            ticket_id: "T".into(),
+            current_subject_ref: Some("opaque-source-ref".into()),
+            auth: auth(),
+        })
+        .unwrap();
+    assert!(ready.ready);
+    let merged = s
+        .complete(CompleteMergeRequest {
+            ticket_id: "T".into(),
+            operation_id: "op".into(),
+            approval_event_id: review.event_id,
+            current_subject_ref: "opaque-source-ref".into(),
+            target_ref_before: "old-target-ref".into(),
+            target_ref_after: "new-target-ref".into(),
+            strategy: MergeStrategy::FastForward,
+            resolution: ConflictResolution::None,
+            auth: auth(),
+            now: at(5),
+        })
+        .unwrap();
+    assert_eq!(merged.approved_source_ref, "opaque-source-ref");
+    let mr = s.get("W", "T").unwrap();
+    assert_eq!(mr.selector_from.as_deref(), Some("work/t"));
+    assert_eq!(mr.state, MergeRequestState::Merged);
+    let json = serde_json::to_string(&mr).unwrap();
+    for banned in [
+        "revision_id",
+        "attempt_id",
+        "base_commit",
+        "head_commit",
+        "source_commit",
+        "result_commit",
+        "current_revision",
+    ] {
+        assert!(!json.contains(banned), "{banned} in {json}")
+    }
+}
+#[test]
+fn source_move_cancels_submission_and_old_approval_is_reusable_when_source_returns() {
+    let (_d, s) = fixture();
+    open(&s);
+    let approved = approve(&s, "source-a", "one");
+    request(&s, "source-b", "two");
+    assert!(
+        s.submit_review(SubmitMergeRequestReview {
+            ticket_id: "T".into(),
+            current_subject_ref: "source-c".into(),
+            capability_token: "two".into(),
+            decision: ReviewDecision::Approve,
+            body: "stale".into(),
+            findings: vec![],
+            now: at(6)
+        })
+        .is_err()
+    );
+    let mr = s.get("W", "T").unwrap();
+    assert!(
+        mr.thread
+            .iter()
+            .any(|e| matches!(e, MergeRequestThreadEvent::ReviewCancelled(_)))
+    );
+    assert_eq!(
+        mr.effective_review("source-a").map(|r| &r.event_id),
+        Some(&approved.event_id)
+    );
+}
+#[test]
+fn review_revocation_invalidates_readiness() {
+    let (_d, s) = fixture();
+    open(&s);
+    let review = approve(&s, "source", "one");
+    s.revoke_review(RevokeMergeRequestReview {
+        ticket_id: "T".into(),
+        review_event_id: review.event_id,
+        reason: "bad evidence".into(),
+        auth: auth(),
+        now: at(7),
+    })
+    .unwrap();
+    let r = s
+        .readiness(ReadinessCheck {
+            ticket_id: "T".into(),
+            current_subject_ref: Some("source".into()),
+            auth: auth(),
+        })
+        .unwrap();
+    assert!(!r.ready);
+}
+
+#[test]
+fn v11_migration_preserves_review_events_and_requires_selector_repair() {
+    let c = Connection::open_in_memory().unwrap();
+    c.execute_batch("CREATE TABLE repositories(workspace_id TEXT,repository_id TEXT,PRIMARY KEY(workspace_id,repository_id));CREATE TABLE typed_tickets(workspace_id TEXT,ticket_id TEXT,PRIMARY KEY(workspace_id,ticket_id));INSERT INTO repositories VALUES('W','R');INSERT INTO typed_tickets VALUES('W','T');CREATE TABLE merge_request_schema(singleton INTEGER PRIMARY KEY,version INTEGER);INSERT INTO merge_request_schema VALUES(1,11);CREATE TABLE merge_requests(workspace_id TEXT,merge_request_id TEXT,repository_id TEXT,state TEXT,target_ref_selector TEXT,current_revision_ordinal INTEGER,current_revision_id TEXT,created_at TEXT,updated_at TEXT,merged_revision_id TEXT,merged_at TEXT);CREATE TABLE merge_request_ticket_relations(workspace_id TEXT,merge_request_id TEXT,ticket_id TEXT,relation_kind TEXT,created_at TEXT);CREATE TABLE merge_request_revisions(workspace_id TEXT,merge_request_id TEXT,revision_id TEXT,ordinal INTEGER,base_commit TEXT,head_commit TEXT,diff_digest TEXT,summary TEXT,assignment_id TEXT,created_at TEXT);CREATE TABLE merge_request_revision_paths(workspace_id TEXT,merge_request_id TEXT,revision_id TEXT,ordinal INTEGER,path TEXT);CREATE TABLE merge_request_reviewer_child_sessions(workspace_id TEXT,child_session_id TEXT,parent_runtime_id TEXT,parent_worker_id TEXT,reviewer_profile TEXT,registered_at TEXT);CREATE TABLE merge_request_review_attempts(workspace_id TEXT,attempt_id TEXT,merge_request_id TEXT,ticket_id TEXT,revision_id TEXT,revision_ordinal INTEGER,parent_assignment_id TEXT,parent_runtime_id TEXT,parent_worker_id TEXT,child_session_id TEXT,reviewer_effective_profile TEXT,capability_token TEXT,status TEXT,created_at TEXT,consumed_at TEXT);CREATE TABLE merge_request_reviews(workspace_id TEXT,attempt_id TEXT,merge_request_id TEXT,revision_id TEXT,decision TEXT,body TEXT,submitted_at TEXT);CREATE TABLE merge_request_review_findings(workspace_id TEXT,attempt_id TEXT,ordinal INTEGER,severity TEXT,code TEXT,path TEXT,line INTEGER,body TEXT);CREATE TABLE merge_request_completion_operations(workspace_id TEXT,operation_id TEXT,ticket_id TEXT,revision_id TEXT,authority_kind TEXT,implementation_assignment_id TEXT,completion_actor_runtime_id TEXT,completion_actor_worker_id TEXT,target_commit TEXT,source_commit TEXT,result_commit TEXT,strategy TEXT,resolution TEXT,fingerprint TEXT,status TEXT,result_ticket_state TEXT,created_at TEXT,updated_at TEXT);INSERT INTO merge_requests VALUES('W','MR','R','open','develop',1,'V','2026-07-26T12:00:00Z','2026-07-26T12:00:00Z',NULL,NULL);INSERT INTO merge_request_ticket_relations VALUES('W','MR','T','implements','2026-07-26T12:00:00Z');INSERT INTO merge_request_revisions VALUES('W','MR','V',1,'base','subject','digest','summary','A','2026-07-26T12:00:00Z');INSERT INTO merge_request_review_attempts VALUES('W','AT','MR','T','V',1,'A','runtime','coder','child','builtin:reviewer','token','submitted','2026-07-26T12:00:00Z','2026-07-26T12:00:01Z');INSERT INTO merge_request_reviews VALUES('W','AT','MR','V','approve','approved','2026-07-26T12:00:01Z');INSERT INTO merge_request_review_attempts VALUES('W','PENDING','MR','T','V',1,'A','runtime','coder','pending-child','builtin:reviewer','pending-token','registered','2026-07-26T12:00:02Z',NULL);").unwrap();
+    merge_request::migrate(&c).unwrap();
+    let selector: Option<String> = c
+        .query_row("SELECT selector_from FROM merge_requests", [], |r| r.get(0))
+        .unwrap();
+    assert!(selector.is_none());
+    let kinds: String = c
+        .query_row(
+            "SELECT group_concat(kind,',') FROM merge_request_thread_events ORDER BY sequence",
+            [],
+            |r| r.get(0),
+        )
+        .unwrap();
+    assert_eq!(
+        kinds,
+        "review_requested,review,review_requested,review_cancelled"
+    );
+    let old: bool = c
+        .query_row(
+            "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name='merge_request_revisions')",
+            [],
+            |r| r.get(0),
+        )
+        .unwrap();
+    assert!(!old);
+}
+
+#[test]
+fn authority_reads_full_thread_while_public_pages_remain_bounded() {
+    let (_d, store) = fixture();
+    open(&store);
+    for index in 0..55 {
+        approve(&store, "same-subject", &format!("token-{index}"));
+    }
+    let mr = store.get("W", "T").unwrap();
+    assert!(mr.thread.len() > 100);
+    assert_eq!(
+        mr.effective_review("same-subject").unwrap().decision,
+        ReviewDecision::Approve
+    );
+    assert_eq!(store.thread_page("W", "T", None, 20).unwrap().len(), 20);
+    assert_eq!(
+        store.thread_page("W", "T", Some(100), 20).unwrap().len(),
+        11
+    );
+}
+
+#[test]
+fn completion_rejects_superseded_approval_for_same_subject() {
+    let (_d, store) = fixture();
+    open(&store);
+    let old_approval = approve(&store, "subject", "approval");
+    request(&store, "subject", "changes");
+    store
+        .submit_review(SubmitMergeRequestReview {
+            ticket_id: "T".into(),
+            current_subject_ref: "subject".into(),
+            capability_token: "changes".into(),
+            decision: ReviewDecision::RequestChanges,
+            body: "changes required".into(),
+            findings: vec![],
+            now: at(5),
+        })
+        .unwrap();
+    let result = store.complete(CompleteMergeRequest {
+        ticket_id: "T".into(),
+        operation_id: "op".into(),
+        approval_event_id: old_approval.event_id,
+        current_subject_ref: "subject".into(),
+        target_ref_before: "before".into(),
+        target_ref_after: "after".into(),
+        strategy: MergeStrategy::FastForward,
+        resolution: ConflictResolution::None,
+        auth: auth(),
+        now: at(6),
    });
-    assert!(matches!(
-        wrong_token,
-        Err(MergeRequestError::InvalidReviewAttempt)
-    ));
+    assert!(matches!(result, Err(MergeRequestError::NotReady(_))));
+}
+
+#[test]
+fn completion_cancels_outstanding_grants_and_late_submit_fails() {
+    let (_d, store) = fixture();
+    open(&store);
+    let approval = approve(&store, "subject", "approval");
+    request(&store, "other-subject", "pending");
+    store
+        .complete(CompleteMergeRequest {
+            ticket_id: "T".into(),
+            operation_id: "op".into(),
+            approval_event_id: approval.event_id,
+            current_subject_ref: "subject".into(),
+            target_ref_before: "before".into(),
+            target_ref_after: "after".into(),
+            strategy: MergeStrategy::FastForward,
+            resolution: ConflictResolution::None,
+            auth: auth(),
+            now: at(6),
+        })
+        .unwrap();
+    let late = store.submit_review(SubmitMergeRequestReview {
+        ticket_id: "T".into(),
+        current_subject_ref: "other-subject".into(),
+        capability_token: "pending".into(),
+        decision: ReviewDecision::Approve,
+        body: "too late".into(),
+        findings: vec![],
+        now: at(7),
+    });
+    assert!(matches!(late, Err(MergeRequestError::Unauthorized(_))));
+    let mr = store.get("W", "T").unwrap();
+    assert!(mr.thread.iter().any(|event| matches!(event,
+        MergeRequestThreadEvent::ReviewCancelled(value)
+            if value.reason.contains("completed before review submission"))));
+}
+
+#[test]
+fn selector_repair_requires_and_accepts_an_approved_resolved_subject() {
+    let (dir, store) = fixture();
+    open(&store);
+    approve(&store, "approved-subject", "approval");
+    Connection::open(dir.path().join("db")).unwrap()
+        .execute("UPDATE merge_requests SET selector_from=NULL WHERE workspace_id='W' AND merge_request_id='MR'", [])
+        .unwrap();
+    let repaired = store
+        .repair_selector_from(RepairSelectorFrom {
+            workspace_id: "W".into(),
+            ticket_id: "T".into(),
+            selector_from: "restored-work".into(),
+            resolved_subject_ref: "approved-subject".into(),
+            repaired_by: WorkerIdentity {
+                runtime_id: "browser".into(),
+                worker_id: "user".into(),
+            },
+            reason: "confirmed migrated source".into(),
+            now: at(8),
+        })
+        .unwrap();
+    assert_eq!(repaired.selector_from.as_deref(), Some("restored-work"));
+}
+
+#[test]
+fn selector_repair_rejects_unapproved_resolved_subject() {
+    let (dir, store) = fixture();
+    open(&store);
+    approve(&store, "approved-subject", "approval");
+    Connection::open(dir.path().join("db")).unwrap()
+        .execute("UPDATE merge_requests SET selector_from=NULL WHERE workspace_id='W' AND merge_request_id='MR'", [])
+        .unwrap();
+    let result = store.repair_selector_from(RepairSelectorFrom {
+        workspace_id: "W".into(),
+        ticket_id: "T".into(),
+        selector_from: "wrong-work".into(),
+        resolved_subject_ref: "different-subject".into(),
+        repaired_by: WorkerIdentity {
+            runtime_id: "browser".into(),
+            worker_id: "user".into(),
+        },
+        reason: "wrong candidate".into(),
+        now: at(8),
+    });
+    assert!(matches!(result, Err(MergeRequestError::NotReady(_))));
+}
+
+#[test]
+fn transactional_completion_rejects_assignment_changed_in_control_plane_db() {
+    let (dir, store) = fixture();
+    open(&store);
+    let approval = approve(&store, "subject", "approval");
+    Connection::open(dir.path().join("db")).unwrap()
+        .execute("UPDATE ticket_current_worker_assignments SET assignment_id='B' WHERE workspace_id='W' AND ticket_id='T'", [])
+        .unwrap();
+    let result = store.complete(CompleteMergeRequest {
+        ticket_id: "T".into(),
+        operation_id: "op".into(),
+        approval_event_id: approval.event_id,
+        current_subject_ref: "subject".into(),
+        target_ref_before: "before".into(),
+        target_ref_after: "after".into(),
+        strategy: MergeStrategy::FastForward,
+        resolution: ConflictResolution::None,
+        auth: auth(),
+        now: at(9),
+    });
+    assert!(matches!(result, Err(MergeRequestError::Unauthorized(_))));
+    let state: String = Connection::open(dir.path().join("db"))
+        .unwrap()
+        .query_row(
+            "SELECT workflow_state FROM typed_tickets WHERE workspace_id='W' AND ticket_id='T'",
+            [],
+            |row| row.get(0),
+        )
+        .unwrap();
+    assert_eq!(state, "inprogress");
 }
@@ -36,8 +36,8 @@ const MAX_DIAGNOSTIC_LIMIT: usize = 500;
 pub const TICKET_BASE_TOOL_NAMES: [&str; 14] = [
    "TicketCreate",
    "TicketEditItem",
-    "TicketList",
-    "TicketShow",
+    "QueryTicket",
+    "ShowTicket",
    "TicketComment",
    "TicketPlan",
    "TicketDecision",
@@ -51,8 +51,8 @@ pub const TICKET_BASE_TOOL_NAMES: [&str; 14] = [
 ];

 pub const TICKET_BASE_READ_ONLY_TOOL_NAMES: [&str; 4] = [
-    "TicketList",
-    "TicketShow",
+    "QueryTicket",
+    "ShowTicket",
    "TicketDependencyCheck",
    "TicketDoctor",
 ];
@@ -71,8 +71,8 @@ pub const TICKET_ORCHESTRATION_READ_ONLY_TOOL_NAMES: [&str; 2] =
 pub const TICKET_TOOL_NAMES: [&str; 19] = [
    "TicketCreate",
    "TicketEditItem",
-    "TicketList",
-    "TicketShow",
+    "QueryTicket",
+    "ShowTicket",
    "TicketComment",
    "TicketPlan",
    "TicketDecision",
@@ -91,8 +91,8 @@ pub const TICKET_TOOL_NAMES: [&str; 19] = [
 ];

 pub const TICKET_READ_ONLY_TOOL_NAMES: [&str; 6] = [
-    "TicketList",
-    "TicketShow",
+    "QueryTicket",
+    "ShowTicket",
    "TicketDependencyCheck",
    "TicketDoctor",
    "TicketRelationQuery",
@@ -121,13 +121,12 @@ backend assigns the id and writes the local Ticket file layout under the configu
 const EDIT_ITEM_DESCRIPTION: &str = "Edit a Ticket item through the configured typed Ticket backend. \
 This updates the current item title/body and appends an audited item_edit thread event. Intended for \
 User/Companion authoring surfaces, not Orchestrator implementation control.";
-const LIST_DESCRIPTION: &str = "List Tickets from the configured typed Ticket backend as a \
-lightweight bounded overview for selection only. Filter by query (`active`, `all`, a single workflow \
-state, or an explicit workflow-state list). Output is short summaries only; use TicketShow before \
-routing, closing, planning, or implementation decisions.";
-const SHOW_DESCRIPTION: &str = "Show one Ticket by id or exact query through the configured \
-typed Ticket backend. Output includes bounded Markdown body, recent thread events, resolution, and \
-artifact metadata.";
+const LIST_DESCRIPTION: &str = "Query Tickets from the configured typed Ticket backend as a bounded \
+overview. The local backend supports workflow-state selection; Workspace-backed Workers replace this \
+definition with the richer authoritative text/event/evidence/relation/Objective/time/attention query.";
+const SHOW_DESCRIPTION: &str = "Show one Ticket by id or exact query through the configured typed \
+Ticket backend. Output includes bounded Markdown body, recent thread events, resolution, and artifact \
+metadata; Workspace-backed Workers replace this definition with the richer authoritative evidence projection.";
 const COMMENT_DESCRIPTION: &str = "Append a typed Ticket comment event. `body` is Markdown.";
 const PLAN_DESCRIPTION: &str = "Append a typed Ticket plan event. `body` is Markdown.";
 const DECISION_DESCRIPTION: &str = "Append a typed Ticket decision event. `body` is Markdown.";
@@ -169,8 +168,8 @@ fn base_tool_description(name: &str) -> &'static str {
    match name {
        "TicketCreate" => CREATE_DESCRIPTION,
        "TicketEditItem" => EDIT_ITEM_DESCRIPTION,
-        "TicketList" => LIST_DESCRIPTION,
-        "TicketShow" => SHOW_DESCRIPTION,
+        "QueryTicket" => LIST_DESCRIPTION,
+        "ShowTicket" => SHOW_DESCRIPTION,
        "TicketComment" => COMMENT_DESCRIPTION,
        "TicketPlan" => PLAN_DESCRIPTION,
        "TicketDecision" => DECISION_DESCRIPTION,
@@ -464,7 +463,7 @@ impl TicketWorkflowStateParam {

 #[derive(Debug, Clone, Copy, Deserialize, schemars::JsonSchema)]
 #[serde(rename_all = "snake_case")]
-enum TicketListStateParam {
+enum QueryTicketStateParam {
    Active,
    Planning,
    Ready,
@@ -475,7 +474,7 @@ enum TicketListStateParam {
    All,
 }

-impl TicketListStateParam {
+impl QueryTicketStateParam {
    fn as_list_state(self) -> Option<TicketListState> {
        match self {
            Self::Planning => Some(TicketListState::Planning),
@@ -490,10 +489,10 @@ impl TicketListStateParam {
 }

 #[derive(Debug, Deserialize, schemars::JsonSchema)]
-struct TicketListParams {
+struct QueryTicketParams {
    /// State filter. Defaults to active Tickets (all non-closed states). Use `all` to include closed Tickets.
    #[serde(default)]
-    state: Option<TicketListStateParam>,
+    state: Option<QueryTicketStateParam>,
    /// Explicit workflow-state filter list. Cannot be combined with `state`.
    #[serde(default)]
    states: Option<Vec<TicketWorkflowStateParam>>,
@@ -502,28 +501,28 @@ struct TicketListParams {
    limit: Option<usize>,
 }

-impl TicketListParams {
+impl QueryTicketParams {
    fn into_query(self) -> Result<(crate::TicketListQuery, String, Option<usize>), TicketError> {
        let query = if let Some(states) = self.states {
            if self.state.is_some() {
                return Err(TicketError::Conflict(
-                    "TicketList accepts either `state` or `states`, not both".to_string(),
+                    "QueryTicket accepts either `state` or `states`, not both".to_string(),
                ));
            }
            if states.is_empty() {
                return Err(TicketError::Conflict(
-                    "TicketList `states` must include at least one workflow state".to_string(),
+                    "QueryTicket `states` must include at least one workflow state".to_string(),
                ));
            }
            crate::TicketListQuery::states(states.into_iter().map(|state| state.into_list_state()))
        } else {
-            match self.state.unwrap_or(TicketListStateParam::Active) {
-                TicketListStateParam::Active => crate::TicketListQuery::active(),
-                TicketListStateParam::All => crate::TicketListQuery::all(),
+            match self.state.unwrap_or(QueryTicketStateParam::Active) {
+                QueryTicketStateParam::Active => crate::TicketListQuery::active(),
+                QueryTicketStateParam::All => crate::TicketListQuery::all(),
                state => crate::TicketListQuery::state(
                    state
                        .as_list_state()
-                        .expect("workflow state list param maps to TicketListState"),
+                        .expect("workflow state list param maps to QueryTicketState"),
                ),
            }
        };
@@ -533,7 +532,7 @@ impl TicketListParams {
 }

 #[derive(Debug, Deserialize, schemars::JsonSchema)]
-struct TicketShowParams {
+struct ShowTicketParams {
    /// Ticket id. Exactly one of `id` or `query` must be provided.
    #[serde(default)]
    id: Option<String>,
@@ -768,17 +767,17 @@ struct TicketRefOutput {
 }

 #[derive(Debug, Serialize)]
-struct TicketListOutput {
+struct QueryTicketOutput {
    state_filter: String,
    count: usize,
    returned: usize,
    truncated: bool,
    limit: usize,
-    tickets: Vec<TicketListTicketOutput>,
+    tickets: Vec<QueryTicketTicketOutput>,
 }

 #[derive(Debug, Serialize)]
-struct TicketListTicketOutput {
+struct QueryTicketTicketOutput {
    id: String,
    title: String,
    state: String,
@@ -808,12 +807,12 @@ struct TicketEditItemTool {
 }

 #[derive(Clone)]
-struct TicketListTool {
+struct QueryTicketTool {
    backend: TicketToolBackend,
 }

 #[derive(Clone)]
-struct TicketShowTool {
+struct ShowTicketTool {
    backend: TicketToolBackend,
 }

@@ -976,28 +975,28 @@ impl Tool for TicketEditItemTool {
 }

 #[async_trait]
-impl Tool for TicketListTool {
+impl Tool for QueryTicketTool {
    async fn execute(
        &self,
        input_json: &str,
        _ctx: llm_engine::tool::ToolExecutionContext,
    ) -> Result<ToolOutput, ToolError> {
-        let params: TicketListParams = parse_input("TicketList", input_json)?;
+        let params: QueryTicketParams = parse_input("QueryTicket", input_json)?;
        let (filter, state_filter, params_limit) = params
            .into_query()
-            .map_err(|error| backend_error("TicketList", error))?;
+            .map_err(|error| backend_error("QueryTicket", error))?;
        let limit = bounded(params_limit, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT);
        let tickets = self
            .backend
            .list(filter)
-            .map_err(|error| backend_error("TicketList", error))?;
+            .map_err(|error| backend_error("QueryTicket", error))?;
        let count = tickets.len();
        let returned_tickets: Vec<_> = tickets
            .into_iter()
            .take(limit)
            .map(ticket_summary_json)
            .collect();
-        let output = TicketListOutput {
+        let output = QueryTicketOutput {
            state_filter: state_filter.to_string(),
            count,
            returned: returned_tickets.len(),
@@ -1017,13 +1016,13 @@ impl Tool for TicketListTool {
 }

 #[async_trait]
-impl Tool for TicketShowTool {
+impl Tool for ShowTicketTool {
    async fn execute(
        &self,
        input_json: &str,
        _ctx: llm_engine::tool::ToolExecutionContext,
    ) -> Result<ToolOutput, ToolError> {
-        let params: TicketShowParams = parse_input("TicketShow", input_json)?;
+        let params: ShowTicketParams = parse_input("ShowTicket", input_json)?;
        let query = id_or_query(params.id, params.query)?;
        let event_limit = bounded(params.event_limit, DEFAULT_EVENT_LIMIT, MAX_EVENT_LIMIT);
        let artifact_limit = bounded(
@@ -1039,7 +1038,7 @@ impl Tool for TicketShowTool {
        let ticket = self
            .backend
            .show(query)
-            .map_err(|error| backend_error("TicketShow", error))?;
+            .map_err(|error| backend_error("ShowTicket", error))?;
        let summary = format!(
            "Ticket {} state {}",
            ticket.meta.id,
@@ -1484,9 +1483,9 @@ fn id_or_query(id: Option<String>, query: Option<String>) -> Result<TicketIdOrSl
    }
 }

-fn ticket_summary_json(ticket: TicketSummary) -> TicketListTicketOutput {
+fn ticket_summary_json(ticket: TicketSummary) -> QueryTicketTicketOutput {
    let hints = ticket_list_hints(&ticket);
-    TicketListTicketOutput {
+    QueryTicketTicketOutput {
        id: ticket.id,
        title: truncate_inline(ticket.title.as_str(), LIST_TITLE_MAX_CHARS),
        state: ticket.workflow_state.as_str().to_string(),
@@ -1722,8 +1721,8 @@ fn input_schema(name: &str) -> Value {
    match name {
        "TicketCreate" => serde_json::to_value(schemars::schema_for!(TicketCreateParams)),
        "TicketEditItem" => serde_json::to_value(schemars::schema_for!(TicketEditItemParams)),
-        "TicketList" => serde_json::to_value(schemars::schema_for!(TicketListParams)),
-        "TicketShow" => serde_json::to_value(schemars::schema_for!(TicketShowParams)),
+        "QueryTicket" => serde_json::to_value(schemars::schema_for!(QueryTicketParams)),
+        "ShowTicket" => serde_json::to_value(schemars::schema_for!(ShowTicketParams)),
        "TicketComment" | "TicketPlan" | "TicketDecision" | "TicketImplementationReport" => {
            serde_json::to_value(schemars::schema_for!(TicketThreadEventParams))
        }
@@ -1769,8 +1768,8 @@ macro_rules! impl_from_backend {

 impl_from_backend!(TicketCreateTool);
 impl_from_backend!(TicketEditItemTool);
-impl_from_backend!(TicketListTool);
-impl_from_backend!(TicketShowTool);
+impl_from_backend!(QueryTicketTool);
+impl_from_backend!(ShowTicketTool);
 impl_from_backend!(TicketCommentTool);
 impl_from_backend!(TicketPlanTool);
 impl_from_backend!(TicketDecisionTool);
@@ -1793,8 +1792,8 @@ pub fn ticket_tools(backend: impl Into<TicketToolBackend>) -> Vec<ToolDefinition
    vec![
        tool_definition::<TicketCreateTool>("TicketCreate", backend.clone()),
        tool_definition::<TicketEditItemTool>("TicketEditItem", backend.clone()),
-        tool_definition::<TicketListTool>("TicketList", backend.clone()),
-        tool_definition::<TicketShowTool>("TicketShow", backend.clone()),
+        tool_definition::<QueryTicketTool>("QueryTicket", backend.clone()),
+        tool_definition::<ShowTicketTool>("ShowTicket", backend.clone()),
        tool_definition::<TicketCommentTool>("TicketComment", backend.clone()),
        tool_definition::<TicketPlanTool>("TicketPlan", backend.clone()),
        tool_definition::<TicketDecisionTool>("TicketDecision", backend.clone()),
@@ -1861,8 +1860,8 @@ mod tests {
        assert_eq!(
            TICKET_READ_ONLY_TOOL_NAMES,
            [
-                "TicketList",
-                "TicketShow",
+                "QueryTicket",
+                "ShowTicket",
                "TicketDependencyCheck",
                "TicketDoctor",
                "TicketRelationQuery",
@@ -1941,8 +1940,8 @@ mod tests {
        let temp = TempDir::new().unwrap();
        let backend = backend(&temp);
        let create = tool_by_name(backend.clone(), "TicketCreate");
-        let list = tool_by_name(backend.clone(), "TicketList");
-        let show = tool_by_name(backend.clone(), "TicketShow");
+        let list = tool_by_name(backend.clone(), "QueryTicket");
+        let show = tool_by_name(backend.clone(), "ShowTicket");
        let doctor = tool_by_name(backend.clone(), "TicketDoctor");

        let created = create
@@ -2004,7 +2003,7 @@ mod tests {
    async fn ticket_list_tool_truncates_long_titles_and_hints() {
        let temp = TempDir::new().unwrap();
        let backend = backend(&temp);
-        let list = tool_by_name(backend.clone(), "TicketList");
+        let list = tool_by_name(backend.clone(), "QueryTicket");
        let mut ticket = NewTicket::new(format!(
            "Long Title {}",
            "x".repeat(LIST_TITLE_MAX_CHARS + 40)
@@ -2032,7 +2031,7 @@ mod tests {
    async fn ticket_list_tool_default_and_max_limits_are_bounded() {
        let temp = TempDir::new().unwrap();
        let backend = backend(&temp);
-        let list = tool_by_name(backend.clone(), "TicketList");
+        let list = tool_by_name(backend.clone(), "QueryTicket");
        for index in 0..(MAX_LIST_LIMIT + 5) {
            backend
                .create(NewTicket::new(format!("Ticket {index:03}")))
@@ -2083,7 +2082,7 @@ mod tests {
    async fn ticket_list_tool_caps_all_and_closed_default_listing() {
        let temp = TempDir::new().unwrap();
        let backend = backend(&temp);
-        let list = tool_by_name(backend.clone(), "TicketList");
+        let list = tool_by_name(backend.clone(), "QueryTicket");
        for index in 0..(DEFAULT_LIST_LIMIT + 3) {
            let mut ticket = NewTicket::new(format!("Closed Ticket {index:03}"));
            ticket.workflow_state = Some(TicketWorkflowState::Closed);
@@ -2141,7 +2140,7 @@ mod tests {
    async fn ticket_list_tool_accepts_multi_state_list_and_rejects_mixed_filters() {
        let temp = TempDir::new().unwrap();
        let backend = backend(&temp);
-        let list = tool_by_name(backend.clone(), "TicketList");
+        let list = tool_by_name(backend.clone(), "QueryTicket");
        let planning = backend.create(NewTicket::new("Planning Ticket")).unwrap();
        let mut ready_input = NewTicket::new("Ready Ticket");
        ready_input.workflow_state = Some(TicketWorkflowState::Ready);
@@ -2188,7 +2187,7 @@ mod tests {
    async fn ticket_list_tool_omits_body_thread_artifact_and_resolution_content() {
        let temp = TempDir::new().unwrap();
        let backend = backend(&temp);
-        let list = tool_by_name(backend.clone(), "TicketList");
+        let list = tool_by_name(backend.clone(), "QueryTicket");
        let close = tool_by_name(backend.clone(), "TicketClose");
        let body_secret = "ITEM_BODY_SECRET_DO_NOT_LIST";
        let thread_secret = "THREAD_SECRET_DO_NOT_LIST";
@@ -2325,7 +2324,7 @@ mod tests {
        let record = tool_by_name(backend.clone(), "TicketRelationRecord");
        let remove = tool_by_name(backend.clone(), "TicketRelationRemove");
        let query = tool_by_name(backend.clone(), "TicketRelationQuery");
-        let show = tool_by_name(backend.clone(), "TicketShow");
+        let show = tool_by_name(backend.clone(), "ShowTicket");

        let recorded = record
            .execute(
@@ -2785,7 +2784,7 @@ mod tests {
    #[tokio::test]
    async fn ticket_show_requires_exactly_one_identifier() {
        let temp = TempDir::new().unwrap();
-        let show = tool_by_name(backend(&temp), "TicketShow");
+        let show = tool_by_name(backend(&temp), "ShowTicket");
        let error = show
            .execute(
                &json!({ "id": "a", "query": "b" }).to_string(),
@@ -2045,7 +2045,7 @@ impl DashboardApp {
            TicketRoleLaunchContext::new(current_workspace_root(), TicketRole::Intake);
        context.ticket = Some(TicketRef::id(ticket_id.clone()));
        context.user_instruction = Some(format!(
-            "Continue Intake for existing Ticket {ticket_id}. Do not create a duplicate Ticket unless the user explicitly requests one. Read TicketShow body/thread/artifacts before making routing or requirements decisions."
+            "Continue Intake for existing Ticket {ticket_id}. Do not create a duplicate Ticket unless the user explicitly requests one. Read ShowTicket body/thread/artifacts before making routing or requirements decisions."
        ));
        let store = match PanelRegistryStore::default_for_workspace(&context.workspace_root) {
            Ok(store) => store,
@@ -3925,7 +3925,7 @@ fn build_ready_ticket_refinement_thread_body(ticket_id: &str, instruction: &str)

 fn build_ready_ticket_refinement_launch_instruction(ticket_id: &str, instruction: &str) -> String {
    format!(
-        "Continue Ticket Intake / requirements sync for existing Ticket {ticket_id}. The Panel has returned the Ticket from ready to planning; do not queue the Ticket, do not route implementation, and do not create a duplicate unless the user explicitly asks for one. Read TicketShow body/thread/artifacts before making requirements or readiness decisions.\n\nUser refinement instruction:\n\n{instruction}"
+        "Continue Ticket Intake / requirements sync for existing Ticket {ticket_id}. The Panel has returned the Ticket from ready to planning; do not queue the Ticket, do not route implementation, and do not create a duplicate unless the user explicitly asks for one. Read ShowTicket body/thread/artifacts before making requirements or readiness decisions.\n\nUser refinement instruction:\n\n{instruction}"
    )
 }

@@ -11,7 +11,6 @@ pub const MERGE_REQUEST_COMMON_TOOL_NAMES: &[&str] = &[
    "MergeRequestShow",
    "MergeRequestReadinessCheck",
    "MergeRequestOpen",
-    "MergeRequestAddRevision",
    "MergeRequestComplete",
 ];
 pub const MERGE_REQUEST_REVIEW_TOOL_NAME: &str = "MergeRequestReviewSubmit";
@@ -20,7 +19,6 @@ enum Kind {
    Show,
    Readiness,
    Open,
-    AddRevision,
    Complete,
    Review,
 }
@@ -29,7 +27,6 @@ struct MergeRequestTool {
    client: Arc<dyn WorkspaceClient>,
    kind: Kind,
 }
-
 #[derive(Debug, Deserialize, JsonSchema)]
 struct ShowInput {
    ticket: String,
@@ -38,23 +35,8 @@ struct ShowInput {
 struct OpenInput {
    ticket: String,
    repository_id: String,
-    revision_id: String,
-    base_commit: String,
-    head_commit: String,
-    #[serde(default)]
-    changed_paths: Vec<String>,
-    #[serde(default)]
-    summary: String,
-}
-#[derive(Debug, Deserialize, JsonSchema)]
-struct AddRevisionInput {
-    ticket: String,
-    expected_current_revision_id: String,
-    revision_id: String,
-    base_commit: String,
-    head_commit: String,
-    #[serde(default)]
-    changed_paths: Vec<String>,
+    selector_from: String,
+    selector_to: String,
    #[serde(default)]
    summary: String,
 }
@@ -62,10 +44,9 @@ struct AddRevisionInput {
 struct CompleteInput {
    ticket: String,
    operation_id: String,
-    expected_revision_id: String,
-    target_commit: String,
-    source_commit: String,
-    result_commit: String,
+    approval_event_id: String,
+    target_ref_before: String,
+    target_ref_after: String,
    strategy: MergeStrategyInput,
    resolution: MergeResolutionInput,
 }
@@ -104,63 +85,48 @@ struct ReviewFindingInput {
    #[serde(default)]
    path: Option<String>,
    #[serde(default)]
-    line: Option<u64>,
+    line: Option<u32>,
    body: String,
 }
-
 impl Kind {
    fn name(self) -> &'static str {
        match self {
            Self::Show => "MergeRequestShow",
            Self::Readiness => "MergeRequestReadinessCheck",
            Self::Open => "MergeRequestOpen",
-            Self::AddRevision => "MergeRequestAddRevision",
            Self::Complete => "MergeRequestComplete",
            Self::Review => "MergeRequestReviewSubmit",
        }
    }
-    fn description(self) -> &'static str {
-        description(self.name()).unwrap_or("Merge Request operation.")
-    }
    fn schema(self) -> serde_json::Value {
        match self {
            Self::Show | Self::Readiness => json!(schemars::schema_for!(ShowInput)),
            Self::Open => json!(schemars::schema_for!(OpenInput)),
-            Self::AddRevision => json!(schemars::schema_for!(AddRevisionInput)),
            Self::Complete => json!(schemars::schema_for!(CompleteInput)),
            Self::Review => json!(schemars::schema_for!(ReviewInput)),
        }
    }
 }
-
 #[async_trait]
 impl Tool for MergeRequestTool {
-    async fn execute(
-        &self,
-        input: &str,
-        _context: ToolExecutionContext,
-    ) -> Result<ToolOutput, ToolError> {
-        let workspace_id = self.client.workspace_id().ok_or_else(|| {
+    async fn execute(&self, input: &str, _: ToolExecutionContext) -> Result<ToolOutput, ToolError> {
+        let ws = self.client.workspace_id().ok_or_else(|| {
            ToolError::ExecutionFailed("Merge Request tools require Workspace identity".into())
        })?;
        let (method, path, body) = match self.kind {
-            Kind::Show => {
-                let v: ShowInput = parse(input)?;
-                nonempty(&v.ticket)?;
-                (
-                    WorkspaceRequestMethod::Get,
-                    format!("/api/w/{workspace_id}/tickets/{}/merge-request", v.ticket),
-                    None,
-                )
-            }
-            Kind::Readiness => {
+            Kind::Show | Kind::Readiness => {
                let v: ShowInput = parse(input)?;
                nonempty(&v.ticket)?;
                (
                    WorkspaceRequestMethod::Get,
                    format!(
-                        "/api/w/{workspace_id}/tickets/{}/merge-request/readiness",
-                        v.ticket
+                        "/api/w/{ws}/tickets/{}/merge-request{}",
+                        v.ticket,
+                        if matches!(self.kind, Kind::Readiness) {
+                            "/readiness"
+                        } else {
+                            ""
+                        }
                    ),
                    None,
                )
@@ -170,62 +136,35 @@ impl Tool for MergeRequestTool {
                nonempty(&v.ticket)?;
                (
                    WorkspaceRequestMethod::Post,
-                    format!("/api/w/{workspace_id}/tickets/{}/merge-request", v.ticket),
+                    format!("/api/w/{ws}/tickets/{}/merge-request", v.ticket),
                    Some(
-                        json!({"repository_id":v.repository_id,"revision_id":v.revision_id,"base_commit":v.base_commit,"head_commit":v.head_commit,"changed_paths":v.changed_paths,"summary":v.summary}),
-                    ),
-                )
-            }
-            Kind::AddRevision => {
-                let v: AddRevisionInput = parse(input)?;
-                nonempty(&v.ticket)?;
-                (
-                    WorkspaceRequestMethod::Post,
-                    format!(
-                        "/api/w/{workspace_id}/tickets/{}/merge-request/revisions",
-                        v.ticket
-                    ),
-                    Some(
-                        json!({"expected_current_revision_id":v.expected_current_revision_id,"revision_id":v.revision_id,"base_commit":v.base_commit,"head_commit":v.head_commit,"changed_paths":v.changed_paths,"summary":v.summary}),
+                        json!({"repository_id":v.repository_id,"selector_from":v.selector_from,"selector_to":v.selector_to,"summary":v.summary}),
                    ),
                )
            }
            Kind::Complete => {
                let v: CompleteInput = parse(input)?;
                nonempty(&v.ticket)?;
-                let strategy = match v.strategy {
-                    MergeStrategyInput::FastForward => "fast_forward",
-                    MergeStrategyInput::Merge => "merge",
-                };
-                let resolution = match v.resolution {
-                    MergeResolutionInput::None => "none",
-                    MergeResolutionInput::Clean => "clean",
-                    MergeResolutionInput::ConflictsResolved => "conflicts_resolved",
-                };
                (
                    WorkspaceRequestMethod::Post,
-                    format!(
-                        "/api/w/{workspace_id}/tickets/{}/merge-request/complete",
-                        v.ticket
-                    ),
+                    format!("/api/w/{ws}/tickets/{}/merge-request/complete", v.ticket),
                    Some(
-                        json!({"operation_id":v.operation_id,"expected_revision_id":v.expected_revision_id,"target_commit":v.target_commit,"source_commit":v.source_commit,"result_commit":v.result_commit,"strategy":strategy,"resolution":resolution}),
+                        json!({"operation_id":v.operation_id,"approval_event_id":v.approval_event_id,"target_ref_before":v.target_ref_before,"target_ref_after":v.target_ref_after,"strategy":match v.strategy{MergeStrategyInput::FastForward=>"fast_forward",MergeStrategyInput::Merge=>"merge"},"resolution":match v.resolution{MergeResolutionInput::None=>"none",MergeResolutionInput::Clean=>"clean",MergeResolutionInput::ConflictsResolved=>"conflicts_resolved"}}),
                    ),
                )
            }
            Kind::Review => {
                let v: ReviewInput = parse(input)?;
-                let context = self.client.reviewer_attempt_context().ok_or_else(|| {
+                let ctx = self.client.reviewer_context().ok_or_else(|| {
                    ToolError::ExecutionFailed(
-                        "MergeRequestReviewSubmit is available only to an attested Reviewer child"
-                            .into(),
+                        "Review submit requires injected Reviewer capability".into(),
                    )
                })?;
                (
                    WorkspaceRequestMethod::Post,
                    format!(
-                        "/api/w/{workspace_id}/tickets/{}/merge-request/reviews",
-                        context.ticket_id
+                        "/api/w/{ws}/tickets/{}/merge-request/reviews",
+                        ctx.ticket_id
                    ),
                    Some(
                        json!({"decision":match v.decision{ReviewDecisionInput::Approve=>"approve",ReviewDecisionInput::RequestChanges=>"request_changes"},"body":v.body,"findings":v.findings.into_iter().map(|f|json!({"severity":f.severity,"code":f.code,"path":f.path,"line":f.line,"body":f.body})).collect::<Vec<_>>() }),
@@ -233,32 +172,32 @@ impl Tool for MergeRequestTool {
                )
            }
        };
-        let request = match body {
-            Some(body) => WorkspaceRequest::json(method, path, body.to_string()),
+        let req = match body {
+            Some(v) => WorkspaceRequest::json(method, path, v.to_string()),
            None => WorkspaceRequest::get(path),
        };
-        let response = self
+        let res = self
            .client
-            .execute(request)
+            .execute(req)
            .map_err(|e| ToolError::ExecutionFailed(e.to_string()))?;
-        if !response.is_success() {
+        if !res.is_success() {
            return Err(ToolError::ExecutionFailed(format!(
                "Merge Request API returned HTTP {}: {}",
-                response.status, response.body
+                res.status, res.body
            )));
        }
        Ok(ToolOutput {
-            summary: self.kind.name().to_string(),
-            content: Some(response.body),
-            attachments: Vec::new(),
+            summary: self.kind.name().into(),
+            content: Some(res.body),
+            attachments: vec![],
        })
    }
 }
-fn parse<T: serde::de::DeserializeOwned>(value: &str) -> Result<T, ToolError> {
-    serde_json::from_str(value).map_err(|e| ToolError::InvalidArgument(e.to_string()))
+fn parse<T: serde::de::DeserializeOwned>(v: &str) -> Result<T, ToolError> {
+    serde_json::from_str(v).map_err(|e| ToolError::InvalidArgument(e.to_string()))
 }
-fn nonempty(value: &str) -> Result<(), ToolError> {
-    if value.trim().is_empty() {
+fn nonempty(v: &str) -> Result<(), ToolError> {
+    if v.trim().is_empty() {
        Err(ToolError::InvalidArgument(
            "ticket must not be empty".into(),
        ))
@@ -268,74 +207,75 @@ fn nonempty(value: &str) -> Result<(), ToolError> {
 }
 fn definition(client: Arc<dyn WorkspaceClient>, kind: Kind) -> ToolDefinition {
    Arc::new(move || {
-        let meta = ToolMeta::new(kind.name())
-            .description(kind.description())
-            .input_schema(kind.schema());
-        let tool: Arc<dyn Tool> = Arc::new(MergeRequestTool {
-            client: client.clone(),
-            kind,
-        });
-        (meta, tool)
+        (
+            ToolMeta::new(kind.name())
+                .description(description(kind.name()).unwrap_or("Merge Request operation."))
+                .input_schema(kind.schema()),
+            Arc::new(MergeRequestTool {
+                client: client.clone(),
+                kind,
+            }) as Arc<dyn Tool>,
+        )
    })
 }
-pub fn common_tools(client: Arc<dyn WorkspaceClient>) -> Vec<ToolDefinition> {
+pub fn common_tools(c: Arc<dyn WorkspaceClient>) -> Vec<ToolDefinition> {
    vec![
-        definition(client.clone(), Kind::Show),
-        definition(client.clone(), Kind::Readiness),
-        definition(client.clone(), Kind::Open),
-        definition(client.clone(), Kind::AddRevision),
-        definition(client, Kind::Complete),
+        definition(c.clone(), Kind::Show),
+        definition(c.clone(), Kind::Readiness),
+        definition(c.clone(), Kind::Open),
+        definition(c, Kind::Complete),
    ]
 }
-pub fn reviewer_tools(client: Arc<dyn WorkspaceClient>) -> Vec<ToolDefinition> {
-    if client.reviewer_attempt_context().is_some() {
+pub fn reviewer_tools(c: Arc<dyn WorkspaceClient>) -> Vec<ToolDefinition> {
+    if c.reviewer_context().is_some() {
        vec![
-            definition(client.clone(), Kind::Show),
-            definition(client, Kind::Review),
+            definition(c.clone(), Kind::Show),
+            definition(c, Kind::Review),
        ]
    } else {
-        Vec::new()
+        vec![]
    }
 }
-pub fn description(name: &str) -> Option<&'static str> {
-    match name {
-        "MergeRequestShow" => Some(
-            "Read the authoritative Merge Request, immutable current revision, and structured review status.",
-        ),
+pub fn description(n: &str) -> Option<&'static str> {
+    match n {
+        "MergeRequestShow" => Some("Read the selector-based Merge Request and append-only thread."),
        "MergeRequestReadinessCheck" => {
-            Some("Check derived merge readiness for the current immutable revision.")
+            Some("Resolve current provider refs and derive readiness from valid review events.")
        }
        "MergeRequestOpen" => {
-            Some("Open an immutable Merge Request revision for the current assigned Coder.")
-        }
-        "MergeRequestAddRevision" => {
-            Some("Append an immutable revision; prior approval cannot carry to the new revision.")
+            Some("Open a Merge Request with immutable source and target selectors.")
        }
        "MergeRequestComplete" => {
-            Some("CAS-complete an approved revision with operation-id replay and crash fencing.")
+            Some("Complete using an approved review event and final target-ref evidence.")
+        }
+        "MergeRequestReviewSubmit" => {
+            Some("Submit the injected Reviewer capability result for its captured subject ref.")
        }
-        "MergeRequestReviewSubmit" => Some(
-            "Submit the attested direct-child Reviewer result bound to its immutable revision.",
-        ),
        _ => None,
    }
 }
-
 #[cfg(test)]
 mod tests {
    use super::*;
-
    #[test]
-    fn merge_request_tool_contract_omits_redundant_revision_evidence_and_candidate_result_tool() {
-        let open = serde_json::to_string(&schemars::schema_for!(OpenInput)).unwrap();
-        let add = serde_json::to_string(&schemars::schema_for!(AddRevisionInput)).unwrap();
-        let complete = serde_json::to_string(&schemars::schema_for!(CompleteInput)).unwrap();
-        assert!(!open.contains("head_tree"));
-        assert!(!add.contains("head_tree"));
-        assert!(!open.contains("diff_digest"));
-        assert!(!add.contains("diff_digest"));
-        assert!(complete.contains("result_commit"));
-        assert!(complete.contains("conflicts_resolved"));
-        assert!(!MERGE_REQUEST_COMMON_TOOL_NAMES.contains(&"MergeRequestRecordMergeResult"));
+    fn schemas_hide_revision_and_commit_authority() {
+        let schemas = [
+            schemars::schema_for!(OpenInput),
+            schemars::schema_for!(CompleteInput),
+        ];
+        for s in schemas {
+            let j = serde_json::to_string(&s).unwrap();
+            for banned in [
+                "revision_id",
+                "attempt_id",
+                "base_commit",
+                "head_commit",
+                "source_commit",
+                "result_commit",
+            ] {
+                assert!(!j.contains(banned), "{banned} in {j}")
+            }
+        }
+        assert!(!MERGE_REQUEST_COMMON_TOOL_NAMES.contains(&"MergeRequestRequestReview"));
    }
 }
@@ -26,36 +26,45 @@ impl WorkspaceHttpObjectiveBackend {
        Self { client }
    }

-    async fn list(&self, input: ObjectiveListInput) -> Result<ToolOutput, ToolError> {
-        let mut url = format!(
-            "/api/w/{}/objectives",
+    async fn list(&self, input: QueryObjectiveInput) -> Result<ToolOutput, ToolError> {
+        let url = format!(
+            "/api/w/{}/objectives/query",
            self.client.workspace_id().unwrap_or_default()
        );
-        if let Some(limit) = input.limit {
-            url.push_str(&format!("?limit={}", limit.min(1000)));
-        }
-        let response = get_json::<ObjectiveListResponse>(self.client.as_ref(), &url)
-            .await
-            .map_err(backend_error)?;
-        let count = response.items.len();
+        let response = send_json::<QueryObjectiveInput, serde_json::Value>(
+            self.client.as_ref(),
+            reqwest::Method::POST,
+            &url,
+            &input,
+        )
+        .await
+        .map_err(backend_error)?;
        Ok(ToolOutput {
-            summary: format!("Listed {count} objective(s)"),
+            summary: "Queried Objectives".to_string(),
            content: Some(serde_json::to_string_pretty(&response).map_err(decode_error)?),
-
            attachments: Vec::new(),
        })
    }

-    async fn show(&self, input: ObjectiveShowInput) -> Result<ToolOutput, ToolError> {
-        let id = validate_id(&input.id, "ObjectiveShow")?;
-        let url = self.objective_url(id);
-        let response = get_json::<ObjectiveDetail>(self.client.as_ref(), &url)
-            .await
-            .map_err(backend_error)?;
-        Ok(objective_output(
-            format!("Read objective {}", response.id),
-            response,
-        )?)
+    async fn show(&self, input: ShowObjectiveInput) -> Result<ToolOutput, ToolError> {
+        let id = validate_id(&input.id, "ShowObjective")?;
+        let url = format!("{}/show", self.objective_url(id));
+        let response = send_json::<ObjectiveShowRequest, serde_json::Value>(
+            self.client.as_ref(),
+            reqwest::Method::POST,
+            &url,
+            &ObjectiveShowRequest {
+                event_limit: input.event_limit,
+                event_cursor: input.event_cursor,
+            },
+        )
+        .await
+        .map_err(backend_error)?;
+        Ok(ToolOutput {
+            summary: format!("Read objective {id}"),
+            content: Some(serde_json::to_string_pretty(&response).map_err(decode_error)?),
+            attachments: Vec::new(),
+        })
    }

    async fn create(&self, input: ObjectiveCreateInput) -> Result<ToolOutput, ToolError> {
@@ -195,13 +204,6 @@ fn backend_error(error: WorkspaceObjectiveBackendError) -> ToolError {
    ToolError::ExecutionFailed(error.to_string())
 }

-async fn get_json<T: for<'de> Deserialize<'de>>(
-    client: &dyn WorkspaceClient,
-    path: &str,
-) -> Result<T, WorkspaceObjectiveBackendError> {
-    decode_response(client.execute(WorkspaceRequest::get(path))?)
-}
-
 async fn send_json<B: Serialize, T: for<'de> Deserialize<'de>>(
    client: &dyn WorkspaceClient,
    method: reqwest::Method,
@@ -270,14 +272,14 @@ pub fn workspace_http_objective_tools(client: Arc<dyn WorkspaceClient>) -> Vec<T
    let backend = WorkspaceHttpObjectiveBackend::new(client);
    vec![
        objective_tool(
-            "ObjectiveList",
+            "QueryObjective",
            LIST_DESCRIPTION,
            list_schema(),
            backend.clone(),
            ObjectiveOperation::List,
        ),
        objective_tool(
-            "ObjectiveShow",
+            "ShowObjective",
            SHOW_DESCRIPTION,
            show_schema(),
            backend.clone(),
@@ -367,11 +369,11 @@ impl Tool for WorkspaceHttpObjectiveTool {
    ) -> Result<ToolOutput, ToolError> {
        match self.operation {
            ObjectiveOperation::List => {
-                let input = parse_input::<ObjectiveListInput>(input_json)?;
+                let input = parse_input::<QueryObjectiveInput>(input_json)?;
                self.backend.list(input).await
            }
            ObjectiveOperation::Show => {
-                let input = parse_input::<ObjectiveShowInput>(input_json)?;
+                let input = parse_input::<ShowObjectiveInput>(input_json)?;
                self.backend.show(input).await
            }
            ObjectiveOperation::Create => {
@@ -402,10 +404,8 @@ fn parse_input<T: for<'de> Deserialize<'de>>(input: &str) -> Result<T, ToolError
    serde_json::from_str(input).map_err(|error| ToolError::InvalidArgument(error.to_string()))
 }

-const LIST_DESCRIPTION: &str =
-    "List Objective records through Backend Workspace API authority as bounded summaries.";
-const SHOW_DESCRIPTION: &str =
-    "Show one Objective record by canonical id through Backend Workspace API authority.";
+const LIST_DESCRIPTION: &str = "Query authoritative Objectives with bounded typed filters, stable snippets, linked-Ticket context, and cursor metadata.";
+const SHOW_DESCRIPTION: &str = "Show one authoritative Objective with its revision, full linked-Ticket context, bounded body, and paged event metadata.";
 const CREATE_DESCRIPTION: &str =
    "Create an Objective record through Backend Workspace API authority.";
 const EDIT_DESCRIPTION: &str =
@@ -422,13 +422,29 @@ fn list_schema() -> serde_json::Value {
        "type":"object",
        "additionalProperties": false,
        "properties":{
-            "limit":{"type":["integer","null"],"minimum":0,"maximum":1000}
+            "query":{"type":["string","null"]},
+            "states":{"type":"array","items":{"type":"string"},"default":[]},
+            "linked_ticket_id":{"type":["string","null"]},
+            "updated_after":{"type":["string","null"]},
+            "updated_before":{"type":["string","null"]},
+            "sort":{"type":["string","null"],"enum":["relevance","updated_desc","created_desc","title",null]},
+            "limit":{"type":["integer","null"],"minimum":1,"maximum":100},
+            "cursor":{"type":["string","null"]}
        }
    })
 }

 fn show_schema() -> serde_json::Value {
-    id_schema(&["id"])
+    json!({
+        "type":"object",
+        "additionalProperties": false,
+        "required":["id"],
+        "properties":{
+            "id":{"type":"string"},
+            "event_limit":{"type":["integer","null"],"minimum":1,"maximum":50},
+            "event_cursor":{"type":["string","null"]}
+        }
+    })
 }

 fn create_schema() -> serde_json::Value {
@@ -480,17 +496,6 @@ fn unlink_ticket_schema() -> serde_json::Value {
    id_ticket_schema(&["id", "ticket_id"])
 }

-fn id_schema(required: &[&str]) -> serde_json::Value {
-    json!({
-        "type":"object",
-        "additionalProperties": false,
-        "required": required,
-        "properties":{
-            "id":{"type":"string"}
-        }
-    })
-}
-
 fn id_ticket_schema(required: &[&str]) -> serde_json::Value {
    json!({
        "type":"object",
@@ -503,14 +508,30 @@ fn id_ticket_schema(required: &[&str]) -> serde_json::Value {
    })
 }

-#[derive(Debug, Deserialize)]
-struct ObjectiveListInput {
+#[derive(Debug, Serialize, Deserialize)]
+struct QueryObjectiveInput {
+    query: Option<String>,
+    #[serde(default)]
+    states: Vec<String>,
+    linked_ticket_id: Option<String>,
+    updated_after: Option<String>,
+    updated_before: Option<String>,
+    sort: Option<String>,
    limit: Option<usize>,
+    cursor: Option<String>,
 }

 #[derive(Debug, Deserialize)]
-struct ObjectiveShowInput {
+struct ShowObjectiveInput {
    id: String,
+    event_limit: Option<usize>,
+    event_cursor: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+struct ObjectiveShowRequest {
+    event_limit: Option<usize>,
+    event_cursor: Option<String>,
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -574,30 +595,6 @@ fn default_state() -> String {
    "active".to_string()
 }

-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
-struct ObjectiveListResponse {
-    items: Vec<ObjectiveSummary>,
-    invalid_records: Vec<InvalidProjectRecord>,
-    record_authority: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
-struct InvalidProjectRecord {
-    label: String,
-    reason: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
-struct ObjectiveSummary {
-    id: String,
-    title: String,
-    state: String,
-    updated_at: Option<String>,
-    summary: String,
-    linked_tickets: Vec<String>,
-    record_source: String,
-}
-
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
 struct ObjectiveDetail {
    id: String,
@@ -637,10 +634,10 @@ mod tests {
                "ObjectiveCreate",
                "ObjectiveEdit",
                "ObjectiveLinkTicket",
-                "ObjectiveList",
                "ObjectiveSetState",
-                "ObjectiveShow",
                "ObjectiveUnlinkTicket",
+                "QueryObjective",
+                "ShowObjective",
            ]
        );
    }
@@ -648,9 +645,12 @@ mod tests {
    #[test]
    fn objective_tool_schemas_are_bounded_and_mutation_scoped() {
        let list = list_schema();
-        assert_eq!(list["properties"]["limit"]["maximum"], 1000);
+        assert_eq!(list["properties"]["limit"]["maximum"], 100);
+        assert!(list["properties"]["cursor"].is_object());
+        assert!(list["properties"]["linked_ticket_id"].is_object());
        let show = show_schema();
        assert_eq!(show["required"][0], "id");
+        assert_eq!(show["properties"]["event_limit"]["maximum"], 50);
        let create = create_schema();
        assert_eq!(create["required"][0], "title");
        let edit = edit_schema();
@@ -9,6 +9,10 @@ use std::{
    sync::Arc,
 };

+use async_trait::async_trait;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
 use ticket::{
    LocalTicketBackend, MarkdownText, NewOrchestrationPlanRecord, NewTicket, NewTicketEvent,
    NewTicketRelation, OrchestrationPlanKind, OrchestrationPlanRecord, Result as TicketResult,
@@ -25,8 +29,238 @@ use crate::feature::{
    FeatureDescriptor, FeatureDiagnostic, FeatureInstallContext, FeatureInstallError,
    FeatureInstructionContribution, FeatureInstructionDeclaration, FeatureInstructionId,
    FeatureModule, ServiceDeclaration, ServiceId, ToolContribution, ToolDeclaration,
+    ToolDefinition,
 };
 use crate::worker::{WorkspaceClient, WorkspaceRequest, WorkspaceRequestMethod};
+use llm_engine::tool::{Tool, ToolError, ToolExecutionContext, ToolMeta, ToolOutput};
+
+#[derive(Clone, Copy)]
+enum WorkspaceTicketReadKind {
+    Query,
+    Show,
+}
+
+impl WorkspaceTicketReadKind {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Query => "QueryTicket",
+            Self::Show => "ShowTicket",
+        }
+    }
+
+    fn description(self) -> &'static str {
+        match self {
+            Self::Query => {
+                "Query authoritative Workspace Tickets with bounded typed filters, stable snippets, evidence summaries, and cursor metadata."
+            }
+            Self::Show => {
+                "Show one authoritative Workspace Ticket with its item revision, paged thread, links, implementation reports, and current Merge Request review evidence."
+            }
+        }
+    }
+
+    fn schema(self) -> Value {
+        match self {
+            Self::Query => serde_json::to_value(schemars::schema_for!(WorkspaceQueryTicketInput))
+                .expect("QueryTicket schema serializes"),
+            Self::Show => serde_json::to_value(schemars::schema_for!(WorkspaceShowTicketInput))
+                .expect("ShowTicket schema serializes"),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum WorkspaceTicketStateFilter {
+    Planning,
+    Ready,
+    Queued,
+    Inprogress,
+    Done,
+    Closed,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum WorkspaceTicketEvidenceFilter {
+    ImplementationReport,
+    ImplementationReportAfterRescope,
+    MergeRequest,
+    Commit,
+    ApprovedReview,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum WorkspaceTicketReviewFilter {
+    None,
+    Pending,
+    Approved,
+    RequestChanges,
+    UnresolvedChanges,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum WorkspaceTicketAttentionFilter {
+    DoneNotClosed,
+    ImplementationReportNotClosed,
+    ReportAfterRescope,
+    UnresolvedReview,
+    MissingCommit,
+    Blocked,
+    Unblocked,
+    Ready,
+    AwaitingReview,
+    UnresolvedChanges,
+    StaleAfterRescope,
+    MissingEvidence,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum WorkspaceTicketRelationFilter {
+    DependsOn,
+    Blocks,
+    Related,
+    Supersedes,
+    DuplicateOf,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+enum WorkspaceTicketSort {
+    Relevance,
+    UpdatedDesc,
+    CreatedDesc,
+    Priority,
+    Title,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+struct WorkspaceQueryTicketInput {
+    /// Full-text match over Ticket title, item body, and bounded thread excerpts.
+    query: Option<String>,
+    /// Exact workflow states. Empty means every state.
+    #[serde(default)]
+    states: Vec<WorkspaceTicketStateFilter>,
+    /// Exact typed event kinds that must occur in the bounded thread window.
+    #[serde(default)]
+    event_kinds: Vec<String>,
+    /// Required evidence kinds: implementation_report, implementation_report_after_rescope,
+    /// merge_request, commit, or approved_review.
+    #[serde(default)]
+    evidence: Vec<WorkspaceTicketEvidenceFilter>,
+    /// Current authoritative Merge Request review status: none, pending, approved,
+    /// request_changes, or unresolved_changes.
+    review_status: Option<WorkspaceTicketReviewFilter>,
+    /// Attention filters include done_not_closed, implementation_report_not_closed,
+    /// report_after_rescope, unresolved_review, missing_commit, blocked, and unblocked.
+    #[serde(default)]
+    attention: Vec<WorkspaceTicketAttentionFilter>,
+    related_ticket_id: Option<String>,
+    relation_kind: Option<WorkspaceTicketRelationFilter>,
+    linked_objective_id: Option<String>,
+    updated_after: Option<String>,
+    updated_before: Option<String>,
+    /// relevance (default when query is present), updated_desc, created_desc,
+    /// priority, or title.
+    sort: Option<WorkspaceTicketSort>,
+    /// Page size; bounded by the Backend to 1..=100.
+    limit: Option<usize>,
+    /// Opaque cursor returned by a prior QueryTicket page.
+    cursor: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+struct WorkspaceShowTicketInput {
+    id: String,
+    /// Most-recent thread entries to return, bounded by the Backend to 1..=50.
+    event_limit: Option<usize>,
+    /// Opaque event cursor returned by a prior ShowTicket page.
+    event_cursor: Option<String>,
+}
+
+#[derive(Clone)]
+struct WorkspaceTicketReadTool {
+    client: Arc<dyn WorkspaceClient>,
+    kind: WorkspaceTicketReadKind,
+}
+
+#[async_trait]
+impl Tool for WorkspaceTicketReadTool {
+    async fn execute(
+        &self,
+        input: &str,
+        _context: ToolExecutionContext,
+    ) -> Result<ToolOutput, ToolError> {
+        let workspace_id = self.client.workspace_id().ok_or_else(|| {
+            ToolError::InvalidArgument("Workspace Ticket reads require workspace identity".into())
+        })?;
+        let (path, body) = match self.kind {
+            WorkspaceTicketReadKind::Query => {
+                let input: WorkspaceQueryTicketInput = serde_json::from_str(&input)
+                    .map_err(|error| ToolError::InvalidArgument(error.to_string()))?;
+                (
+                    format!("/api/w/{workspace_id}/tickets/query"),
+                    serde_json::to_value(input)
+                        .map_err(|error| ToolError::ExecutionFailed(error.to_string()))?,
+                )
+            }
+            WorkspaceTicketReadKind::Show => {
+                let input: WorkspaceShowTicketInput = serde_json::from_str(&input)
+                    .map_err(|error| ToolError::InvalidArgument(error.to_string()))?;
+                if input.id.trim().is_empty() {
+                    return Err(ToolError::InvalidArgument(
+                        "ShowTicket.id must not be empty".into(),
+                    ));
+                }
+                let path = format!("/api/w/{workspace_id}/tickets/{}/show", input.id.trim());
+                let body = json!({
+                    "event_limit": input.event_limit,
+                    "event_cursor": input.event_cursor,
+                });
+                (path, body)
+            }
+        };
+        let response = self
+            .client
+            .execute(WorkspaceRequest::json(
+                WorkspaceRequestMethod::Post,
+                path,
+                serde_json::to_string(&body)
+                    .map_err(|error| ToolError::Internal(error.to_string()))?,
+            ))
+            .map_err(|error| ToolError::ExecutionFailed(error.to_string()))?;
+        if !response.is_success() {
+            return Err(ToolError::ExecutionFailed(format!(
+                "Workspace Ticket API returned HTTP {}: {}",
+                response.status, response.body
+            )));
+        }
+        Ok(ToolOutput {
+            summary: self.kind.name().to_string(),
+            content: Some(response.body),
+            attachments: Vec::new(),
+        })
+    }
+}
+
+fn workspace_ticket_read_definition(
+    client: Arc<dyn WorkspaceClient>,
+    kind: WorkspaceTicketReadKind,
+) -> ToolDefinition {
+    Arc::new(move || {
+        let meta = ToolMeta::new(kind.name())
+            .description(kind.description())
+            .input_schema(kind.schema());
+        let tool: Arc<dyn Tool> = Arc::new(WorkspaceTicketReadTool {
+            client: client.clone(),
+            kind,
+        });
+        (meta, tool)
+    })
+}

 const FEATURE_ID: &str = "ticket";
 const FEATURE_NAME: &str = "Ticket tools";
@@ -142,14 +376,7 @@ impl TicketFeatureAccess {
    }
 }

-const READ_ONLY_TOOL_NAMES: &[&str] = &[
-    "TicketList",
-    "TicketShow",
-    "TicketDependencyCheck",
-    "TicketDoctor",
-    "TicketRelationQuery",
-    "TicketOrchestrationPlanQuery",
-];
+const READ_ONLY_TOOL_NAMES: &[&str] = &["QueryTicket", "ShowTicket"];

 const AUTHORING_TOOL_NAMES: &[&str] = &[
    "TicketCreate",
@@ -168,31 +395,25 @@ const INTAKE_TOOL_NAMES: &[&str] = &["TicketIntakeReady"];
 const WORKSPACE_AUTHORING_TOOL_NAMES: &[&str] = &[
    "TicketCreate",
    "TicketEditItem",
-    "TicketList",
-    "TicketShow",
+    "QueryTicket",
+    "ShowTicket",
    "TicketComment",
    "TicketQueue",
    "TicketClose",
-    "TicketDependencyCheck",
-    "TicketDoctor",
    "TicketRelationRecord",
    "TicketRelationRemove",
-    "TicketRelationQuery",
-    "TicketOrchestrationPlanQuery",
 ];

 #[cfg(test)]
 const WORKFLOW_TOOL_NAMES: &[&str] = &[
-    "TicketList",
-    "TicketShow",
+    "QueryTicket",
+    "ShowTicket",
    "TicketComment",
    "TicketWorkflowState",
    "TicketClose",
    "TicketDependencyCheck",
-    "TicketDoctor",
    "TicketRelationRecord",
    "TicketRelationRemove",
-    "TicketRelationQuery",
    "TicketOrchestrationPlanRecord",
    "TicketOrchestrationPlanQuery",
 ];
@@ -200,9 +421,11 @@ const WORKFLOW_TOOL_NAMES: &[&str] = &[
 const WORKFLOW_ADDITIONAL_TOOL_NAMES: &[&str] = &[
    "TicketWorkflowState",
    "TicketClose",
+    "TicketDependencyCheck",
    "TicketRelationRecord",
    "TicketRelationRemove",
    "TicketOrchestrationPlanRecord",
+    "TicketOrchestrationPlanQuery",
 ];

 #[derive(Clone, Debug)]
@@ -366,7 +589,7 @@ impl FeatureModule for TicketFeature {
            ));
        }
        if let TicketFeatureBackend::WorkspaceClient(client) = &self.backend {
-            let names: Vec<&str> = if client.reviewer_attempt_context().is_some() {
+            let names: Vec<&str> = if client.reviewer_context().is_some() {
                vec![
                    "MergeRequestShow",
                    merge_request::MERGE_REQUEST_REVIEW_TOOL_NAME,
@@ -413,6 +636,10 @@ impl FeatureModule for TicketFeature {
                ticket_workflow_instruction(),
            ))?;
        let allowed_tool_names = self.enabled_tool_names();
+        let workspace_client = match &self.backend {
+            TicketFeatureBackend::WorkspaceClient(client) => Some(client.clone()),
+            TicketFeatureBackend::Local { .. } => None,
+        };
        let mut tools = context.tools();
        for definition in ticket_tools(backend) {
            let (meta, _) = definition();
@@ -423,10 +650,19 @@ impl FeatureModule for TicketFeature {
            {
                continue;
            }
+            let definition = match (name.as_str(), workspace_client.as_ref()) {
+                ("QueryTicket", Some(client)) => {
+                    workspace_ticket_read_definition(client.clone(), WorkspaceTicketReadKind::Query)
+                }
+                ("ShowTicket", Some(client)) => {
+                    workspace_ticket_read_definition(client.clone(), WorkspaceTicketReadKind::Show)
+                }
+                _ => definition,
+            };
            tools.register(ToolContribution::new(name, definition))?;
        }
        if let TicketFeatureBackend::WorkspaceClient(client) = &self.backend {
-            let definitions = if client.reviewer_attempt_context().is_some() {
+            let definitions = if client.reviewer_context().is_some() {
                merge_request::reviewer_tools(client.clone())
            } else {
                merge_request::common_tools(client.clone())
@@ -1044,6 +1280,47 @@ mod tests {
            .expect("tool exists")
    }

+    #[test]
+    fn workspace_ticket_reads_expose_bounded_query_and_show_contracts_without_legacy_aliases() {
+        let client: Arc<dyn WorkspaceClient> = Arc::new(
+            crate::worker::TestWorkspaceHttpClient::new("workspace", "http://backend"),
+        );
+        let (query, _) =
+            workspace_ticket_read_definition(client.clone(), WorkspaceTicketReadKind::Query)();
+        assert_eq!(query.name, "QueryTicket");
+        assert!(query.input_schema["properties"]["evidence"].is_object());
+        assert!(query.input_schema["properties"]["attention"].is_object());
+        assert!(query.input_schema["properties"]["cursor"].is_object());
+        let query_schema = serde_json::to_string(&query.input_schema).unwrap();
+        assert!(query_schema.contains("done_not_closed"));
+        assert!(query_schema.contains("request_changes"));
+        assert!(query_schema.contains("created_desc"));
+        assert!(
+            query_schema.len() < 8_000,
+            "QueryTicket schema grew unexpectedly"
+        );
+        let (show, _) = workspace_ticket_read_definition(client, WorkspaceTicketReadKind::Show)();
+        assert_eq!(show.name, "ShowTicket");
+        assert!(show.input_schema["properties"]["event_limit"].is_object());
+        let tool_names = TicketFeatureAccess::workspace_authoring().tool_names();
+        assert_eq!(tool_names.len(), 9);
+        assert!(
+            tool_names.len() < 13,
+            "authoring catalog must stay below the prior broad catalog"
+        );
+        let workflow_names = TicketFeatureAccess::workflow().tool_names();
+        assert_eq!(workflow_names.len(), 10);
+        assert!(
+            workflow_names.len() < 12,
+            "workflow catalog must stay below the prior broad catalog"
+        );
+        assert_eq!(TicketFeatureAccess::review().tool_names().len(), 2);
+        assert!(tool_names.contains(&"QueryTicket"));
+        assert!(tool_names.contains(&"ShowTicket"));
+        assert!(!tool_names.contains(&"TicketList"));
+        assert!(!tool_names.contains(&"TicketShow"));
+    }
+
    #[test]
    fn descriptor_declares_ticket_tools() {
        let temp = TempDir::new().unwrap();
@@ -1200,8 +1477,8 @@ language = "Japanese"
        let descriptor_description = descriptor
            .tools
            .iter()
-            .find(|tool| tool.name == "TicketShow")
-            .expect("TicketShow declared")
+            .find(|tool| tool.name == "ShowTicket")
+            .expect("ShowTicket declared")
            .description
            .clone();
        assert!(descriptor_description.contains("Ticket record language: Japanese"));
@@ -1214,7 +1491,7 @@ language = "Japanese"

        assert_eq!(pending_tools.len(), READ_ONLY_TOOL_NAMES.len());
        assert_eq!(report.reports[0].installed_tools, READ_ONLY_TOOL_NAMES);
-        let description = pending_tool_description(&pending_tools, "TicketShow");
+        let description = pending_tool_description(&pending_tools, "ShowTicket");
        assert!(description.contains("Ticket record language: Japanese"));
        assert!(description.contains("distinct from worker.language"));
        assert!(description.contains("Preserve protocol literals"));
@@ -132,7 +132,7 @@ mod tests {
        let request = ShutdownAfterIdleRequest::default();
        let hook = TicketIntakeReadyShutdownHook::new(request.clone(), true);

-        hook.observe_tool_result(&tool_result("TicketShow", false));
+        hook.observe_tool_result(&tool_result("ShowTicket", false));

        assert!(!request.is_requested());
    }
@@ -28,7 +28,7 @@ use crate::internal_worker::{
 use crate::prompt::catalog::PromptCatalog;
 use crate::spawn::registry::SpawnedWorkerRegistry;
 use crate::worker::{
-    ReviewerAttemptContext, ReviewerChildWorkspaceClient, Worker, WorkerFilesystemAuthority,
+    ReviewerChildWorkspaceClient, ReviewerContext, Worker, WorkerFilesystemAuthority,
    WorkspaceRequest, WorkspaceRequestMethod,
 };
 use protocol::Method;
@@ -58,8 +58,8 @@ struct SubWorkerSpawnInput {
    /// spawner's explicit delegation authority; direct tool scope alone is not
    /// sufficient. Omit `recursive` for normal workspace/worktree delegation; it defaults to true.
    scope: Vec<ScopeRuleInput>,
-    /// Binds an actual read-only builtin Reviewer child to an immutable Merge Request revision.
-    /// Review attempt identity and capability material are generated by the trusted spawn layer.
+    /// Binds an actual read-only builtin Reviewer child to the current Merge Request candidate.
+    /// Review capability material is generated by the trusted spawn layer.
    #[serde(default)]
    review: Option<ReviewerHandoffInput>,
 }
@@ -67,7 +67,6 @@ struct SubWorkerSpawnInput {
 #[derive(Debug, Deserialize, schemars::JsonSchema)]
 struct ReviewerHandoffInput {
    ticket_id: String,
-    revision_id: String,
 }

 #[derive(Debug, Deserialize, schemars::JsonSchema)]
@@ -337,9 +336,9 @@ fn validate_reviewer_handoff(input: &SubWorkerSpawnInput) -> Result<(), ToolErro
    let Some(review) = &input.review else {
        return Ok(());
    };
-    if review.ticket_id.trim().is_empty() || review.revision_id.trim().is_empty() {
+    if review.ticket_id.trim().is_empty() {
        return Err(ToolError::InvalidArgument(
-            "reviewer handoff requires non-empty ticket_id and revision_id".to_string(),
+            "reviewer handoff requires non-empty ticket_id".to_string(),
        ));
    }
    if input.profile.as_deref() != Some("builtin:reviewer") {
@@ -418,11 +417,9 @@ impl Tool for SubWorkerSpawnTool {
                .map_err(|error| {
                    ToolError::ExecutionFailed(format!("resolve child manifest: {error}"))
                })?;
-        let reviewer_attempt = input.review.as_ref().map(|review| {
+        let reviewer_capability = input.review.as_ref().map(|review| {
            (
                review.ticket_id.clone(),
-                review.revision_id.clone(),
-                uuid::Uuid::now_v7().to_string(),
                format!(
                    "{}{}",
                    uuid::Uuid::now_v7().simple(),
@@ -431,7 +428,7 @@ impl Tool for SubWorkerSpawnTool {
            )
        });
        let child_workspace_context =
-            if let Some((ticket_id, revision_id, _, capability_token)) = &reviewer_attempt {
+            if let Some((ticket_id, capability_token)) = &reviewer_capability {
                let workspace_id =
                    self.workspace_context
                        .workspace_id()
@@ -450,9 +447,8 @@ impl Tool for SubWorkerSpawnTool {
                let child_client: Arc<dyn crate::worker::WorkspaceClient> =
                    Arc::new(ReviewerChildWorkspaceClient::new(
                        parent_client.clone(),
-                        ReviewerAttemptContext {
+                        ReviewerContext {
                            ticket_id: ticket_id.clone(),
-                            revision_id: revision_id.clone(),
                        },
                        capability_token.clone(),
                    ));
@@ -547,9 +543,9 @@ impl Tool for SubWorkerSpawnTool {
            }
        };

-        if let Some((ticket_id, revision_id, attempt_id, capability_token)) = &reviewer_attempt {
+        if let Some((ticket_id, capability_token)) = &reviewer_capability {
            let workspace_id = self.workspace_context.workspace_id().ok_or_else(|| {
-                ToolError::ExecutionFailed("reviewer attempt lost Workspace identity".to_string())
+                ToolError::ExecutionFailed("review capability lost Workspace identity".to_string())
            })?;
            let child_session_id = session.session_id_string();
            let child_registration = WorkspaceRequest::json(
@@ -577,15 +573,13 @@ impl Tool for SubWorkerSpawnTool {
                )));
            }
            let body = serde_json::json!({
-                "attempt_id": attempt_id,
-                "revision_id": revision_id,
                "child_session_id": child_session_id,
                "capability_token": capability_token,
            });
            let request = WorkspaceRequest::json(
                WorkspaceRequestMethod::Post,
                format!(
-                    "/api/w/{}/tickets/{}/merge-request/review-attempts",
+                    "/api/w/{}/tickets/{}/merge-request/review-capabilities",
                    workspace_id.as_str(),
                    ticket_id
                ),
@@ -596,12 +590,12 @@ impl Tool for SubWorkerSpawnTool {
                .client()
                .execute(request)
                .map_err(|error| {
-                    ToolError::ExecutionFailed(format!("register reviewer attempt: {error}"))
+                    ToolError::ExecutionFailed(format!("register review capability: {error}"))
                })?;
            if !response.is_success() {
                let _ = session.stop().await;
                return Err(ToolError::ExecutionFailed(format!(
-                    "register reviewer attempt failed with status {}: {}",
+                    "register review capability failed with status {}: {}",
                    response.status, response.body
                )));
            }
@@ -1044,21 +1038,21 @@ mod tests {
        let valid: SubWorkerSpawnInput = serde_json::from_value(serde_json::json!({
            "name":"reviewer","task":"review","profile":"builtin:reviewer",
            "scope":[{"target":"/tmp/work","permission":"read"}],
-            "review":{"ticket_id":"T1","revision_id":"V1"}
+            "review":{"ticket_id":"T1"}
        }))
        .unwrap();
        assert!(validate_reviewer_handoff(&valid).is_ok());
        let wrong_profile: SubWorkerSpawnInput = serde_json::from_value(serde_json::json!({
            "name":"reviewer","task":"review","profile":"builtin:coder",
            "scope":[{"target":"/tmp/work","permission":"read"}],
-            "review":{"ticket_id":"T1","revision_id":"V1"}
+            "review":{"ticket_id":"T1"}
        }))
        .unwrap();
        assert!(validate_reviewer_handoff(&wrong_profile).is_err());
        let writable: SubWorkerSpawnInput = serde_json::from_value(serde_json::json!({
            "name":"reviewer","task":"review","profile":"builtin:reviewer",
            "scope":[{"target":"/tmp/work","permission":"write"}],
-            "review":{"ticket_id":"T1","revision_id":"V1"}
+            "review":{"ticket_id":"T1"}
        }))
        .unwrap();
        assert!(validate_reviewer_handoff(&writable).is_err());
@@ -238,30 +238,29 @@ pub trait WorkspaceClient: std::fmt::Debug + Send + Sync {
        ))
    }

-    /// Trusted review-attempt context is injected by the Internal SubWorker spawn layer.
+    /// Trusted review capability context is injected by the Internal SubWorker spawn layer.
    /// It is never accepted from a model-visible tool argument.
-    fn reviewer_attempt_context(&self) -> Option<&ReviewerAttemptContext> {
+    fn reviewer_context(&self) -> Option<&ReviewerContext> {
        None
    }
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ReviewerAttemptContext {
+pub struct ReviewerContext {
    pub ticket_id: String,
-    pub revision_id: String,
 }

 #[derive(Debug)]
 pub struct ReviewerChildWorkspaceClient {
    inner: Arc<dyn WorkspaceClient>,
-    context: ReviewerAttemptContext,
+    context: ReviewerContext,
    capability_token: String,
 }

 impl ReviewerChildWorkspaceClient {
    pub fn new(
        inner: Arc<dyn WorkspaceClient>,
-        context: ReviewerAttemptContext,
+        context: ReviewerContext,
        capability_token: String,
    ) -> Self {
        Self {
@@ -282,7 +281,7 @@ impl WorkspaceClient for ReviewerChildWorkspaceClient {
    fn is_available(&self) -> bool {
        self.inner.is_available()
    }
-    fn reviewer_attempt_context(&self) -> Option<&ReviewerAttemptContext> {
+    fn reviewer_context(&self) -> Option<&ReviewerContext> {
        Some(&self.context)
    }

@@ -306,10 +305,6 @@ impl WorkspaceClient for ReviewerChildWorkspaceClient {
                    "review submission body must be an object".to_string(),
                )
            })?;
-            object.insert(
-                "revision_id".to_string(),
-                serde_json::Value::String(self.context.revision_id.clone()),
-            );
            object.insert(
                "capability_token".to_string(),
                serde_json::Value::String(self.capability_token.clone()),
@@ -450,9 +445,8 @@ mod reviewer_client_tests {
        });
        let client = ReviewerChildWorkspaceClient::new(
            inner,
-            ReviewerAttemptContext {
+            ReviewerContext {
                ticket_id: "T1".into(),
-                revision_id: "V1".into(),
            },
            "secret".into(),
        );
@@ -49,9 +49,11 @@ pub struct TicketDetail {
    pub id: String,
    pub title: String,
    pub state: String,
+    pub readiness: Option<String>,
    pub priority: String,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
+    pub item_revision: String,
    pub queued_by: Option<String>,
    pub queued_at: Option<String>,
    pub assignee: Option<String>,
@@ -62,9 +64,15 @@ pub struct TicketDetail {
    pub body_truncated: bool,
    pub event_count: usize,
    pub events: Vec<TicketEventDetail>,
+    pub event_page: QueryPage,
    pub artifact_count: usize,
    pub artifacts: Vec<String>,
    pub relations: TicketRelationView,
+    pub linked_objectives: Vec<ObjectiveLinkSummary>,
+    pub implementation_reports: Vec<TicketEvidenceEvent>,
+    pub current_assignment: Option<TicketAssignmentSummary>,
+    pub merge_request: Option<TicketMergeRequestSummary>,
+    pub evidence: TicketEvidenceSummary,
    pub resolution: Option<String>,
    pub record_source: String,
 }
@@ -73,6 +81,7 @@ pub struct TicketDetail {
 #[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
 pub struct TicketEventDetail {
    pub sequence: usize,
+    pub event_ref: String,
    pub kind: String,
    pub author: Option<String>,
    pub at: Option<String>,
@@ -83,6 +92,8 @@ pub struct TicketEventDetail {
    pub state_field: Option<String>,
    pub heading: Option<String>,
    pub body: Option<String>,
+    pub attributes: std::collections::BTreeMap<String, String>,
+    pub references: Vec<String>,
 }

 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
@@ -185,11 +196,196 @@ impl From<ticket::TicketRelationView> for TicketRelationView {
    }
 }

+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct QueryPage {
+    pub limit: usize,
+    pub returned: usize,
+    pub has_more: bool,
+    pub next_cursor: Option<String>,
+    pub sort: String,
+    pub source_limit: Option<usize>,
+    pub source_truncated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct ObjectiveLinkSummary {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketEvidenceEvent {
+    pub event_ref: String,
+    pub sequence: usize,
+    pub kind: String,
+    pub at: Option<String>,
+    pub author: Option<String>,
+    pub excerpt: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketAssignmentSummary {
+    pub assignment_id: String,
+    pub runtime_id: String,
+    pub worker_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketMergeRequestSummary {
+    pub merge_request_id: String,
+    pub state: String,
+    pub review_status: String,
+    pub selector_from: Option<String>,
+    pub selector_to: String,
+    pub updated_at: String,
+    pub review_subject_ref: Option<String>,
+    pub review_submitted_at: Option<String>,
+    pub review_excerpt: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketEvidenceSummary {
+    pub has_implementation_report: bool,
+    pub implementation_report_after_rescope: bool,
+    pub has_merge_request: bool,
+    pub has_commit: bool,
+    pub review_status: Option<String>,
+    pub approved: bool,
+    pub unresolved_request_changes: bool,
+    pub complete_for_integration: bool,
+    pub missing: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketQueryRequest {
+    pub query: Option<String>,
+    #[serde(default)]
+    pub states: Vec<String>,
+    #[serde(default)]
+    pub event_kinds: Vec<String>,
+    #[serde(default)]
+    pub evidence: Vec<String>,
+    pub review_status: Option<String>,
+    #[serde(default)]
+    pub attention: Vec<String>,
+    pub related_ticket_id: Option<String>,
+    pub relation_kind: Option<String>,
+    pub linked_objective_id: Option<String>,
+    pub updated_after: Option<String>,
+    pub updated_before: Option<String>,
+    pub sort: Option<String>,
+    pub limit: Option<usize>,
+    pub cursor: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketQueryItem {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+    pub readiness: Option<String>,
+    pub priority: String,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+    pub item_revision: String,
+    pub workspace_action_priority: String,
+    pub matched_fields: Vec<String>,
+    pub snippet: Option<String>,
+    pub matching_event: Option<TicketEvidenceEvent>,
+    pub linked_objective_ids: Vec<String>,
+    pub relation_count: usize,
+    pub blocker_count: usize,
+    pub unresolved_blocker_count: usize,
+    pub unresolved_review_count: usize,
+    pub evidence: TicketEvidenceSummary,
+    pub merge_request: Option<TicketMergeRequestSummary>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketQueryResponse {
+    pub items: Vec<TicketQueryItem>,
+    pub page: QueryPage,
+    pub record_authority: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct TicketShowRequest {
+    pub event_limit: Option<usize>,
+    pub event_cursor: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub struct ObjectiveQueryRequest {
+    pub query: Option<String>,
+    #[serde(default)]
+    pub states: Vec<String>,
+    pub linked_ticket_id: Option<String>,
+    pub updated_after: Option<String>,
+    pub updated_before: Option<String>,
+    pub sort: Option<String>,
+    pub limit: Option<usize>,
+    pub cursor: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ObjectiveQueryItem {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+    pub matched_fields: Vec<String>,
+    pub snippet: Option<String>,
+    pub linked_ticket_count: usize,
+    pub linked_tickets: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ObjectiveQueryResponse {
+    pub items: Vec<ObjectiveQueryItem>,
+    pub page: QueryPage,
+    pub record_authority: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+pub struct ObjectiveShowRequest {
+    pub event_limit: Option<usize>,
+    pub event_cursor: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "typescript", derive(ts_rs::TS))]
+pub struct ObjectiveEventDetail {
+    pub event_ref: String,
+    pub kind: String,
+    pub body: Option<String>,
+    pub created_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ObjectiveLinkedTicketSummary {
+    pub id: String,
+    pub title: String,
+    pub state: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct ObjectiveSummary {
    pub id: String,
    pub title: String,
    pub state: String,
+    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    pub summary: String,
    pub linked_tickets: Vec<String>,
@@ -201,12 +397,16 @@ pub struct ObjectiveDetail {
    pub id: String,
    pub title: String,
    pub state: String,
+    pub revision: String,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    pub linked_tickets: Vec<String>,
+    pub linked_ticket_summaries: Vec<ObjectiveLinkedTicketSummary>,
    pub resources: Vec<ObjectiveResourceSummary>,
    pub body: String,
    pub body_truncated: bool,
+    pub events: Vec<ObjectiveEventDetail>,
+    pub event_page: QueryPage,
    pub record_source: String,
 }

@@ -227,7 +427,17 @@ pub fn ticket_api_typescript() -> String {
        InvalidProjectRecord::decl(&config),
        TicketSummary::decl(&config),
        TicketListResponse::decl(&config),
+        QueryPage::decl(&config),
        TicketEventDetail::decl(&config),
+        ObjectiveLinkSummary::decl(&config),
+        TicketEvidenceEvent::decl(&config),
+        TicketAssignmentSummary::decl(&config),
+        TicketMergeRequestSummary::decl(&config),
+        TicketEvidenceSummary::decl(&config),
+        TicketQueryRequest::decl(&config),
+        TicketQueryItem::decl(&config),
+        TicketQueryResponse::decl(&config),
+        TicketShowRequest::decl(&config),
        TicketRelation::decl(&config),
        DerivedTicketRelation::decl(&config),
        TicketRelationBlocker::decl(&config),
@@ -626,6 +626,12 @@ pub trait ControlPlaneStore: Send + Sync {

    fn upsert_objective(&self, record: &ObjectiveRecord) -> Result<()>;
    fn list_objectives(&self, workspace_id: &str, limit: usize) -> Result<Vec<ObjectiveRecord>>;
+    fn list_objectives_for_ticket(
+        &self,
+        workspace_id: &str,
+        ticket_id: &str,
+        limit: usize,
+    ) -> Result<Vec<ObjectiveRecord>>;
    fn get_objective(
        &self,
        workspace_id: &str,
@@ -1532,6 +1538,33 @@ impl ControlPlaneStore for SqliteWorkspaceStore {
        })
    }

+    fn list_objectives_for_ticket(
+        &self,
+        workspace_id: &str,
+        ticket_id: &str,
+        limit: usize,
+    ) -> Result<Vec<ObjectiveRecord>> {
+        self.with_conn(|conn| {
+            let mut stmt = conn.prepare(
+                r#"SELECT o.workspace_id, o.objective_id, o.title, o.state, o.body_md,
+                          o.created_at, o.updated_at
+                   FROM objectives AS o
+                   INNER JOIN objective_ticket_links AS l
+                     ON l.workspace_id = o.workspace_id
+                    AND l.objective_id = o.objective_id
+                   WHERE o.workspace_id = ?1 AND l.ticket_id = ?2
+                   ORDER BY o.updated_at DESC, o.objective_id ASC
+                   LIMIT ?3"#,
+            )?;
+            let rows = stmt.query_map(
+                params![workspace_id, ticket_id, limit as i64],
+                read_objective_record,
+            )?;
+            rows.collect::<std::result::Result<Vec<_>, _>>()
+                .map_err(Error::from)
+        })
+    }
+
    fn get_objective(
        &self,
        workspace_id: &str,