treewide: fix error handling and dropped handles

- Replace `.unwrap()` with `.context()` for UTF-8 path conversion
- Store and properly manage auto-sync task handle with graceful shutdown
- Store tick timer handle in Scheduler actor, abort on stop
- Add error logging for JobCompleted message send failures
- Add cleanup of all running job handles on actor shutdown

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: aster-void

src/main.rs

@@ -2,7 +2,7 @@ mod config;
 mod git;
 mod scheduler;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use clap::Parser;
 use scheduler::{ConfigUpdate, Scheduler, SyncRequest};
 use std::path::PathBuf;
@@ -32,7 +32,7 @@ async fn main() -> Result<()> {
         PathBuf::from(&args.repo)
             .canonicalize()?
             .to_str()
-            .unwrap()
+            .context("Path contains invalid UTF-8")?
             .to_string()
     } else {
         args.repo.clone()
@@ -63,7 +63,7 @@ async fn main() -> Result<()> {
     let source_clone = source.clone();
     let pull_interval = args.pull_interval;
     let scheduler_clone = scheduler.clone();
-    tokio::spawn(async move {
+    let sync_handle = tokio::spawn(async move {
         let mut ticker = interval(Duration::from_secs(pull_interval));
         loop {
             ticker.tick().await;
@@ -106,9 +106,18 @@ async fn main() -> Result<()> {
         }
     });
 
-    // Keep main alive while scheduler runs
-    // The scheduler actor runs indefinitely with its internal ticker
-    std::future::pending::<()>().await;
+    // Wait for shutdown signal or task panic
+    tokio::select! {
+        _ = tokio::signal::ctrl_c() => {
+            println!("[rollcron] Shutting down...");
+        }
+        result = sync_handle => {
+            match result {
+                Ok(()) => eprintln!("[rollcron] Sync task exited unexpectedly"),
+                Err(e) => eprintln!("[rollcron] Sync task panicked: {}", e),
+            }
+        }
+    }
 
     Ok(())
 }

src/scheduler/mod.rs

@@ -20,6 +20,7 @@ pub struct Scheduler {
     runner: RunnerConfig,
     pending_syncs: HashSet<String>,
     job_handles: HashMap<String, Vec<JoinHandle<()>>>,
+    tick_handle: Option<JoinHandle<()>>,
 }
 
 impl Scheduler {
@@ -30,6 +31,7 @@ impl Scheduler {
             runner,
             pending_syncs: HashSet::new(),
             job_handles: HashMap::new(),
+            tick_handle: None,
         }
     }
 
@@ -63,19 +65,30 @@ impl Actor for Scheduler {
 
     async fn started(&mut self, mailbox: &Mailbox<Self>) -> Result<(), Self::Stop> {
         let addr = mailbox.address();
-        tokio::spawn(async move {
+        self.tick_handle = Some(tokio::spawn(async move {
             let mut interval = tokio::time::interval(Duration::from_secs(1));
             loop {
                 interval.tick().await;
                 if addr.send(Tick).await.is_err() {
                     break;
                 }
             }
-        });
+        }));
         Ok(())
     }
 
-    async fn stopped(self) -> Self::Stop {}
+    async fn stopped(mut self) -> Self::Stop {
+        // Abort tick timer
+        if let Some(handle) = self.tick_handle.take() {
+            handle.abort();
+        }
+        // Abort all running jobs
+        for (_, handles) in self.job_handles.drain() {
+            for handle in handles {
+                handle.abort();
+            }
+        }
+    }
 }
 
 // === Messages ===
@@ -205,11 +218,14 @@ impl Scheduler {
 
     fn spawn_job(&mut self, job: Job, addr: Address<Scheduler, Weak>) {
         let job_id = job.id.clone();
+        let job_id_for_log = job.id.clone();
         let work_dir = resolve_work_dir(&self.sot_path, &job.id, &job.working_dir);
 
         let handle = tokio::spawn(async move {
             execute_job(&job, &work_dir).await;
-            let _ = addr.send(JobCompleted).await;
+            if let Err(e) = addr.send(JobCompleted).await {
+                eprintln!("[job:{}] Failed to notify completion: {}", job_id_for_log, e);
+            }
         });
 
         self.job_handles.entry(job_id).or_default().push(handle);