journal: remove all stringly-typed key patterns, use NodeType

- journal_new: key is slugified title (agent names things properly)
- journal_tail: sort by created_at (immutable), not timestamp (mutable)
- journal_update: find latest by created_at
- {{latest_journal}}: query by NodeType::EpisodicSession, not "journal" key
- poc-memory journal write: requires a name argument
- Removed all journal#j-{timestamp}-{slug} patterns from:
  - prompts.rs (rename candidates)
  - graph.rs (date extraction, organize skip list)
  - cursor.rs (date extraction)
  - store/mod.rs (doc comment)
- graph.rs organize: filter by NodeType::Semantic instead of key prefix
- cursor.rs: use created_at for date extraction instead of key parsing

Co-Authored-By: Kent Overstreet <kent.overstreet@linux.dev>

src/agent/tools/memory.rs

@@ -156,7 +156,8 @@ pub fn dispatch(name: &str, args: &serde_json::Value, provenance: Option<&str>)
             let mut entries: Vec<&crate::store::Node> = store.nodes.values()
                 .filter(|n| n.node_type == crate::store::NodeType::EpisodicSession)
                 .collect();
-            entries.sort_by_key(|n| n.timestamp);
+            // Sort by creation time (immutable), not update time
+            entries.sort_by_key(|n| n.created_at);
             let start = entries.len().saturating_sub(count);
             if entries[start..].is_empty() {
                 Ok("(no journal entries)".into())
@@ -173,19 +174,18 @@ pub fn dispatch(name: &str, args: &serde_json::Value, provenance: Option<&str>)
             let ts = chrono::Local::now().format("%Y-%m-%dT%H:%M");
             let content = format!("## {} — {}\n\n{}", ts, title, body);
 
-            let slug: String = title.split_whitespace()
-                .take(6)
+            // Key from title — the agent names things, not a placeholder slug
+            let key: String = title.split_whitespace()
                 .map(|w| w.to_lowercase()
                     .chars().filter(|c| c.is_alphanumeric() || *c == '-')
                     .collect::<String>())
+                .filter(|s| !s.is_empty())
                 .collect::<Vec<_>>()
                 .join("-");
-            let slug = if slug.len() > 50 { &slug[..50] } else { &slug };
-            let key = format!("journal-j-{}-{}",
-                ts.to_string().to_lowercase().replace(':', "-"), slug);
+            let key = if key.len() > 80 { &key[..80] } else { &key };
 
             let mut store = Store::load().map_err(|e| anyhow::anyhow!("{}", e))?;
-            let mut node = crate::store::new_node(&key, &content);
+            let mut node = crate::store::new_node(key, &content);
             node.node_type = crate::store::NodeType::EpisodicSession;
             node.provenance = prov.to_string();
             store.upsert_node(node).map_err(|e| anyhow::anyhow!("{}", e))?;
@@ -196,10 +196,10 @@ pub fn dispatch(name: &str, args: &serde_json::Value, provenance: Option<&str>)
         "journal_update" => {
             let body = get_str(args, "body")?;
             let mut store = Store::load().map_err(|e| anyhow::anyhow!("{}", e))?;
-            // Find most recent EpisodicSession node
+            // Find most recent EpisodicSession by creation time
             let latest_key = store.nodes.values()
                 .filter(|n| n.node_type == crate::store::NodeType::EpisodicSession)
-                .max_by_key(|n| n.timestamp)
+                .max_by_key(|n| n.created_at)
                 .map(|n| n.key.clone());
             let Some(key) = latest_key else {
                 anyhow::bail!("no journal entry to update — use journal_new first");