fix sync job subscription slice filtering

Add slice_uri field to JobStatus struct and implement proper filtering in GraphQL subscriptions to prevent cross-slice job updates from appearing on the wrong slice's sync page.

- Add slice_uri to JobStatus struct in jobs.rs
- Update all JobStatus creations to include slice_uri from payload or database
- Implement slice filtering in syncJobUpdated subscription
- Add sliceUri field to SyncJob GraphQL type

api/src/graphql/schema_ext/sync.rs

···
         })
     }));
 
+    job = job.field(Field::new("sliceUri", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let container = ctx.parent_value.try_downcast_ref::<JobStatusContainer>()?;
+            Ok(Some(GraphQLValue::from(container.status.slice_uri.clone())))
+        })
+    }));
+
     job = job.field(Field::new("status", TypeRef::named_nn(TypeRef::STRING), |ctx| {
         FieldFuture::new(async move {
             let container = ctx.parent_value.try_downcast_ref::<JobStatusContainer>()?;
···
                 let mut receiver = sender_lock.subscribe();
                 drop(sender_lock); // Release lock
 
+                // Get optional slice filter from arguments
+                let slice_filter: Option<String> = ctx.args.get("slice")
+                    .and_then(|val| val.string().ok())
+                    .map(|s| s.to_string());
+
                 let stream = async_stream::stream! {
                     while let Ok(job_status) = receiver.recv().await {
                         // Filter by job_id if provided
···
                             }
                         }
 
-                        // Filter by slice_uri if provided (need to query for slice_uri)
-                        // For now, skip slice filtering since JobStatus doesn't include slice_uri
-                        // TODO: Add slice_uri to JobStatus or query it separately
+                        // Filter by slice_uri if provided
+                        if let Some(ref filter_slice) = slice_filter {
+                            if &job_status.slice_uri != filter_slice {
+                                continue;
+                            }
+                        }
 
                         // Convert to GraphQL value and yield
                         let container = JobStatusContainer { status: job_status };

api/src/jobs.rs

···
     // Publish job running status to subscribers
     let running_status = JobStatus {
         job_id: payload.job_id,
+        slice_uri: payload.slice_uri.clone(),
         status: "running".to_string(),
         created_at: now,
         started_at: Some(now),
···
             // Publish job status update to GraphQL subscribers
             let job_status = JobStatus {
                 job_id: payload.job_id,
+                slice_uri: payload.slice_uri.clone(),
                 status: "completed".to_string(),
                 created_at: chrono::Utc::now(),
                 started_at: Some(chrono::Utc::now()),
···
             // Publish job status update to GraphQL subscribers
             let job_status = JobStatus {
                 job_id: payload.job_id,
+                slice_uri: payload.slice_uri.clone(),
                 status: "failed".to_string(),
                 created_at: chrono::Utc::now(),
                 started_at: Some(chrono::Utc::now()),
···
     // Publish job creation event to subscribers
     let job_status = JobStatus {
         job_id,
+        slice_uri: slice_uri.clone(),
         status: "pending".to_string(),
         created_at: chrono::Utc::now(),
         started_at: None,
···
 pub struct JobStatus {
     /// Unique identifier for the job
     pub job_id: Uuid,
+    /// Slice URI this job belongs to
+    pub slice_uri: String,
     /// Current status: "pending", "running", "completed", or "failed"
     pub status: String,
     /// Timestamp when job was enqueued
···
 
         return Ok(Some(JobStatus {
             job_id,
+            slice_uri: result.slice_uri,
             status: result.status,
             created_at: result.created_at,
             started_at: Some(result.created_at),
···
 
     match queue_row {
         Some(row) => {
+            // Extract slice_uri from payload JSON
+            let slice_uri = row.payload_json
+                .as_ref()
+                .and_then(|json| json.get("slice_uri"))
+                .and_then(|v| v.as_str())
+                .unwrap_or_default()
+                .to_string();
+
             // Determine status based on attempt_at timestamp
             let status = if row.attempt_at.is_none() {
                 "completed".to_string()
···
 
             Ok(Some(JobStatus {
                 job_id,
+                slice_uri,
                 status: status.clone(),
                 created_at: row.created_at.unwrap_or_else(chrono::Utc::now),
                 started_at: if status == "running" || status == "completed" {
···
 
         results.push(JobStatus {
             job_id: row.job_id.unwrap_or_else(Uuid::new_v4),
+            slice_uri: row.slice_uri.clone().unwrap_or_default(),
             status: row.status.unwrap_or_default(),
             created_at: row.created_at.unwrap_or_else(chrono::Utc::now),
             started_at: row.created_at,
···
 
         results.push(JobStatus {
             job_id: row.job_id.unwrap_or_else(Uuid::new_v4),
+            slice_uri: row.slice_uri.clone().unwrap_or_default(),
             status: row.status.unwrap_or_default(),
             created_at: row.created_at.unwrap_or_else(chrono::Utc::now),
             started_at: row.created_at,
···
     // Publish job status update for subscribers
     let job_status = JobStatus {
         job_id,
+        slice_uri,
         status: "cancelled".to_string(),
         created_at: now,
         started_at: None,

frontend-v2/schema.graphql

···
 type SyncJob {
   id: ID!
   jobId: String!
+  sliceUri: String!
   status: String!
   createdAt: String!
   startedAt: String