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

@@ -101,7 +101,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,
@@ -350,9 +350,21 @@ impl TaskStore {
     }
 
     pub async fn update(&self, task_number: i64, input: UpdateTaskInput) -> Result<Option<Task>> {
+        Ok(self
+            .update_with_previous(task_number, input)
+            .await?
+            .map(|(_, updated)| updated))
+    }
+
+    pub async fn update_with_previous(
+        &self,
+        task_number: i64,
+        input: UpdateTaskInput,
+    ) -> Result<Option<(Task, Task)>> {
         let Some(current) = self.get_by_number(task_number).await? else {
             return Ok(None);
         };
+        let previous = current.clone();
 
         if let Some(next_status) = input.status
             && !can_transition(current.status, next_status)
@@ -452,7 +464,10 @@ impl TaskStore {
             .await
             .context("failed to update task")?;
 
-        self.get_by_number(task_number).await
+        Ok(self
+            .get_by_number(task_number)
+            .await?
+            .map(|updated| (previous, updated)))
     }
 
     pub async fn delete(&self, task_number: i64) -> Result<bool> {
@@ -869,6 +884,33 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn update_with_previous_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 (previous, updated) = store
+            .update_with_previous(
+                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!(previous.title, "old title");
+        assert_eq!(previous.priority, TaskPriority::Medium);
+        assert_eq!(updated.title, "new title");
+        assert_eq!(updated.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,6 +1,6 @@
 //! Task update tool for branch and worker processes.
 
-use crate::tasks::{TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput};
+use crate::tasks::{Task, TaskPriority, TaskStatus, TaskStore, TaskSubtask, UpdateTaskInput};
 use crate::{AgentId, WorkerId};
 use rig::completion::ToolDefinition;
 use rig::tool::Tool;
@@ -213,9 +213,9 @@ impl Tool for TaskUpdateTool {
             ),
         };
 
-        let updated = self
+        let (previous, updated) = self
             .task_store
-            .update(
+            .update_with_previous(
                 task_number,
                 UpdateTaskInput {
                     title: args.title,
@@ -236,14 +236,9 @@ impl Tool for TaskUpdateTool {
             .ok_or_else(|| TaskUpdateError(format!("task #{} not found", task_number)))?;
 
         if let Some(working_memory) = &self.working_memory {
+            let summary = task_update_memory_summary(&previous, &updated);
             working_memory
-                .emit(
-                    crate::memory::WorkingMemoryEventType::TaskUpdate,
-                    format!(
-                        "Task #{} updated to {}",
-                        updated.task_number, updated.status
-                    ),
-                )
+                .emit(crate::memory::WorkingMemoryEventType::TaskUpdate, summary)
                 .importance(0.4)
                 .record();
         }
@@ -256,3 +251,131 @@ 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::task_update_memory_summary;
+    use crate::tasks::{Task, TaskPriority, TaskStatus, TaskSubtask};
+
+    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"
+        );
+    }
+}