refactor: consolidate hypotheses, agent_signals, and process_logs into action-based smart tools

EFFECTIVE_DISCOURSE.md

@@ -48,7 +48,7 @@ When entering a new file, avoid having the LLM read the entire contents blindly.
 Stop copy-pasting giant walls of logs into the chat interface.
 * **Don't say:** "Here is the error: [paste 500 lines of logs]"
 * **Do say:** "The daemon crashed. Fetch the recent logs from daemon.log." or "Watch the process logs for server.log."
-* **Tool Triggered:** `get_recent_logs`, `watch_process_logs`
+* **Tool Triggered:** `process_logs` (action: "get", action: "watch")
 
 ---
 
@@ -60,11 +60,11 @@ When you've been working independently and need to loop the LLM back in on your
 
 ---
 
-## 8. Clipboard Watch Mode (Research & Triage)
-When you are doing intense debugging across StackOverflow, logs, and docs, use the clipboard watcher to auto-ingest your breadcrumbs.
-* **Action:** Ask the LLM to turn it on: "Enable clipboard watch mode."
-* **Do say:** "I'm going to reproduce the bug and copy some stack traces and IDs. Give me a minute, then read my latest sticky notes to catch up."
-* **Tool Triggered:** `toggle_clipboard_watch_mode`, followed by internal Sticky Note reads.
+## 8. Inter-Agent Signal Bus & Coordination
+When multiple subagents collaborate or background tasks complete.
+* **Don't say:** "Let me manually tell the ScrumMaster that testing finished."
+* **Do say:** "Broadcast an agent signal that unit tests passed and ping the PrePushAuditor."
+* **Tool Triggered:** `agent_signals` (action: "broadcast", action: "query")
 
 ---
 
@@ -117,7 +117,7 @@ Actively instruct the LLM to maintain its memory constraints and use canonical c
 ## 15. Diagnostic Hypotheses & Reasoning Traces
 * **Don't say:** "Let's test three guesses and remember what we tried in chat."
 * **Do say:** "Log a hypothesis for this memory leak with tested evidence."
-* **Tool Triggered:** `log_hypothesis` / `query_hypotheses`
+* **Tool Triggered:** `hypotheses` (action: "log", action: "query")
 
 ---
 

README.md

@@ -29,7 +29,7 @@ To prevent graph fragmentation and ensure optimal LLM tokenization and retrieval
 
 ## 🛠️ Consolidated Smart MCP Tools
 
-The server consolidates granular single-purpose tools into 8 concise, action-oriented smart domain handlers with zero prefix clutter:
+The server consolidates granular single-purpose tools into 11 concise, action-oriented smart domain handlers with zero prefix clutter:
 
 * **`tasks`**: Complete task lifecycle management (`add`, `update`, `delete`, `list`, `set_criteria`, `verify`).
 * **`milestones`**: Milestone tracking (`add`, `update`, `list`).
@@ -39,7 +39,9 @@ The server consolidates granular single-purpose tools into 8 concise, action-ori
 * **`tech_debt`**: Engineering technical debt backlog (`log`, `resolve`, `list`).
 * **`environment`**: Infrastructure & tool fingerprints tracking (`update_fingerprint`, `read_fingerprint`, `log_requirement`, `register`, `get_details`).
 * **`clipboard`**: Cross-OS clipboard management (`read`, `write`).
-
+* **`hypotheses`**: Diagnostic hypothesis memory (`log`, `query`).
+* **`agent_signals`**: Inter-agent signal bus (`broadcast`, `query`).
+* **`process_logs`**: Process and daemon log management (`watch`, `get`, `clear`).
 ---
 
 ## Key Features & Capabilities
@@ -79,10 +81,16 @@ Traces the full causal chain linking tasks, ADRs, audit ledger entries, git comm
 ### 🎯 Topological Unblocked Task Resolver (`get_next_actionable_tasks`)
 Evaluates task dependency graphs and returns unblocked, ready-to-run tasks for subagent execution.
 
-### 🧠 Chain-of-Thought & Diagnostic Hypothesis Memory (`log_hypothesis` / `query_hypotheses`)
-Records structured diagnostic hypotheses, test evidence, and verification statuses to preserve reasoning across sessions.
+### 🧠 Chain-of-Thought & Diagnostic Hypothesis Memory (`hypotheses`)
+Records structured diagnostic hypotheses, test evidence, and verification statuses (actions: `log`, `query`) to preserve reasoning across sessions.
+
+### 📡 Inter-Agent Signal Bus (`agent_signals`)
+Facilitates real-time peer-to-peer signal exchange between autonomous subagents (actions: `broadcast`, `query`) with TTL expiration and activity feeds.
 
 ### 🔒 Resilient Storage & Serde Parameter Tolerances
+### 📑 Process & Daemon Log Management (`process_logs`)
+Registers and tails live process and daemon log files with UTF-8 safe seeking (actions: `watch`, `get`, `clear`) to diagnose runtime behavior without reading multi-megabyte files into chat context.
+
 * **Explicit Fail-Fast Persistence Safety**: Replaced unsafe silent fallback to temporary databases (`/tmp/mcp_store_fallback_*`) with an explicit open retry and fail-fast panic unless `MCP_ALLOW_TMP_FALLBACK=1` is explicitly set, preventing silent data loss.
 * **Store Write Lock Minimization**: Releases write lock immediately following in-memory mutation, serializing JSON payloads under read locks to allow non-blocking concurrent readers.
 * **Two-Phase Graph Condensation**: Employs a non-destructive 2-phase commit in `condense_graph_worker` (reading without clearing, inserting into the knowledge graph, and only pruning summarized records by timestamp/content upon verified success).
@@ -185,5 +193,5 @@ To view the dashboard, open your browser at:
 * **Bounded Telemetry Detail Records**: Activity and terminal telemetry buffers enforce a 4,000 character truncation ceiling on log details (`ActivityRecord`, `TerminalHistory`) to prevent unbounded RAM growth under heavy RPC traffic.
 * **Zero-Allocation Stream Formatting**: Graph condensation loops (`condense_graph_worker`) use `std::fmt::Write` string stream buffers to format subgraphs without allocating temporary string intermediates.
 * **SIMD-Friendly Single-Pass Cosine Similarity**: `cosine_similarity` calculates dot product and Euclidean norm squares in a single iterator fold pass over float vectors, enabling SIMD compiler auto-vectorization.
-* **Safe Stream Decoding on Log Tails**: Log tail operations (`get_recent_logs`) read raw bytes and decode using lossy UTF-8 conversion (`String::from_utf8_lossy`) to ensure resilience when seeking across multi-byte UTF-8 boundaries.
-* **Serde Parameter & Enum Tolerance**: All action enums (`StickyNoteAction`, `SnippetSearchMode`, `Relation`) support case-insensitive variants and field aliases (`source`/`from`, `target`/`to`, `relationType`/`relation_type`) to ensure seamless execution when LLMs pass varied string formatting.
+* **Safe Stream Decoding on Log Tails**: Process log tailing (`process_logs`, action: `get`) reads raw bytes and decodes using lossy UTF-8 conversion (`String::from_utf8_lossy`) to ensure resilience when seeking across multi-byte UTF-8 boundaries.
+* **Serde Parameter & Enum Tolerance**: All action enums (`HandoffMemoAction`, `HypothesisAction`, `AgentSignalAction`, `ProcessLogAction`, `SnippetSearchMode`, `Relation`) support case-insensitive variants and field aliases (`source`/`from`, `target`/`to`, `relationType`/`relation_type`) to ensure seamless execution when LLMs pass varied string formatting.

agent-rules/mcp_memory_workflow.md

