workspace: add typed Ticket API and targets

crates/ticket/src/lib.rs

@@ -495,6 +495,8 @@ pub struct NewTicket {
     pub workflow_state: Option<TicketWorkflowState>,
     pub queued_by: Option<String>,
     pub queued_at: Option<String>,
+    pub repository_id: Option<String>,
+    pub ref_selector: Option<String>,
 }
 
 impl NewTicket {
@@ -513,10 +515,51 @@ impl NewTicket {
             workflow_state: None,
             queued_by: None,
             queued_at: None,
+            repository_id: None,
+            ref_selector: None,
         }
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
+#[serde(tag = "action", rename_all = "snake_case")]
+pub enum TicketTargetEdit {
+    Set {
+        repository_id: String,
+        ref_selector: Option<String>,
+    },
+    Clear,
+}
+
+impl TicketTargetEdit {
+    fn validate(&self) -> Result<()> {
+        if let Self::Set {
+            repository_id,
+            ref_selector,
+        } = self
+        {
+            validate_ticket_target(Some(repository_id), ref_selector.as_deref())?;
+        }
+        Ok(())
+    }
+}
+
+fn validate_ticket_target(repository_id: Option<&str>, ref_selector: Option<&str>) -> Result<()> {
+    let Some(repository_id) = repository_id else {
+        if ref_selector.is_some() {
+            return Err(TicketError::Conflict(
+                "ref_selector requires repository_id".to_string(),
+            ));
+        }
+        return Ok(());
+    };
+    validate_required_event_value("repository_id", repository_id)?;
+    if let Some(ref_selector) = ref_selector {
+        validate_required_event_value("ref_selector", ref_selector)?;
+    }
+    Ok(())
+}
+
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct TicketItemEdit {
     pub title: Option<String>,
@@ -525,6 +568,7 @@ pub struct TicketItemEdit {
     pub body: Option<MarkdownText>,
     #[serde(default)]
     pub body_replacement: Option<TicketBodyReplacement>,
+    pub target: Option<TicketTargetEdit>,
     pub author: Option<String>,
 }
 
@@ -560,12 +604,18 @@ impl TicketItemEdit {
         if let Some(replacement) = &self.body_replacement {
             replacement.validate()?;
         }
+        if let Some(target) = &self.target {
+            target.validate()?;
+        }
 
         Ok(())
     }
 
     fn has_changes(&self) -> bool {
-        self.title.is_some() || self.body.is_some() || self.body_replacement.is_some()
+        self.title.is_some()
+            || self.body.is_some()
+            || self.body_replacement.is_some()
+            || self.target.is_some()
     }
 }
 
@@ -1373,6 +1423,8 @@ pub struct TicketMeta {
     pub workflow_state_explicit: bool,
     pub queued_by: Option<String>,
     pub queued_at: Option<String>,
+    pub repository_id: Option<String>,
+    pub ref_selector: Option<String>,
     pub raw: BTreeMap<String, String>,
 }
 
@@ -2298,6 +2350,8 @@ CREATE TABLE IF NOT EXISTS typed_tickets (
     queued_by TEXT,
     queued_at TEXT,
     resolution TEXT,
+    repository_id TEXT,
+    ref_selector TEXT,
     PRIMARY KEY (workspace_id, ticket_id)
 );
 CREATE TABLE IF NOT EXISTS typed_ticket_labels (
@@ -2368,7 +2422,11 @@ CREATE TABLE IF NOT EXISTS typed_ticket_artifacts (
     PRIMARY KEY (workspace_id, ticket_id, relative_path),
     FOREIGN KEY (workspace_id, ticket_id) REFERENCES typed_tickets(workspace_id, ticket_id) ON DELETE CASCADE
 );
-"#).map_err(sqlite_err)
+"#)
+        .map_err(sqlite_err)?;
+        ensure_sqlite_ticket_column(conn, "repository_id", "TEXT")?;
+        ensure_sqlite_ticket_column(conn, "ref_selector", "TEXT")?;
+        Ok(())
     }
 
     fn with_write<R>(&self, op: impl FnOnce(&Connection) -> Result<R>) -> Result<R> {
@@ -2475,9 +2533,9 @@ CREATE TABLE IF NOT EXISTS typed_ticket_artifacts (
 
     fn insert_ticket(&self, conn: &Connection, ticket: &Ticket) -> Result<()> {
         conn.execute(r#"INSERT INTO typed_tickets
-            (workspace_id, ticket_id, slug, title, status, kind, priority, body, created_at, updated_at, assignee, readiness, workflow_state, workflow_state_explicit, queued_by, queued_at, resolution)
+            (workspace_id, ticket_id, slug, title, status, kind, priority, body, created_at, updated_at, assignee, readiness, workflow_state, workflow_state_explicit, queued_by, queued_at, resolution, repository_id, ref_selector)
-            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17)"#,
+            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19)"#,
-            params![self.workspace_id, ticket.meta.id, ticket.meta.slug, ticket.meta.title, ticket.meta.status.as_str(), ticket.meta.kind, ticket.meta.priority, ticket.document.body.as_str(), ticket.meta.created_at, ticket.meta.updated_at, ticket.meta.assignee, ticket.meta.readiness, ticket.meta.workflow_state.as_str(), if ticket.meta.workflow_state_explicit { 1 } else { 0 }, ticket.meta.queued_by, ticket.meta.queued_at, ticket.resolution.as_ref().map(|body| body.as_str())]
+            params![self.workspace_id, ticket.meta.id, ticket.meta.slug, ticket.meta.title, ticket.meta.status.as_str(), ticket.meta.kind, ticket.meta.priority, ticket.document.body.as_str(), ticket.meta.created_at, ticket.meta.updated_at, ticket.meta.assignee, ticket.meta.readiness, ticket.meta.workflow_state.as_str(), if ticket.meta.workflow_state_explicit { 1 } else { 0 }, ticket.meta.queued_by, ticket.meta.queued_at, ticket.resolution.as_ref().map(|body| body.as_str()), ticket.meta.repository_id, ticket.meta.ref_selector]
         ).map_err(sqlite_err)?;
         self.insert_ordered_values(
             conn,
@@ -2565,12 +2623,14 @@ CREATE TABLE IF NOT EXISTS typed_ticket_artifacts (
             workflow_state_explicit: row.get::<_, i64>(13)? != 0,
             queued_by: row.get(14)?,
             queued_at: row.get(15)?,
+            repository_id: row.get(16)?,
+            ref_selector: row.get(17)?,
             raw: BTreeMap::new(),
         })
     }
 
     fn load_ticket(&self, conn: &Connection, ticket_id: &str) -> Result<Ticket> {
-        let (mut meta, body, resolution): (TicketMeta, String, Option<String>) = conn.query_row(r#"SELECT ticket_id, slug, title, status, kind, priority, created_at, updated_at, assignee, readiness, body, resolution, workflow_state, workflow_state_explicit, queued_by, queued_at FROM typed_tickets WHERE workspace_id = ?1 AND ticket_id = ?2"#,
+        let (mut meta, body, resolution): (TicketMeta, String, Option<String>) = conn.query_row(r#"SELECT ticket_id, slug, title, status, kind, priority, created_at, updated_at, assignee, readiness, body, resolution, workflow_state, workflow_state_explicit, queued_by, queued_at, repository_id, ref_selector FROM typed_tickets WHERE workspace_id = ?1 AND ticket_id = ?2"#,
             params![self.workspace_id, ticket_id], |row| Ok((Self::ticket_meta_from_row(row)?, row.get(10)?, row.get(11)?))).optional().map_err(sqlite_err)?.ok_or_else(|| TicketError::NotFound(ticket_id.to_string()))?;
         meta.labels = self.load_ordered_values(conn, "typed_ticket_labels", "label", ticket_id)?;
         meta.risk_flags =
@@ -2733,7 +2793,7 @@ CREATE TABLE IF NOT EXISTS typed_ticket_artifacts (
         conn: &Connection,
         filter: TicketListQuery,
     ) -> Result<Vec<TicketSummary>> {
-        let mut stmt = conn.prepare(r#"SELECT ticket_id, slug, title, status, kind, priority, created_at, updated_at, assignee, readiness, body, resolution, workflow_state, workflow_state_explicit, queued_by, queued_at FROM typed_tickets WHERE workspace_id = ?1 ORDER BY ticket_id ASC"#).map_err(sqlite_err)?;
+        let mut stmt = conn.prepare(r#"SELECT ticket_id, slug, title, status, kind, priority, created_at, updated_at, assignee, readiness, body, resolution, workflow_state, workflow_state_explicit, queued_by, queued_at, repository_id, ref_selector FROM typed_tickets WHERE workspace_id = ?1 ORDER BY ticket_id ASC"#).map_err(sqlite_err)?;
         let rows = stmt
             .query_map(params![self.workspace_id], Self::ticket_meta_from_row)
             .map_err(sqlite_err)?;
@@ -2806,6 +2866,30 @@ CREATE TABLE IF NOT EXISTS typed_ticket_artifacts (
     }
 }
 
+fn ensure_sqlite_ticket_column(
+    conn: &rusqlite::Connection,
+    name: &str,
+    sql_type: &str,
+) -> Result<()> {
+    let mut statement = conn
+        .prepare("PRAGMA table_info(typed_tickets)")
+        .map_err(sqlite_err)?;
+    let columns = statement
+        .query_map([], |row| row.get::<_, String>(1))
+        .map_err(sqlite_err)?;
+    for column in columns {
+        if column.map_err(sqlite_err)? == name {
+            return Ok(());
+        }
+    }
+    conn.execute(
+        format!("ALTER TABLE typed_tickets ADD COLUMN {name} {sql_type}").as_str(),
+        [],
+    )
+    .map_err(sqlite_err)?;
+    Ok(())
+}
+
 fn finish_sqlite_transaction<R>(conn: &Connection, result: Result<R>) -> Result<R> {
     match result {
         Ok(output) => {
@@ -2865,6 +2949,10 @@ impl TicketBackend for SqliteTicketBackend {
                     "ticket title must not be empty".to_string(),
                 ));
             }
+            validate_ticket_target(
+                input.repository_id.as_deref(),
+                input.ref_selector.as_deref(),
+            )?;
             let base_millis = unix_epoch_millis_now().map_err(|err| {
                 TicketError::Conflict(format!("failed to read ticket id timestamp: {err}"))
             })?;
@@ -2900,6 +2988,8 @@ impl TicketBackend for SqliteTicketBackend {
                 workflow_state_explicit: true,
                 queued_by: input.queued_by,
                 queued_at: input.queued_at,
+                repository_id: input.repository_id,
+                ref_selector: input.ref_selector,
                 raw: BTreeMap::new(),
             };
             let body = if input.body.as_str() == DEFAULT_TICKET_BODY {
@@ -2948,7 +3038,7 @@ impl TicketBackend for SqliteTicketBackend {
             edit.validate_body_edit_request()?;
             if !edit.has_changes() {
                 return Err(TicketError::Conflict(
-                    "TicketEditItem requires at least one of title, body, or body_replacement"
+                    "TicketEditItem requires at least one of title, body, body_replacement, or target"
                         .to_string(),
                 ));
             }
@@ -2986,6 +3076,20 @@ impl TicketBackend for SqliteTicketBackend {
             if let Some(body) = updated_body.as_ref() {
                 conn.execute("UPDATE typed_tickets SET body = ?3, updated_at = ?4 WHERE workspace_id = ?1 AND ticket_id = ?2", params![self.workspace_id, ticket_id, body.as_str(), now]).map_err(sqlite_err)?;
             }
+            if let Some(target) = edit.target.as_ref() {
+                let (repository_id, ref_selector) = match target {
+                    TicketTargetEdit::Set {
+                        repository_id,
+                        ref_selector,
+                    } => (Some(repository_id.as_str()), ref_selector.as_deref()),
+                    TicketTargetEdit::Clear => (None, None),
+                };
+                conn.execute(
+                    "UPDATE typed_tickets SET repository_id = ?3, ref_selector = ?4, updated_at = ?5 WHERE workspace_id = ?1 AND ticket_id = ?2",
+                    params![self.workspace_id, ticket_id, repository_id, ref_selector, now],
+                )
+                .map_err(sqlite_err)?;
+            }
 
             let mut changes = Vec::new();
             if edit.title.is_some() {
@@ -2994,6 +3098,9 @@ impl TicketBackend for SqliteTicketBackend {
             if !matches!(body_edit_audit, TicketBodyEditAudit::None) {
                 changes.push("body");
             }
+            if edit.target.is_some() {
+                changes.push("target");
+            }
             let mut attributes = BTreeMap::new();
             attributes.insert("changes".to_string(), changes.join(","));
             let body = match body_edit_audit {
@@ -3305,6 +3412,10 @@ impl TicketBackend for LocalTicketBackend {
                 "ticket title must not be empty".to_string(),
             ));
         }
+        validate_ticket_target(
+            input.repository_id.as_deref(),
+            input.ref_selector.as_deref(),
+        )?;
         let base_millis = unix_epoch_millis_now().map_err(|err| {
             TicketError::Conflict(format!("failed to read ticket id timestamp: {err}"))
         })?;
@@ -3375,6 +3486,18 @@ impl TicketBackend for LocalTicketBackend {
                 format_yaml_string_scalar(queued_at.as_str()),
             ));
         }
+        if let Some(repository_id) = input.repository_id {
+            fields.push((
+                "repository_id".to_string(),
+                format_yaml_string_scalar(repository_id.as_str()),
+            ));
+        }
+        if let Some(ref_selector) = input.ref_selector {
+            fields.push((
+                "ref_selector".to_string(),
+                format_yaml_string_scalar(ref_selector.as_str()),
+            ));
+        }
         let item_body = if input.body.as_str() == DEFAULT_TICKET_BODY {
             self.generated_default_body()
         } else {
@@ -3426,6 +3549,48 @@ impl TicketBackend for LocalTicketBackend {
                 }
             })?;
         }
+        if let Some(target) = edit.target.as_ref() {
+            match target {
+                TicketTargetEdit::Set {
+                    repository_id,
+                    ref_selector,
+                } => {
+                    content = replace_frontmatter_fields(
+                        &content,
+                        &[("repository_id", repository_id.as_str())],
+                    )
+                    .map_err(|message| TicketError::Parse {
+                        path: item.clone(),
+                        message,
+                    })?;
+                    if let Some(ref_selector) = ref_selector {
+                        content = replace_frontmatter_fields(
+                            &content,
+                            &[("ref_selector", ref_selector.as_str())],
+                        )
+                        .map_err(|message| TicketError::Parse {
+                            path: item.clone(),
+                            message,
+                        })?;
+                    } else {
+                        content = remove_frontmatter_fields(&content, &["ref_selector"]).map_err(
+                            |message| TicketError::Parse {
+                                path: item.clone(),
+                                message,
+                            },
+                        )?;
+                    }
+                }
+                TicketTargetEdit::Clear => {
+                    content =
+                        remove_frontmatter_fields(&content, &["repository_id", "ref_selector"])
+                            .map_err(|message| TicketError::Parse {
+                                path: item.clone(),
+                                message,
+                            })?;
+                }
+            }
+        }
         if let Some(body) = edit.body.as_ref() {
             content = replace_item_body(&content, body.as_str()).map_err(|message| {
                 TicketError::Parse {
@@ -3461,6 +3626,9 @@ impl TicketBackend for LocalTicketBackend {
         if !matches!(body_edit_audit, TicketBodyEditAudit::None) {
             changes.push("body");
         }
+        if edit.target.is_some() {
+            changes.push("target");
+        }
         let mut attrs = Vec::new();
         attrs.push(("changes", changes.join(",")));
         let body = match body_edit_audit {
@@ -4104,6 +4272,8 @@ struct TicketItemFrontmatter {
     state_explicit: bool,
     queued_by: Option<String>,
     queued_at: Option<String>,
+    repository_id: Option<String>,
+    ref_selector: Option<String>,
     raw: BTreeMap<String, String>,
 }
 
@@ -4211,6 +4381,8 @@ fn parse_ticket_frontmatter(content: &str) -> std::result::Result<TicketItemFron
         state_explicit,
         queued_by: yaml_string(&mapping, "queued_by")?,
         queued_at: yaml_string(&mapping, "queued_at")?,
+        repository_id: yaml_string(&mapping, "repository_id")?,
+        ref_selector: yaml_string(&mapping, "ref_selector")?,
         raw,
     })
 }
@@ -4340,6 +4512,8 @@ fn ticket_meta(frontmatter: TicketItemFrontmatter, id: String) -> TicketMeta {
         workflow_state_explicit: frontmatter.state_explicit,
         queued_by: frontmatter.queued_by,
         queued_at: frontmatter.queued_at,
+        repository_id: frontmatter.repository_id,
+        ref_selector: frontmatter.ref_selector,
         raw: frontmatter.raw,
     }
 }
@@ -5032,6 +5206,37 @@ fn replace_frontmatter_fields(
     Ok(out)
 }
 
+fn remove_frontmatter_fields(
+    content: &str,
+    fields: &[&str],
+) -> std::result::Result<String, String> {
+    let mut lines: Vec<String> = content.lines().map(ToOwned::to_owned).collect();
+    if lines.first().map(String::as_str) != Some("---") {
+        return Err("item.md missing frontmatter opener".to_string());
+    }
+    let Some(end) = lines
+        .iter()
+        .enumerate()
+        .skip(1)
+        .find_map(|(idx, line)| (line == "---").then_some(idx))
+    else {
+        return Err("item.md missing frontmatter closer".to_string());
+    };
+    for index in (1..end).rev() {
+        let should_remove = lines[index]
+            .split_once(':')
+            .is_some_and(|(key, _)| fields.contains(&key.trim()));
+        if should_remove {
+            lines.remove(index);
+        }
+    }
+    let mut out = lines.join("\n");
+    if content.ends_with('\n') {
+        out.push('\n');
+    }
+    Ok(out)
+}
+
 fn replace_item_body(content: &str, body: &str) -> std::result::Result<String, String> {
     let mut lines = content.lines();
     if lines.next() != Some("---") {
@@ -5692,6 +5897,56 @@ mod tests {
         LocalTicketBackend::new(dir.path().join("tickets"))
     }
 
+    fn assert_ticket_target_edit_semantics<B: TicketBackend>(backend: &B) {
+        let mut input = NewTicket::new("Target Ticket");
+        input.repository_id = Some("main".to_string());
+        input.ref_selector = Some("feature/api".to_string());
+        let created = backend.create(input).unwrap();
+        let ticket = backend
+            .show(TicketIdOrSlug::Id(created.id.clone()))
+            .unwrap();
+        assert_eq!(ticket.meta.repository_id.as_deref(), Some("main"));
+        assert_eq!(ticket.meta.ref_selector.as_deref(), Some("feature/api"));
+
+        let edited = backend
+            .edit_item(
+                TicketIdOrSlug::Id(created.id.clone()),
+                TicketItemEdit {
+                    target: Some(TicketTargetEdit::Set {
+                        repository_id: "secondary".to_string(),
+                        ref_selector: None,
+                    }),
+                    author: Some("tester".to_string()),
+                    ..Default::default()
+                },
+            )
+            .unwrap();
+        assert_eq!(edited.meta.repository_id.as_deref(), Some("secondary"));
+        assert_eq!(edited.meta.ref_selector, None);
+        let edit_event = edited
+            .events
+            .iter()
+            .rev()
+            .find(|event| event.kind == TicketEventKind::Other("item_edit".to_string()))
+            .expect("item_edit event");
+        assert_eq!(
+            edit_event.attributes.get("changes"),
+            Some(&"target".to_string())
+        );
+
+        let cleared = backend
+            .edit_item(
+                TicketIdOrSlug::Id(created.id),
+                TicketItemEdit {
+                    target: Some(TicketTargetEdit::Clear),
+                    ..Default::default()
+                },
+            )
+            .unwrap();
+        assert_eq!(cleared.meta.repository_id, None);
+        assert_eq!(cleared.meta.ref_selector, None);
+    }
+
     fn assert_partial_body_replacement_semantics<B: TicketBackend>(backend: &B) {
         let mut input = NewTicket::new("Body Edit Ticket");
         input.body = MarkdownText::new("alpha\nbeta\nalpha\n");
@@ -6092,6 +6347,38 @@ state: planning
         assert!(report.is_ok(), "{:?}", report.diagnostics);
     }
 
+    #[test]
+    fn local_backend_persists_and_edits_ticket_target() {
+        let tmp = TempDir::new().unwrap();
+        let backend = backend(&tmp);
+        assert_ticket_target_edit_semantics(&backend);
+    }
+
+    #[test]
+    fn sqlite_backend_persists_and_edits_ticket_target() {
+        let tmp = TempDir::new().unwrap();
+        let backend = SqliteTicketBackend::new(tmp.path().join("workspace.db"), "workspace-test");
+        assert_ticket_target_edit_semantics(&backend);
+    }
+
+    #[test]
+    fn sqlite_ticket_target_columns_are_added_to_existing_table() {
+        let tmp = TempDir::new().unwrap();
+        let conn = rusqlite::Connection::open(tmp.path().join("workspace.db")).unwrap();
+        conn.execute_batch("CREATE TABLE typed_tickets (ticket_id TEXT PRIMARY KEY);")
+            .unwrap();
+        ensure_sqlite_ticket_column(&conn, "repository_id", "TEXT").unwrap();
+        ensure_sqlite_ticket_column(&conn, "ref_selector", "TEXT").unwrap();
+        let mut statement = conn.prepare("PRAGMA table_info(typed_tickets)").unwrap();
+        let columns = statement
+            .query_map([], |row| row.get::<_, String>(1))
+            .unwrap()
+            .collect::<std::result::Result<Vec<_>, _>>()
+            .unwrap();
+        assert!(columns.iter().any(|column| column == "repository_id"));
+        assert!(columns.iter().any(|column| column == "ref_selector"));
+    }
+
     #[test]
     fn local_backend_edit_item_supports_partial_body_replacement() {
         let tmp = TempDir::new().unwrap();

crates/ticket/src/tool.rs

@@ -382,6 +382,12 @@ struct TicketCreateParams {
     /// Optional queued_at frontmatter value.
     #[serde(default)]
     queued_at: Option<String>,
+    /// Optional target Workspace repository id.
+    #[serde(default)]
+    repository_id: Option<String>,
+    /// Optional target Git ref selector. Requires `repository_id`.
+    #[serde(default)]
+    ref_selector: Option<String>,
 }
 
 #[derive(Debug, Deserialize, schemars::JsonSchema)]
@@ -403,6 +409,9 @@ struct TicketEditItemParams {
     /// Replace every occurrence of `old_string`; by default exactly one occurrence is required.
     #[serde(default)]
     replace_all: bool,
+    /// Optional target repository/ref update.
+    #[serde(default)]
+    target: Option<crate::TicketTargetEdit>,
     /// Optional thread author for the audited item_edit event.
     #[serde(default)]
     author: Option<String>,
@@ -916,6 +925,8 @@ impl Tool for TicketCreateTool {
         input.workflow_state = params.state.map(TicketWorkflowStateParam::into_state);
         input.queued_by = params.queued_by;
         input.queued_at = params.queued_at;
+        input.repository_id = params.repository_id;
+        input.ref_selector = params.ref_selector;
 
         let created = self
             .backend
@@ -959,6 +970,7 @@ impl Tool for TicketEditItemTool {
             title: params.title,
             body: params.body.map(MarkdownText::new),
             body_replacement,
+            target: params.target,
             author: params.author,
         };
         let ticket = self

crates/workspace-server/src/authority.rs

@@ -10,7 +10,7 @@ use ticket::{
 
 use crate::records::{
     ObjectiveDetail, ObjectiveResourceSummary, ObjectiveSummary, ProjectRecordList, TicketDetail,
-    TicketSummary, summarize_body, truncate_body, validate_project_id,
+    TicketEventDetail, TicketSummary, summarize_body, truncate_body, validate_project_id,
 };
 use crate::store::{
     ControlPlaneStore, MemoryDocumentRecord, MemoryStagingRecord, MemoryStagingResolutionRecord,
@@ -19,6 +19,8 @@ use crate::store::{
 use crate::{Error, Result};
 
 const DETAIL_BODY_LIMIT: usize = 64 * 1024;
+const TICKET_EVENT_LIMIT: usize = 100;
+const TICKET_EVENT_BODY_LIMIT: usize = 16 * 1024;
 const DEFAULT_MEMORY_DOCUMENT_BODY: &str = "# Memory\n\n";
 const RECORD_SOURCE_WORKSPACE_SQLITE: &str = "workspace-sqlite";
 
@@ -244,6 +246,25 @@ impl TicketAuthority for SqliteWorkspaceAuthority {
             .show(TicketIdOrSlug::Id(id.to_string()))?;
         let (body, body_truncated) =
             truncate_body(ticket.document.body.as_str(), DETAIL_BODY_LIMIT);
+        let event_start = ticket.events.len().saturating_sub(TICKET_EVENT_LIMIT);
+        let events = ticket.events[event_start..]
+            .iter()
+            .enumerate()
+            .map(|(index, event)| TicketEventDetail {
+                sequence: event_start + index,
+                kind: event.kind.as_str().to_owned(),
+                author: event.author.clone(),
+                at: event.at.clone(),
+                status: event.status.clone(),
+                from: event.from.clone(),
+                to: event.to.clone(),
+                reason: event.reason.clone(),
+                state_field: event.state_field.clone(),
+                heading: event.heading.clone(),
+                body: (!event.body.as_str().is_empty())
+                    .then(|| truncate_body(event.body.as_str(), TICKET_EVENT_BODY_LIMIT).0),
+            })
+            .collect();
         Ok(TicketDetail {
             id: ticket.meta.id,
             title: ticket.meta.title,
@@ -253,11 +274,22 @@ impl TicketAuthority for SqliteWorkspaceAuthority {
             updated_at: ticket.meta.updated_at,
             queued_by: ticket.meta.queued_by,
             queued_at: ticket.meta.queued_at,
+            repository_id: ticket.meta.repository_id,
+            ref_selector: ticket.meta.ref_selector,
             risk_flags: ticket.meta.risk_flags,
             body,
             body_truncated,
             event_count: ticket.events.len(),
+            events,
             artifact_count: ticket.artifacts.len(),
+            artifacts: ticket
+                .artifacts
+                .into_iter()
+                .map(|artifact| artifact.relative_path.display().to_string())
+                .collect(),
+            resolution: ticket
+                .resolution
+                .map(|resolution| resolution.as_str().to_string()),
             record_source: "sqlite_yoi_ticket".to_string(),
         })
     }

crates/workspace-server/src/records.rs

@@ -41,14 +41,34 @@ pub struct TicketDetail {
     pub updated_at: Option<String>,
     pub queued_by: Option<String>,
     pub queued_at: Option<String>,
+    pub repository_id: Option<String>,
+    pub ref_selector: Option<String>,
     pub risk_flags: Vec<String>,
     pub body: String,
     pub body_truncated: bool,
     pub event_count: usize,
+    pub events: Vec<TicketEventDetail>,
     pub artifact_count: usize,
+    pub artifacts: Vec<String>,
+    pub resolution: Option<String>,
     pub record_source: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TicketEventDetail {
+    pub sequence: usize,
+    pub kind: String,
+    pub author: Option<String>,
+    pub at: Option<String>,
+    pub status: Option<String>,
+    pub from: Option<String>,
+    pub to: Option<String>,
+    pub reason: Option<String>,
+    pub state_field: Option<String>,
+    pub heading: Option<String>,
+    pub body: Option<String>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct ObjectiveSummary {
     pub id: String,

crates/workspace-server/src/server.rs

@@ -19,6 +19,11 @@ use memory::backend::{
 use protocol::stream::{decode_method, encode_event};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
+use ticket::{
+    MarkdownText, NewTicketEvent, TicketBackend, TicketBodyReplacement, TicketEventKind,
+    TicketIdOrSlug, TicketItemEdit, TicketReview, TicketReviewResult, TicketStateChange,
+    TicketTargetEdit, TicketWorkflowState,
+};
 use ticket::{
     SqliteTicketBackend, TicketBackendHttpResponse, TicketBackendOperation,
     execute_ticket_backend_operation,
@@ -511,7 +516,30 @@ pub fn build_router(api: WorkspaceApi) -> Router {
             "/api/w/{workspace_id}/skills/{name}/activate",
             get(scoped_activate_skill),
         )
-        .route("/api/w/{workspace_id}/tickets/{id}", get(scoped_get_ticket))
+        .route(
+            "/api/w/{workspace_id}/tickets/{id}",
+            get(scoped_get_ticket).patch(scoped_edit_ticket_item),
+        )
+        .route(
+            "/api/w/{workspace_id}/tickets/{id}/state",
+            post(scoped_transition_ticket_state),
+        )
+        .route(
+            "/api/w/{workspace_id}/tickets/{id}/events",
+            post(scoped_append_ticket_event),
+        )
+        .route(
+            "/api/w/{workspace_id}/tickets/{id}/reviews",
+            post(scoped_review_ticket),
+        )
+        .route(
+            "/api/w/{workspace_id}/tickets/{id}/queue",
+            post(scoped_queue_ticket),
+        )
+        .route(
+            "/api/w/{workspace_id}/tickets/{id}/close",
+            post(scoped_close_ticket),
+        )
         .route("/api/objectives", get(list_objectives))
         .route(
             "/api/w/{workspace_id}/objectives",
@@ -1526,6 +1554,220 @@ async fn scoped_get_ticket(
     get_ticket(State(api), AxumPath(path.id)).await
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BrowserEditTicketRequest {
+    title: Option<String>,
+    body: Option<String>,
+    old_string: Option<String>,
+    new_string: Option<String>,
+    #[serde(default)]
+    replace_all: bool,
+    target: Option<TicketTargetEdit>,
+    author: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BrowserTransitionTicketStateRequest {
+    state: TicketWorkflowState,
+    reason: Option<String>,
+    body: Option<String>,
+    author: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum BrowserTicketThreadRole {
+    Comment,
+    Plan,
+    Decision,
+    ImplementationReport,
+}
+
+impl From<BrowserTicketThreadRole> for TicketEventKind {
+    fn from(role: BrowserTicketThreadRole) -> Self {
+        match role {
+            BrowserTicketThreadRole::Comment => Self::Comment,
+            BrowserTicketThreadRole::Plan => Self::Plan,
+            BrowserTicketThreadRole::Decision => Self::Decision,
+            BrowserTicketThreadRole::ImplementationReport => Self::ImplementationReport,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BrowserAppendTicketEventRequest {
+    role: BrowserTicketThreadRole,
+    body: String,
+    author: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BrowserReviewTicketRequest {
+    result: TicketReviewResult,
+    body: String,
+    author: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BrowserQueueTicketRequest {
+    queued_by: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BrowserCloseTicketRequest {
+    resolution: String,
+}
+
+fn browser_ticket_backend(api: &WorkspaceApi) -> Result<SqliteTicketBackend> {
+    let config = ticket::config::TicketConfig::load_workspace(&api.config.workspace_root)
+        .map_err(|error| Error::Config(format!("load Ticket workspace settings: {error}")))?;
+    Ok(SqliteTicketBackend::new(
+        api.config.database_path.clone(),
+        api.config.workspace_id.clone(),
+    )
+    .with_record_language(config.ticket_record_language()))
+}
+
+fn browser_ticket_detail(api: &WorkspaceApi, ticket_id: &str) -> ApiResult<Json<TicketDetail>> {
+    Ok(Json(api.authority.ticket(ticket_id)?))
+}
+
+async fn scoped_edit_ticket_item(
+    State(api): State<WorkspaceApi>,
+    AxumPath(path): AxumPath<ScopedRecordPath>,
+    Json(request): Json<BrowserEditTicketRequest>,
+) -> ApiResult<Json<TicketDetail>> {
+    validate_workspace_scope(&api, &path.workspace_id)?;
+    if let Some(TicketTargetEdit::Set { repository_id, .. }) = request.target.as_ref() {
+        if !api
+            .store
+            .list_repositories(&api.config.workspace_id)?
+            .iter()
+            .any(|repository| repository.repository_id == *repository_id)
+        {
+            return Err(settings_bad_request(
+                "unknown_ticket_repository",
+                "repository_id must identify a repository registered in this Workspace",
+            ));
+        }
+    }
+    browser_ticket_backend(&api)?
+        .edit_item(
+            TicketIdOrSlug::Id(path.id.clone()),
+            TicketItemEdit {
+                title: request.title,
+                body: request.body.map(MarkdownText::new),
+                body_replacement: match (request.old_string, request.new_string) {
+                    (Some(old_string), Some(new_string)) => Some(TicketBodyReplacement {
+                        old_string,
+                        new_string,
+                        replace_all: request.replace_all,
+                    }),
+                    (None, None) => None,
+                    _ => {
+                        return Err(settings_bad_request(
+                            "invalid_ticket_edit_replacement",
+                            "old_string and new_string must be provided together",
+                        ));
+                    }
+                },
+                target: request.target,
+                author: request.author,
+            },
+        )
+        .map_err(Error::from)?;
+    browser_ticket_detail(&api, &path.id)
+}
+
+async fn scoped_transition_ticket_state(
+    State(api): State<WorkspaceApi>,
+    AxumPath(path): AxumPath<ScopedRecordPath>,
+    Json(request): Json<BrowserTransitionTicketStateRequest>,
+) -> ApiResult<Json<TicketDetail>> {
+    validate_workspace_scope(&api, &path.workspace_id)?;
+    let current = api.authority.ticket(&path.id)?;
+    let mut change = TicketStateChange::new(
+        current.state,
+        request.state.as_str(),
+        request
+            .reason
+            .unwrap_or_else(|| "state changed from Web Ticket API".to_owned()),
+        request.body.unwrap_or_default(),
+    );
+    change.author = request.author;
+    browser_ticket_backend(&api)?
+        .set_workflow_state(TicketIdOrSlug::Id(path.id.clone()), change)
+        .map_err(Error::from)?;
+    browser_ticket_detail(&api, &path.id)
+}
+
+async fn scoped_append_ticket_event(
+    State(api): State<WorkspaceApi>,
+    AxumPath(path): AxumPath<ScopedRecordPath>,
+    Json(request): Json<BrowserAppendTicketEventRequest>,
+) -> ApiResult<Json<TicketDetail>> {
+    validate_workspace_scope(&api, &path.workspace_id)?;
+    let mut event = NewTicketEvent::new(request.role.into(), request.body);
+    event.author = request.author;
+    browser_ticket_backend(&api)?
+        .add_event(TicketIdOrSlug::Id(path.id.clone()), event)
+        .map_err(Error::from)?;
+    browser_ticket_detail(&api, &path.id)
+}
+
+async fn scoped_review_ticket(
+    State(api): State<WorkspaceApi>,
+    AxumPath(path): AxumPath<ScopedRecordPath>,
+    Json(request): Json<BrowserReviewTicketRequest>,
+) -> ApiResult<Json<TicketDetail>> {
+    validate_workspace_scope(&api, &path.workspace_id)?;
+    browser_ticket_backend(&api)?
+        .review(
+            TicketIdOrSlug::Id(path.id.clone()),
+            TicketReview {
+                result: request.result,
+                body: MarkdownText::new(request.body),
+                author: request.author,
+            },
+        )
+        .map_err(Error::from)?;
+    browser_ticket_detail(&api, &path.id)
+}
+
+async fn scoped_queue_ticket(
+    State(api): State<WorkspaceApi>,
+    AxumPath(path): AxumPath<ScopedRecordPath>,
+    Json(request): Json<BrowserQueueTicketRequest>,
+) -> ApiResult<Json<TicketDetail>> {
+    validate_workspace_scope(&api, &path.workspace_id)?;
+    let queued_by = request.queued_by.as_deref().unwrap_or("web");
+    browser_ticket_backend(&api)?
+        .queue_ready(TicketIdOrSlug::Id(path.id.clone()), queued_by)
+        .map_err(Error::from)?;
+    browser_ticket_detail(&api, &path.id)
+}
+
+async fn scoped_close_ticket(
+    State(api): State<WorkspaceApi>,
+    AxumPath(path): AxumPath<ScopedRecordPath>,
+    Json(request): Json<BrowserCloseTicketRequest>,
+) -> ApiResult<Json<TicketDetail>> {
+    validate_workspace_scope(&api, &path.workspace_id)?;
+    browser_ticket_backend(&api)?
+        .close(
+            TicketIdOrSlug::Id(path.id.clone()),
+            MarkdownText::new(request.resolution),
+        )
+        .map_err(Error::from)?;
+    browser_ticket_detail(&api, &path.id)
+}
+
 async fn scoped_ticket_backend_operation(
     State(api): State<WorkspaceApi>,
     AxumPath(path): AxumPath<ScopedWorkspacePath>,
@@ -4329,19 +4571,35 @@ async fn create_workspace_worker(
             },
         )
         .map_err(|err| err.into_error())?;
+    Ok(Json(record_browser_worker_spawn(
+        &api,
+        request.runtime_id,
+        display_name,
+        selected_working_directory_id,
+        result,
+    )?))
+}
+
+fn record_browser_worker_spawn(
+    api: &WorkspaceApi,
+    requested_runtime_id: String,
+    display_name: String,
+    selected_working_directory_id: Option<String>,
+    result: WorkerSpawnResult,
+) -> ApiResult<BrowserCreateWorkerResponse> {
     if result.state != WorkerOperationState::Accepted {
         return Err(worker_create_not_accepted_error(
-            request.runtime_id.clone(),
+            requested_runtime_id.clone(),
             result.diagnostics,
         ));
     }
     let worker = result.worker.ok_or_else(|| Error::RuntimeOperationFailed {
-        runtime_id: request.runtime_id.clone(),
+        runtime_id: requested_runtime_id,
         code: "workspace_worker_create_missing_summary".to_string(),
         message: "Runtime completed worker creation without returning a Worker summary".to_string(),
     })?;
     let worker_record = record_worker_summary(
-        &api,
+        api,
         &worker,
         display_name.as_str(),
         worker.profile.clone(),
@@ -4349,13 +4607,9 @@ async fn create_workspace_worker(
     )?;
     if let Some(working_directory) = worker.working_directory.as_ref() {
         let workdir_record =
-            workdir_record_from_summary(&api, worker.runtime_id.as_str(), working_directory);
+            workdir_record_from_summary(api, worker.runtime_id.as_str(), working_directory);
         api.store.upsert_workdir_registry(&workdir_record)?;
-        link_worker_to_workdir(
+        link_worker_to_workdir(api, &worker_record, &working_directory.working_directory_id)?;
-            &api,
-            &worker_record,
-            &working_directory.working_directory_id,
-        )?;
     }
     if let Some(workdir_id) = selected_working_directory_id.as_deref() {
         if api
@@ -4370,7 +4624,7 @@ async fn create_workspace_worker(
             {
                 if let Some(status) = result.working_directory {
                     let record = workdir_record_from_summary(
-                        &api,
+                        api,
                         worker.runtime_id.as_str(),
                         &status.summary,
                     );
@@ -4383,7 +4637,7 @@ async fn create_workspace_worker(
             .get_workdir_registry(&api.config.workspace_id, workdir_id)?
             .is_some()
         {
-            link_worker_to_workdir(&api, &worker_record, workdir_id)?;
+            link_worker_to_workdir(api, &worker_record, workdir_id)?;
         }
     }
     let runtime_id = worker.runtime_id.clone();
@@ -4395,14 +4649,14 @@ async fn create_workspace_worker(
         encode_path_segment(&runtime_id),
         encode_path_segment(&worker_id)
     );
-    Ok(Json(BrowserCreateWorkerResponse {
+    Ok(BrowserCreateWorkerResponse {
         workspace_id,
         runtime_id,
         worker_id,
         console_href,
         worker,
         diagnostics: result.diagnostics,
-    }))
+    })
 }
 
 async fn post_internal_runtime_resource_fetch(
@@ -6749,6 +7003,7 @@ fn workspace_id_mismatch_error() -> ApiError {
     )
 }
 
+#[derive(Debug)]
 struct ApiError {
     error: Error,
     diagnostics: Vec<RuntimeDiagnostic>,
@@ -6762,6 +7017,22 @@ impl From<Error> for ApiError {
                 severity: DiagnosticSeverity::Error,
                 message: sanitize_backend_error(message),
             }],
+            Error::Ticket(ticket_error) => vec![RuntimeDiagnostic {
+                code: match ticket_error {
+                    ticket::TicketError::NotFound(_) => "ticket_not_found",
+                    ticket::TicketError::Ambiguous { .. } => "ticket_ambiguous",
+                    ticket::TicketError::Locked { .. } => "ticket_locked",
+                    ticket::TicketError::Conflict(_) => "ticket_conflict",
+                    ticket::TicketError::InvalidPathComponent(_)
+                    | ticket::TicketError::PathEscapesRoot { .. } => "invalid_ticket_request",
+                    ticket::TicketError::Io { .. }
+                    | ticket::TicketError::Parse { .. }
+                    | ticket::TicketError::Sqlite(_) => "ticket_backend_error",
+                }
+                .to_string(),
+                severity: DiagnosticSeverity::Error,
+                message: sanitize_backend_error(&ticket_error.to_string()),
+            }],
             _ => Vec::new(),
         };
         Self { error, diagnostics }
@@ -6778,6 +7049,16 @@ impl IntoResponse for ApiError {
     fn into_response(self) -> Response {
         let status = match &self.error {
             Error::InvalidRuntimeIdentifier { .. } => StatusCode::BAD_REQUEST,
+            Error::Ticket(ticket::TicketError::NotFound(_)) => StatusCode::NOT_FOUND,
+            Error::Ticket(
+                ticket::TicketError::Ambiguous { .. }
+                | ticket::TicketError::Locked { .. }
+                | ticket::TicketError::Conflict(_),
+            ) => StatusCode::CONFLICT,
+            Error::Ticket(
+                ticket::TicketError::InvalidPathComponent(_)
+                | ticket::TicketError::PathEscapesRoot { .. },
+            ) => StatusCode::BAD_REQUEST,
             Error::InvalidRecordId(_)
             | Error::MissingFrontmatter(_)
             | Error::UnknownHost(_)
@@ -6896,6 +7177,21 @@ mod tests {
     const TEST_REPOSITORY_ID: &str = "main";
     const TEST_CREATED_AT: &str = "2026-06-23T06:43:28Z";
 
+    #[test]
+    fn ticket_api_errors_preserve_http_status() {
+        let not_found = ApiError::from(Error::Ticket(ticket::TicketError::NotFound(
+            "0000000000000".to_string(),
+        )))
+        .into_response();
+        assert_eq!(not_found.status(), StatusCode::NOT_FOUND);
+
+        let conflict = ApiError::from(Error::Ticket(ticket::TicketError::Conflict(
+            "invalid transition".to_string(),
+        )))
+        .into_response();
+        assert_eq!(conflict.status(), StatusCode::CONFLICT);
+    }
+
     #[test]
     fn backend_worker_projection_preserves_missing_rows_links_and_redacts_paths() {
         let worker = WorkerRegistryRecord {
@@ -7669,6 +7965,127 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn ticket_browser_endpoints_mutate_typed_backend_and_return_thread() {
+        let dir = tempfile::tempdir().unwrap();
+        let api = test_api(dir.path()).await;
+        let Json(created) = scoped_ticket_backend_operation(
+            State(api.clone()),
+            AxumPath(ScopedWorkspacePath {
+                workspace_id: TEST_WORKSPACE_ID.to_string(),
+            }),
+            Json(TicketBackendOperation::Create {
+                input: ticket::NewTicket::new("Browser Ticket API"),
+            }),
+        )
+        .await
+        .unwrap();
+        let ticket_id = match created {
+            TicketBackendHttpResponse::Ok {
+                result: ticket::TicketBackendOperationResult::TicketRef(ticket_ref),
+            } => ticket_ref.id,
+            other => panic!("unexpected create response: {other:?}"),
+        };
+        let path = || ScopedRecordPath {
+            workspace_id: TEST_WORKSPACE_ID.to_string(),
+            id: ticket_id.clone(),
+        };
+
+        let Json(edited) = scoped_edit_ticket_item(
+            State(api.clone()),
+            AxumPath(path()),
+            Json(BrowserEditTicketRequest {
+                title: Some("Browser Ticket API edited".to_string()),
+                body: Some("Updated from the Browser API.".to_string()),
+                old_string: None,
+                new_string: None,
+                replace_all: false,
+                target: Some(TicketTargetEdit::Set {
+                    repository_id: "main".to_string(),
+                    ref_selector: Some("feature/api".to_string()),
+                }),
+                author: Some("browser-user".to_string()),
+            }),
+        )
+        .await
+        .unwrap();
+        assert_eq!(edited.title, "Browser Ticket API edited");
+        assert_eq!(edited.body, "Updated from the Browser API.");
+        assert_eq!(edited.repository_id.as_deref(), Some("main"));
+        assert_eq!(edited.ref_selector.as_deref(), Some("feature/api"));
+
+        let Json(commented) = scoped_append_ticket_event(
+            State(api.clone()),
+            AxumPath(path()),
+            Json(BrowserAppendTicketEventRequest {
+                role: BrowserTicketThreadRole::Comment,
+                body: "API comment".to_string(),
+                author: Some("browser-user".to_string()),
+            }),
+        )
+        .await
+        .unwrap();
+        assert!(commented.events.iter().any(|event| {
+            event.kind == "comment" && event.body.as_deref() == Some("API comment")
+        }));
+
+        let Json(ready) = scoped_transition_ticket_state(
+            State(api.clone()),
+            AxumPath(path()),
+            Json(BrowserTransitionTicketStateRequest {
+                state: TicketWorkflowState::Ready,
+                reason: Some("intake complete".to_string()),
+                body: Some("Ready for queue".to_string()),
+                author: Some("browser-user".to_string()),
+            }),
+        )
+        .await
+        .unwrap();
+        assert_eq!(ready.state, "ready");
+
+        let Json(queued) = scoped_queue_ticket(
+            State(api.clone()),
+            AxumPath(path()),
+            Json(BrowserQueueTicketRequest {
+                queued_by: Some("browser-user".to_string()),
+            }),
+        )
+        .await
+        .unwrap();
+        assert_eq!(queued.state, "queued");
+        assert_eq!(queued.queued_by.as_deref(), Some("browser-user"));
+
+        let Json(reviewed) = scoped_review_ticket(
+            State(api.clone()),
+            AxumPath(path()),
+            Json(BrowserReviewTicketRequest {
+                result: TicketReviewResult::Approve,
+                body: "API review".to_string(),
+                author: Some("reviewer".to_string()),
+            }),
+        )
+        .await
+        .unwrap();
+        assert!(reviewed.events.iter().any(|event| {
+            event.kind == "review" && event.body.as_deref() == Some("API review")
+        }));
+
+        let Json(closed) = scoped_close_ticket(
+            State(api),
+            AxumPath(path()),
+            Json(BrowserCloseTicketRequest {
+                resolution: "Closed through the Browser API.".to_string(),
+            }),
+        )
+        .await
+        .unwrap();
+        assert_eq!(closed.state, "closed");
+        assert_eq!(
+            closed.resolution.as_deref(),
+            Some("Closed through the Browser API.")
+        );
+    }
+
     #[tokio::test]
     async fn ticket_backend_endpoint_uses_workspace_sqlite_backend() {
         let dir = tempfile::tempdir().unwrap();

crates/workspace-server/src/store.rs

@@ -82,6 +82,11 @@ const MIGRATIONS: &[Migration] = &[
         name: "objective mutation audit events",
         apply: create_objective_event_tables,
     },
+    Migration {
+        version: 14,
+        name: "remove unused control-plane Ticket tables",
+        apply: remove_unused_control_plane_ticket_tables,
+    },
 ];
 
 struct Migration {
@@ -2156,6 +2161,20 @@ CREATE TABLE IF NOT EXISTS memory_staging_resolutions (
     Ok(())
 }
 
+fn remove_unused_control_plane_ticket_tables(conn: &Connection) -> Result<()> {
+    conn.execute_batch(
+        r#"
+DROP TABLE IF EXISTS ticket_target_paths;
+DROP TABLE IF EXISTS ticket_worker_links;
+DROP TABLE IF EXISTS ticket_targets;
+DROP TABLE IF EXISTS ticket_relations;
+DROP TABLE IF EXISTS ticket_events;
+DROP TABLE IF EXISTS tickets;
+"#,
+    )?;
+    Ok(())
+}
+
 fn create_objective_event_tables(conn: &Connection) -> Result<()> {
     conn.execute_batch(
         r#"
@@ -2649,68 +2668,6 @@ CREATE TABLE IF NOT EXISTS workspaces (
     updated_at TEXT NOT NULL
 );
 
-CREATE TABLE IF NOT EXISTS tickets (
-    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
-    ticket_id TEXT PRIMARY KEY,
-    title TEXT NOT NULL,
-    state TEXT NOT NULL,
-    priority TEXT,
-    assignee_kind TEXT,
-    assignee_key TEXT,
-    assignee_display TEXT,
-    body_md TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    closed_at TEXT,
-    resolution_event_id TEXT
-);
-
-CREATE TABLE IF NOT EXISTS ticket_events (
-    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
-    event_id TEXT PRIMARY KEY,
-    ticket_id TEXT NOT NULL REFERENCES tickets(ticket_id) ON DELETE CASCADE,
-    event_seq INTEGER NOT NULL,
-    kind TEXT NOT NULL,
-    activity_id TEXT,
-    author_kind TEXT NOT NULL,
-    author_key TEXT NOT NULL,
-    author_display TEXT NOT NULL,
-    author_source_kind TEXT,
-    author_source_key TEXT,
-    created_at TEXT NOT NULL,
-    body_md TEXT,
-    subject_kind TEXT,
-    subject_id TEXT,
-    previous_state TEXT,
-    new_state TEXT,
-    status TEXT,
-    artifact_id TEXT,
-    worker_ref_kind TEXT,
-    worker_ref_key TEXT,
-    worker_display TEXT,
-    host_ref_kind TEXT,
-    host_ref_key TEXT,
-    host_display TEXT,
-    repository_id TEXT,
-    caused_by_event_id TEXT,
-    UNIQUE (ticket_id, event_seq)
-);
-
-CREATE TABLE IF NOT EXISTS ticket_relations (
-    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
-    source_ticket_id TEXT NOT NULL REFERENCES tickets(ticket_id) ON DELETE CASCADE,
-    target_ticket_id TEXT NOT NULL REFERENCES tickets(ticket_id) ON DELETE CASCADE,
-    kind TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    author_kind TEXT NOT NULL,
-    author_key TEXT NOT NULL,
-    author_display TEXT NOT NULL,
-    author_source_kind TEXT,
-    author_source_key TEXT,
-    note TEXT,
-    PRIMARY KEY (source_ticket_id, target_ticket_id, kind)
-);
-
 CREATE TABLE IF NOT EXISTS objectives (
     workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
     objective_id TEXT PRIMARY KEY,
@@ -2793,43 +2750,6 @@ CREATE TABLE IF NOT EXISTS repositories (
     updated_at TEXT NOT NULL
 );
 
-CREATE TABLE IF NOT EXISTS ticket_targets (
-    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
-    ticket_id TEXT NOT NULL REFERENCES tickets(ticket_id) ON DELETE CASCADE,
-    target_id TEXT NOT NULL,
-    repository_id TEXT NOT NULL REFERENCES repositories(repository_id) ON DELETE CASCADE,
-    role TEXT NOT NULL,
-    intent TEXT NOT NULL,
-    ref_selector TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (ticket_id, target_id)
-);
-
-CREATE TABLE IF NOT EXISTS ticket_target_paths (
-    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
-    ticket_id TEXT NOT NULL,
-    target_id TEXT NOT NULL,
-    path TEXT NOT NULL,
-    PRIMARY KEY (ticket_id, target_id, path),
-    FOREIGN KEY (ticket_id, target_id) REFERENCES ticket_targets(ticket_id, target_id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS ticket_worker_links (
-    workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
-    ticket_id TEXT NOT NULL REFERENCES tickets(ticket_id) ON DELETE CASCADE,
-    worker_ref_kind TEXT NOT NULL,
-    worker_ref_key TEXT NOT NULL,
-    worker_display TEXT,
-    role TEXT NOT NULL,
-    status TEXT NOT NULL,
-    activity_id TEXT,
-    assigned_at TEXT,
-    released_at TEXT,
-    last_event_id TEXT,
-    PRIMARY KEY (ticket_id, worker_ref_kind, worker_ref_key, role)
-);
-
 CREATE TABLE IF NOT EXISTS artifacts (
     workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id) ON DELETE CASCADE,
     artifact_id TEXT PRIMARY KEY,
@@ -2904,13 +2824,40 @@ mod tests {
     use super::*;
     use std::collections::BTreeSet;
 
+    #[test]
+    fn removes_unused_control_plane_ticket_tables() {
+        let conn = Connection::open_in_memory().unwrap();
+        conn.execute_batch(
+            r#"
+CREATE TABLE tickets (ticket_id TEXT PRIMARY KEY);
+CREATE TABLE ticket_events (event_id TEXT PRIMARY KEY, ticket_id TEXT REFERENCES tickets(ticket_id));
+CREATE TABLE ticket_relations (source_ticket_id TEXT, target_ticket_id TEXT);
+CREATE TABLE ticket_targets (ticket_id TEXT, target_id TEXT, PRIMARY KEY (ticket_id, target_id));
+CREATE TABLE ticket_target_paths (ticket_id TEXT, target_id TEXT, path TEXT);
+CREATE TABLE ticket_worker_links (ticket_id TEXT, worker_ref_key TEXT);
+"#,
+        )
+        .unwrap();
+        remove_unused_control_plane_ticket_tables(&conn).unwrap();
+        for table in [
+            "tickets",
+            "ticket_events",
+            "ticket_relations",
+            "ticket_targets",
+            "ticket_target_paths",
+            "ticket_worker_links",
+        ] {
+            assert!(!table_exists(&conn, table).unwrap(), "{table} still exists");
+        }
+    }
+
     #[tokio::test]
     async fn migrates_sqlite_and_preserves_workspace_record() {
         let dir = tempfile::tempdir().unwrap();
         let db = dir.path().join("control-plane.sqlite");
         let store = SqliteWorkspaceStore::open(&db).unwrap();
 
-        assert_eq!(store.schema_version().await.unwrap(), 13);
+        assert_eq!(store.schema_version().await.unwrap(), 14);
 
         let record = WorkspaceRecord {
             workspace_id: "local-dev".to_string(),
@@ -2923,7 +2870,7 @@ mod tests {
         store.upsert_workspace(&record).await.unwrap();
 
         let reopened = SqliteWorkspaceStore::open(&db).unwrap();
-        assert_eq!(reopened.schema_version().await.unwrap(), 13);
+        assert_eq!(reopened.schema_version().await.unwrap(), 14);
         assert_eq!(
             reopened.get_workspace("local-dev").await.unwrap(),
             Some(record)
@@ -2939,9 +2886,6 @@ mod tests {
         let tables = table_names(&conn);
         for expected in [
             "workspaces",
-            "tickets",
-            "ticket_events",
-            "ticket_relations",
             "objectives",
             "objective_ticket_links",
             "objective_resources",
@@ -2949,9 +2893,6 @@ mod tests {
             "workspace_memory_documents",
             "memory_staging_resolutions",
             "repositories",
-            "ticket_targets",
-            "ticket_target_paths",
-            "ticket_worker_links",
             "artifacts",
             "audit_events",
             "worker_registry",
@@ -2977,6 +2918,12 @@ mod tests {
             "actors",
             "validation_results",
             "ci_results",
+            "tickets",
+            "ticket_events",
+            "ticket_relations",
+            "ticket_targets",
+            "ticket_target_paths",
+            "ticket_worker_links",
         ] {
             assert!(
                 !tables.contains(forbidden),
@@ -3017,39 +2964,6 @@ mod tests {
                 "updated_at",
             ],
         );
-        assert_columns(
-            &conn,
-            "ticket_events",
-            [
-                "workspace_id",
-                "event_id",
-                "ticket_id",
-                "event_seq",
-                "kind",
-                "activity_id",
-                "author_kind",
-                "author_key",
-                "author_display",
-                "author_source_kind",
-                "author_source_key",
-                "created_at",
-                "body_md",
-                "subject_kind",
-                "subject_id",
-                "previous_state",
-                "new_state",
-                "status",
-                "artifact_id",
-                "worker_ref_kind",
-                "worker_ref_key",
-                "worker_display",
-                "host_ref_kind",
-                "host_ref_key",
-                "host_display",
-                "repository_id",
-                "caused_by_event_id",
-            ],
-        );
         assert_columns(
             &conn,
             "worker_registry",
@@ -3098,7 +3012,7 @@ mod tests {
             ],
         );
 
-        for table in ["workspaces", "repositories", "ticket_events", "artifacts"] {
+        for table in ["workspaces", "repositories", "artifacts"] {
             let columns = table_columns(&conn, table).unwrap();
             for forbidden_column in [
                 "payload",
@@ -3144,7 +3058,7 @@ mod tests {
         .unwrap();
 
         let store = SqliteWorkspaceStore::from_connection(conn).unwrap();
-        assert_eq!(store.schema_version().await.unwrap(), 13);
+        assert_eq!(store.schema_version().await.unwrap(), 14);
 
         store
             .with_conn(|conn| {
@@ -3152,9 +3066,6 @@ mod tests {
                 for expected in [
                     "workspaces",
                     "repositories",
-                    "tickets",
-                    "ticket_events",
-                    "ticket_worker_links",
                     "artifacts",
                     "audit_events",
                     "workspace_memory_documents",
@@ -3172,7 +3083,19 @@ mod tests {
                         "missing {expected} after upgrade"
                     );
                 }
-                for forbidden in ["runs", "hosts", "workers", "actors", "validation_results"] {
+                for forbidden in [
+                    "runs",
+                    "hosts",
+                    "workers",
+                    "actors",
+                    "validation_results",
+                    "tickets",
+                    "ticket_events",
+                    "ticket_relations",
+                    "ticket_targets",
+                    "ticket_target_paths",
+                    "ticket_worker_links",
+                ] {
                     assert!(
                         !tables.contains(forbidden),
                         "upgraded schema must not retain forbidden canonical table {forbidden}"
@@ -3238,7 +3161,7 @@ mod tests {
     #[tokio::test]
     async fn repository_records_round_trip() {
         let store = SqliteWorkspaceStore::in_memory().unwrap();
-        assert_eq!(store.schema_version().await.unwrap(), 13);
+        assert_eq!(store.schema_version().await.unwrap(), 14);
         let workspace = WorkspaceRecord {
             workspace_id: "local-dev".to_string(),
             owner_account_id: None,
@@ -3276,7 +3199,7 @@ mod tests {
     #[tokio::test]
     async fn memory_authority_records_round_trip_and_close_staging() {
         let store = SqliteWorkspaceStore::in_memory().unwrap();
-        assert_eq!(store.schema_version().await.unwrap(), 13);
+        assert_eq!(store.schema_version().await.unwrap(), 14);
         let workspace = WorkspaceRecord {
             workspace_id: "local-dev".to_string(),
             owner_account_id: None,
@@ -3450,7 +3373,7 @@ mod tests {
     #[tokio::test]
     async fn account_and_login_records_round_trip() {
         let store = SqliteWorkspaceStore::in_memory().unwrap();
-        assert_eq!(store.schema_version().await.unwrap(), 13);
+        assert_eq!(store.schema_version().await.unwrap(), 14);
         let now = "2026-07-22T00:00:00Z".to_string();
         let account = AccountRecord {
             account_id: "acct-user-alice".to_string(),