Restore full N×M memory scoring matrix (/score command)

The full matrix scorer was deleted during the AST conversion. Restore
it: /score runs score_memories() which computes divergence for every
memory × response pair, stores the MemoryScore on MindState, and
displays per-memory weights with bar charts on the F2 screen.

Both scoring paths now use ActivityGuard::update() for live progress
in the status bar instead of creating a new activity per iteration.

Also bumps score API timeout from 120s to 300s and adds progress
logging throughout.

Co-Authored-By: Proof of Concept <poc@bcachefs.org>
Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

src/user/context.rs

@@ -39,7 +39,7 @@ impl ConsciousScreen {
             if let AstNode::Leaf(leaf) = node {
                 if let NodeBody::Memory { key, score, text } = leaf.body() {
                     let status = match score {
-                        Some(s) => { scored += 1; format!("score: {:.2}", s) }
+                        Some(s) => { scored += 1; format!("{:.2}", s) }
                         None => { unscored += 1; String::new() }
                     };
                     mem_children.push(SectionView {
@@ -63,7 +63,51 @@ impl ConsciousScreen {
             });
         }
 
-        views.push(section_to_view("Conversation", ctx.conversation()));
+        let conv = ctx.conversation();
+        let mut conv_children: Vec<SectionView> = Vec::new();
+        for node in conv {
+            let mut view = SectionView {
+                name: node.label(),
+                tokens: node.tokens(),
+                content: match node {
+                    AstNode::Leaf(leaf) => leaf.body().text().to_string(),
+                    _ => String::new(),
+                },
+                children: match node {
+                    AstNode::Branch { children, .. } => children.iter()
+                        .map(|c| SectionView {
+                            name: c.label(), tokens: c.tokens(),
+                            content: match c { AstNode::Leaf(l) => l.body().text().to_string(), _ => String::new() },
+                            children: Vec::new(), status: String::new(),
+                        }).collect(),
+                    _ => Vec::new(),
+                },
+                status: String::new(),
+            };
+            // Show memory attribution inline as status text
+            if let AstNode::Branch { memory_scores: ms, .. } = node {
+                if !ms.is_empty() {
+                    let mut attrs: Vec<(&str, f64)> = ms.iter()
+                        .map(|(k, v)| (k.as_str(), *v))
+                        .collect();
+                    attrs.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
+                    let parts: Vec<String> = attrs.iter()
+                        .map(|(k, s)| format!("{}({:.1})", k, s))
+                        .collect();
+                    view.status = format!("← {}", parts.join(" "));
+                }
+            }
+            conv_children.push(view);
+        }
+        let conv_tokens: usize = conv_children.iter().map(|c| c.tokens).sum();
+        views.push(SectionView {
+            name: format!("Conversation ({} entries)", conv_children.len()),
+            tokens: conv_tokens,
+            content: String::new(),
+            children: conv_children,
+            status: String::new(),
+        });
+
         views
     }
 }