@@ -24,6 +24,9 @@ The MCP Memory server is the central brain. You must be PROACTIVE, not reactive,
 - **Task Management**: When creating tasks, supply `priority` ('low'|'medium'|'high'|'urgent'), `assigned_agent` (e.g. subagent role), `verification_command` (automated test command), and `acceptance_criteria`.
 - **VCS & SVN Agnosticism**: Supply `vcs_type` ('git'|'svn'|'hg'), `vcs_revision` (git hash or svn revision like 'r12345'), and `upstream_url` to `log_code_change` and workspace tools.
 - **Terminal & Shell Context**: Terminal sessions and commands are automatically tracked in the server. Query `/terminal/history` or recent logs when analyzing shell execution context.
+- **Hypotheses & Root Cause Analysis**: When diagnosing complex bugs or race conditions, call `hypotheses` (action: "log" / "query") to record test evidence and maintain reasoning trails across sessions.
+- **Inter-Agent Coordination**: Autonomous subagents should call `agent_signals` (action: "broadcast" / "query") to publish events and discover peer agent status.
+- **Process & Daemon Logs**: Query or tail daemon logs with `process_logs` (action: "get", "watch", "clear") instead of dumping log files into context.
 
 ## 3. Delegation
 Continue to use the `MemoryLibrarian` subagent to log routine code changes (`log_code_change`) in the background to prevent cluttering the main conversation context.

agent-rules/state_management.md

@@ -1,7 +1,7 @@
 # Antigravity State Management & Git Worktree Rules
 
 ## State Tracking & Persistent Memory
-- **Long-term Knowledge (MCP):** Use the MCP memory graph strictly for long-term, persistent facts such as architectural decisions, environment invariants, SSH mappings, and user preferences.
+- **Long-term Knowledge (MCP):** Use the MCP memory graph strictly for long-term, persistent facts such as architectural decisions, environment invariants, SSH mappings, and domain entities. Static developer preferences and rules are kept in git-tracked markdown files.
 - **Transient State (Git):** Do NOT write transient task progress (e.g., "currently editing line 42") to MCP memory. Continue to use verbose, incremental local `git` commits to track short-term state and maintain rollback safety.
 
 ## Branching Strategy & Workflow (Git Worktrees)

design.md

@@ -21,7 +21,7 @@ The server hosts a rich Single Page Application (SPA) natively on the root route
 *   `GET /`: The Brain Monitor live HTML dashboard SPA.
 *   `GET /api/graph`: Returns the full node/edge topology for the interactive physics-simulated canvas.
 *   `GET /api/tasks` & `POST /api/tasks/{id}/complete`: Drives the actionable Kanban board.
-*   `GET /api/sticky` & `GET /api/search`: Powers the sticky notes tab and global fuzzy search UI.
+*   `GET /api/ledger` & `GET /api/search`: Powers the code change ledger and global fuzzy search UI.
 *   `GET /api/stats`: Returns a JSON snapshot of current entity, relation, task, and tech debt counts.
 
 ### Git & IDE Integration Endpoints
@@ -61,7 +61,7 @@ The daemon has completely eliminated raw JSON file sprawl and fragmented delta-f
 The system leverages a modular, thread-safe generic `Store<T>` abstraction that automatically transparently serializes and deserializes native Rust structs directly into the underlying `redb` tables.
 Currently implemented persistent stores include:
 *   **Audit Ledger & Tasks:** Tracks agent actions and active background tasks.
-*   **Context & Handoffs:** Sticky notes, Session Summaries, Handoff Memos, and Context Workspaces.
+*   **Context & Handoffs:** Session Summaries, Handoff Memos, Hypotheses, and Agent Signals.
 *   **Engineering Tracking:** ADRs (Architecture Decision Records), Snippets, Error Fixes, Tech Debt, and PR Checklists.
 *   **Environment State:** Pinned Files, Env Fingerprints, Milestones, and Environments.
 *   **Safety Gates:** Authorized execution gates (Push Safety).
@@ -91,7 +91,7 @@ The physical storage location of the knowledge graph and all persistent stores i
 The server implements the Model Context Protocol (MCP) by exposing a vast suite of tools via the JSON-RPC interface, categorized broadly into:
 *   **Graph Management:** create_entities, create_relations, merge_entities, 
 read_graph, etc.
-*   **Task & Context Tracking:** tasks, milestones, handoff_memos, add_session_summary, etc.
+*   **Task & Context Tracking:** tasks, milestones, handoff_memos, hypotheses, agent_signals, process_logs, add_session_summary, etc.
 *   **Engineering & DevOps:** log_code_change, log_error_fix, tech_debt, decisions, etc.
 *   **Environment & Workspaces:** environment, manage_checkpoint, manage_subagent_namespace, snippets, etc.
 

instructions.md

@@ -73,6 +73,19 @@ The server consolidates granular single-purpose tools into domain-named smart to
   - `action: "read"`: Read OS clipboard.
   - `action: "write"`: Write text/html/files/image to clipboard.
 
+* **`hypotheses`**: Diagnostic hypothesis memory.
+  - `action: "log"`: Record diagnostic hypothesis (requires `hypothesis`, optional `status: "open" | "verified" | "disproven"`, `evidence: Vec<String>`, `test_command`, `git_branch`, `repo_name`).
+  - `action: "query"`: Query hypotheses (optional `status`, `git_branch`, `repo_name`).
+
+* **`agent_signals`**: Inter-agent signal bus.
+  - `action: "broadcast"`: Broadcast signal to other agents (requires `signal_type`, `payload`, optional `target_agent`, `ttl_seconds`).
+  - `action: "query"`: Query active signals (optional `signal_type`, `include_expired: bool`).
+
+* **`process_logs`**: Process and daemon log management.
+  - `action: "watch"`: Register or update log file watcher (requires `label`, `file_path`, optional `description`).
+  - `action: "get"`: Retrieve recent log lines from watched process log (requires `label`, optional `tail_lines: usize`).
+  - `action: "clear"`: Clear or truncate watched process log file (requires `label`).
+
 ---
 
 ## 3. VCS & SVN Agnosticism & Multi-Repo Provenance
@@ -185,16 +198,16 @@ To maintain maximum security, speed, and cross-platform reliability:
 * **Batch Vector Indexing & Similarity Score Guidance**: `VectorDB` provides `index_documents_batch` for single-request multi-point vector upserts and explicit score calibration notes ($\ge 0.75$ high confidence match).
 * **Compact JSON MCP Resources & UTF-8 Activity Truncation**: MCP resources serialize using compact JSON (`to_string`), `TerminalHistoryResource` / `MilestonesResource` enforce output bounds, and `format_tool_activity_description` uses `floor_char_boundary` for guaranteed UTF-8 safety.
 * **SIMD-Friendly Single-Pass Cosine Similarity**: `cosine_similarity` calculates dot product and Euclidean norm squares in a single linear pass over float vectors, enabling SIMD compiler auto-vectorization.
