1use crate::backends::{ExternalBackend, ExternalId, ExternalTask, Status};
2use crate::engine::dependencies;
3use crate::engine::events::TaskEvent;
4use crate::store::{self, TaskStatus, TaskStore};
5use serde::{Deserialize, Serialize};
6use std::fmt;
7use std::fmt::Debug;
8use std::fmt::Formatter;
9use std::sync::Arc;
10use tokio::sync::broadcast::Sender;
11
12pub fn is_internal_id(id: &str) -> bool {
14 id.starts_with("internal:")
15}
16
17pub fn parse_internal_id(id: &str) -> Option<i64> {
19 id.strip_prefix("internal:")?.parse().ok()
20}
21
22pub fn status_to_task_status(status: Status) -> TaskStatus {
24 match status {
25 Status::New => TaskStatus::New,
26 Status::Routed => TaskStatus::Routed,
27 Status::InProgress => TaskStatus::InProgress,
28 Status::Done => TaskStatus::Done,
29 Status::Blocked => TaskStatus::Blocked,
30 Status::InReview => TaskStatus::InReview,
31 Status::Approved => TaskStatus::Approved,
32 Status::NeedsReview => TaskStatus::NeedsReview,
33 Status::Waiting => TaskStatus::Waiting,
34 }
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(rename_all = "snake_case")]
39pub enum TaskType {
40 External,
41 Internal,
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
45pub struct CreateTaskRequest {
46 pub title: String,
47 pub body: String,
48 pub task_type: TaskType,
49 pub labels: Vec<String>,
50 pub source: String,
51 pub source_id: String,
52}
53
54#[derive(Debug, Clone, Default, Serialize, Deserialize)]
55pub struct TaskFilter {
56 pub status: Option<String>,
57 pub source: Option<String>,
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62#[expect(
63 clippy::large_enum_variant,
64 reason = "tasks are few and boxing would touch every match"
65)]
66pub enum Task {
67 External(ExternalTask),
68 Internal(store::Task),
69}
70
71#[derive(Debug, Clone, Default)]
74struct TaskSnapshot {
75 old_status: Option<String>,
76 agent: Option<String>,
77 model: Option<String>,
78 branch: Option<String>,
79 pr_number: Option<String>,
80 error: Option<String>,
81 title: Option<String>,
82 summary: Option<String>,
83 duration_seconds: Option<f64>,
84}
85
86pub struct TaskManager {
87 backend: Arc<dyn ExternalBackend>,
88 store: Option<Arc<TaskStore>>,
90 repo: String,
92 event_tx: Option<Sender<TaskEvent>>,
94}
95
96impl Debug for TaskManager {
97 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
98 f.debug_struct("TaskManager")
99 .field("repo", &self.repo)
100 .finish_non_exhaustive()
101 }
102}
103
104impl Clone for TaskManager {
105 fn clone(&self) -> Self {
106 Self {
107 backend: Arc::clone(&self.backend),
108 store: self.store.clone(),
109 repo: self.repo.clone(),
110 event_tx: self.event_tx.clone(),
111 }
112 }
113}
114
115impl TaskManager {
116 #[cfg(test)]
117 pub fn new(backend: Arc<dyn ExternalBackend>) -> Self {
118 Self {
119 backend,
120 store: None,
121 repo: String::new(),
122 event_tx: None,
123 }
124 }
125
126 pub fn with_store(
128 backend: Arc<dyn ExternalBackend>,
129 store: Arc<TaskStore>,
130 repo: String,
131 ) -> Self {
132 Self {
133 backend,
134 store: Some(store),
135 repo,
136 event_tx: None,
137 }
138 }
139
140 pub fn with_events(
142 backend: Arc<dyn ExternalBackend>,
143 store: Arc<TaskStore>,
144 repo: String,
145 event_tx: Sender<TaskEvent>,
146 ) -> Self {
147 Self {
148 backend,
149 store: Some(store),
150 repo,
151 event_tx: Some(event_tx),
152 }
153 }
154
155 pub async fn create_task(&self, req: CreateTaskRequest) -> anyhow::Result<Task> {
156 match req.task_type {
157 TaskType::Internal => {
158 let store = self
159 .store
160 .as_ref()
161 .ok_or_else(|| anyhow::anyhow!("store required for internal tasks"))?;
162 let id = store
163 .create_internal(
164 &self.repo,
165 &req.title,
166 &req.body,
167 &req.source,
168 &req.source_id,
169 None,
170 )
171 .await?;
172 let task = store.get(id).await?;
173 Ok(Task::Internal(task))
174 }
175 TaskType::External => {
176 let ext_id = self
177 .backend
178 .create_task(&req.title, &req.body, &req.labels)
179 .await?;
180 let task = self.backend.get_task(&ext_id).await?;
181 Ok(Task::External(task))
182 }
183 }
184 }
185
186 pub async fn get_task(&self, id: i64) -> anyhow::Result<Task> {
187 if let Some(ref store) = self.store
189 && let Ok(task) = store.get(id).await
190 && task.origin == "internal"
191 {
192 return Ok(Task::Internal(task));
193 }
194 let ext_id = ExternalId(id.to_string());
198 match self.backend.get_task(&ext_id).await {
199 Ok(external) => Ok(Task::External(external)),
200 Err(external_err) => Err(anyhow::anyhow!(
201 "task {id} not found in store or externally (external: {external_err})"
202 )),
203 }
204 }
205
206 pub async fn list_tasks(&self, filter: TaskFilter) -> anyhow::Result<Vec<Task>> {
209 let mut tasks = Vec::new();
210
211 let is_all = filter.status.as_deref() == Some("all");
212
213 if let Some(status_str) = &filter.status {
214 if !is_all {
215 let task_status = TaskStatus::from_str(status_str)
216 .ok_or_else(|| anyhow::anyhow!(
217 "invalid status: '{status_str}'. allowed: new, routed, in_progress, needs_review, in_review, approved, blocked, waiting, done, all"
218 ))?;
219 let backend_status = match status_str.as_str() {
220 "new" => Status::New,
221 "routed" => Status::Routed,
222 "in_progress" => Status::InProgress,
223 "done" => Status::Done,
224 "blocked" => Status::Blocked,
225 "in_review" => Status::InReview,
226 "approved" => Status::Approved,
227 "needs_review" => Status::NeedsReview,
228 "waiting" => Status::Waiting,
229 _ => unreachable!(),
230 };
231
232 if let Some(ref store) = self.store {
234 let internal_tasks = store
235 .list_internal_by_status(&self.repo, task_status)
236 .await?;
237 for t in internal_tasks {
238 if let Some(ref source) = filter.source
239 && t.source != *source
240 {
241 continue;
242 }
243 tasks.push(Task::Internal(t));
244 }
245 }
246
247 let external_tasks = self.list_external_by_status(backend_status).await?;
249 for t in external_tasks {
250 tasks.push(Task::External(t));
251 }
252 }
253 } else if let Some(source) = &filter.source {
254 if let Some(ref store) = self.store {
256 let by_source = store.list_internal_by_source(&self.repo, source).await?;
257 for t in by_source {
258 tasks.push(Task::Internal(t));
259 }
260 }
261 }
262
263 if filter.status.is_none() || is_all {
265 let mut has_external_in_store = false;
266 let store_tasks = if let Some(ref store) = self.store {
267 if is_all {
268 let tasks = store.list_all(&self.repo).await?;
269 has_external_in_store = match store.has_external_tasks(&self.repo).await {
270 Ok(has_external) => has_external,
271 Err(e) => {
272 tracing::warn!(
273 repo = %self.repo,
274 error = %e,
275 "failed to check external task sentinel; using store-only list path"
276 );
277 true
278 }
279 };
280 tasks
281 } else {
282 let tasks = store.list_active(&self.repo).await?;
283 has_external_in_store = match store.has_external_tasks(&self.repo).await {
284 Ok(has_external) => has_external,
285 Err(e) => {
286 tracing::warn!(
287 repo = %self.repo,
288 error = %e,
289 "failed to check external task sentinel; using store-only list path"
290 );
291 true
292 }
293 };
294 tasks
295 }
296 } else {
297 vec![]
298 };
299
300 for t in store_tasks {
301 if t.origin == "internal" {
302 tasks.push(Task::Internal(t));
303 } else {
304 tasks.push(Task::External(store_task_to_external(&t)));
305 }
306 }
307
308 if !has_external_in_store {
309 let external_tasks = self.backend.list_all_tasks().await?;
310 for t in external_tasks {
311 tasks.push(Task::External(t));
312 }
313 }
314 }
315
316 Ok(tasks)
317 }
318
319 pub async fn list_all_external_tasks(&self) -> anyhow::Result<Vec<ExternalTask>> {
322 if let Some(ref store) = self.store {
323 let tasks = store.list_all_external(&self.repo).await?;
324 if !tasks.is_empty() {
325 return Ok(tasks.iter().map(store_task_to_external).collect());
326 }
327 }
328 self.backend.list_all_tasks().await
329 }
330
331 pub async fn list_external_by_status(
335 &self,
336 status: Status,
337 ) -> anyhow::Result<Vec<ExternalTask>> {
338 if let Some(ref store) = self.store {
339 let db_status = status_to_task_status(status);
340 let external = store.list_external_by_status(&self.repo, db_status).await?;
341 let has_external_in_store = if external.is_empty() {
344 match store.has_external_tasks(&self.repo).await {
345 Ok(has_external) => has_external,
346 Err(e) => {
347 tracing::warn!(
348 repo = %self.repo,
349 status = ?status,
350 error = %e,
351 "failed to check external task sentinel; skipping backend fallback"
352 );
353 true
354 }
355 }
356 } else {
357 true
358 };
359 if has_external_in_store {
360 let external: Vec<ExternalTask> =
361 external.iter().map(store_task_to_external).collect();
362 return Ok(external);
363 }
364 }
365 self.backend.list_by_status(status).await
366 }
367
368 pub async fn list_all_by_status(&self, status: Status) -> anyhow::Result<Vec<ExternalTask>> {
373 let mut tasks = Vec::new();
374
375 if let Some(ref store) = self.store {
377 let db_status = status_to_task_status(status);
378 let external = store.list_external_by_status(&self.repo, db_status).await?;
379 let has_external_in_store = if external.is_empty() {
382 match store.has_external_tasks(&self.repo).await {
383 Ok(has_external) => has_external,
384 Err(e) => {
385 tracing::warn!(
386 repo = %self.repo,
387 status = ?status,
388 error = %e,
389 "failed to check external task sentinel; skipping backend fallback"
390 );
391 true
392 }
393 }
394 } else {
395 true
396 };
397 if has_external_in_store {
398 tasks.extend(external.into_iter().map(|t| store_task_to_external(&t)));
399 } else {
400 tasks.extend(self.backend.list_by_status(status).await?);
402 }
403 } else {
404 tasks.extend(self.backend.list_by_status(status).await?);
406 }
407
408 if self.store.is_some()
410 && let Ok(internal) = self
411 .list_internal_by_status(status_to_task_status(status))
412 .await
413 {
414 tasks.extend(internal);
415 }
416
417 Ok(tasks)
418 }
419
420 pub async fn list_routable(&self) -> anyhow::Result<Vec<ExternalTask>> {
424 if let Some(ref store) = self.store {
425 let all_new = store.list_routable(&self.repo).await?;
426 let has_external_new = all_new.iter().any(|t| t.origin != "internal");
429 let tasks: Vec<ExternalTask> = all_new.iter().map(store_task_to_external).collect();
430 let has_external_in_store = if has_external_new {
431 true
432 } else {
433 match store.has_external_tasks(&self.repo).await {
434 Ok(has_external) => has_external,
435 Err(e) => {
436 tracing::warn!(
437 repo = %self.repo,
438 error = %e,
439 "failed to check external task sentinel; skipping backend fallback"
440 );
441 true
442 }
443 }
444 };
445 if has_external_in_store {
446 return Ok(tasks);
447 }
448 }
449
450 let mut tasks = self.backend.list_routable().await?;
452 if let Some(ref store) = self.store {
453 let internal_new = store
454 .list_internal_by_status(&self.repo, TaskStatus::New)
455 .await?;
456 for t in internal_new {
457 tasks.push(store_task_to_external(&t));
458 }
459 }
460 Ok(tasks)
461 }
462
463 pub async fn update_task_status(&self, id: &ExternalId, status: Status) -> anyhow::Result<()> {
467 self.update_task_status_with_duration(id, status, None)
468 .await
469 }
470
471 pub async fn update_task_status_and_result(
472 &self,
473 id: &ExternalId,
474 status: Status,
475 updates: &[(&str, serde_json::Value)],
476 ) -> anyhow::Result<()> {
477 let task_status = status_to_task_status(status);
478 self.release_dependents_if_done(task_status, &self.repo, &id.0)
479 .await;
480
481 let (pre_snapshot, snapshot_store_id) = self.read_task_snapshot(&id.0).await;
483
484 if is_internal_id(&id.0) {
485 let store = self
487 .store
488 .as_ref()
489 .ok_or_else(|| anyhow::anyhow!("store required for internal task status update"))?;
490 let store_id = snapshot_store_id
491 .ok_or_else(|| anyhow::anyhow!("internal task {} not found in store", id.0))?;
492
493 store
494 .update_status_and_fields(store_id, task_status, updates)
495 .await?;
496 self.publish_event(id, status, &pre_snapshot, &self.repo, None);
498 return Ok(());
499 }
500
501 if let Some(ref store) = self.store
503 && let Some(store_id) = snapshot_store_id
504 {
505 store
506 .update_status_and_fields(store_id, task_status, updates)
507 .await?;
508 }
509
510 if let Err(e) = self.backend.update_status(id, status).await {
512 tracing::warn!(
513 task_id = id.0,
514 ?status,
515 err = %e,
516 "failed to mirror status to backend — store is authoritative"
517 );
518 }
519
520 self.publish_event(id, status, &pre_snapshot, &self.repo, None);
522
523 Ok(())
524 }
525
526 pub async fn update_task_status_if(
531 &self,
532 id: &ExternalId,
533 status: Status,
534 expected_status: Status,
535 ) -> anyhow::Result<bool> {
536 let task_status = status_to_task_status(status);
537 self.release_dependents_if_done(task_status, &self.repo, &id.0)
538 .await;
539 let expected_task_status = status_to_task_status(expected_status);
540
541 let (pre_snapshot, snapshot_store_id) = self.read_task_snapshot(&id.0).await;
542
543 if is_internal_id(&id.0) {
544 let store = self
545 .store
546 .as_ref()
547 .ok_or_else(|| anyhow::anyhow!("store required for internal task status update"))?;
548 let store_id = snapshot_store_id
549 .ok_or_else(|| anyhow::anyhow!("internal task {} not found in store", id.0))?;
550 let updated = store
551 .update_status_if(store_id, task_status, expected_task_status)
552 .await?;
553 if updated {
554 self.publish_event(id, status, &pre_snapshot, &self.repo, None);
555 }
556 return Ok(updated);
557 }
558
559 if let Some(ref store) = self.store {
566 if let Some(store_id) = snapshot_store_id {
567 let updated = store
568 .update_status_if(store_id, task_status, expected_task_status)
569 .await?;
570 if !updated {
571 return Ok(false);
572 }
573 } else {
574 tracing::warn!(
575 task_id = id.0,
576 ?expected_task_status,
577 "update_task_status_if: external task has no store record — cannot perform conditional update"
578 );
579 return Ok(false);
580 }
581 } else {
582 tracing::warn!(
583 task_id = id.0,
584 ?expected_task_status,
585 "update_task_status_if: no store available — cannot perform conditional update for external task"
586 );
587 return Ok(false);
588 }
589
590 if let Err(e) = self.backend.update_status(id, status).await {
591 tracing::warn!(
592 task_id = id.0,
593 ?status,
594 err = %e,
595 "failed to mirror status to backend — store is authoritative"
596 );
597 }
598
599 self.publish_event(id, status, &pre_snapshot, &self.repo, None);
600 Ok(true)
601 }
602
603 pub async fn update_task_status_with_duration(
608 &self,
609 id: &ExternalId,
610 status: Status,
611 duration_seconds: Option<f64>,
612 ) -> anyhow::Result<()> {
613 let task_status = status_to_task_status(status);
614 self.release_dependents_if_done(task_status, &self.repo, &id.0)
615 .await;
616 let (pre_snapshot, snapshot_store_id) = self.read_task_snapshot(&id.0).await;
617
618 if is_internal_id(&id.0) {
619 let store = self
620 .store
621 .as_ref()
622 .ok_or_else(|| anyhow::anyhow!("store required for internal task status update"))?;
623 let store_id = snapshot_store_id
624 .ok_or_else(|| anyhow::anyhow!("internal task {} not found in store", id.0))?;
625 if task_status != TaskStatus::Blocked {
626 store.set_block_reason(store_id, None).await?;
627 }
628 store.update_status(store_id, task_status).await?;
629 self.publish_event(id, status, &pre_snapshot, &self.repo, duration_seconds);
630 return Ok(());
631 }
632
633 if let Some(ref store) = self.store
634 && let Some(store_id) = snapshot_store_id
635 {
636 if task_status != TaskStatus::Blocked {
637 store.set_block_reason(store_id, None).await?;
638 }
639 store.update_status(store_id, task_status).await?;
640 }
641
642 if let Err(e) = self.backend.update_status(id, status).await {
643 tracing::warn!(
644 task_id = id.0,
645 ?status,
646 err = %e,
647 "failed to mirror status to backend — store is authoritative"
648 );
649 }
650
651 self.publish_event(id, status, &pre_snapshot, &self.repo, duration_seconds);
652
653 Ok(())
654 }
655
656 async fn read_task_snapshot(&self, task_id: &str) -> (TaskSnapshot, Option<i64>) {
660 let Some(ref store) = self.store else {
661 return (TaskSnapshot::default(), None);
662 };
663 let Ok(Some(store_id)) = store.resolve_task_id(&self.repo, task_id).await else {
664 return (TaskSnapshot::default(), None);
665 };
666 let snapshot = Self::snapshot_for_store_id(store, store_id, task_id).await;
667 (snapshot, Some(store_id))
668 }
669
670 async fn snapshot_for_store_id(
674 store: &TaskStore,
675 store_id: i64,
676 metric_task_id: &str,
677 ) -> TaskSnapshot {
678 match store.get(store_id).await {
679 Ok(task) => {
680 let duration_seconds = store.latest_task_metric_duration(metric_task_id).await;
681 TaskSnapshot {
682 old_status: Some(task.status.as_str().to_string()),
683 agent: task.agent.clone(),
684 model: task.model.clone(),
685 branch: if task.branch.is_empty() {
686 None
687 } else {
688 Some(task.branch.clone())
689 },
690 pr_number: task.pr_number.map(|n| n.to_string()),
691 error: if task.last_error.is_empty() {
692 None
693 } else {
694 Some(task.last_error.clone())
695 },
696 title: if task.title.is_empty() {
697 None
698 } else {
699 Some(task.title.clone())
700 },
701 summary: if task.summary.is_empty() {
702 None
703 } else {
704 Some(task.summary.clone())
705 },
706 duration_seconds,
707 }
708 }
709 Err(e) => {
710 tracing::warn!(
711 task_id = store_id,
712 err = %e,
713 "failed to read task snapshot for event enrichment — event context will be empty"
714 );
715 TaskSnapshot::default()
716 }
717 }
718 }
719
720 async fn release_dependents_if_done(&self, status: TaskStatus, repo: &str, ext_id: &str) {
727 if status != TaskStatus::Done {
728 return;
729 }
730 if let Some(ref store) = self.store {
731 dependencies::clear_blocker_read_cache(store, repo, ext_id).await;
732 }
733 }
734
735 fn publish_event(
737 &self,
738 id: &ExternalId,
739 status: Status,
740 snapshot: &TaskSnapshot,
741 repo: &str,
742 duration_seconds: Option<f64>,
743 ) {
744 if let Some(ref tx) = self.event_tx {
745 let event = TaskEvent {
746 task_id: id.0.clone(),
747 repo: repo.to_string(),
748 old_status: snapshot.old_status.clone().unwrap_or_default(),
749 new_status: status.as_label().trim_start_matches("status:").to_string(),
750 agent: snapshot.agent.clone(),
751 model: snapshot.model.clone(),
752 pr_number: snapshot.pr_number.clone(),
753 branch: snapshot.branch.clone(),
754 review_context: None,
755 error: snapshot.error.clone(),
756 timestamp: chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string(),
757 title: snapshot.title.clone(),
758 summary: snapshot.summary.clone(),
759 duration_seconds: duration_seconds.or(snapshot.duration_seconds),
760 };
761 let _ = tx.send(event);
762 }
763 }
764
765 pub async fn mark_task_done_by_store_id(
771 &self,
772 store_id: i64,
773 repo: &str,
774 ext_id: &ExternalId,
775 ) -> anyhow::Result<()> {
776 self.update_task_status_by_store_id(store_id, repo, ext_id, Status::Done)
777 .await
778 }
779
780 pub async fn update_task_status_by_store_id(
788 &self,
789 store_id: i64,
790 repo: &str,
791 ext_id: &ExternalId,
792 status: Status,
793 ) -> anyhow::Result<()> {
794 let store = self
795 .store
796 .as_ref()
797 .ok_or_else(|| anyhow::anyhow!("store required for status update"))?;
798 let task_status = status_to_task_status(status);
799 self.release_dependents_if_done(task_status, repo, &ext_id.0)
800 .await;
801
802 let snapshot = Self::snapshot_for_store_id(store, store_id, &ext_id.0).await;
803 if task_status != TaskStatus::Blocked {
804 store.set_block_reason(store_id, None).await?;
805 }
806 store.update_status(store_id, task_status).await?;
807 self.publish_event(ext_id, status, &snapshot, repo, None);
808 Ok(())
809 }
810
811 pub async fn update_task_status_and_result_by_store_id(
814 &self,
815 store_id: i64,
816 repo: &str,
817 ext_id: &ExternalId,
818 status: Status,
819 updates: &[(&str, serde_json::Value)],
820 ) -> anyhow::Result<()> {
821 let store = self
822 .store
823 .as_ref()
824 .ok_or_else(|| anyhow::anyhow!("store required for status update"))?;
825 let task_status = status_to_task_status(status);
826 self.release_dependents_if_done(task_status, repo, &ext_id.0)
827 .await;
828
829 let snapshot = Self::snapshot_for_store_id(store, store_id, &ext_id.0).await;
830 store
831 .update_status_and_fields(store_id, task_status, updates)
832 .await?;
833 self.publish_event(ext_id, status, &snapshot, repo, None);
834 Ok(())
835 }
836
837 pub async fn list_internal_by_status(
840 &self,
841 status: TaskStatus,
842 ) -> anyhow::Result<Vec<ExternalTask>> {
843 let store = self
844 .store
845 .as_ref()
846 .ok_or_else(|| anyhow::anyhow!("store required"))?;
847 let tasks = store.list_internal_by_status(&self.repo, status).await?;
848 Ok(tasks
849 .into_iter()
850 .map(|t| store_task_to_external(&t))
851 .collect())
852 }
853
854 pub async fn list_all_internal(&self) -> anyhow::Result<Vec<store::Task>> {
856 let store = self
857 .store
858 .as_ref()
859 .ok_or_else(|| anyhow::anyhow!("store required"))?;
860 store.list_all_internal(&self.repo).await
861 }
862
863 pub async fn publish_task(&self, id: i64, labels: &[String]) -> anyhow::Result<ExternalId> {
864 let store = self
865 .store
866 .as_ref()
867 .ok_or_else(|| anyhow::anyhow!("store required for publish_task"))?;
868 let task = store.get(id).await?;
869 let ext_id = self
870 .backend
871 .create_task(&task.title, &task.body, labels)
872 .await?;
873 store.update_external_id(id, &ext_id.0).await?;
874 store.update_status(id, TaskStatus::New).await?;
875 Ok(ext_id)
876 }
877}
878
879pub fn store_task_to_external(t: &store::Task) -> ExternalTask {
882 let ext_id = t
883 .external_id
884 .clone()
885 .unwrap_or_else(|| format!("internal:{}", t.id));
886 ExternalTask {
887 id: ExternalId(ext_id),
888 title: t.title.clone(),
889 body: t.body.clone(),
890 state: "open".to_string(),
891 labels: {
892 let mut labels: Vec<String> = t
893 .labels
894 .iter()
895 .filter(|l| !l.starts_with("status:"))
896 .cloned()
897 .collect();
898 labels.push(format!("status:{}", t.status.as_str()));
899 labels
900 },
901 author: t.source.clone(),
902 created_at: t.created_at.clone(),
903 updated_at: t.updated_at.clone(),
904 url: t.url.clone(),
905 }
906}
907
908#[cfg(test)]
909mod tests {
910 use super::*;
911 use crate::backends::{ExternalId, ExternalTask, Mention};
912 use crate::store::{NewTask, TaskStore};
913 use async_trait::async_trait;
914 use std::sync::{Arc, Mutex};
915 use tokio::sync::broadcast;
916
917 type StatusTaskMap = Arc<Mutex<Vec<(Status, Vec<ExternalTask>)>>>;
918
919 struct MockBackend {
921 status_updates: Arc<Mutex<Vec<(String, Status)>>>,
922 status_tasks: StatusTaskMap,
923 routable_tasks: Arc<Mutex<Vec<ExternalTask>>>,
924 }
925
926 impl MockBackend {
927 fn new() -> Self {
928 Self {
929 status_updates: Arc::new(Mutex::new(vec![])),
930 status_tasks: Arc::new(Mutex::new(vec![])),
931 routable_tasks: Arc::new(Mutex::new(vec![])),
932 }
933 }
934
935 fn with_status_tasks(self, status: Status, tasks: Vec<ExternalTask>) -> Self {
936 self.status_tasks.lock().unwrap().push((status, tasks));
937 self
938 }
939
940 fn with_routable_tasks(self, tasks: Vec<ExternalTask>) -> Self {
941 *self.routable_tasks.lock().unwrap() = tasks;
942 self
943 }
944 }
945
946 #[async_trait]
947 impl ExternalBackend for MockBackend {
948 fn name(&self) -> &'static str {
949 "mock"
950 }
951 async fn create_task(
952 &self,
953 _t: &str,
954 _b: &str,
955 _l: &[String],
956 ) -> anyhow::Result<ExternalId> {
957 Ok(ExternalId("new".to_string()))
958 }
959 async fn get_task(&self, id: &ExternalId) -> anyhow::Result<ExternalTask> {
960 Ok(ExternalTask {
961 id: id.clone(),
962 title: "Mock".to_string(),
963 body: String::new(),
964 state: "open".to_string(),
965 labels: vec![],
966 author: "bot".to_string(),
967 created_at: "2026-01-01T00:00:00Z".to_string(),
968 updated_at: "2026-01-01T00:00:00Z".to_string(),
969 url: String::new(),
970 })
971 }
972 async fn list_by_status(&self, status: Status) -> anyhow::Result<Vec<ExternalTask>> {
973 Ok(self
974 .status_tasks
975 .lock()
976 .unwrap()
977 .iter()
978 .find(|(s, _)| *s == status)
979 .map(|(_, tasks)| tasks.clone())
980 .unwrap_or_default())
981 }
982 async fn list_routable(&self) -> anyhow::Result<Vec<ExternalTask>> {
983 Ok(self.routable_tasks.lock().unwrap().clone())
984 }
985 async fn post_comment(&self, _id: &ExternalId, _b: &str) -> anyhow::Result<()> {
986 Ok(())
987 }
988 async fn set_labels(&self, _id: &ExternalId, _l: &[String]) -> anyhow::Result<()> {
989 Ok(())
990 }
991 async fn remove_label(&self, _id: &ExternalId, _l: &str) -> anyhow::Result<()> {
992 Ok(())
993 }
994 async fn get_sub_issues(&self, _id: &ExternalId) -> anyhow::Result<Vec<ExternalId>> {
995 Ok(vec![])
996 }
997 async fn create_sub_task(
998 &self,
999 _p: &ExternalId,
1000 _t: &str,
1001 _b: &str,
1002 _l: &[String],
1003 ) -> anyhow::Result<ExternalId> {
1004 Ok(ExternalId("child".to_string()))
1005 }
1006 async fn ensure_status_label(&self, _l: &str) -> anyhow::Result<()> {
1007 Ok(())
1008 }
1009 async fn has_open_issue_with_title(&self, _t: &str, _l: &str) -> anyhow::Result<bool> {
1010 Ok(false)
1011 }
1012 async fn health_check(&self) -> anyhow::Result<()> {
1013 Ok(())
1014 }
1015 async fn is_pr_merged(&self, _b: &str) -> anyhow::Result<bool> {
1016 Ok(false)
1017 }
1018 async fn get_authenticated_user(&self) -> anyhow::Result<Option<String>> {
1019 Ok(Some("testbot".to_string()))
1020 }
1021 async fn get_mentions(&self, _s: &str) -> anyhow::Result<Vec<Mention>> {
1022 Ok(vec![])
1023 }
1024 async fn update_status(&self, id: &ExternalId, status: Status) -> anyhow::Result<()> {
1025 self.status_updates
1026 .lock()
1027 .unwrap()
1028 .push((id.0.clone(), status));
1029 Ok(())
1030 }
1031 }
1032
1033 #[tokio::test]
1034 async fn with_store_constructor_enables_dual_write() {
1035 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1036 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1037
1038 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1039
1040 assert!(tm.store.is_some(), "store should be set via with_store");
1041 assert_eq!(tm.repo, "owner/repo");
1042 }
1043
1044 #[tokio::test]
1045 async fn update_status_dual_writes_to_store_for_external_task() {
1046 let mock = MockBackend::new();
1047 let backend: Arc<dyn ExternalBackend> = Arc::new(mock);
1048 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1049
1050 store
1052 .create(&NewTask {
1053 external_id: Some("42".to_string()),
1054 repo: "owner/repo".to_string(),
1055 origin: "github".to_string(),
1056 title: "Test".to_string(),
1057 ..Default::default()
1058 })
1059 .await
1060 .unwrap();
1061
1062 let tm = TaskManager::with_store(
1063 Arc::clone(&backend),
1064 Arc::clone(&store),
1065 "owner/repo".to_string(),
1066 );
1067
1068 tm.update_task_status(&ExternalId("42".to_string()), Status::InProgress)
1070 .await
1071 .unwrap();
1072
1073 let task = store.get(1).await.unwrap();
1075 assert_eq!(
1076 task.status,
1077 TaskStatus::InProgress,
1078 "store should have updated status"
1079 );
1080 }
1081
1082 #[tokio::test]
1083 async fn update_status_skips_store_when_task_not_in_store() {
1084 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1085 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1086
1087 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1088
1089 let result = tm
1091 .update_task_status(&ExternalId("999".to_string()), Status::Done)
1092 .await;
1093 assert!(result.is_ok(), "should succeed even when task not in store");
1094 }
1095
1096 #[tokio::test]
1097 async fn update_status_works_without_store() {
1098 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1099
1100 let tm = TaskManager::new(backend);
1102
1103 let result = tm
1104 .update_task_status(&ExternalId("42".to_string()), Status::Routed)
1105 .await;
1106 assert!(
1107 result.is_ok(),
1108 "should work without store (backward compat)"
1109 );
1110 }
1111
1112 #[tokio::test]
1113 async fn update_status_writes_to_store_for_internal_task() {
1114 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1115 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1116
1117 let internal_id = store
1119 .create_internal("owner/repo", "Internal task", "body", "cron", "job:1", None)
1120 .await
1121 .unwrap();
1122
1123 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1124
1125 let id_str = format!("internal:{internal_id}");
1127 tm.update_task_status(&ExternalId(id_str), Status::Routed)
1128 .await
1129 .unwrap();
1130
1131 let task = store.get(internal_id).await.unwrap();
1133 assert_eq!(task.status, TaskStatus::Routed);
1134 }
1135
1136 #[tokio::test]
1137 async fn status_to_task_status_maps_all_variants() {
1138 assert_eq!(status_to_task_status(Status::New), TaskStatus::New);
1139 assert_eq!(status_to_task_status(Status::Routed), TaskStatus::Routed);
1140 assert_eq!(
1141 status_to_task_status(Status::InProgress),
1142 TaskStatus::InProgress
1143 );
1144 assert_eq!(status_to_task_status(Status::Done), TaskStatus::Done);
1145 assert_eq!(status_to_task_status(Status::Blocked), TaskStatus::Blocked);
1146 assert_eq!(
1147 status_to_task_status(Status::InReview),
1148 TaskStatus::InReview
1149 );
1150 assert_eq!(
1151 status_to_task_status(Status::NeedsReview),
1152 TaskStatus::NeedsReview
1153 );
1154 }
1155
1156 #[test]
1157 fn is_internal_id_detects_prefix() {
1158 assert!(is_internal_id("internal:5"));
1159 assert!(is_internal_id("internal:0"));
1160 assert!(!is_internal_id("42"));
1161 assert!(!is_internal_id(""));
1162 assert!(!is_internal_id("internal"));
1163 }
1164
1165 #[test]
1166 fn parse_internal_id_extracts_number() {
1167 assert_eq!(parse_internal_id("internal:5"), Some(5));
1168 assert_eq!(parse_internal_id("internal:0"), Some(0));
1169 assert_eq!(parse_internal_id("internal:abc"), None);
1170 assert_eq!(parse_internal_id("42"), None);
1171 assert_eq!(parse_internal_id(""), None);
1172 }
1173
1174 #[tokio::test]
1175 async fn create_internal_task_via_task_manager() {
1176 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1177 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1178 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1179
1180 let task = tm
1181 .create_task(CreateTaskRequest {
1182 title: "Internal task".to_string(),
1183 body: "Do something".to_string(),
1184 task_type: TaskType::Internal,
1185 labels: vec![],
1186 source: "cron".to_string(),
1187 source_id: "job:daily".to_string(),
1188 })
1189 .await
1190 .unwrap();
1191
1192 match task {
1193 Task::Internal(t) => {
1194 assert_eq!(t.title, "Internal task");
1195 assert_eq!(t.origin, "internal");
1196 assert!(
1197 t.external_id
1198 .as_deref()
1199 .is_some_and(|s| s.starts_with("internal:"))
1200 );
1201 }
1202 Task::External(_) => panic!("expected Internal variant"),
1203 }
1204 }
1205
1206 #[tokio::test]
1207 async fn create_internal_task_fails_without_store() {
1208 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1209 let tm = TaskManager::new(backend);
1210
1211 let result = tm
1212 .create_task(CreateTaskRequest {
1213 title: "No store".to_string(),
1214 body: String::new(),
1215 task_type: TaskType::Internal,
1216 labels: vec![],
1217 source: "manual".to_string(),
1218 source_id: String::new(),
1219 })
1220 .await;
1221
1222 assert!(result.is_err(), "should fail without store");
1223 }
1224
1225 #[tokio::test]
1228 async fn update_status_internal_task_not_found_returns_err_and_no_event() {
1229 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1230 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1231
1232 let (event_tx, mut event_rx) = broadcast::channel::<TaskEvent>(16);
1233
1234 let tm = TaskManager::with_events(
1235 backend,
1236 Arc::clone(&store),
1237 "owner/repo".to_string(),
1238 event_tx,
1239 );
1240
1241 let result = tm
1243 .update_task_status(&ExternalId("internal:999".to_string()), Status::Done)
1244 .await;
1245
1246 assert!(
1247 result.is_err(),
1248 "should return Err when internal task is not found in store"
1249 );
1250
1251 assert!(
1253 event_rx.try_recv().is_err(),
1254 "no event should be published for a not-found internal task"
1255 );
1256 }
1257
1258 #[tokio::test]
1264 async fn mark_task_done_by_store_id_succeeds_across_repos() {
1265 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1266 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1267
1268 let store_id = store
1269 .create_internal(
1270 "other/repo",
1271 "Cross-repo task",
1272 "body",
1273 "cron",
1274 "job:1",
1275 None,
1276 )
1277 .await
1278 .unwrap();
1279 let ext_id = ExternalId(format!("internal:{store_id}"));
1280
1281 let tm = TaskManager::with_store(backend, Arc::clone(&store), "active/repo".to_string());
1283
1284 let resolve_result = tm.update_task_status(&ext_id, Status::Done).await;
1286 assert!(
1287 resolve_result.is_err(),
1288 "repo-scoped update_task_status must fail for a cross-repo task"
1289 );
1290
1291 tm.mark_task_done_by_store_id(store_id, "other/repo", &ext_id)
1293 .await
1294 .unwrap();
1295
1296 let task = store.get(store_id).await.unwrap();
1297 assert_eq!(task.status, TaskStatus::Done);
1298 }
1299
1300 #[tokio::test]
1301 async fn get_task_returns_internal_from_store() {
1302 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1303 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1304 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1305
1306 let id = store
1307 .create_internal("owner/repo", "Fetch me", "body", "cron", "job:1", None)
1308 .await
1309 .unwrap();
1310
1311 let task = tm.get_task(id).await.unwrap();
1312 match task {
1313 Task::Internal(t) => assert_eq!(t.title, "Fetch me"),
1314 Task::External(_) => panic!("expected Internal variant"),
1315 }
1316 }
1317
1318 #[tokio::test]
1319 async fn list_routable_includes_internal_new_tasks() {
1320 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1321 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1322 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1323
1324 store
1326 .create_internal("owner/repo", "Route me", "", "cron", "job:2", None)
1327 .await
1328 .unwrap();
1329
1330 let routable = tm.list_routable().await.unwrap();
1331 assert_eq!(routable.len(), 1);
1332 assert!(routable[0].id.0.starts_with("internal:"));
1333 assert_eq!(routable[0].title, "Route me");
1334 }
1335
1336 #[tokio::test]
1337 async fn list_routable_excludes_non_new_internal_tasks() {
1338 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1339 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1340 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1341
1342 let id = store
1343 .create_internal("owner/repo", "Already routed", "", "cron", "job:3", None)
1344 .await
1345 .unwrap();
1346 store
1347 .update_status(id, TaskStatus::InProgress)
1348 .await
1349 .unwrap();
1350
1351 let routable = tm.list_routable().await.unwrap();
1352 assert!(
1353 routable.is_empty(),
1354 "in_progress tasks should not be routable"
1355 );
1356 }
1357
1358 #[tokio::test]
1359 async fn list_internal_by_status_returns_external_tasks() {
1360 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1361 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1362 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1363
1364 store
1365 .create_internal("owner/repo", "Task A", "", "cron", "a", None)
1366 .await
1367 .unwrap();
1368 let id_b = store
1369 .create_internal("owner/repo", "Task B", "", "cron", "b", None)
1370 .await
1371 .unwrap();
1372 store.update_status(id_b, TaskStatus::Done).await.unwrap();
1373
1374 let new_tasks = tm.list_internal_by_status(TaskStatus::New).await.unwrap();
1375 assert_eq!(new_tasks.len(), 1);
1376 assert_eq!(new_tasks[0].title, "Task A");
1377 assert!(new_tasks[0].labels.contains(&"status:new".to_string()));
1379 }
1380
1381 #[tokio::test]
1382 async fn store_task_to_external_maps_fields_correctly() {
1383 let store = TaskStore::open_memory().await.unwrap();
1384 let id = store
1385 .create_internal(
1386 "owner/repo",
1387 "Convert me",
1388 "body text",
1389 "manual",
1390 "m:1",
1391 None,
1392 )
1393 .await
1394 .unwrap();
1395 let task = store.get(id).await.unwrap();
1396 let ext = store_task_to_external(&task);
1397
1398 assert!(ext.id.0.starts_with("internal:"));
1399 assert_eq!(ext.title, "Convert me");
1400 assert_eq!(ext.body, "body text");
1401 assert_eq!(ext.state, "open");
1402 assert!(ext.labels.contains(&"status:new".to_string()));
1403 assert_eq!(ext.author, "manual"); }
1405
1406 #[tokio::test]
1407 async fn list_all_internal_returns_store_tasks() {
1408 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1409 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1410 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1411
1412 store
1413 .create_internal("owner/repo", "T1", "", "cron", "1", None)
1414 .await
1415 .unwrap();
1416 store
1417 .create_internal("owner/repo", "T2", "", "cron", "2", None)
1418 .await
1419 .unwrap();
1420 store
1422 .create_internal("other/repo", "T3", "", "cron", "3", None)
1423 .await
1424 .unwrap();
1425
1426 let tasks = tm.list_all_internal().await.unwrap();
1427 assert_eq!(tasks.len(), 2);
1428 }
1429
1430 #[tokio::test]
1433 async fn list_external_by_status_reads_from_store() {
1434 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1435 let backend = Arc::new(MockBackend::new());
1436 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1437
1438 let id = store
1440 .upsert_external(&crate::store::UpsertExternal {
1441 repo: "owner/repo",
1442 ext_id: "42",
1443 title: "Store task",
1444 body: "",
1445 author: "",
1446 url: "",
1447 labels: &[],
1448 origin: "github",
1449 })
1450 .await
1451 .unwrap();
1452 store.update_status(id, TaskStatus::Routed).await.unwrap();
1453
1454 let routed = tm.list_external_by_status(Status::Routed).await.unwrap();
1455 assert_eq!(routed.len(), 1);
1456 assert_eq!(routed[0].id.0, "42");
1457 assert_eq!(routed[0].title, "Store task");
1458 }
1459
1460 #[tokio::test]
1461 async fn list_external_by_status_excludes_internal_tasks() {
1462 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1463 let backend = Arc::new(MockBackend::new());
1464 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1465
1466 let id = store
1468 .create_internal("owner/repo", "Internal task", "", "cron", "1", None)
1469 .await
1470 .unwrap();
1471 store.update_status(id, TaskStatus::Routed).await.unwrap();
1472
1473 store
1475 .upsert_external(&crate::store::UpsertExternal {
1476 repo: "owner/repo",
1477 ext_id: "99",
1478 title: "External",
1479 body: "",
1480 author: "",
1481 url: "",
1482 labels: &[],
1483 origin: "github",
1484 })
1485 .await
1486 .unwrap();
1487
1488 let routed = tm.list_external_by_status(Status::Routed).await.unwrap();
1489 assert_eq!(routed.len(), 0);
1491 }
1492
1493 #[tokio::test]
1494 async fn list_external_by_status_falls_back_when_store_has_only_internal_tasks() {
1495 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1496 let backend = Arc::new(MockBackend::new().with_status_tasks(
1497 Status::Routed,
1498 vec![ExternalTask {
1499 id: ExternalId("123".to_string()),
1500 title: "Backend routed".to_string(),
1501 body: String::new(),
1502 state: "open".to_string(),
1503 labels: vec!["status:routed".to_string()],
1504 author: "bot".to_string(),
1505 created_at: "2026-01-01T00:00:00Z".to_string(),
1506 updated_at: "2026-01-01T00:00:00Z".to_string(),
1507 url: String::new(),
1508 }],
1509 ));
1510 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1511
1512 let id = store
1513 .create_internal("owner/repo", "Internal task", "", "cron", "1", None)
1514 .await
1515 .unwrap();
1516 store.update_status(id, TaskStatus::Routed).await.unwrap();
1517
1518 let routed = tm.list_external_by_status(Status::Routed).await.unwrap();
1519 assert_eq!(routed.len(), 1);
1520 assert_eq!(routed[0].id.0, "123");
1521 }
1522
1523 #[tokio::test]
1524 async fn list_routable_reads_from_store_when_populated() {
1525 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1526 let backend = Arc::new(MockBackend::new());
1527 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1528
1529 store
1531 .upsert_external(&crate::store::UpsertExternal {
1532 repo: "owner/repo",
1533 ext_id: "10",
1534 title: "New external",
1535 body: "",
1536 author: "",
1537 url: "",
1538 labels: &[],
1539 origin: "github",
1540 })
1541 .await
1542 .unwrap();
1543 store
1545 .create_internal("owner/repo", "New internal", "", "cron", "1", None)
1546 .await
1547 .unwrap();
1548
1549 let routable = tm.list_routable().await.unwrap();
1550 assert_eq!(routable.len(), 2);
1552 }
1553
1554 #[tokio::test]
1555 async fn list_routable_falls_back_when_store_has_only_internal_tasks() {
1556 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1557 let backend = Arc::new(MockBackend::new().with_routable_tasks(vec![ExternalTask {
1558 id: ExternalId("55".to_string()),
1559 title: "Backend new".to_string(),
1560 body: String::new(),
1561 state: "open".to_string(),
1562 labels: vec!["status:new".to_string()],
1563 author: "bot".to_string(),
1564 created_at: "2026-01-01T00:00:00Z".to_string(),
1565 updated_at: "2026-01-01T00:00:00Z".to_string(),
1566 url: String::new(),
1567 }]));
1568 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1569
1570 store
1571 .create_internal("owner/repo", "Internal new", "", "cron", "1", None)
1572 .await
1573 .unwrap();
1574
1575 let routable = tm.list_routable().await.unwrap();
1576 assert_eq!(routable.len(), 2);
1577 assert!(routable.iter().any(|task| task.id.0 == "55"));
1578 assert!(
1579 routable
1580 .iter()
1581 .any(|task| task.id.0.starts_with("internal:"))
1582 );
1583 }
1584
1585 #[tokio::test]
1586 async fn list_all_external_tasks_reads_from_store() {
1587 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1588 let backend = Arc::new(MockBackend::new());
1589 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1590
1591 let id1 = store
1593 .upsert_external(&crate::store::UpsertExternal {
1594 repo: "owner/repo",
1595 ext_id: "1",
1596 title: "Task 1",
1597 body: "",
1598 author: "",
1599 url: "",
1600 labels: &[],
1601 origin: "github",
1602 })
1603 .await
1604 .unwrap();
1605 let id2 = store
1606 .upsert_external(&crate::store::UpsertExternal {
1607 repo: "owner/repo",
1608 ext_id: "2",
1609 title: "Task 2",
1610 body: "",
1611 author: "",
1612 url: "",
1613 labels: &[],
1614 origin: "github",
1615 })
1616 .await
1617 .unwrap();
1618 store.update_status(id1, TaskStatus::Done).await.unwrap();
1619 store
1620 .update_status(id2, TaskStatus::InProgress)
1621 .await
1622 .unwrap();
1623
1624 store
1626 .create_internal("owner/repo", "Internal", "", "cron", "1", None)
1627 .await
1628 .unwrap();
1629
1630 let all = tm.list_all_external_tasks().await.unwrap();
1631 assert_eq!(all.len(), 2);
1632 }
1633
1634 #[tokio::test]
1635 async fn list_all_external_tasks_falls_back_when_store_has_only_internal_tasks() {
1636 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1637 let backend = Arc::new(MockBackend::new().with_status_tasks(
1638 Status::Done,
1639 vec![ExternalTask {
1640 id: ExternalId("200".to_string()),
1641 title: "Backend done".to_string(),
1642 body: String::new(),
1643 state: "closed".to_string(),
1644 labels: vec!["status:done".to_string()],
1645 author: "bot".to_string(),
1646 created_at: "2026-01-01T00:00:00Z".to_string(),
1647 updated_at: "2026-01-01T00:00:00Z".to_string(),
1648 url: String::new(),
1649 }],
1650 ));
1651 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1652
1653 store
1654 .create_internal("owner/repo", "Internal", "", "cron", "1", None)
1655 .await
1656 .unwrap();
1657
1658 let all = tm.list_all_external_tasks().await.unwrap();
1659 assert_eq!(all.len(), 1);
1660 assert_eq!(all[0].id.0, "200");
1661 }
1662
1663 #[tokio::test]
1664 async fn list_tasks_without_status_merges_backend_external_when_store_only_has_internal() {
1665 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1666 let backend = Arc::new(MockBackend::new().with_status_tasks(
1667 Status::New,
1668 vec![ExternalTask {
1669 id: ExternalId("301".to_string()),
1670 title: "Backend new".to_string(),
1671 body: String::new(),
1672 state: "open".to_string(),
1673 labels: vec!["status:new".to_string()],
1674 author: "bot".to_string(),
1675 created_at: "2026-01-01T00:00:00Z".to_string(),
1676 updated_at: "2026-01-01T00:00:00Z".to_string(),
1677 url: String::new(),
1678 }],
1679 ));
1680 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1681
1682 let internal_id = store
1683 .create_internal("owner/repo", "Internal task", "", "cron", "1", None)
1684 .await
1685 .unwrap();
1686
1687 let listed = tm.list_tasks(TaskFilter::default()).await.unwrap();
1688 assert_eq!(listed.len(), 2);
1689 assert!(listed.iter().any(|task| matches!(
1690 task,
1691 Task::External(external) if external.id.0 == "301"
1692 )));
1693 assert!(listed.iter().any(|task| matches!(
1694 task,
1695 Task::Internal(internal) if internal.id == internal_id
1696 )));
1697 }
1698
1699 #[tokio::test]
1700 async fn list_tasks_status_all_merges_backend_external_when_store_only_has_internal() {
1701 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1702 let backend = Arc::new(MockBackend::new().with_status_tasks(
1703 Status::Done,
1704 vec![ExternalTask {
1705 id: ExternalId("302".to_string()),
1706 title: "Backend done".to_string(),
1707 body: String::new(),
1708 state: "closed".to_string(),
1709 labels: vec!["status:done".to_string()],
1710 author: "bot".to_string(),
1711 created_at: "2026-01-01T00:00:00Z".to_string(),
1712 updated_at: "2026-01-01T00:00:00Z".to_string(),
1713 url: String::new(),
1714 }],
1715 ));
1716 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1717
1718 let internal_id = store
1719 .create_internal("owner/repo", "Internal task", "", "cron", "1", None)
1720 .await
1721 .unwrap();
1722
1723 let listed = tm
1724 .list_tasks(TaskFilter {
1725 status: Some("all".to_string()),
1726 source: None,
1727 })
1728 .await
1729 .unwrap();
1730 assert_eq!(listed.len(), 2);
1731 assert!(listed.iter().any(|task| matches!(
1732 task,
1733 Task::External(external) if external.id.0 == "302"
1734 )));
1735 assert!(listed.iter().any(|task| matches!(
1736 task,
1737 Task::Internal(internal) if internal.id == internal_id
1738 )));
1739 }
1740
1741 #[tokio::test]
1744 async fn update_task_status_writes_store_first_for_external() {
1745 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1746 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1747 let tm = TaskManager::with_store(
1748 Arc::clone(&backend),
1749 Arc::clone(&store),
1750 "owner/repo".to_string(),
1751 );
1752
1753 let store_id = store
1755 .upsert_external(&crate::store::UpsertExternal {
1756 repo: "owner/repo",
1757 ext_id: "42",
1758 title: "Test",
1759 body: "",
1760 author: "user",
1761 url: "",
1762 labels: &[],
1763 origin: "github",
1764 })
1765 .await
1766 .unwrap();
1767 assert_eq!(store.get(store_id).await.unwrap().status, TaskStatus::New);
1768
1769 let ext_id = ExternalId("42".to_string());
1771 tm.update_task_status(&ext_id, Status::Routed)
1772 .await
1773 .unwrap();
1774
1775 let task = store.get(store_id).await.unwrap();
1777 assert_eq!(task.status, TaskStatus::Routed);
1778 }
1779
1780 #[tokio::test]
1781 async fn update_task_status_handles_internal_tasks() {
1782 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1783 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1784 let tm = TaskManager::with_store(
1785 Arc::clone(&backend),
1786 Arc::clone(&store),
1787 "owner/repo".to_string(),
1788 );
1789
1790 let store_id = store
1792 .create_internal("owner/repo", "task", "body", "manual", "", None)
1793 .await
1794 .unwrap();
1795
1796 let internal_id = ExternalId(format!("internal:{store_id}"));
1797 tm.update_task_status(&internal_id, Status::InProgress)
1798 .await
1799 .unwrap();
1800
1801 let task = store.get(store_id).await.unwrap();
1802 assert_eq!(task.status, TaskStatus::InProgress);
1803 }
1804
1805 #[tokio::test]
1806 async fn update_task_status_publishes_event() {
1807 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1808 let (tx, mut rx) = broadcast::channel::<TaskEvent>(16);
1809 let tm = TaskManager {
1810 backend,
1811 store: None,
1812 repo: "owner/repo".to_string(),
1813 event_tx: Some(tx),
1814 };
1815 let id = ExternalId("42".to_string());
1817 tm.update_task_status(&id, Status::Routed).await.unwrap();
1818 let event = rx.try_recv().unwrap();
1819 assert_eq!(event.task_id, "42");
1820 assert_eq!(event.new_status, "routed");
1821 assert_eq!(event.repo, "owner/repo");
1822 }
1823
1824 #[tokio::test]
1825 async fn event_includes_old_status_and_context() {
1826 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1827 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1828 let (tx, mut rx) = broadcast::channel::<TaskEvent>(16);
1829
1830 let store_id = store
1832 .upsert_external(&crate::store::UpsertExternal {
1833 repo: "owner/repo",
1834 ext_id: "77",
1835 title: "Context test",
1836 body: "",
1837 author: "user",
1838 url: "",
1839 labels: &[],
1840 origin: "github",
1841 })
1842 .await
1843 .unwrap();
1844
1845 store
1847 .set_fields(
1848 store_id,
1849 &[
1850 ("agent", serde_json::Value::String("claude".to_string())),
1851 ("model", serde_json::Value::String("sonnet".to_string())),
1852 ("branch", serde_json::Value::String("feat-77".to_string())),
1853 ("pr_number", serde_json::Value::Number(42.into())),
1854 (
1855 "last_error",
1856 serde_json::Value::String("timeout".to_string()),
1857 ),
1858 ],
1859 )
1860 .await
1861 .unwrap();
1862
1863 let tm =
1864 TaskManager::with_events(backend, Arc::clone(&store), "owner/repo".to_string(), tx);
1865
1866 let ext_id = ExternalId("77".to_string());
1868 tm.update_task_status(&ext_id, Status::Routed)
1869 .await
1870 .unwrap();
1871
1872 let event = rx.try_recv().unwrap();
1873 assert_eq!(event.task_id, "77");
1874 assert_eq!(event.old_status, "new");
1875 assert_eq!(event.new_status, "routed");
1876 assert_eq!(event.agent.as_deref(), Some("claude"));
1877 assert_eq!(event.model.as_deref(), Some("sonnet"));
1878 assert_eq!(event.branch.as_deref(), Some("feat-77"));
1879 assert_eq!(event.pr_number.as_deref(), Some("42"));
1880 assert_eq!(event.error.as_deref(), Some("timeout"));
1881 }
1882
1883 #[tokio::test]
1884 async fn event_includes_old_status_for_internal_task() {
1885 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1886 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1887 let (tx, mut rx) = broadcast::channel::<TaskEvent>(16);
1888
1889 let store_id = store
1891 .create_internal(
1892 "owner/repo",
1893 "internal ctx test",
1894 "body",
1895 "manual",
1896 "",
1897 None,
1898 )
1899 .await
1900 .unwrap();
1901
1902 let tm =
1903 TaskManager::with_events(backend, Arc::clone(&store), "owner/repo".to_string(), tx);
1904
1905 let internal_id = ExternalId(format!("internal:{store_id}"));
1907 tm.update_task_status(&internal_id, Status::Routed)
1908 .await
1909 .unwrap();
1910
1911 let event = rx.try_recv().unwrap();
1912 assert_eq!(event.old_status, "new");
1913 assert_eq!(event.new_status, "routed");
1914
1915 tm.update_task_status(&internal_id, Status::InProgress)
1917 .await
1918 .unwrap();
1919
1920 let event2 = rx.try_recv().unwrap();
1921 assert_eq!(event2.old_status, "routed");
1922 assert_eq!(event2.new_status, "in_progress");
1923 }
1924
1925 #[tokio::test]
1928 async fn update_task_status_if_applies_when_status_matches() {
1929 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1930 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1931 let tm = TaskManager::with_store(backend, Arc::clone(&store), "owner/repo".to_string());
1932
1933 let store_id = store
1934 .upsert_external(&crate::store::UpsertExternal {
1935 repo: "owner/repo",
1936 ext_id: "10",
1937 title: "T",
1938 body: "",
1939 author: "u",
1940 url: "",
1941 labels: &[],
1942 origin: "github",
1943 })
1944 .await
1945 .unwrap();
1946 store
1948 .update_status(store_id, TaskStatus::InReview)
1949 .await
1950 .unwrap();
1951
1952 let id = ExternalId("10".to_string());
1953 let updated = tm
1954 .update_task_status_if(&id, Status::NeedsReview, Status::InReview)
1955 .await
1956 .unwrap();
1957 assert!(updated, "should update when expected status matches");
1958
1959 let task = store.get(store_id).await.unwrap();
1960 assert_eq!(task.status, TaskStatus::NeedsReview);
1961 }
1962
1963 #[tokio::test]
1964 async fn update_task_status_if_is_noop_when_status_mismatches() {
1965 let store = Arc::new(TaskStore::open_memory().await.unwrap());
1966 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
1967 let (tx, mut rx) = broadcast::channel::<TaskEvent>(16);
1968 let tm =
1969 TaskManager::with_events(backend, Arc::clone(&store), "owner/repo".to_string(), tx);
1970
1971 let store_id = store
1972 .upsert_external(&crate::store::UpsertExternal {
1973 repo: "owner/repo",
1974 ext_id: "11",
1975 title: "T",
1976 body: "",
1977 author: "u",
1978 url: "",
1979 labels: &[],
1980 origin: "github",
1981 })
1982 .await
1983 .unwrap();
1984 store
1986 .update_status(store_id, TaskStatus::Done)
1987 .await
1988 .unwrap();
1989
1990 let id = ExternalId("11".to_string());
1991 let updated = tm
1993 .update_task_status_if(&id, Status::NeedsReview, Status::InReview)
1994 .await
1995 .unwrap();
1996 assert!(
1997 !updated,
1998 "should not update when status has already changed"
1999 );
2000
2001 let task = store.get(store_id).await.unwrap();
2003 assert_eq!(task.status, TaskStatus::Done);
2004
2005 assert!(
2007 rx.try_recv().is_err(),
2008 "no event should be published on a no-op update"
2009 );
2010 }
2011 async fn duration_fixture(
2012 internal: bool,
2013 ) -> (
2014 TaskManager,
2015 Arc<TaskStore>,
2016 i64,
2017 ExternalId,
2018 broadcast::Receiver<TaskEvent>,
2019 ) {
2020 let store = Arc::new(TaskStore::open_memory().await.unwrap());
2021 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
2022 let (tx, rx) = broadcast::channel::<TaskEvent>(16);
2023 let (store_id, id) = if internal {
2024 let sid = store
2025 .create_internal("owner/repo", "task", "body", "manual", "", None)
2026 .await
2027 .unwrap();
2028 (sid, ExternalId(format!("internal:{sid}")))
2029 } else {
2030 let sid = store
2031 .upsert_external(&crate::store::UpsertExternal {
2032 repo: "owner/repo",
2033 ext_id: "91",
2034 title: "t",
2035 body: "",
2036 author: "user",
2037 url: "",
2038 labels: &[],
2039 origin: "github",
2040 })
2041 .await
2042 .unwrap();
2043 (sid, ExternalId("91".to_string()))
2044 };
2045 store
2046 .set_block_reason(store_id, Some("stale reason"))
2047 .await
2048 .unwrap();
2049 let tm =
2050 TaskManager::with_events(backend, Arc::clone(&store), "owner/repo".to_string(), tx);
2051 (tm, store, store_id, id, rx)
2052 }
2053
2054 #[tokio::test]
2055 async fn status_update_clears_block_reason_and_publishes_event_for_both_kinds() {
2056 for internal in [false, true] {
2057 let (tm, store, store_id, id, mut rx) = duration_fixture(internal).await;
2058 tm.update_task_status(&id, Status::Routed).await.unwrap();
2059 let task = store.get(store_id).await.unwrap();
2060 assert_eq!(task.status, TaskStatus::Routed);
2061 assert_eq!(task.block_reason, None);
2062 let event = rx.try_recv().unwrap();
2063 assert_eq!(event.old_status, "new");
2064 assert_eq!(event.new_status, "routed");
2065 assert_eq!(event.duration_seconds, None);
2066 }
2067 }
2068
2069 #[tokio::test]
2070 async fn status_update_with_duration_clears_block_reason_and_carries_duration() {
2071 for internal in [false, true] {
2072 let (tm, store, store_id, id, mut rx) = duration_fixture(internal).await;
2073 tm.update_task_status_with_duration(&id, Status::Routed, Some(12.5))
2074 .await
2075 .unwrap();
2076 let task = store.get(store_id).await.unwrap();
2077 assert_eq!(task.status, TaskStatus::Routed);
2078 assert_eq!(task.block_reason, None);
2079 let event = rx.try_recv().unwrap();
2080 assert_eq!(event.old_status, "new");
2081 assert_eq!(event.new_status, "routed");
2082 assert_eq!(event.duration_seconds, Some(12.5));
2083 }
2084 }
2085
2086 #[tokio::test]
2087 async fn status_update_to_blocked_keeps_block_reason() {
2088 for internal in [false, true] {
2089 let (tm, store, store_id, id, _rx) = duration_fixture(internal).await;
2090 tm.update_task_status(&id, Status::Blocked).await.unwrap();
2091 let task = store.get(store_id).await.unwrap();
2092 assert_eq!(task.status, TaskStatus::Blocked);
2093 assert_eq!(task.block_reason.as_deref(), Some("stale reason"));
2094
2095 let (tm, store, store_id, id, _rx) = duration_fixture(internal).await;
2096 tm.update_task_status_with_duration(&id, Status::Blocked, None)
2097 .await
2098 .unwrap();
2099 let task = store.get(store_id).await.unwrap();
2100 assert_eq!(task.block_reason.as_deref(), Some("stale reason"));
2101 }
2102 }
2103
2104 #[tokio::test]
2105 async fn status_update_internal_without_store_or_row_errors() {
2106 let backend: Arc<dyn ExternalBackend> = Arc::new(MockBackend::new());
2107 let tm = TaskManager::new(Arc::clone(&backend));
2108 let id = ExternalId("internal:1".to_string());
2109 assert!(tm.update_task_status(&id, Status::Routed).await.is_err());
2110 assert!(
2111 tm.update_task_status_with_duration(&id, Status::Routed, None)
2112 .await
2113 .is_err()
2114 );
2115 }
2116}