feat(desktop): manual session rename (double-click in sidebar)

Completes the naming mechanism: auto-title (#104) + manual override. Double-
click a session in the sidebar → inline input → Enter/blur saves, Esc cancels.
- Rust session_set_title(id, title) writes the title onto the session_meta
  header line (prepends one for older sessions); empty clears it → falls back
  to the auto-derived title.
- derive_session_title now prefers a manual meta title over the first-user-
  message derivation.
- tauri-api sessionSetTitle; Sidebar inline-edit (stopPropagation so editing
  doesn't trigger select; reloads the list after save).

+1 Rust test (derive prefers meta title, else first user msg). Rust 9 pass;
desktop typecheck/lint/format clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: oratis

apps/desktop/src-tauri/src/commands.rs

@@ -236,10 +236,12 @@ pub struct SessionMeta {
     pub title: String,
 }
 
-/// First non-empty line of the first user message, truncated for display. Used
-/// as a session's auto-title in the sidebar (no manual naming required).
+/// A session's display title. Prefers a manual title set on the `session_meta`
+/// header line (via session_set_title); otherwise derives one from the first
+/// user message (first non-empty line, truncated). Returns None if neither.
 fn derive_session_title(path: &std::path::Path) -> Option<String> {
     let text = std::fs::read_to_string(path).ok()?;
+    let mut from_user: Option<String> = None;
     for line in text.lines() {
         let line = line.trim();
         if line.is_empty() {
@@ -248,25 +250,71 @@ fn derive_session_title(path: &std::path::Path) -> Option<String> {
         let Ok(v) = serde_json::from_str::<serde_json::Value>(line) else {
             continue;
         };
-        if v.get("type").and_then(|t| t.as_str()) != Some("message") {
-            continue;
-        }
-        if v.get("role").and_then(|r| r.as_str()) != Some("user") {
-            continue;
-        }
-        let content = v.get("content").and_then(|c| c.as_array())?;
-        for block in content {
-            if block.get("type").and_then(|t| t.as_str()) == Some("text") {
-                if let Some(txt) = block.get("text").and_then(|t| t.as_str()) {
-                    let title = clean_title(txt);
-                    if !title.is_empty() {
-                        return Some(title);
+        match v.get("type").and_then(|t| t.as_str()) {
+            // Manual title wins — return immediately.
+            Some("session_meta") => {
+                if let Some(t) = v.get("title").and_then(|t| t.as_str()) {
+                    let t = t.trim();
+                    if !t.is_empty() {
+                        return Some(clean_title(t));
                     }
                 }
             }
+            Some("message") if v.get("role").and_then(|r| r.as_str()) == Some("user") => {
+                if from_user.is_none() {
+                    if let Some(content) = v.get("content").and_then(|c| c.as_array()) {
+                        for block in content {
+                            if block.get("type").and_then(|t| t.as_str()) == Some("text") {
+                                if let Some(txt) = block.get("text").and_then(|t| t.as_str()) {
+                                    let title = clean_title(txt);
+                                    if !title.is_empty() {
+                                        from_user = Some(title);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
         }
     }
-    None
+    from_user
+}
+
+/// Set (or clear, with "") a session's manual title on its session_meta header.
+#[tauri::command]
+pub fn session_set_title(id: String, title: String) -> Result<(), String> {
+    let Some(home) = dirs::home_dir() else {
+        return Err("no home directory".into());
+    };
+    let path = home
+        .join(".deepcode")
+        .join("sessions")
+        .join(format!("{id}.jsonl"));
+    let text = std::fs::read_to_string(&path).map_err(|e| format!("read {}: {}", path.display(), e))?;
+    let trimmed = title.trim();
+    let mut lines: Vec<String> = text.lines().map(|l| l.to_string()).collect();
+    let mut updated = false;
+    for line in lines.iter_mut() {
+        let Ok(mut v) = serde_json::from_str::<serde_json::Value>(line.trim()) else {
+            continue;
+        };
+        if v.get("type").and_then(|t| t.as_str()) == Some("session_meta") {
+            v["title"] = serde_json::Value::String(trimmed.to_string());
+            *line = v.to_string();
+            updated = true;
+            break;
+        }
+    }
+    if !updated {
+        // No meta header (older session) — prepend one carrying the title.
+        let meta = serde_json::json!({ "type": "session_meta", "id": id, "title": trimmed });
+        lines.insert(0, meta.to_string());
+    }
+    std::fs::write(&path, lines.join("\n") + "\n")
+        .map_err(|e| format!("write {}: {}", path.display(), e))
 }
 
 /// Strip a leading <system-reminder>…</system-reminder> block (CLI-created
@@ -409,4 +457,36 @@ mod contract_tests {
         assert_eq!(t.chars().count(), 49); // 48 + '…'
         assert!(t.ends_with('…'));
     }
+
+    #[test]
+    fn derive_title_prefers_meta_then_first_user() {
+        use std::io::Write;
+        let dir = std::env::temp_dir();
+        let pid = std::process::id();
+
+        // A manual title on the meta header wins over the first user message.
+        let p1 = dir.join(format!("dc-title-{pid}-a.jsonl"));
+        let mut f = std::fs::File::create(&p1).unwrap();
+        writeln!(f, r#"{{"type":"session_meta","id":"x","title":"My Custom Name"}}"#).unwrap();
+        writeln!(
+            f,
+            r#"{{"type":"message","role":"user","content":[{{"type":"text","text":"the prompt"}}]}}"#
+        )
+        .unwrap();
+        assert_eq!(derive_session_title(&p1).as_deref(), Some("My Custom Name"));
+
+        // No meta title → derive from the first user message (CJK).
+        let p2 = dir.join(format!("dc-title-{pid}-b.jsonl"));
+        let mut f2 = std::fs::File::create(&p2).unwrap();
+        writeln!(f2, r#"{{"type":"session_meta","id":"y"}}"#).unwrap();
+        writeln!(
+            f2,
+            r#"{{"type":"message","role":"user","content":[{{"type":"text","text":"做一个游戏"}}]}}"#
+        )
+        .unwrap();
+        assert_eq!(derive_session_title(&p2).as_deref(), Some("做一个游戏"));
+
+        std::fs::remove_file(&p1).ok();
+        std::fs::remove_file(&p2).ok();
+    }
 }

apps/desktop/src-tauri/src/lib.rs

@@ -18,6 +18,7 @@ use commands::{
     append_allow_matcher, cli_path, get_app_info, get_settings_path, list_sessions,
     load_keybindings, load_settings_file, open_url, read_credentials, save_credentials,
     save_keybindings, save_settings_file, session_append, session_create, session_read,
+    session_set_title,
 };
 use tools::{tool_bash, tool_edit, tool_glob, tool_grep, tool_read, tool_write};
 use tauri::Manager;
@@ -44,6 +45,7 @@ pub fn run() {
             session_create,
             session_append,
             session_read,
+            session_set_title,
             list_sessions,
             cli_path,
             open_url,

apps/desktop/src/components/Sidebar.tsx

@@ -4,9 +4,9 @@
 // folder + a small switch-folder button. Below: sessions bucketed by
 // Today/Yesterday/Earlier per the spec note ①.
 
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { projectName } from '../lib/project.js';
-import { listSessions, type SessionMeta } from '../lib/tauri-api.js';
+import { listSessions, sessionSetTitle, type SessionMeta } from '../lib/tauri-api.js';
 import { BrandMark } from './BrandMark.js';
 
 interface SidebarProps {
@@ -46,14 +46,31 @@ export function Sidebar({
 }: SidebarProps): JSX.Element {
   const [sessions, setSessions] = useState<SessionMeta[]>([]);
   const [now, setNow] = useState<number>(Math.floor(Date.now() / 1000));
+  // Inline rename: which session is being edited + its draft title.
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [editValue, setEditValue] = useState('');
 
-  useEffect(() => {
+  const reload = useCallback(() => {
     void listSessions()
       .then(setSessions)
       .catch(() => setSessions([]));
+  }, []);
+
+  useEffect(() => {
+    reload();
     const t = setInterval(() => setNow(Math.floor(Date.now() / 1000)), 30_000);
     return () => clearInterval(t);
-  }, []);
+  }, [reload]);
+
+  async function commitRename(id: string): Promise<void> {
+    setEditingId(null);
+    try {
+      await sessionSetTitle(id, editValue.trim());
+      reload();
+    } catch {
+      /* keep the old title on failure */
+    }
+  }
 
   const grouped: Record<Bucket, SessionMeta[]> = {
     Today: [],
@@ -150,11 +167,42 @@ export function Sidebar({
               <div
                 key={s.id}
                 className={'item' + (s.id === activeSessionId ? ' active' : '')}
-                onClick={() => onPickSession(s.id)}
-                title={`${s.title} · ${s.id}`}
+                onClick={() => editingId !== s.id && onPickSession(s.id)}
+                onDoubleClick={(e) => {
+                  e.stopPropagation();
+                  setEditingId(s.id);
+                  setEditValue(s.title?.trim() ? s.title : '');
+                }}
+                title={`${s.title} · ${s.id}  (double-click to rename)`}
               >
                 <span className="dot" />
-                <span className="label">{s.title?.trim() ? s.title : shortTitle(s.id)}</span>
+                {editingId === s.id ? (
+                  <input
+                    className="label"
+                    autoFocus
+                    value={editValue}
+                    placeholder="Session name…"
+                    onChange={(e) => setEditValue(e.target.value)}
+                    onClick={(e) => e.stopPropagation()}
+                    onKeyDown={(e) => {
+                      if (e.key === 'Enter') void commitRename(s.id);
+                      else if (e.key === 'Escape') setEditingId(null);
+                    }}
+                    onBlur={() => void commitRename(s.id)}
+                    style={{
+                      flex: 1,
+                      minWidth: 0,
+                      background: 'transparent',
+                      border: '1px solid var(--line)',
+                      borderRadius: 4,
+                      color: 'var(--text-0)',
+                      font: 'inherit',
+                      padding: '0 4px',
+                    }}
+                  />
+                ) : (
+                  <span className="label">{s.title?.trim() ? s.title : shortTitle(s.id)}</span>
+                )}
                 <span className="meta">{relTime(s.updated_at_secs, now)}</span>
               </div>
             ))}

apps/desktop/src/lib/tauri-api.ts

@@ -132,6 +132,11 @@ export async function sessionCreate(cwd: string): Promise<string> {
   return (await invoke('session_create', { cwd })) as string;
 }
 
+/** Set (or clear, with '') a session's manual title. */
+export async function sessionSetTitle(id: string, title: string): Promise<void> {
+  await invoke('session_set_title', { id, title });
+}
+
 /** Append one JSON message line to a session's JSONL file. */
 export async function sessionAppend(id: string, message: Record<string, unknown>): Promise<void> {
   await invoke('session_append', { id, message });