-* **Safe Stream Decoding on Log Tails**: Log tail operations (`get_recent_logs`) read raw bytes and decode using lossy UTF-8 conversion (`String::from_utf8_lossy`) to ensure resilience when seeking across multi-byte UTF-8 boundaries.
+* **Safe Stream Decoding on Log Tails**: Log tail operations (`process_logs`, action: "get") read raw bytes and decode using lossy UTF-8 conversion (`String::from_utf8_lossy`) to ensure resilience when seeking across multi-byte UTF-8 boundaries.
 * **Task Summary UTF-8 Truncation Safety**: `tasks` tool (`action = "list"`) truncates serialized task text strictly along UTF-8 character boundaries using `floor_char_boundary` when enforcing `max_tokens`.
 * **Sequential Snapshot Lock Scope Flattening**: `GenerateStandupReportHandler` reads `tasks`, `ledger`, and `session_summaries` sequentially rather than nesting read locks, preventing multi-lock deadlocks during concurrent store modifications.
 * **Directory Tree Depth Safeguard**: `ReadDirectoryArchitectureHandler` caps directory recursion at depth 10 to prevent stack overflow on deep or cyclic directory structures.
 * **Deterministic Total-Order Score Ranking**: `OmniSearchHandler` uses `f64::total_cmp` for Reciprocal Rank Fusion (RRF) score sorting, guaranteeing deterministic NaN-safe search result ordering.
 * **RPC Timeout Memory Hygiene**: `nvim-core` maintains request hygiene by removing pending request entries from static RPC maps upon timeout or channel drop, eliminating orphan memory leaks.
 * **Embedding Input Safeguard**: `generate_embedding_async` returns explicit errors for empty/0-length text inputs instead of returning empty vectors, preventing downstream vector dimension mismatches during cosine similarity calculations.
-* **Path Traversal Security Guards**: `validate_safe_path` enforces path canonicalization and rejects relative parent traversal components (`..`) across file and process log handlers (`GetRecentLogsTool`, `WatchProcessLogsTool`).
+* **Path Traversal Security Guards**: `validate_safe_path` enforces path canonicalization and rejects relative parent traversal components (`..`) across file and process log handlers (`process_logs` / `ProcessLogsTool`).
 * **Watcher Map Memory Eviction**: Proactive daemon file watcher in `watcher.rs` caps `last_processed` map size at 1,000 entries and purges entries older than 10 minutes to prevent monotonic memory leakage.
-* **Comprehensive Serde Casing Aliases**: All 8 consolidated tool action enums (TaskAction, MilestoneAction, SnippetAction, DecisionAction, TechDebtAction, EnvAction, ClipboardAction, HandoffMemoAction) include serde alias attributes supporting `snake_case`, `camelCase`, `PascalCase`, and uppercase variants for maximum LLM casing resilience.
+* **Comprehensive Serde Casing Aliases**: All 11 consolidated tool action enums (TaskAction, MilestoneAction, SnippetAction, DecisionAction, TechDebtAction, EnvAction, ClipboardAction, HandoffMemoAction, HypothesisAction, AgentSignalAction, ProcessLogAction) include serde alias attributes supporting `snake_case`, `camelCase`, `PascalCase`, and uppercase variants for maximum LLM casing resilience.
 * **Two-Phase Graph Condensation**: `condense_graph_worker` uses a 2-phase commit (non-destructive `read_with` -> graph insert -> prune by timestamp/content) to prevent data loss if summarization or graph insertion fails.
 * **Store Write Lock Minimization**: `Store::modify` and `Store::modify_async` unblock concurrent readers during JSON serialization by releasing the write lock immediately after mutating memory state.
 * **Redb Database Lock Retry Backoff**: `init_db` retries transient Redb lock contention with exponential backoff (3 attempts, 150ms delay) before falling back.

mcp_tools_review.md

@@ -5,27 +5,21 @@
 Our current MCP ecosystem is highly advanced, utilizing a **Dual-Transport Leader/Stub Architecture** (Windows Host + WSL Proxy) to completely eliminate cross-OS I/O latency. 
 
 ### 1. Context & Token Optimization
-*   ␍ead_file_skeleton: Highly effective. Uses 	ree-sitter to extract ASTs (Rust, Python, TS). **Score: A+ (Massive token savings)**
-*   get_active_worktree_context: Native git2 integration. Bypasses shell parsing for clean JSON diffs. **Score: A**
-*   watch_process_logs / get_recent_logs: Direct file seeking. Prevents LLMs from reading multi-megabyte log files. **Score: A**
+*   `read_file_skeleton`: Highly effective. Uses tree-sitter to extract ASTs (Rust, Python, TS). **Score: A+ (Massive token savings)**
+*   `get_active_worktree_context`: Native git2 integration. Bypasses shell parsing for clean JSON diffs. **Score: A**
+*   `process_logs`: Direct file seeking and daemon log management (`watch`, `get`, `clear`). Prevents LLMs from reading multi-megabyte log files. **Score: A**
 
-### 2. Neovim IDE Integration (
-vim-core)
-*   
-vim_set_preview, 
-vim_goto_line, 
-vim_set_diagnostics, 
-vim_execute_lua, 
-vim_get_active_buffer.
+### 2. Neovim IDE Integration (nvim-core)
+*   `nvim_buffer`, `nvim_window`, `nvim_view`, `nvim_diagnostics`, `nvim_visual`, `nvim_execute_lua`, `nvim_system`.
 *   **Review:** Exceptional human QoL. The agent interacts with the code where the human's eyes actually are. Ghost text and diagnostic extmarks provide an IDE-like experience usually reserved for closed-source tools like Cursor. **Score: S-Tier**
 
 ### 3. Clipboard & Workflow
-*   write_clipboard, ␍ead_clipboard, 	oggle_clipboard_watch_mode.
-*   **Review:** Native cross-OS clipboard-win and rboard implementation. Auto-ingesting into StickyNotes bridges the gap between manual human research and the agent's context. **Score: A**
+*   `clipboard` (`read`, `write`).
+*   **Review:** Native cross-OS clipboard-win and arboard implementation with on-demand image grab. Bridges the gap between manual human research and the agent's context. **Score: A**
 
 ### 4. Graph & Memory Management
-*   create_entities, dd_sticky_note, save_context_workspace, handoff_routine.
-*   **Review:** Solid foundation for state persistence across branches and days. **Score: B+** (Could use more automated TTL/decay for outdated context).
+*   `create_entities`, `hypotheses`, `agent_signals`, `handoff_routine`.
+*   **Review:** Solid foundation for state persistence across branches and days. **Score: A**
 
 ---
 
@@ -33,29 +27,27 @@ vim_get_active_buffer.
 
 To push the system to the absolute bleeding edge of autonomous coding, I propose the following 5 new tools/enhancements.
 
-### 1. ␍eplace_ast_node (Robust Structural Editing)
-*   **The Problem:** The current ␍eplace_file_content uses exact string matching and line numbers. Line numbers change when humans edit simultaneously, and string matching fails on whitespace/indentation.
-*   **The Solution:** An MCP tool that takes (file_path, node_type, node_name, new_content). It uses 	ree-sitter to find the exact boundary of n execute(...) and replaces just that AST node.
+### 1. `replace_ast_node` (Robust Structural Editing)
+*   **The Problem:** Standard text replacement uses exact string matching and line numbers. Line numbers change when humans edit simultaneously, and string matching fails on whitespace/indentation.
+*   **The Solution:** An MCP tool that takes `(file_path, node_type, node_name, new_content)`. It uses tree-sitter to find the exact boundary of `fn execute(...)` and replaces just that AST node.
 *   **Impact:** Zero LLM syntax/indentation errors. 100% robust edits. Drastically lowers Time-to-Resolve (T2R) by eliminating failed edit loops.
 
-### 2. semantic_code_search (Local Vector Embeddings)
-*   **The Problem:** grep_search relies on exact regex. If the LLM guesses the wrong variable name, it wastes tokens searching and reading the wrong files.
-*   **The Solution:** We already have 	antivy and astembed in our Cargo.toml. We can index the AST blocks of the codebase in the background. The LLM can query *"Where is the auth token validated?"* and get the exact 3 relevant functions instantly.
+### 2. `semantic_code_search` (Local Vector Embeddings)
+*   **The Problem:** Text search relies on exact regex. If the LLM guesses the wrong variable name, it wastes tokens searching and reading the wrong files.
+*   **The Solution:** Using Tantivy and BERT embeddings in our backend. We index the AST blocks of the codebase in the background. The LLM can query *"Where is the auth token validated?"* and get the exact 3 relevant functions instantly.
 *   **Impact:** Massive token cost reduction (no blind file reading). Instant T2R for codebase exploration.
 
