fix(memory): describe task update deltas

Author: vsumner

docs/design-docs/working-memory-triage.md

@@ -53,8 +53,8 @@ Findings from CodeRabbit review + bug reports. Tracking resolution before merge.
 - [x] **R15 — UTF-8 panic on topic truncation** (`src/memory/working.rs:739`)
   Byte-index slice at 80 can split multibyte chars. **Fixed:** `floor_char_boundary(80)`.
 
-- [ ] **R16 — Task update event always says "status change"** (`src/tools/task_update.rs:246`)
-  Every update emits `"updated to <status>"` even for title/description edits. Compute actual delta.
+- [x] **R16 — Task update event always says "status change"** (`src/tools/task_update.rs:246`)
+  Every update emits `"updated to <status>"` even for title/description edits. **Fixed in this slice:** task-update working-memory events now compare the before/after task record and name the actual changed fields, while preserving the existing status-only wording.
 
 ## Live Observations (from prompt inspect, March 19)
 

src/tasks/store.rs

@@ -103,7 +103,7 @@ impl std::fmt::Display for TaskPriority {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, utoipa::ToSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema, utoipa::ToSchema)]
 pub struct TaskSubtask {
     pub title: String,
     pub completed: bool,
@@ -163,6 +163,7 @@ pub struct UpdateTaskInput {
 
 #[derive(Debug, Clone)]
 pub struct TaskUpdateResult {
+    pub previous_task: Task,
     pub previous_status: TaskStatus,
     pub task: Task,
 }
@@ -403,6 +404,7 @@ impl TaskStore {
         };
 
         let current = task_from_row(row)?;
+        let previous_task = current.clone();
         let previous_status = current.status;
         let task = Self::update_current_in_tx(&mut tx, task_number, current, input).await?;
 
@@ -411,6 +413,7 @@ impl TaskStore {
             .context("failed to commit task update transaction")?;
 
         Ok(Some(TaskUpdateResult {
+            previous_task,
             previous_status,
             task,
         }))
@@ -458,6 +461,7 @@ impl TaskStore {
         };
 
         let current = task_from_row(row)?;
+        let previous_task = current.clone();
         let previous_status = current.status;
         let task = Self::update_current_in_tx(&mut tx, task_number, current, input).await?;
 
@@ -467,6 +471,7 @@ impl TaskStore {
 
         Ok(WorkerTaskUpdateResult::Updated(Box::new(
             TaskUpdateResult {
+                previous_task,
                 previous_status,
                 task,
             },
@@ -1086,6 +1091,33 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn update_result_returns_applied_snapshot_pair() {
+        let store = setup_store().await;
+        let created = store
+            .create(self_assigned_input("old title", TaskStatus::Backlog))
+            .await
+            .expect("task should be created");
+
+        let result = store
+            .update_with_status_transition(
+                created.task_number,
+                UpdateTaskInput {
+                    title: Some("new title".to_string()),
+                    priority: Some(TaskPriority::High),
+                    ..Default::default()
+                },
+            )
+            .await
+            .expect("update should succeed")
+            .expect("task should exist");
+
+        assert_eq!(result.previous_task.title, "old title");
+        assert_eq!(result.previous_task.priority, TaskPriority::Medium);
+        assert_eq!(result.task.title, "new title");
+        assert_eq!(result.task.priority, TaskPriority::High);
+    }
+
     #[tokio::test]
     async fn global_task_numbers_are_unique_across_agents() {
         let store = setup_store().await;

src/tools/task_update.rs

@@ -1,7 +1,7 @@
 //! Task update tool for branch and worker processes.
 
 use crate::tasks::{
-    TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput, WorkerTaskUpdateResult,
+    Task, TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput, WorkerTaskUpdateResult,
 };
 use crate::{AgentId, WorkerId};
 use rig::completion::ToolDefinition;
@@ -235,6 +235,7 @@ impl Tool for TaskUpdateTool {
                 }
             },
         };
+        let previous_task = update_result.previous_task;
         let previous_status = update_result.previous_status;
         let updated = update_result.task;
 
@@ -250,10 +251,7 @@ impl Tool for TaskUpdateTool {
             } else {
                 (
                     crate::memory::WorkingMemoryEventType::TaskUpdate,
-                    format!(
-                        "Task #{} updated to {}",
-                        updated.task_number, updated.status
-                    ),
+                    task_update_memory_summary(&previous_task, &updated),
                     0.4,
                 )
             };
@@ -272,13 +270,69 @@ impl Tool for TaskUpdateTool {
     }
 }
 
+fn task_update_memory_summary(previous: &Task, updated: &Task) -> String {
+    let mut changes = Vec::new();
+
+    if previous.status != updated.status {
+        changes.push(format!("status {} -> {}", previous.status, updated.status));
+    }
+    if previous.priority != updated.priority {
+        changes.push(format!(
+            "priority {} -> {}",
+            previous.priority, updated.priority
+        ));
+    }
+    if previous.title != updated.title {
+        changes.push("title".to_string());
+    }
+    if previous.description != updated.description {
+        changes.push("description".to_string());
+    }
+    if previous.subtasks != updated.subtasks {
+        changes.push("subtasks".to_string());
+    }
+    if previous.metadata != updated.metadata {
+        changes.push("metadata".to_string());
+    }
+    if previous.worker_id != updated.worker_id {
+        changes.push(match (&previous.worker_id, &updated.worker_id) {
+            (None, Some(_)) => "worker assigned".to_string(),
+            (Some(_), None) => "worker unassigned".to_string(),
+            _ => "worker binding".to_string(),
+        });
+    }
+    if previous.approved_by != updated.approved_by {
+        changes.push("approval".to_string());
+    }
+    if previous.assigned_agent_id != updated.assigned_agent_id {
+        changes.push("assignment".to_string());
+    }
+
+    if changes.is_empty() {
+        return format!("Task #{} updated", updated.task_number);
+    }
+
+    if changes.len() == 1 && previous.status != updated.status {
+        return format!(
+            "Task #{} updated to {}",
+            updated.task_number, updated.status
+        );
+    }
+
+    format!(
+        "Task #{} updated: {}",
+        updated.task_number,
+        changes.join(", ")
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::memory::working::WorkingMemoryEvent;
     use crate::memory::{WorkingMemoryEventType, WorkingMemoryStore};
     use crate::tasks::store::setup_test_store;
+    use crate::tasks::{Task, TaskPriority, TaskStatus, TaskSubtask};
     use chrono_tz::Tz;
     use sqlx::sqlite::SqlitePoolOptions;
     use std::time::Duration;
@@ -313,6 +367,72 @@ mod tests {
         .expect("timed out waiting for working memory event")
     }
 
+    fn task_fixture() -> Task {
+        Task {
+            id: "task-id".to_string(),
+            task_number: 7,
+            title: "Original title".to_string(),
+            description: Some("Original description".to_string()),
+            status: TaskStatus::Backlog,
+            priority: TaskPriority::Medium,
+            owner_agent_id: "agent".to_string(),
+            assigned_agent_id: "agent".to_string(),
+            subtasks: Vec::new(),
+            metadata: serde_json::json!({}),
+            source_memory_id: None,
+            worker_id: None,
+            created_by: "branch".to_string(),
+            approved_at: None,
+            approved_by: None,
+            created_at: "2026-04-19T00:00:00Z".to_string(),
+            updated_at: "2026-04-19T00:00:00Z".to_string(),
+            completed_at: None,
+        }
+    }
+
+    #[test]
+    fn task_update_memory_summary_preserves_status_update_wording() {
+        let previous = task_fixture();
+        let mut updated = previous.clone();
+        updated.status = TaskStatus::Ready;
+
+        assert_eq!(
+            task_update_memory_summary(&previous, &updated),
+            "Task #7 updated to ready"
+        );
+    }
+
+    #[test]
+    fn task_update_memory_summary_names_non_status_changes() {
+        let previous = task_fixture();
+        let mut updated = previous.clone();
+        updated.title = "New title".to_string();
+        updated.description = Some("New description".to_string());
+        updated.priority = TaskPriority::High;
+        updated.subtasks = vec![TaskSubtask {
+            title: "Check output".to_string(),
+            completed: true,
+        }];
+        updated.metadata = serde_json::json!({"source": "review"});
+        updated.worker_id = Some("worker-1".to_string());
+        updated.approved_by = Some("victor".to_string());
+
+        assert_eq!(
+            task_update_memory_summary(&previous, &updated),
+            "Task #7 updated: priority medium -> high, title, description, subtasks, metadata, worker assigned, approval"
+        );
+    }
+
+    #[test]
+    fn task_update_memory_summary_handles_no_actual_delta() {
+        let previous = task_fixture();
+
+        assert_eq!(
+            task_update_memory_summary(&previous, &previous),
+            "Task #7 updated"
+        );
+    }
+
     #[tokio::test]
     async fn task_update_emits_outcome_for_done_status() {
         let task_store = Arc::new(setup_test_store().await);
@@ -409,7 +529,7 @@ mod tests {
         assert_eq!(event.event_type, WorkingMemoryEventType::TaskUpdate);
         assert_eq!(
             event.summary,
-            format!("Task #{} updated to done", created.task_number)
+            format!("Task #{} updated: title", created.task_number)
         );
     }