feat(memory): expand working-memory event semantics

Author: vsumner

docs/design-docs/working-memory-implementation-plan.md

@@ -158,6 +158,12 @@ pub enum WorkingMemoryEventType {
     CronExecuted,
     MemorySaved,
     Decision,
+    UserCorrection,
+    DecisionRevised,
+    DeadlineSet,
+    BlockedOn,
+    Constraint,
+    Outcome,
     Error,
     TaskUpdate,
     AgentMessage,
@@ -861,7 +867,8 @@ Update `prompts/en/memory_persistence.md.j2` to add:
 In addition to saving graph memories, identify key decisions and important events
 from the conversation. For each, include it in the `events` field of
 memory_persistence_complete. Events should be one-line summaries with a type
-("decision", "error", "system") and importance score (0.0-1.0).
+("decision", "user_correction", "decision_revised", "deadline_set", "blocked_on",
+"constraint", "outcome", "error", "system") and importance score (0.0-1.0).
 ```
 
 Update `src/tools/memory_persistence_complete.rs`:

docs/design-docs/working-memory.md

@@ -75,6 +75,18 @@ pub enum WorkingMemoryEventType {
     MemorySaved,
     /// A decision was made (extracted from conversation)
     Decision,
+    /// The user corrected a prior assumption, instruction, or framing
+    UserCorrection,
+    /// A prior decision changed after feedback or new information
+    DecisionRevised,
+    /// A concrete due date, deadline, or scheduled milestone was set
+    DeadlineSet,
+    /// Progress is waiting on approval, missing input, or an external dependency
+    BlockedOn,
+    /// A hard requirement, limitation, or non-negotiable boundary was stated
+    Constraint,
+    /// A task, branch, or delegated step reached a clear terminal result
+    Outcome,
     /// An error or failure occurred
     Error,
     /// A task was created or updated
@@ -455,19 +467,19 @@ The periodic memory persistence branch currently runs every 50 user messages. Re
 
 ### Persistence Branch Dual Output
 
-The memory persistence branch gains a second responsibility: in addition to saving graph memories, it emits `Decision` and `MemorySaved` events into the working memory log. This connects the two systems:
+The memory persistence branch gains a second responsibility: in addition to saving graph memories, it emits typed conversational events into the working memory log. This connects the two systems:
 
 ```
 Persistence branch runs:
   1. Recalls existing graph memories (avoid duplicates)
   2. Reads conversation history since last run
   3. Saves new graph memories via memory_save (as today)
   4. Identifies key decisions and events
-  5. Emits working memory events for each decision identified
+  5. Emits working memory events for each important event identified
   6. Calls memory_persistence_complete
 ```
 
-Step 5 is new. The persistence branch prompt is updated to instruct it to identify decisions explicitly. The `memory_persistence_complete` tool gains an optional `events` field:
+Step 5 is new. The persistence branch prompt is updated to identify durable temporal events explicitly: decisions, user corrections, revised decisions, concrete deadlines, blockers, constraints, terminal outcomes, errors, and system events. The `memory_persistence_complete` tool gains an optional `events` field:
 
 ```rust
 pub struct MemoryPersistenceCompleteArgs {
@@ -477,7 +489,7 @@ pub struct MemoryPersistenceCompleteArgs {
 }
 
 pub struct WorkingMemoryEventInput {
-    pub event_type: String,       // "decision", "error", etc.
+    pub event_type: String,       // "decision", "blocked_on", "outcome", etc.
     pub summary: String,
     pub importance: Option<f32>,
 }
@@ -490,14 +502,18 @@ The majority of working memory events are captured programmatically, with zero L
 | Event            | Emitter                                      | How                                                                  |
 | ---------------- | -------------------------------------------- | -------------------------------------------------------------------- |
 | Worker spawned   | `spawn_worker` tool handler                  | After successful spawn, write event with task description as summary |
-| Worker completed | Worker state machine terminal transition     | Write event with worker result summary (truncated to 200 chars)      |
-| Branch completed | Branch return path in channel                | Write event with branch conclusion (truncated to 200 chars)          |
+| Worker completed | Worker state machine terminal transition     | Write typed result, blocker, constraint, or deadline event when the summary uses a recognized prefix; otherwise write `WorkerCompleted` |
+| Branch completed | Branch return path in channel                | Write typed result, blocker, constraint, or deadline event when the summary uses a recognized prefix; otherwise write `BranchCompleted` |
 | Cron executed    | Cron scheduler after job completes           | Write event with cron name + outcome                                 |
 | Memory saved     | `memory_save` tool handler                   | Write event with memory type + content preview                       |
-| Task updated     | Task tool handlers                           | Write event with task title + new status                             |
+| Task updated     | Task tool handlers                           | Write `Outcome` when a task transitions to `done`; otherwise write `TaskUpdate` with task status |
+| Duplicate worker | `spawn_worker` duplicate guard               | Write `BlockedOn` with the active worker ID and duplicate task preview |
+| Agent delegation | `send_agent_message` tool handler            | Write `Outcome` when delegation creates the cross-agent task          |
 | Error            | SpacebotHook on tool failure, worker failure | Write event with error description                                   |
 | System           | Startup, config change, maintenance          | Write event with description                                         |
 
+Branch and worker summaries may opt into richer event types with these prefixes: `outcome:`, `blocked_on:` or `blocked on:`, `constraint:`, and `deadline_set:` or `deadline:`. The prefix is stripped before rendering the event summary.
+
 Each emitter calls `working_memory_store.record_event()` as a fire-and-forget `tokio::spawn`. The message processing pipeline never waits on event recording.
 
 ```rust

prompts/en/memory_persistence.md.j2

@@ -32,13 +32,17 @@ This is an automatic process triggered periodically during conversation. You are
      - `"decision"` for commitments or choices made
      - `"user_correction"` when the user corrects a prior assumption, instruction, or framing
      - `"decision_revised"` when a prior choice changes after feedback or new information
+     - `"deadline_set"` when the conversation establishes a concrete due date, deadline, or scheduled milestone
+     - `"blocked_on"` when progress is waiting on an approval, dependency, missing input, or external action
+     - `"constraint"` when the user or system states a hard requirement, limitation, or non-negotiable boundary
+     - `"outcome"` when a task, branch, or delegated step reaches a clear terminal result worth retaining in temporal memory
      - `"error"` for failures or problems
      - `"system"` for other notable events
    - `summary`: one-line description of what happened
    - Normalize relative time references to absolute dates/times with timezone
      (for example `2026-03-31T14:20:00-04:00`) so downstream memory checks are
      stable across sessions.
-   - `importance`: 0.0-1.0 score (`decision`, `user_correction`, and `decision_revised` are typically 0.6-0.8)
+   - `importance`: 0.0-1.0 score (`decision`, `user_correction`, `decision_revised`, `blocked_on`, and `outcome` are typically 0.6-0.8)
    - Events feed the agent's temporal working memory — they help the agent remember *what happened today*, not just facts.
 
 5. **Finish with the terminal tool.** You must call `memory_persistence_complete` before finishing:

src/agent/channel.rs

@@ -119,6 +119,70 @@ fn should_flush_coalesce_buffer_for_event(event: &ProcessEvent) -> bool {
     )
 }
 
+fn classify_conversational_event_summary(
+    summary: &str,
+    default_event_type: crate::memory::WorkingMemoryEventType,
+) -> (crate::memory::WorkingMemoryEventType, String) {
+    let trimmed = summary.trim();
+    if trimmed.is_empty() {
+        return (default_event_type, String::new());
+    }
+
+    if let Some((prefix, rest)) = trimmed.split_once(':') {
+        let rest_trimmed = rest.trim();
+        let prefix = prefix.trim().to_ascii_lowercase().replace([' ', '-'], "_");
+        if prefix == "outcome" {
+            return (
+                crate::memory::WorkingMemoryEventType::Outcome,
+                rest_trimmed.to_string(),
+            );
+        }
+        if prefix == "blocked_on" {
+            return (
+                crate::memory::WorkingMemoryEventType::BlockedOn,
+                rest_trimmed.to_string(),
+            );
+        }
+        if prefix == "constraint" {
+            return (
+                crate::memory::WorkingMemoryEventType::Constraint,
+                rest_trimmed.to_string(),
+            );
+        }
+        if prefix == "deadline_set" || prefix == "deadline" {
+            return (
+                crate::memory::WorkingMemoryEventType::DeadlineSet,
+                rest_trimmed.to_string(),
+            );
+        }
+    }
+
+    (default_event_type, trimmed.to_string())
+}
+
+fn format_conversational_event_summary(
+    event_type: crate::memory::WorkingMemoryEventType,
+    source: &str,
+    event_summary: &str,
+) -> String {
+    let label = match event_type {
+        crate::memory::WorkingMemoryEventType::Outcome => "outcome",
+        crate::memory::WorkingMemoryEventType::BlockedOn => "blocked on",
+        crate::memory::WorkingMemoryEventType::Constraint => "constraint",
+        crate::memory::WorkingMemoryEventType::DeadlineSet => "deadline set",
+        crate::memory::WorkingMemoryEventType::Error => "failed",
+        crate::memory::WorkingMemoryEventType::BranchCompleted
+        | crate::memory::WorkingMemoryEventType::WorkerCompleted => "completed",
+        _ => "concluded",
+    };
+
+    if event_summary.is_empty() {
+        format!("{source} {label}")
+    } else {
+        format!("{source} {label}: {event_summary}")
+    }
+}
+
 fn sentence_contains_decision_marker(sentence: &str) -> bool {
     let sentence_lower = sentence.to_ascii_lowercase();
     DECISION_MARKERS
@@ -3224,11 +3288,19 @@ impl Channel {
                     } else {
                         conclusion.clone()
                     };
+                    let (event_type, event_summary) = classify_conversational_event_summary(
+                        &summary,
+                        crate::memory::WorkingMemoryEventType::BranchCompleted,
+                    );
                     self.deps
                         .working_memory
                         .emit(
-                            crate::memory::WorkingMemoryEventType::BranchCompleted,
-                            format!("Branch concluded: {summary}"),
+                            event_type,
+                            format_conversational_event_summary(
+                                event_type,
+                                "Branch",
+                                &event_summary,
+                            ),
                         )
                         .channel(self.id.to_string())
                         .importance(0.7)
@@ -3297,20 +3369,18 @@ impl Channel {
                 } else {
                     result.clone()
                 };
-                let event_type = if *success {
+                let default_event_type = if *success {
                     crate::memory::WorkingMemoryEventType::WorkerCompleted
                 } else {
                     crate::memory::WorkingMemoryEventType::Error
                 };
+                let (event_type, event_summary) =
+                    classify_conversational_event_summary(&worker_summary, default_event_type);
                 self.deps
                     .working_memory
                     .emit(
                         event_type,
-                        if *success {
-                            format!("Worker completed: {worker_summary}")
-                        } else {
-                            format!("Worker failed: {worker_summary}")
-                        },
+                        format_conversational_event_summary(event_type, "Worker", &event_summary),
                     )
                     .channel(self.id.to_string())
                     .importance(if *success { 0.6 } else { 0.8 })
@@ -3890,12 +3960,13 @@ fn is_dm_conversation_id(conv_id: &str) -> bool {
 #[cfg(test)]
 mod tests {
     use super::{
-        ObserveModeFallbackState, compute_listen_mode_invocation, decision_user_id,
-        extract_decision_summary_from_reply, is_dm_conversation_id, recv_channel_event,
+        ObserveModeFallbackState, classify_conversational_event_summary,
+        compute_listen_mode_invocation, decision_user_id, extract_decision_summary_from_reply,
+        format_conversational_event_summary, is_dm_conversation_id, recv_channel_event,
         should_process_event_for_channel, should_send_discord_quiet_mode_ping_ack,
         should_send_quiet_mode_fallback,
     };
-    use crate::memory::MemoryType;
+    use crate::memory::{MemoryType, WorkingMemoryEventType};
     use crate::{AgentId, ChannelId, InboundMessage, MessageContent, ProcessEvent, ProcessId};
     use std::collections::HashMap;
     use std::sync::Arc;
@@ -4136,6 +4207,98 @@ mod tests {
         assert!(!should_process_event_for_channel(&event, &channel_id));
     }
 
+    #[test]
+    fn conversational_event_summary_extracts_outcome_prefix() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "outcome: implemented the migration safety check",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::Outcome);
+        assert_eq!(summary, "implemented the migration safety check");
+    }
+
+    #[test]
+    fn conversational_event_summary_extracts_blocked_on_prefix() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "blocked_on: waiting for review from infra",
+            WorkingMemoryEventType::Error,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::BlockedOn);
+        assert_eq!(summary, "waiting for review from infra");
+    }
+
+    #[test]
+    fn conversational_event_summary_falls_back_to_default_type() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "completed with no blockers",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::WorkerCompleted);
+        assert_eq!(summary, "completed with no blockers");
+    }
+
+    #[test]
+    fn conversational_event_summary_extracts_constraint_prefix_case_insensitively() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "CoNsTrAiNt: must keep migrations immutable",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::Constraint);
+        assert_eq!(summary, "must keep migrations immutable");
+    }
+
+    #[test]
+    fn conversational_event_summary_is_case_insensitive_across_prefixes() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "OUTCOME: implemented the follow-up",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::Outcome);
+        assert_eq!(summary, "implemented the follow-up");
+
+        let (event_type, summary) = classify_conversational_event_summary(
+            "Blocked_On: waiting on reviewer signoff",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::BlockedOn);
+        assert_eq!(summary, "waiting on reviewer signoff");
+
+        let (event_type, summary) = classify_conversational_event_summary(
+            "blocked on: user approval",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::BlockedOn);
+        assert_eq!(summary, "user approval");
+    }
+
+    #[test]
+    fn conversational_event_summary_treats_empty_prefixed_content_as_empty_summary() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "outcome:   ",
+            WorkingMemoryEventType::WorkerCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::Outcome);
+        assert!(summary.is_empty());
+        assert_eq!(
+            format_conversational_event_summary(event_type, "Worker", &summary),
+            "Worker outcome"
+        );
+    }
+
+    #[test]
+    fn conversational_event_summary_extracts_deadline_prefix() {
+        let (event_type, summary) = classify_conversational_event_summary(
+            "deadline-set: ship by 2026-04-20",
+            WorkingMemoryEventType::BranchCompleted,
+        );
+        assert_eq!(event_type, WorkingMemoryEventType::DeadlineSet);
+        assert_eq!(summary, "ship by 2026-04-20");
+        assert_eq!(
+            format_conversational_event_summary(event_type, "Branch", &summary),
+            "Branch deadline set: ship by 2026-04-20"
+        );
+    }
+
     #[test]
     fn quiet_mode_invocation_uses_discord_mention_and_reply_metadata() {
         let message = inbound_message(