Implement chat and markdown views, enhance status bar, and add workflow panel

- Added `chat.rs` for rendering chat messages with timestamps and roles.
- Introduced `markdown.rs` for rendering markdown content with styling.
- Created `status.rs` to display the application status bar with session and message counts.
- Developed `workflow.rs` to show the current workflow status, including tool calls and active jobs.
- Established a `theme.rs` for centralized color management across the UI.
- Updated `mod.rs` to include new modules and manage rendering logic.

src/app/state/rest.rs

@@ -0,0 +1,125 @@
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use tokio::sync::RwLock;
+
+use super::misc::{DirCache, InputState, MiscState, ScrollState};
+use super::runtime::SessionRuntime;
+use super::types::{AgentMode, Origin, Toast, TranscriptCache};
+use crate::model::editlog::EditLog;
+use crate::model::settings::Settings;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChatMessageDisplay {
+    pub role: crate::dto::chat::message::Role,
+    pub content: String,
+    pub timestamp: i64,
+}
+
+impl ChatMessageDisplay {
+    pub fn new(role: crate::dto::chat::message::Role, content: String) -> Self {
+        ChatMessageDisplay {
+            role,
+            content,
+            timestamp: chrono::Utc::now().timestamp_millis(),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct CronJob {
+    pub id: String,
+    pub description: String,
+    pub cron_expr: String,
+    pub active: bool,
+}
+
+#[derive(Clone)]
+pub struct AppStateRest {
+    pub mode: AgentMode,
+    pub settings: Settings,
+    pub workspace_roots: Vec<PathBuf>,
+    pub session_dir: PathBuf,
+    pub memory_dir: PathBuf,
+    pub download_dir: PathBuf,
+    pub worktrees_dir: PathBuf,
+    pub current_dir: PathBuf,
+    pub dir_cache: Arc<RwLock<DirCache>>,
+    pub edit_log: EditLog,
+    pub session_runtime: Option<SessionRuntime>,
+    pub sessions: Vec<crate::model::session::Session>,
+    pub crons: Vec<CronJob>,
+    pub transcript_cache: TranscriptCache,
+    pub scroll: ScrollState,
+    pub input: InputState,
+    pub misc: MiscState,
+    pub pending_api_response: Arc<Mutex<Option<String>>>,
+    pub dirty: bool,
+    pub quit: bool,
+}
+
+impl AppStateRest {
+    pub fn new(workspace_roots: Vec<PathBuf>, session_dir: PathBuf, memory_dir: PathBuf) -> Self {
+        let settings = Settings::load();
+        let download_dir = memory_dir.parent().unwrap_or(&memory_dir).join("downloads");
+        let worktrees_dir = memory_dir.parent().unwrap_or(&memory_dir).join("worktrees");
+        let dir_cache = DirCache::new();
+        AppStateRest {
+            mode: AgentMode::Normal,
+            settings,
+            workspace_roots,
+            session_dir: session_dir.clone(),
+            memory_dir,
+            download_dir,
+            worktrees_dir,
+            current_dir: std::env::current_dir().unwrap_or_default(),
+            pending_api_response: Arc::new(Mutex::new(None)),
+            dir_cache: Arc::new(RwLock::new(dir_cache)),
+            edit_log: EditLog::new(&session_dir),
+            session_runtime: Some(SessionRuntime::new(session_dir.clone())),
+            sessions: Vec::new(),
+            crons: Vec::new(),
+            transcript_cache: TranscriptCache::new(200),
+            scroll: ScrollState::new(),
+            input: InputState::new(),
+            misc: MiscState::new(),
+            dirty: true,
+            quit: false,
+        }
+    }
+
+    pub fn mode(&self) -> AgentMode {
+        self.mode
+    }
+
+    pub fn set_mode(&mut self, mode: AgentMode) {
+        self.mode = mode;
+        self.dirty = true;
+    }
+
+    pub fn push_transcript(&mut self, msg: ChatMessageDisplay) {
+        self.transcript_cache.messages.push(msg);
+        if self.transcript_cache.messages.len() > self.transcript_cache.max_lines {
+            self.transcript_cache.messages.remove(0);
+        }
+        self.transcript_cache.dirty = true;
+        self.dirty = true;
+    }
+
+    pub fn push_toast(&mut self, toast: Toast) {
+        self.misc.push_toast(toast);
+        self.dirty = true;
+    }
+
+    pub fn tool_ctx(&self) -> crate::tool::ToolCtx {
+        crate::tool::ToolCtx {
+            workspaces: self.workspace_roots.clone(),
+            session_dir: self.session_dir.clone(),
+            memory_dir: self.memory_dir.clone(),
+            download_dir: self.download_dir.clone(),
+            worktrees_dir: self.worktrees_dir.clone(),
+            dir_cache: self.dir_cache.clone(),
+            internet_mode: self.settings.internet_mode.clone(),
+            origin: Origin::Main,
+        }
+    }
+}