-### 3. 
-vim_send_to_terminal (Interactive Execution QoL)
-*   **The Problem:** When the agent runs a background terminal command (cargo build, 
-pm run dev), the output is hidden from the human, and interactive prompts cause the background task to hang indefinitely.
-*   **The Solution:** A tool that opens a Neovim :term split (or uses a 	mux pane) and sends the command there.
-*   **Impact:** Massive Human QoL. The human can watch the tests run natively, interact with prompts, see ANSI colors, and press <C-c> to kill it if it loops.
+### 3. `nvim_system` terminal execution (Interactive Execution QoL)
+*   **The Problem:** When the agent runs a background terminal command (`cargo build`, `npm run dev`), the output is hidden from the human, and interactive prompts cause the background task to hang indefinitely.
+*   **The Solution:** Dispatch to Neovim terminal splits where the human can watch the tests run natively, interact with prompts, see ANSI colors, and interact seamlessly.
+*   **Impact:** Massive Human QoL.
 
-### 4. ␍ead_directory_architecture (Bird's-Eye View)
-*   **The Problem:** ␍ead_file_skeleton works for one file. When entering a new repository, the LLM usually runs ls -R and then has to guess what files do based on their names.
-*   **The Solution:** A tool that scans a directory structure and uses basic heuristic parsing (or a tiny local embedding lookup) to return a JSON tree of files alongside a 1-sentence summary of what each file is responsible for.
+### 4. `read_directory_architecture` (Bird's-Eye View)
+*   **The Problem:** Single file inspection works for one file. When entering a new repository, the LLM usually runs `ls -R` and then has to guess what files do based on their names.
+*   **The Solution:** A tool that scans a directory structure and returns a clean hierarchical tree alongside summaries of what each directory and key file is responsible for.
 *   **Impact:** Immediate holistic context. Eliminates the "exploration phase" token tax.
 
-### 5. query_database_schema (Introspection)
-*   **The Problem:** Working with databases usually involves the LLM writing clunky bash scripts to run psql or sqlite3 to view table definitions, which often fail due to missing env vars or wrong dialects.
-*   **The Solution:** A direct MCP tool that parses the local .env, connects to the database (Postgres/SQLite), and returns a clean Markdown representation of the schema (Tables, Columns, Types, Foreign Keys).
+### 5. `query_database_schema` (Introspection)
+*   **The Problem:** Working with databases usually involves the LLM writing clunky scripts to view table definitions, which often fail due to missing env vars or wrong dialects.
+*   **The Solution:** A direct MCP tool that parses the local `.env`, connects to the database (PostgreSQL), and returns a clean Markdown representation of the schema (Tables, Columns, Types, Foreign Keys).
 *   **Impact:** Prevents hallucinations about database structure. Fixes DB-related bugs significantly faster (T2R).

server/src/bin/export_schemas.rs

@@ -67,6 +67,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
+    // Sync instructions.md
+    let instructions_src = PathBuf::from(r"C:\Users\reazul.ashraf\workspace\rust\mcp-memory\instructions.md");
+    if instructions_src.exists() {
+        let _ = fs::copy(&instructions_src, win_dir.join("instructions.md"));
+        let _ = fs::copy(&instructions_src, wsl_dir.join("instructions.md"));
+        println!("  [OK] Synchronized instructions.md to Win and WSL");
+    }
+
     let _ = fs::remove_dir_all(&temp_dir);
 
     println!("Schema export complete!");

server/src/dashboard.js

