feat(workspace): add daily memory file management for OpenClaw

Add browse, edit, create and delete support for daily memory files
(~/.openclaw/workspace/memory/YYYY-MM-DD.md) in the Workspace panel.

src-tauri/src/commands/workspace.rs

@@ -1,3 +1,6 @@
+use regex::Regex;
+use std::sync::LazyLock;
+
 use crate::config::write_text_file;
 use crate::openclaw_config::get_openclaw_dir;
 
@@ -24,6 +27,146 @@ fn validate_filename(filename: &str) -> Result<(), String> {
     Ok(())
 }
 
+// --- Daily memory files (memory/YYYY-MM-DD.md) ---
+
+static DAILY_MEMORY_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^\d{4}-\d{2}-\d{2}\.md$").unwrap());
+
+fn validate_daily_memory_filename(filename: &str) -> Result<(), String> {
+    if !DAILY_MEMORY_RE.is_match(filename) {
+        return Err(format!(
+            "Invalid daily memory filename: {filename}. Expected: YYYY-MM-DD.md"
+        ));
+    }
+    Ok(())
+}
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DailyMemoryFileInfo {
+    pub filename: String,
+    pub date: String,
+    pub size_bytes: u64,
+    pub modified_at: u64,
+    pub preview: String,
+}
+
+// --- Daily memory commands ---
+
+/// List all daily memory files under `workspace/memory/`.
+#[tauri::command]
+pub async fn list_daily_memory_files() -> Result<Vec<DailyMemoryFileInfo>, String> {
+    let memory_dir = get_openclaw_dir().join("workspace").join("memory");
+
+    if !memory_dir.exists() {
+        return Ok(Vec::new());
+    }
+
+    let mut files: Vec<DailyMemoryFileInfo> = Vec::new();
+
+    let entries = std::fs::read_dir(&memory_dir)
+        .map_err(|e| format!("Failed to read memory directory: {e}"))?;
+
+    for entry in entries.flatten() {
+        let name = entry.file_name().to_string_lossy().to_string();
+        if !name.ends_with(".md") {
+            continue;
+        }
+
+        let meta = match entry.metadata() {
+            Ok(m) => m,
+            Err(_) => continue,
+        };
+        if !meta.is_file() {
+            continue;
+        }
+
+        let date = name.trim_end_matches(".md").to_string();
+
+        let size_bytes = meta.len();
+        let modified_at = meta
+            .modified()
+            .ok()
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+
+        let preview = std::fs::read_to_string(entry.path())
+            .unwrap_or_default()
+            .chars()
+            .take(200)
+            .collect::<String>();
+
+        files.push(DailyMemoryFileInfo {
+            filename: name,
+            date,
+            size_bytes,
+            modified_at,
+            preview,
+        });
+    }
+
+    // Sort by modified_at descending (newest first)
+    files.sort_by(|a, b| b.modified_at.cmp(&a.modified_at));
+
+    Ok(files)
+}
+
+/// Read a daily memory file.
+#[tauri::command]
+pub async fn read_daily_memory_file(filename: String) -> Result<Option<String>, String> {
+    validate_daily_memory_filename(&filename)?;
+
+    let path = get_openclaw_dir()
+        .join("workspace")
+        .join("memory")
+        .join(&filename);
+
+    if !path.exists() {
+        return Ok(None);
+    }
+
+    std::fs::read_to_string(&path)
+        .map(Some)
+        .map_err(|e| format!("Failed to read daily memory file {filename}: {e}"))
+}
+
+/// Write a daily memory file (atomic write).
+#[tauri::command]
+pub async fn write_daily_memory_file(filename: String, content: String) -> Result<(), String> {
+    validate_daily_memory_filename(&filename)?;
+
+    let memory_dir = get_openclaw_dir().join("workspace").join("memory");
+
+    std::fs::create_dir_all(&memory_dir)
+        .map_err(|e| format!("Failed to create memory directory: {e}"))?;
+
+    let path = memory_dir.join(&filename);
+
+    write_text_file(&path, &content)
+        .map_err(|e| format!("Failed to write daily memory file {filename}: {e}"))
+}
+
+/// Delete a daily memory file (idempotent).
+#[tauri::command]
+pub async fn delete_daily_memory_file(filename: String) -> Result<(), String> {
+    validate_daily_memory_filename(&filename)?;
+
+    let path = get_openclaw_dir()
+        .join("workspace")
+        .join("memory")
+        .join(&filename);
+
+    if path.exists() {
+        std::fs::remove_file(&path)
+            .map_err(|e| format!("Failed to delete daily memory file {filename}: {e}"))?;
+    }
+
+    Ok(())
+}
+
+// --- Workspace file commands ---
+
 /// Read an OpenClaw workspace file content.
 /// Returns None if the file does not exist.
 #[tauri::command]

src-tauri/src/lib.rs

@@ -1071,6 +1071,11 @@ pub fn run() {
             // Workspace files (OpenClaw)
             commands::read_workspace_file,
             commands::write_workspace_file,
+            // Daily memory files (OpenClaw workspace)
+            commands::list_daily_memory_files,
+            commands::read_daily_memory_file,
+            commands::write_daily_memory_file,
+            commands::delete_daily_memory_file,
         ]);
 
     let app = builder