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/app/runtime/stream/tools/mod.rs

@@ -1,3 +1,16 @@
+//! Standalone accumulator for streamed tool-call deltas.
+//!
+//! Flow: `ToolCallAccumulator::add_delta` is fed incremental `(index, id,
+//! name, arguments_delta)` chunks as they arrive over SSE → grows its
+//! internal `Vec<ParsedToolCall>` as needed → `is_complete` reports once
+//! every accumulated call has both a name and arguments.
+//!
+//! Why: mirrors the accumulation logic built into `StreamedTurn::apply_event`
+//! but as an independent, reusable type for callers that want to track
+//! tool-call deltas without a full `StreamedTurn` (e.g. a lighter-weight
+//! preview). Currently unused (`#[allow(dead_code)]`), kept for that future
+//! use case.
+
 use super::turn::ParsedToolCall;
 use serde_json::{json, Value};
 
@@ -11,10 +24,15 @@ pub struct ToolCallAccumulator {
 
 #[allow(dead_code)]
 impl ToolCallAccumulator {
+    /// Construct an empty accumulator with no tool calls tracked yet.
+    ///
+    /// Return: a fresh `ToolCallAccumulator`.
     pub fn new() -> Self {
         ToolCallAccumulator { calls: Vec::new() }
     }
 
+    /// Append a delta to the tool call at the given index, growing the
+    /// calls vector if needed.
     pub fn add_delta(
         &mut self,
         index: usize,
@@ -44,18 +62,23 @@ impl ToolCallAccumulator {
         tc.arguments.push_str(arguments_delta);
     }
 
+    /// Borrow the accumulated tool calls.
     pub fn calls(&self) -> &[ParsedToolCall] {
         &self.calls
     }
 
+    /// Return true once all tool calls have both a name and arguments.
     pub fn is_complete(&self) -> bool {
         !self.calls.is_empty() && self.calls.iter().all(|tc| !tc.name.is_empty() && !tc.arguments.is_empty())
     }
 
+    /// Clear all accumulated calls (starting a fresh turn).
     pub fn reset(&mut self) {
         self.calls.clear();
     }
 
+    /// Build a JSON-serialisable `Vec<Value>` of pending (non-empty-name)
+    /// tool calls, suitable for downstream inspection or replay.
     pub fn pending_args(&self) -> Vec<Value> {
         self.calls
             .iter()