@@ -521,7 +521,7 @@ function parseActivityPayload(item) {
     TASK_CREATE: "#1abc9c",
     TASK_UPDATE: "#1abc9c",
     CLIPBOARD: "#9b59b6",
-    STICKY_NOTE: "#e67e22",
+    HANDOFF_MEMO: "#e67e22",
     CHECKPOINT: "#e74c3c",
     ERROR_FIX: "#e74c3c",
     TECH_DEBT: "#d35400",

server/src/dashboard.ts

@@ -711,7 +711,7 @@ function parseActivityPayload(item: any): string {
     TASK_CREATE: "#1abc9c",
     TASK_UPDATE: "#1abc9c",
     CLIPBOARD: "#9b59b6",
-    STICKY_NOTE: "#e67e22",
+    HANDOFF_MEMO: "#e67e22",
     CHECKPOINT: "#e74c3c",
     ERROR_FIX: "#e74c3c",
     TECH_DEBT: "#d35400",

server/src/embedding.rs

@@ -14,6 +14,9 @@ struct CandleEmbeddingModel {
 
 impl CandleEmbeddingModel {
     fn new() -> Result<Self, String> {
+        if cfg!(test) || std::env::var("MCP_OFFLINE_EMBEDDINGS").is_ok() {
+            return Err("Offline embedding mode active (tests/offline flag)".to_string());
+        }
         let client = hf_hub::HFClientSync::new().map_err(|e| e.to_string())?;
         let repo = client.model("sentence-transformers", "all-MiniLM-L6-v2");
 

server/src/handlers/graph.rs

@@ -1223,7 +1223,7 @@ impl McpTool for SummarizeSubgraphHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::handlers::meta::{BroadcastAgentSignalHandler, QueryAgentSignalsHandler};
+    use crate::handlers::meta::AgentSignalsHandler;
     use serde_json::json;
 
 
@@ -1515,19 +1515,21 @@ mod tests {
         }), state.clone()).await.unwrap();
         assert_eq!(del_rel_res, "Relations deleted");
 
-        let bcast_handler = BroadcastAgentSignalHandler;
+        let bcast_handler = AgentSignalsHandler;
         let bcast_res = bcast_handler.execute(json!({
+            "action": "broadcast",
             "sender": "agent1",
             "signal_type": "task_completed",
             "payload": "fix_bug"
         }), state.clone()).await.unwrap();
         assert!(bcast_res.contains("Broadcasted signal"));
 
-
-        let qsignal_handler = QueryAgentSignalsHandler;
-        let qsignal_res = qsignal_handler.execute(json!({"sender": "agent1"}), state.clone()).await.unwrap();
+        let qsignal_handler = AgentSignalsHandler;
+        let qsignal_res = qsignal_handler.execute(json!({
+            "action": "query",
+            "sender": "agent1"
+        }), state.clone()).await.unwrap();
         assert!(qsignal_res.contains("task_completed"));
-
         let read_paged_handler = ReadGraphHandler;
         let paged_res = read_paged_handler
             .execute(json!({"limit": 1, "offset": 0}), state.clone())

server/src/handlers/logs.rs

@@ -1,31 +1,33 @@
 use crate::router::McpTool;
 use crate::state::MemoryState;
-use crate::tools::{GetRecentLogsTool, WatchProcessLogsTool};
+use crate::tools::{ProcessLogAction, ProcessLogsTool};
 use async_trait::async_trait;
 use serde_json::Value;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
 use std::sync::Arc;
 
-pub struct WatchProcessLogsHandler;
+pub struct ProcessLogsHandler;
 
 #[async_trait]
-impl McpTool for WatchProcessLogsHandler {
+impl McpTool for ProcessLogsHandler {
     fn name(&self) -> &'static str {
-        "watch_process_logs"
+        "process_logs"
     }
 
     fn schema(&self) -> Value {
-        crate::mcp::tool_def::<WatchProcessLogsTool>(
-            "watch_process_logs",
-            "Tail a specific log file in the background.",
+        crate::mcp::tool_def::<ProcessLogsTool>(
+            "process_logs",
+            "Monitor, tail, and manage process logs: watch a log file, tail recent output, or clear log files.",
         )
     }
 
     async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: WatchProcessLogsTool =
-            serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let tool_args: ProcessLogsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
         let safe_path = crate::handlers::utils::validate_safe_path(&tool_args.file_path)?;
+
+        match tool_args.action {
+            ProcessLogAction::Watch => {
                 if !safe_path.exists() {
                     return Err(crate::error::AppError::Internal(format!(
                         "File does not exist: {}",
@@ -34,28 +36,8 @@ impl McpTool for WatchProcessLogsHandler {
                 }
                 Ok(format!("Started watching logs for {}", tool_args.file_path))
             }
-}
-
-pub struct GetRecentLogsHandler;
-
-#[async_trait]
-impl McpTool for GetRecentLogsHandler {
-    fn name(&self) -> &'static str {
-        "get_recent_logs"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<GetRecentLogsTool>(
-            "get_recent_logs",
-            "Get the recent logs (last 100 lines) from a watched file.",
-        )
-    }
-
-    async fn execute(&self, args: Value, _state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let tool_args: GetRecentLogsTool =
-            serde_json::from_value(args).map_err(|e| e.to_string())?;
-        let safe_path = crate::handlers::utils::validate_safe_path(&tool_args.file_path)?;
-
+            ProcessLogAction::Get => {
+                let max_lines = tool_args.max_lines.unwrap_or(100);
                 let result = tokio::task::spawn_blocking(move || -> crate::error::Result<String> {
                     let mut file = File::open(&safe_path).map_err(|e| {
                         crate::error::AppError::Internal(format!("Failed to open file: {}", e))
@@ -71,10 +53,9 @@ impl McpTool for GetRecentLogsHandler {
                         .map_err(|e| e.to_string())?;
 
                     let buffer = String::from_utf8_lossy(&vec_buf).to_string();
-
                     let lines: Vec<&str> = buffer.lines().collect();
-            let recent_lines = if lines.len() > 100 {
-                lines[lines.len() - 100..].join("\n")
+                    let recent_lines = if lines.len() > max_lines {
+                        lines[lines.len() - max_lines..].join("\n")
                     } else {
                         buffer
                     };
@@ -86,6 +67,16 @@ impl McpTool for GetRecentLogsHandler {
 
                 Ok(result)
             }
+            ProcessLogAction::Clear => {
+                if safe_path.exists() {
+                    std::fs::write(&safe_path, "").map_err(|e| {
+                        crate::error::AppError::Internal(format!("Failed to clear log file: {}", e))
+                    })?;
+                }
+                Ok(format!("Cleared logs in {}", tool_args.file_path))
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -96,15 +87,16 @@ mod tests {
     use tempfile::tempdir;
 
     #[tokio::test]
-    async fn test_watch_process_logs() {
+    async fn test_process_logs_watch() {
         let dir = tempdir().unwrap();
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
-        let handler = WatchProcessLogsHandler;
+        let handler = ProcessLogsHandler;
 
         let log_file = dir.path().join("test.log");
         std::fs::write(&log_file, "line1\nline2").unwrap();
 
         let args = json!({
+            "action": "watch",
             "file_path": log_file.to_str().unwrap()
         });
 
@@ -117,15 +109,16 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_get_recent_logs() {
+    async fn test_process_logs_get() {
         let dir = tempdir().unwrap();
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
-        let handler = GetRecentLogsHandler;
+        let handler = ProcessLogsHandler;
 
         let log_file = dir.path().join("test_recent.log");
         std::fs::write(&log_file, "line1\nline2\nline3").unwrap();
 
         let args = json!({
+            "action": "get",
             "file_path": log_file.to_str().unwrap()
         });
 
@@ -139,10 +132,31 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_get_recent_logs_with_large_file() {
+    async fn test_process_logs_clear() {
+        let dir = tempdir().unwrap();
+        let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
+        let handler = ProcessLogsHandler;
+
+        let log_file = dir.path().join("test_clear.log");
+        std::fs::write(&log_file, "line1\nline2\nline3").unwrap();
+
+        let args = json!({
+            "action": "clear",
+            "file_path": log_file.to_str().unwrap()
+        });
+
+        let result = handler.execute(args, state.clone()).await.unwrap();
+        assert!(result.contains("Cleared logs"));
+
+        let content = std::fs::read_to_string(&log_file).unwrap();
+        assert_eq!(content, "");
+    }
+
+    #[tokio::test]
+    async fn test_process_logs_get_with_large_file() {
         let dir = tempfile::tempdir().unwrap();
         let state = Arc::new(MemoryState::new(dir.path().to_str().unwrap()));
-        let handler = GetRecentLogsHandler;
+        let handler = ProcessLogsHandler;
 
         let log_file = dir.path().join("large_test.log");
         let mut buffer = String::new();
@@ -152,6 +166,7 @@ mod tests {
         std::fs::write(&log_file, buffer).unwrap();
 
         let args = serde_json::json!({
+            "action": "get",
             "file_path": log_file.to_str().unwrap()
         });
 
@@ -163,4 +178,3 @@ mod tests {
         assert!(result.contains("line"));
     }
 }
-

server/src/handlers/meta.rs

@@ -1384,23 +1384,29 @@ impl McpTool for GetNextActionableTasksHandler {
     }
 }
 
-pub struct LogHypothesisHandler;
+pub struct HypothesesHandler;
 
 #[async_trait]
-impl McpTool for LogHypothesisHandler {
+impl McpTool for HypothesesHandler {
     fn name(&self) -> &'static str {
-        "log_hypothesis"
+        "hypotheses"
     }
 
     fn schema(&self) -> Value {
-        crate::mcp::tool_def::<LogHypothesisTool>(
-            "log_hypothesis",
-            "Log a diagnostic hypothesis and associated evidence for a task",
+        crate::mcp::tool_def::<HypothesesTool>(
+            "hypotheses",
+            "Manage diagnostic hypotheses, tested evidence, and status during problem solving: log new hypotheses or query existing ones.",
         )
     }
 
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let req: LogHypothesisTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let req: HypothesesTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+
+        match req.action {
+            HypothesisAction::Log => {
+                let hyp_text = req.hypothesis.ok_or_else(|| {
+                    crate::error::AppError::Internal("Missing required 'hypothesis' for action 'log'".to_string())
+                })?;
                 let hyp_id = format!(
                     "HYP-{}",
                     uuid::Uuid::new_v4().to_string()[..8].to_uppercase()
@@ -1410,7 +1416,7 @@ impl McpTool for LogHypothesisHandler {
                 let record = crate::models::Hypothesis {
                     id: hyp_id.clone(),
                     task_id: req.task_id,
-            hypothesis: req.hypothesis,
+                    hypothesis: hyp_text,
                     status: req.status.unwrap_or_else(|| "unverified".to_string()),
                     evidence: req.evidence,
                     timestamp,
@@ -1421,26 +1427,7 @@ impl McpTool for LogHypothesisHandler {
 
                 Ok(format!("Hypothesis '{}' logged successfully.", hyp_id))
             }
-}
-
-pub struct QueryHypothesesHandler;
-
-#[async_trait]
-impl McpTool for QueryHypothesesHandler {
-    fn name(&self) -> &'static str {
-        "query_hypotheses"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<QueryHypothesesTool>(
-            "query_hypotheses",
-            "Query active diagnostic hypotheses and evidence by task ID or keyword",
-        )
-    }
-
-    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let req: QueryHypothesesTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-
+            HypothesisAction::Query => {
                 let hypotheses = state.code.hypotheses.read_with(|h| h.clone());
                 let filtered: Vec<_> = hypotheses
                     .into_iter()
@@ -1464,6 +1451,8 @@ impl McpTool for QueryHypothesesHandler {
                 Ok(serde_json::to_string_pretty(&filtered)?)
             }
         }
+    }
+}
 
 pub struct GetPreflightContextHandler;
 
@@ -1542,24 +1531,35 @@ impl McpTool for GetPreflightContextHandler {
     }
 }
 
-pub struct BroadcastAgentSignalHandler;
+pub struct AgentSignalsHandler;
 
 #[async_trait]
-impl McpTool for BroadcastAgentSignalHandler {
+impl McpTool for AgentSignalsHandler {
     fn name(&self) -> &'static str {
-        "broadcast_agent_signal"
+        "agent_signals"
     }
 
     fn schema(&self) -> Value {
-        crate::mcp::tool_def::<BroadcastAgentSignalTool>(
-            "broadcast_agent_signal",
-            "Broadcast real-time inter-agent signal to peer subagents.",
+        crate::mcp::tool_def::<AgentSignalsTool>(
+            "agent_signals",
+            "Real-time inter-agent communication bus: broadcast signals or query active signals from peer subagents.",
         )
     }
 
     async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let req: BroadcastAgentSignalTool =
-            serde_json::from_value(args).map_err(|e| e.to_string())?;
+        let req: AgentSignalsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
+
+        match req.action {
+            AgentSignalAction::Broadcast => {
+                let sender = req.sender.ok_or_else(|| {
+                    crate::error::AppError::Internal("Missing required 'sender' for action 'broadcast'".to_string())
+                })?;
+                let signal_type = req.signal_type.ok_or_else(|| {
+                    crate::error::AppError::Internal("Missing required 'signal_type' for action 'broadcast'".to_string())
+                })?;
+                let payload = req.payload.ok_or_else(|| {
+                    crate::error::AppError::Internal("Missing required 'payload' for action 'broadcast'".to_string())
+                })?;
 
                 let timestamp = std::time::SystemTime::now()
                     .duration_since(std::time::UNIX_EPOCH)
@@ -1569,9 +1569,9 @@ impl McpTool for BroadcastAgentSignalHandler {
                 let sig_id = format!("sig_{}", timestamp);
                 let signal = crate::models::AgentSignal {
                     id: sig_id.clone(),
-            sender: req.sender.clone(),
-            signal_type: req.signal_type.clone(),
-            payload: req.payload,
+                    sender: sender.clone(),
+                    signal_type: signal_type.clone(),
+                    payload,
                     timestamp,
                     ttl_seconds: req.ttl_seconds,
                     ..Default::default()
@@ -1592,35 +1592,16 @@ impl McpTool for BroadcastAgentSignalHandler {
                 });
                 state.record_activity(
                     "agent_signal",
-            &format!("{}: {}", req.sender, req.signal_type),
+                    &format!("{}: {}", sender, signal_type),
                     None,
                 );
 
                 Ok(format!(
                     "Broadcasted signal '{}' from agent '{}'.",
-            sig_id, req.sender
+                    sig_id, sender
                 ))
             }
-}
-
-pub struct QueryAgentSignalsHandler;
-
-#[async_trait]
-impl McpTool for QueryAgentSignalsHandler {
-    fn name(&self) -> &'static str {
-        "query_agent_signals"
-    }
-
-    fn schema(&self) -> Value {
-        crate::mcp::tool_def::<QueryAgentSignalsTool>(
-            "query_agent_signals",
-            "Query active inter-agent signals from subagent signal bus.",
-        )
-    }
-
-    async fn execute(&self, args: Value, state: Arc<MemoryState>) -> crate::error::Result<String> {
-        let req: QueryAgentSignalsTool = serde_json::from_value(args).map_err(|e| e.to_string())?;
-
+            AgentSignalAction::Query => {
                 let now = std::time::SystemTime::now()
                     .duration_since(std::time::UNIX_EPOCH)
                     .unwrap_or_default()
@@ -1655,6 +1636,8 @@ impl McpTool for QueryAgentSignalsHandler {
                 Ok(serde_json::to_string_pretty(&filtered)?)
             }
         }
+    }
+}
 
 pub struct AutoSessionCheckpointHandler;
 
@@ -2048,11 +2031,12 @@ mod tests {
             .await;
         assert!(res_td_res.is_ok());
 
-        // LogHypothesis & QueryHypotheses
-        let log_hyp = LogHypothesisHandler;
-        let hyp_res = log_hyp
+        // Hypotheses
+        let hyp_handler = HypothesesHandler;
+        let hyp_res = hyp_handler
             .execute(
                 serde_json::json!({
+                    "action": "log",
                     "hypothesis": "Caching improves response speed",
                     "status": "testing"
                 }),
@@ -2062,9 +2046,8 @@ mod tests {
             .unwrap();
         assert!(hyp_res.contains("Hypothesis"));
 
-        let q_hyp = QueryHypothesesHandler;
-        let q_hyp_res = q_hyp
-            .execute(serde_json::json!({}), state.clone())
+        let q_hyp_res = hyp_handler
+            .execute(serde_json::json!({"action": "query"}), state.clone())
             .await
             .unwrap();
         assert!(q_hyp_res.contains("Caching improves response speed"));
@@ -2185,10 +2168,11 @@ mod tests {
         assert!(q_lin_res.contains("timeline"));
 
         // Agent Signals
-        let bcast = BroadcastAgentSignalHandler;
-        let bcast_res = bcast
+        let sig_handler = AgentSignalsHandler;
+        let bcast_res = sig_handler
             .execute(
                 serde_json::json!({
+                    "action": "broadcast",
                     "sender": "Agent1",
                     "signal_type": "info",
                     "payload": "Agent starting task"
@@ -2199,9 +2183,8 @@ mod tests {
             .unwrap();
         assert!(bcast_res.contains("Broadcasted signal"));
 
-        let q_sig = QueryAgentSignalsHandler;
-        let q_sig_res = q_sig
-            .execute(serde_json::json!({}), state.clone())
+        let q_sig_res = sig_handler
+            .execute(serde_json::json!({"action": "query"}), state.clone())
             .await
             .unwrap();
         assert!(q_sig_res.contains("Agent1"));
@@ -2464,11 +2447,12 @@ mod tests {
             .unwrap();
         assert!(preflight_res2.contains("active_tasks"));
 
-        // QueryHypotheses with task_id and query
-        let q_hyp = QueryHypothesesHandler;
-        let q_hyp_res = q_hyp
+        // Hypotheses query with task_id and query
+        let hyp_handler = HypothesesHandler;
+        let q_hyp_res = hyp_handler
             .execute(
                 serde_json::json!({
+                    "action": "query",
                     "task_id": "t-1",
                     "query": "Caching"
                 }),
@@ -2563,10 +2547,11 @@ mod tests {
         assert!(q_lin_res.contains("lineage_count"));
 
         // Agent signals filtering
-        let bcast_sig = BroadcastAgentSignalHandler;
-        bcast_sig
+        let sig_handler = AgentSignalsHandler;
+        sig_handler
             .execute(
                 serde_json::json!({
+                    "action": "broadcast",
                     "sender": "AgentA",
                     "signal_type": "handshake",
                     "payload": "status: ready",
@@ -2577,10 +2562,10 @@ mod tests {
             .await
             .unwrap();
 
-        let q_sig = QueryAgentSignalsHandler;
-        let q_sig_res = q_sig
+        let q_sig_res = sig_handler
             .execute(
                 serde_json::json!({
+                    "action": "query",
                     "sender": "AgentA",
                     "signal_type": "handshake"
                 }),

server/src/instructions.md

@@ -68,6 +68,19 @@ The server consolidates granular single-purpose tools into domain-named smart to
   - `action: "read"`: Read OS clipboard.
   - `action: "write"`: Write text/html/files/image to clipboard.
 
+* **`hypotheses`**: Diagnostic hypothesis memory.
+  - `action: "log"`: Record diagnostic hypothesis (requires `hypothesis`, optional `status: "open" | "verified" | "disproven"`, `evidence: Vec<String>`, `test_command`, `git_branch`, `repo_name`).
+  - `action: "query"`: Query hypotheses (optional `status`, `git_branch`, `repo_name`).
+
+* **`agent_signals`**: Inter-agent signal bus.
+  - `action: "broadcast"`: Broadcast signal to other agents (requires `signal_type`, `payload`, optional `target_agent`, `ttl_seconds`).
+  - `action: "query"`: Query active signals (optional `signal_type`, `include_expired: bool`).
+
+* **`process_logs`**: Process and daemon log management.
+  - `action: "watch"`: Register or update log file watcher (requires `label`, `file_path`, optional `description`).
+  - `action: "get"`: Retrieve recent log lines from watched process log (requires `label`, optional `tail_lines: usize`).
+  - `action: "clear"`: Clear or truncate watched process log file (requires `label`).
+
 ---
 
 ## 3. VCS & SVN Agnosticism & Multi-Repo Provenance
@@ -180,16 +193,16 @@ To maintain maximum security, speed, and cross-platform reliability:
 * **Batch Vector Indexing & Similarity Score Guidance**: `VectorDB` provides `index_documents_batch` for single-request multi-point vector upserts and explicit score calibration notes ($\ge 0.75$ high confidence match).
 * **Compact JSON MCP Resources & UTF-8 Activity Truncation**: MCP resources serialize using compact JSON (`to_string`), `TerminalHistoryResource` / `MilestonesResource` enforce output bounds, and `format_tool_activity_description` uses `floor_char_boundary` for guaranteed UTF-8 safety.
 * **SIMD-Friendly Single-Pass Cosine Similarity**: `cosine_similarity` calculates dot product and Euclidean norm squares in a single linear pass over float vectors, enabling SIMD compiler auto-vectorization.
-* **Safe Stream Decoding on Log Tails**: Log tail operations (`get_recent_logs`) read raw bytes and decode using lossy UTF-8 conversion (`String::from_utf8_lossy`) to ensure resilience when seeking across multi-byte UTF-8 boundaries.
+* **Safe Stream Decoding on Log Tails**: Log tail operations (`process_logs`, action: "get") read raw bytes and decode using lossy UTF-8 conversion (`String::from_utf8_lossy`) to ensure resilience when seeking across multi-byte UTF-8 boundaries.
 * **Task Summary UTF-8 Truncation Safety**: `tasks` tool (`action = "list"`) truncates serialized task text strictly along UTF-8 character boundaries using `floor_char_boundary` when enforcing `max_tokens`.
 * **Sequential Snapshot Lock Scope Flattening**: `GenerateStandupReportHandler` reads `tasks`, `ledger`, and `session_summaries` sequentially rather than nesting read locks, preventing multi-lock deadlocks during concurrent store modifications.
 * **Directory Tree Depth Safeguard**: `ReadDirectoryArchitectureHandler` caps directory recursion at depth 10 to prevent stack overflow on deep or cyclic directory structures.
 * **Deterministic Total-Order Score Ranking**: `OmniSearchHandler` uses `f64::total_cmp` for Reciprocal Rank Fusion (RRF) score sorting, guaranteeing deterministic NaN-safe search result ordering.
 * **RPC Timeout Memory Hygiene**: `nvim-core` maintains request hygiene by removing pending request entries from static RPC maps upon timeout or channel drop, eliminating orphan memory leaks.
 * **Embedding Input Safeguard**: `generate_embedding_async` returns explicit errors for empty/0-length text inputs instead of returning empty vectors, preventing downstream vector dimension mismatches during cosine similarity calculations.
-* **Path Traversal Security Guards**: `validate_safe_path` enforces path canonicalization and rejects relative parent traversal components (`..`) across file and process log handlers (`GetRecentLogsTool`, `WatchProcessLogsTool`).
+* **Path Traversal Security Guards**: `validate_safe_path` enforces path canonicalization and rejects relative parent traversal components (`..`) across file and process log handlers (`process_logs` / `ProcessLogsTool`).
 * **Watcher Map Memory Eviction**: Proactive daemon file watcher in `watcher.rs` caps `last_processed` map size at 1,000 entries and purges entries older than 10 minutes to prevent monotonic memory leakage.
-* **Comprehensive Serde Casing Aliases**: All 8 consolidated tool action enums (TaskAction, MilestoneAction, SnippetAction, DecisionAction, TechDebtAction, EnvAction, ClipboardAction, HandoffMemoAction) include serde alias attributes supporting `snake_case`, `camelCase`, `PascalCase`, and uppercase variants for maximum LLM casing resilience.
+* **Comprehensive Serde Casing Aliases**: All 11 consolidated tool action enums (TaskAction, MilestoneAction, SnippetAction, DecisionAction, TechDebtAction, EnvAction, ClipboardAction, HandoffMemoAction, HypothesisAction, AgentSignalAction, ProcessLogAction) include serde alias attributes supporting `snake_case`, `camelCase`, `PascalCase`, and uppercase variants for maximum LLM casing resilience.
 * **Two-Phase Graph Condensation**: `condense_graph_worker` uses a 2-phase commit (non-destructive `read_with` -> graph insert -> prune by timestamp/content) to prevent data loss if summarization or graph insertion fails.
 * **Store Write Lock Minimization**: `Store::modify` and `Store::modify_async` unblock concurrent readers during JSON serialization by releasing the write lock immediately after mutating memory state.
 * **Redb Database Lock Retry Backoff**: `init_db` retries transient Redb lock contention with exponential backoff (3 attempts, 150ms delay) before falling back.

server/src/router.rs

@@ -515,8 +515,7 @@ impl MemoryHandler {
 
         register!(git::GetActiveWorktreeContextHandler);
         register!(git::QueryGitDiffsHandler);
-        register!(logs::WatchProcessLogsHandler);
-        register!(logs::GetRecentLogsHandler);
+        register!(logs::ProcessLogsHandler);
         register!(ast::ReadFileSkeletonHandler);
         register!(ast::ReplaceAstNodeHandler);
         register!(ast::FindSymbolReferencesHandler);
@@ -530,13 +529,11 @@ impl MemoryHandler {
         register!(graph::SweepGraphHealthHandler);
         register!(meta::QueryLineageHandler);
         register!(meta::GetNextActionableTasksHandler);
-        register!(meta::LogHypothesisHandler);
-        register!(meta::QueryHypothesesHandler);
+        register!(meta::HypothesesHandler);
         register!(meta::GetPreflightContextHandler);
         register!(graph::ResolveStaleSymbolsHandler);
         register!(graph::SummarizeSubgraphHandler);
-        register!(meta::BroadcastAgentSignalHandler);
-        register!(meta::QueryAgentSignalsHandler);
+        register!(meta::AgentSignalsHandler);
         register!(meta::AutoSessionCheckpointHandler);
 
         Self {
@@ -731,13 +728,16 @@ impl MemoryHandler {
                     "log_error_fix" => "ERROR_FIX",
                     "tech_debt" => "TECH_DEBT",
                     "tasks" | "milestones" => "TASK",
-                    "handoff_memos" => "STICKY_NOTE",
+                    "handoff_memos" => "HANDOFF_MEMO",
                     "manage_checkpoint" => "CHECKPOINT",
                     "manage_subagent_namespace" => "SUBAGENT",
                     "snippets" => "SNIPPET",
                     "search_web" => "WEB_SEARCH",
                     "omni_search" => "OMNI_SEARCH",
                     "environment" => "ENVIRONMENT",
+                    "hypotheses" => "HYPOTHESIS",
+                    "agent_signals" => "AGENT_SIGNAL",
+                    "process_logs" => "PROCESS_LOG",
                     _ => "TOOL",
                 };
 
@@ -849,6 +849,35 @@ pub fn format_tool_activity_description(name: &str, args: &serde_json::Value) ->
                 .unwrap_or_default();
             ("Create Entities", names)
         }
+        "hypotheses" => {
+            let act = args.get("action").and_then(|v| v.as_str()).unwrap_or("manage");
+            let hyp = args
+                .get("hypothesis")
+                .or_else(|| args.get("query"))
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            (
+                "Hypotheses",
+                format!("{}: {}", act, hyp).trim_end_matches(": ").to_string(),
+            )
+        }
+        "agent_signals" => {
+            let act = args.get("action").and_then(|v| v.as_str()).unwrap_or("signal");
+            let sender = args.get("sender").and_then(|v| v.as_str()).unwrap_or("");
+            let st = args.get("signal_type").and_then(|v| v.as_str()).unwrap_or("");
+            (
+                "Agent Signals",
+                format!("{}: {} [{}]", act, sender, st).trim_end_matches(": ").to_string(),
+            )
+        }
+        "process_logs" => {
+            let act = args.get("action").and_then(|v| v.as_str()).unwrap_or("logs");
+            let file = args.get("file_path").and_then(|v| v.as_str()).unwrap_or("");
+            (
+                "Process Logs",
+                format!("{}: {}", act, file).trim_end_matches(": ").to_string(),
+            )
+        }
         _ => return name.to_string(),
     };
     if detail.is_empty() {

server/src/tools.rs

@@ -338,25 +338,27 @@ pub struct GetNextActionableTasksTool {
     pub limit: Option<usize>,
 }
 
-/// Log a structured diagnostic hypothesis, tested evidence, and status during problem solving.
+#[derive(Debug, Deserialize, Serialize, JsonSchema, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum HypothesisAction {
+    Log,
+    Query,
+}
+
+/// Manage diagnostic hypotheses, tested evidence, and status during problem solving.
 #[derive(Debug, Deserialize, Serialize, JsonSchema)]
-pub struct LogHypothesisTool {
-    /// Optional task ID associated with this hypothesis.
+pub struct HypothesesTool {
+    /// Action to perform: 'log' or 'query'.
+    pub action: HypothesisAction,
+    /// Optional task ID associated with this hypothesis or to filter hypotheses.
     pub task_id: Option<String>,
-    /// The diagnostic hypothesis or potential root cause.
-    pub hypothesis: String,
+    /// The diagnostic hypothesis or potential root cause (required for action 'log').
+    pub hypothesis: Option<String>,
     /// Status: 'unverified', 'verified', or 'rejected'. Defaults to 'unverified'.
     pub status: Option<String>,
     /// Evidence or test results supporting or disproving the hypothesis.
     pub evidence: Option<String>,
-}
-
-/// Query previously logged diagnostic hypotheses and test results.
-#[derive(Debug, Deserialize, Serialize, JsonSchema)]
-pub struct QueryHypothesesTool {
-    /// Optional task ID to filter hypotheses for.
-    pub task_id: Option<String>,
-    /// Optional search query text.
+    /// Optional search query text (for action 'query').
     pub query: Option<String>,
 }
 #[cfg(test)]
@@ -397,15 +399,23 @@ mod tests {
 #[derive(Debug, Deserialize, Serialize, JsonSchema)]
 pub struct GetActiveWorktreeContextTool {}
 /// Tail a specific log file in the background so it can be queried later.
-#[derive(Debug, Deserialize, Serialize, JsonSchema)]
-pub struct WatchProcessLogsTool {
-    pub file_path: String,
+#[derive(Debug, Deserialize, Serialize, JsonSchema, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum ProcessLogAction {
+    Watch,
+    Get,
+    Clear,
 }
 
-/// Get the recent logs from a watched file.
+/// Monitor, tail, and manage process logs: watch a log file, tail recent output, or clear log files.
 #[derive(Debug, Deserialize, Serialize, JsonSchema)]
-pub struct GetRecentLogsTool {
+pub struct ProcessLogsTool {
+    /// Action to perform: 'watch', 'get', or 'clear'.
+    pub action: ProcessLogAction,
+    /// Path to the log file.
     pub file_path: String,
+    /// Maximum number of lines to return for action 'get'. Defaults to 100.
+    pub max_lines: Option<usize>,
 }
 
 /// Read a file and return only its AST skeleton (Imports, Structs, Enums, Traits, Functions)
@@ -537,30 +547,29 @@ pub struct SummarizeSubgraphTool {
     pub max_tokens: Option<usize>,
 }
 
-/// Broadcast a real-time signal or status transition to other subagents on the inter-agent signal bus.
+#[derive(Debug, Deserialize, Serialize, JsonSchema, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum AgentSignalAction {
+    Broadcast,
+    Query,
+}
+
+/// Real-time inter-agent communication bus: broadcast signals or query active signals from peer subagents.
 #[derive(Debug, Deserialize, Serialize, JsonSchema)]
-pub struct BroadcastAgentSignalTool {
-    /// Sender agent ID or role (e.g. 'PrePushAuditor', 'MemoryLibrarian').
-    pub sender: String,
-    /// Signal type or event category (e.g. 'AUDIT_PASSED', 'REPRODUCER_READY', 'TESTS_FAILED').
-    pub signal_type: String,
-    /// JSON or text payload containing event details or artifact URIs.
-    pub payload: String,
+pub struct AgentSignalsTool {
+    /// Action to perform: 'broadcast' or 'query'.
+    pub action: AgentSignalAction,
+    /// Sender agent ID or role (e.g. 'PrePushAuditor', 'MemoryLibrarian'). Required for broadcast; optional filter for query.
+    pub sender: Option<String>,
+    /// Signal type or event category (e.g. 'AUDIT_PASSED', 'REPRODUCER_READY', 'TESTS_FAILED'). Required for broadcast; optional filter for query.
+    pub signal_type: Option<String>,
+    /// JSON or text payload containing event details or artifact URIs (required for action 'broadcast').
+    pub payload: Option<String>,
     /// Optional Time-To-Live in seconds for the signal. Defaults to 3600 (1 hour).
     pub ttl_seconds: Option<u64>,
-}
-
-/// Query active inter-agent signals published by subagents on the inter-agent signal bus.
-#[derive(Debug, Deserialize, Serialize, JsonSchema)]
-pub struct QueryAgentSignalsTool {
-    /// Optional sender filter (e.g. 'PrePushAuditor').
-    pub sender: Option<String>,
-    /// Optional signal_type filter (e.g. 'AUDIT_PASSED').
-    pub signal_type: Option<String>,
-    /// Optional limit on returned signals. Defaults to 20.
+    /// Optional limit on returned signals (for action 'query'). Defaults to 20.
     pub limit: Option<usize>,
 }
-
 /// Trigger an automated context checkpoint, summarizing active tasks, hypotheses, recent commits, and open tech debt into a permanent HandoffMemo.
 #[derive(Debug, Deserialize, Serialize, JsonSchema)]
 pub struct AutoSessionCheckpointTool {