Enhance tool documentation and add new features

- Added module-level documentation for memory tools (`remember`, `recall`, `forget`) to clarify their purpose.
- Improved documentation in `recall.rs` and `remember.rs` to describe the functionality and flow of memory entry operations.
- Updated `mod.rs` to include descriptions for the tool trait and execution context.
- Enhanced `plan.rs` with detailed comments on plan-mode signaling tools.
- Documented text search tools in `search.rs` to explain their functionality.
- Improved sequential-thinking tool documentation in `seqthink.rs`.
- Added safety filter documentation in `shell_filter` for credential and git operations.
- Enhanced utility tools documentation, including `cd`, `dir_cache_update`, and `todowrite`.
- Improved rendering documentation in view modules (`chat`, `markdown`, `status`, `workflow`) to clarify rendering flows and purposes.

src/model/editlog.rs

@@ -1,5 +1,10 @@
+//! Append-only JSONL edit log recording every file mutation made by tools,
+//! for audit and undo/history purposes.
+
 use serde::{Deserialize, Serialize};
 
+/// A single recorded file edit: which tool made it, to which path, why,
+/// and a content hash/size delta for verification.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EditLogEntry {
     pub ts: i64,
@@ -12,6 +17,7 @@ pub struct EditLogEntry {
     pub session_id: String,
 }
 
+/// In-memory view of a session's edit log, backed by `edits.jsonl` on disk.
 #[derive(Debug, Clone)]
 pub struct EditLog {
     pub entries: Vec<EditLogEntry>,
@@ -19,6 +25,8 @@ pub struct EditLog {
 }
 
 impl EditLog {
+    /// Open (or start tracking) the edit log for a session directory,
+    /// replaying any existing `edits.jsonl` into memory.
     pub fn new(session_dir: &std::path::Path) -> Self {
         let path = session_dir.join("edits.jsonl");
         let entries = Self::load_from_disk(&path);
@@ -40,6 +48,17 @@ impl EditLog {
             .collect()
     }
 
+    /// Append one entry to `edits.jsonl` on disk and to the in-memory log.
+    ///
+    /// Flow: serialize `entry` to a JSON line → ensure parent dir exists →
+    /// open the file in append mode → write the line → push into
+    /// `self.entries`.
+    ///
+    /// Why: appending (not rewriting) keeps the log durable and cheap even
+    /// as it grows across a long session.
+    ///
+    /// Return: `Ok(())` on success; an `io::Error` if serialization or
+    /// any filesystem operation fails.
     pub fn append(&mut self, entry: EditLogEntry) -> std::io::Result<()> {
         let line = serde_json::to_string(&entry)? + "\n";
         let parent = self.path.parent().unwrap();
@@ -54,6 +73,7 @@ impl EditLog {
         Ok(())
     }
 
+    /// Number of edit entries recorded so far in this log.
     pub fn len(&self) -> usize {
         self.entries.len()
     }