fix: worker cancellation sets status to 'cancelled' instead of 'failed'

src/agent/channel.rs

@@ -164,7 +164,7 @@ impl ChannelState {
         };
 
         self.process_run_logger
-            .log_worker_completed(worker_id, &result, false);
+            .log_worker_cancelled(worker_id, &result);
         if let Err(error) = self.deps.event_tx.send(ProcessEvent::WorkerComplete {
             agent_id: self.deps.agent_id.clone(),
             worker_id,

src/conversation/history.rs

@@ -475,10 +475,20 @@ impl ProcessRunLogger {
 
     /// Record a worker completing with its result. Fire-and-forget.
     pub fn log_worker_completed(&self, worker_id: WorkerId, result: &str, success: bool) {
+        let status = if success { "done" } else { "failed" };
+        self.log_worker_completed_with_status(worker_id, result, status);
+    }
+
+    /// Record a worker as cancelled. Fire-and-forget.
+    pub fn log_worker_cancelled(&self, worker_id: WorkerId, result: &str) {
+        self.log_worker_completed_with_status(worker_id, result, "cancelled");
+    }
+
+    fn log_worker_completed_with_status(&self, worker_id: WorkerId, result: &str, status: &str) {
         let pool = self.pool.clone();
         let id = worker_id.to_string();
         let result = result.to_string();
-        let status = if success { "done" } else { "failed" };
+        let status = status.to_string();
 
         tokio::spawn(async move {
             if let Err(error) = sqlx::query(
@@ -1054,6 +1064,82 @@ mod tests {
         assert_eq!(result, "Worker cancelled");
     }
 
+    #[tokio::test]
+    async fn log_worker_completed_success_sets_done_status() {
+        let pool = setup_worker_runs_table().await;
+        let logger = ProcessRunLogger::new(pool.clone());
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query("INSERT INTO worker_runs (id, channel_id, status, result) VALUES (?, 'ch-1', 'running', '')")
+            .bind(worker_id.to_string())
+            .execute(&pool)
+            .await
+            .expect("insert");
+
+        logger.log_worker_completed(worker_id, "task finished", true);
+        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
+        let row = sqlx::query("SELECT status, result FROM worker_runs WHERE id = ?")
+            .bind(worker_id.to_string())
+            .fetch_one(&pool)
+            .await
+            .expect("fetch");
+        let status: String = sqlx::Row::try_get(&row, "status").expect("status");
+        let result: String = sqlx::Row::try_get(&row, "result").expect("result");
+        assert_eq!(status, "done");
+        assert_eq!(result, "task finished");
+    }
+
+    #[tokio::test]
+    async fn log_worker_completed_failure_sets_failed_status() {
+        let pool = setup_worker_runs_table().await;
+        let logger = ProcessRunLogger::new(pool.clone());
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query("INSERT INTO worker_runs (id, channel_id, status, result) VALUES (?, 'ch-1', 'running', '')")
+            .bind(worker_id.to_string())
+            .execute(&pool)
+            .await
+            .expect("insert");
+
+        logger.log_worker_completed(worker_id, "something broke", false);
+        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
+        let row = sqlx::query("SELECT status FROM worker_runs WHERE id = ?")
+            .bind(worker_id.to_string())
+            .fetch_one(&pool)
+            .await
+            .expect("fetch");
+        let status: String = sqlx::Row::try_get(&row, "status").expect("status");
+        assert_eq!(status, "failed");
+    }
+
+    #[tokio::test]
+    async fn log_worker_cancelled_sets_cancelled_status() {
+        let pool = setup_worker_runs_table().await;
+        let logger = ProcessRunLogger::new(pool.clone());
+        let worker_id = uuid::Uuid::new_v4();
+
+        sqlx::query("INSERT INTO worker_runs (id, channel_id, status, result) VALUES (?, 'ch-1', 'running', '')")
+            .bind(worker_id.to_string())
+            .execute(&pool)
+            .await
+            .expect("insert");
+
+        logger.log_worker_cancelled(worker_id, "Worker cancelled: user requested");
+        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
+        let row = sqlx::query("SELECT status, result FROM worker_runs WHERE id = ?")
+            .bind(worker_id.to_string())
+            .fetch_one(&pool)
+            .await
+            .expect("fetch");
+        let status: String = sqlx::Row::try_get(&row, "status").expect("status");
+        let result: String = sqlx::Row::try_get(&row, "result").expect("result");
+        assert_eq!(status, "cancelled");
+        assert_eq!(result, "Worker cancelled: user requested");
+    }
+
     #[tokio::test]
     async fn cancel_running_detached_worker_does_not_touch_channel_bound_rows() {
         let pool = setup_worker_runs_table().await;

src/tools/send_message_to_another_channel.rs

@@ -150,14 +150,13 @@ impl Tool for SendMessageTool {
             // If explicit prefix returned default "signal" adapter but we're in a named
             // Signal adapter conversation (e.g., signal:gvoice1), use the current adapter
             // to ensure the message goes through the correct account.
-            if target.adapter == "signal" {
-                if let Some(current_adapter) = self
+            if target.adapter == "signal"
+                && let Some(current_adapter) = self
                     .current_adapter
                     .as_ref()
                     .filter(|adapter| adapter.starts_with("signal:"))
-                {
-                    target.adapter = current_adapter.clone();
-                }
+            {
+                target.adapter = current_adapter.clone();
             }
 
             self.messaging_manager
@@ -189,31 +188,28 @@ impl Tool for SendMessageTool {
             .current_adapter
             .as_ref()
             .filter(|adapter| adapter.starts_with("signal"))
+            && let Some(target) = parse_implicit_signal_shorthand(&args.target, current_adapter)
         {
-            if let Some(target) = parse_implicit_signal_shorthand(&args.target, current_adapter) {
-                self.messaging_manager
-                    .broadcast(
-                        &target.adapter,
-                        &target.target,
-                        crate::OutboundResponse::Text(args.message),
-                    )
-                    .await
-                    .map_err(|error| {
-                        SendMessageError(format!("failed to send message: {error}"))
-                    })?;
-
-                tracing::info!(
-                    adapter = %target.adapter,
-                    broadcast_target = %"[REDACTED]",
-                    "message sent via implicit Signal shorthand"
-                );
-
-                return Ok(SendMessageOutput {
-                    success: true,
-                    target: target.target,
-                    platform: target.adapter,
-                });
-            }
+            self.messaging_manager
+                .broadcast(
+                    &target.adapter,
+                    &target.target,
+                    crate::OutboundResponse::Text(args.message),
+                )
+                .await
+                .map_err(|error| SendMessageError(format!("failed to send message: {error}")))?;
+
+            tracing::info!(
+                adapter = %target.adapter,
+                broadcast_target = %"[REDACTED]",
+                "message sent via implicit Signal shorthand"
+            );
+
+            return Ok(SendMessageOutput {
+                success: true,
+                target: target.target,
+                platform: target.adapter,
+            });
         }
 
         // Check for explicit email target