Update Cargo configuration and introduce gemini-ipc crate

- Added the `gemini-ipc` crate to facilitate Inter-Process Communication between components.
- Updated `Cargo.toml` files across multiple modules to replace the `ipc` dependency with `gemini-ipc`.
- Refactored code in the MCP and CLI modules to utilize the new `gemini-ipc` crate, enhancing code organization and maintainability.
- Removed deprecated `HAPPE` and `IDA` modules and their associated files to streamline the project structure.
- Improved overall code readability and organization by consolidating imports and removing unused modules.

Author: frostdev-ops

.cursor/rules/01-project-overview.mdc

@@ -0,0 +1,20 @@
+---
+description: Use this rule to get a high-level project overview, identify the core function of each crate, understand major subsystems, and find the entry-point documentation for components.
+globs: 
+alwaysApply: false
+---
+# Gemini Rust Suite: Project Overview and Core Crates
+
+This project is a Cargo workspace providing a suite of Rust crates for interacting with Google Gemini models, featuring tool usage (MCP), persistent memory, and a CLI.
+
+See the main [README.md](mdc:README.md) for a full overview.
+
+## Core Crates:
+
+*   **`gemini-core` ([core/README.md](mdc:core/README.md))**: Foundational components. Includes the async `GeminiClient`, API types, configuration (`GeminiConfig`), error handling, and shared JSON-RPC types.
+*   **`gemini-ipc` ([ipc/README.md](mdc:ipc/README.md))**: Centralizes Inter-Process Communication message definitions (structs/enums) used between daemons (`HAPPE`, `IDA`, `mcp-hostd`) and clients (`gemini-cli`).
+*   **`gemini-mcp` ([mcp/README.md](mdc:mcp/README.md))**: Implements the Model Context Protocol (MCP) **host** side. Manages discovering, launching, and communicating with MCP **servers** (tools). Includes the `mcp-hostd` binary and built-in server implementations.
+*   **`gemini-memory` ([memory/README.md](mdc:memory/README.md))**: Implements persistent semantic memory using LanceDB. Relies on an MCP host (`McpHostInterface`) for embedding generation.
+*   **`gemini-cli` ([cli/README.md](mdc:cli/README.md))**: The main command-line interface. Integrates the other crates for user interaction, tool use, and memory.
+*   **`HAPPE` ([HAPPE/README.md](mdc:HAPPE/README.md))**: Host Application Environment daemon. Manages interactions between user, LLM, `IDA`, and MCP servers. Intended as the primary execution environment.
+*   **`IDA` ([IDA/README.md](mdc:IDA/README.md))**: Internal Dialogue App daemon. Manages persistent memory and background cognitive tasks, communicating with `HAPPE` via IPC.

.cursor/rules/02-cli.mdc

@@ -0,0 +1,20 @@
+---
+description: Use this rule to understand CLI configuration (API key, model, prompts, history/memory flags), history persistence via the wrapper function, interaction modes, MCP/memory integration points, and where to configure tool servers.
+globs: 
+alwaysApply: false
+---
+# Gemini Rust Suite: Command Line Interface (CLI)
+
+The primary user interface is provided by the `gemini-cli` crate ([cli/README.md](mdc:cli/README.md)).
+
+## Key Components:
+
+*   **Binary:** `gemini-cli-bin` is the compiled executable.
+*   **Wrapper:** The `gemini` command (usually installed via `install.sh` to `~/.bashrc` or `~/.zshrc`) is a crucial wrapper around `gemini-cli-bin` that manages session environment variables (`GEMINI_SESSION_ID`) for history persistence across separate command invocations. See the wrapper function definition in [README.md](mdc:README.md).
+*   **Dependencies:** Leverages `gemini-core` for API communication, `gemini-mcp` for tool integration, and `gemini-memory` for memory features.
+*   **Configuration:**
+    *   `~/.config/gemini-cli/config.toml`: Stores API key, default model, system prompt, feature flags (history, memory). Managed via `gemini --set-...` flags or manual editing. See [cli/README.md](mdc:cli/README.md) for details.
+    *   `~/.config/gemini-cli/mcp_servers.json`: Configures connections to MCP servers (used by the embedded MCP host or the `mcp-hostd` daemon). See [mcp/README.md](mdc:mcp/README.md).
+*   **Interaction Modes:** Supports single-shot prompts (default), interactive chat (`-i`), task loops (`-t`), and combined interactive task mode (`-i -t`). These are detailed in [INTERACTIVE-TASKS.md](mdc:INTERACTIVE-TASKS.md).
+*   **History:** Saved in `~/.local/share/gemini-cli/history/`. Requires the wrapper function for history across commands.
+*   **Built-in Server Execution:** Can run built-in MCP servers directly via flags (`--filesystem-mcp`, `--command-mcp`, `--memory-store-mcp`).

.cursor/rules/03-mcp.mdc

@@ -0,0 +1,32 @@
+---
+description: Use this rule to learn how external tools are integrated via MCP, find the MCP host code and server configuration file, identify built-in and external (E5 embedding) servers, and trace how Gemini function calls are executed as MCP tool requests.
+globs: 
+alwaysApply: false
+---
+# Gemini Rust Suite: Model Context Protocol (MCP)
+
+MCP allows Gemini to use external tools and services. This is primarily handled by the `gemini-mcp` crate ([mcp/README.md](mdc:mcp/README.md)).
+
+## Key Components:
+
+*   **MCP Host:** The core logic resides in `McpHost` ([mcp/src/host.rs](mdc:mcp/src/host.rs)). It discovers, manages, and communicates with MCP servers.
+    *   Can run embedded within the CLI.
+    *   Can run as a standalone daemon: `mcp-hostd` ([mcp/src/bin/mcp-hostd.rs](mdc:mcp/src/bin/mcp-hostd.rs)).
+*   **MCP Servers:** External processes providing tools (capabilities). The host connects to them based on configuration.
+    *   **Configuration:** Defined in `~/.config/gemini-cli/mcp_servers.json`. Specifies server name, transport (stdio, sse, websocket), command to launch (for stdio), etc. See [mcp/README.md](mdc:mcp/README.md) for format.
+    *   **Transports:** Supports `Stdio`, `SSE`, and `WebSocket`.
+    *   **Communication:** Uses JSON-RPC 2.0.
+*   **Built-in Servers:** The source code for common servers is included within `gemini-mcp`:
+    *   `command` ([mcp/src/servers/command/mod.rs](mdc:mcp/src/servers/command/mod.rs)): Executes shell commands (requires user confirmation by default).
+    *   `filesystem` ([mcp/src/servers/filesystem/mod.rs](mdc:mcp/src/servers/filesystem/mod.rs)): Reads/writes files, lists directories.
+    *   `memory_store` ([mcp/src/servers/memory_store/mod.rs](mdc:mcp/src/servers/memory_store/mod.rs)): Simple key-value storage (distinct from the main `gemini-memory` LanceDB store). *Note: This server might be less relevant now with the dedicated E5 embedding server.* 
+    *   These can be run via CLI flags (e.g., `gemini --filesystem-mcp`) or configured in `mcp_servers.json` to be launched by the host.
+*   **External Python E5 Embedding Server:** A crucial server for semantic memory.
+    *   Located in [mcp_embedding_server/](mdc:mcp_embedding_server).
+    *   Provides the `embed` tool using E5 models.
+    *   Communicates via `stdio` JSON-RPC.
+    *   See [mcp_embedding_server/README.md](mdc:mcp_embedding_server/README.md) and the server script [mcp_embedding_server/server.py](mdc:mcp_embedding_server/server.py).
+*   **Gemini Integration:**
+    *   The MCP host translates server capabilities into Gemini `FunctionDeclaration`s.
+    *   It dispatches Gemini `FunctionCall`s to the appropriate MCP server's tool.
+    *   Handles user confirmation for potentially sensitive tools.

.cursor/rules/04-memory.mdc

@@ -0,0 +1,32 @@
+---
+description: Use this rule to locate the persistent memory storage code (MemoryStore), understand the LanceDB backend and embedding generation via MCP, see how prompts are enhanced with context, and find semantic search/filtering logic.
+globs: 
+alwaysApply: false
+---
+# Gemini Rust Suite: Persistent Memory and Embeddings
+
+Persistent, semantic memory is managed by the `gemini-memory` crate ([memory/README.md](mdc:memory/README.md)).
+
+## Key Components:
+
+*   **`MemoryStore` ([memory/src/store.rs](mdc:memory/src/store.rs))**: Main struct for interacting with the memory database.
+*   **`Memory` Struct ([memory/src/memory.rs](mdc:memory/src/memory.rs))**: Represents a single memory item (key, value, timestamp, tags, metadata, vector embedding).
+*   **LanceDB Integration:**
+    *   Uses LanceDB ([https://lancedb.com/](mdc:https:/lancedb.com)) as the vector database for efficient storage and semantic search.
+    *   Database typically located at `~/.local/share/gemini-cli/memory.db` ([memory/src/config.rs](mdc:memory/src/config.rs)).
+    *   Schema defined using Apache Arrow ([memory/src/schema.rs](mdc:memory/src/schema.rs)), including a vector column.
+    *   CRUD operations and vector search are implemented using the LanceDB Rust SDK.
+*   **Embeddings via MCP:**
+    *   Generating vector embeddings (numerical representations of text meaning) is required for semantic search.
+    *   This is **delegated** to an external MCP server providing an `embed` tool.
+    *   The `MemoryStore` requires an implementation of the `McpHostInterface` trait ([memory/src/broker.rs](mdc:memory/src/broker.rs)) to call this external tool.
+    *   The primary embedding server used is the Python E5 server ([mcp_embedding_server/README.md](mdc:mcp_embedding_server/README.md)).
+*   **Semantic Search:**
+    *   The `get_semantically_similar` method ([memory/src/store.rs](mdc:memory/src/store.rs)) takes query text, calls the MCP `embed` tool to get the query vector, and then performs a vector similarity search in LanceDB.
+    *   More advanced search combining semantic, keyword, tag, and time filters is available via `search_memories` ([memory/src/store.rs](mdc:memory/src/store.rs)).
+*   **Prompt Enhancement:**
+    *   The `enhance_prompt` function ([memory/src/broker.rs](mdc:memory/src/broker.rs)) automatically retrieves relevant memories based on a user prompt (using semantic search) and prepends them as context.
+    *   Configurable via the `enable_memory_broker` flag/setting.
+*   **Auto Memory:**
+    *   Automatically extracts and saves key information from conversations.
+    *   Configurable via the `enable_auto_memory` flag/setting. Requires analysis logic (potentially involving LLM calls) and uses the `add_memory` function.

.cursor/rules/05-daemons-ipc.mdc

@@ -0,0 +1,22 @@
+---
+description: Use this rule to understand the roles of the HAPPE/IDA/mcp-hostd daemons, how HAPPE and IDA communicate via IPC, find the IPC message structure definitions, trace the memory retrieval flow, and identify daemon responsibilities.
+globs: 
+alwaysApply: false
+---
+# Gemini Rust Suite: Daemons and IPC
+
+For more complex, persistent scenarios, the system uses background daemons communicating via Inter-Process Communication (IPC).
+
+*   **`HAPPE` Daemon ([HAPPE/README.md](mdc:HAPPE/README.md))**: The Host Application Environment. Orchestrates user interactions, LLM calls, MCP tool execution, and communication with `IDA`.
+*   **`IDA` Daemon ([IDA/README.md](mdc:IDA/README.md))**: Internal Dialogue App. Manages persistent memory interactions (retrieval/storage via Memory MCP Server) and other background cognitive tasks.
+*   **`mcp-hostd` Daemon ([mcp/README.md](mdc:mcp/README.md))**: Standalone MCP host process. Manages connections to MCP tool servers.
+*   **IPC Definitions (`gemini-ipc`)**: The `gemini-ipc` crate ([ipc/README.md](mdc:ipc/README.md)) centralizes message structures for communication between these components.
+    *   `internal_messages.rs` ([ipc/src/internal_messages.rs](mdc:ipc/src/internal_messages.rs)): Defines messages between `HAPPE` and `IDA`.
+    *   `daemon_messages.rs` ([ipc/src/daemon_messages.rs](mdc:ipc/src/daemon_messages.rs)): Defines messages between clients (like `gemini-cli`) and `mcp-hostd`.
+*   **Communication Flow:**
+    *   `User/Client` -> `HAPPE`
+    *   `HAPPE` <-> `IDA` (via IPC, using `internal_messages`)
+    *   `IDA` -> `Memory MCP Server` (via MCP)
+    *   `HAPPE` -> `Main LLM`
+    *   `HAPPE` -> `Other MCP Servers` (via MCP, potentially through `mcp-hostd`)
+    *   `gemini-cli` -> `mcp-hostd` (optional, via IPC, using `daemon_messages`)

.cursor/rules/coding-style.mdc

@@ -0,0 +1,25 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+# Coding Style Guidelines
+
+This project follows standard Rust coding conventions.
+
+## Formatting
+
+*   Code formatting is enforced using `rustfmt`. Ensure `rustfmt` is run before committing changes.
+*   Configuration for `rustfmt` might be present in `rustfmt.toml` or within [`Cargo.toml`](mdc:Cargo.toml) files (though none was found in the root `Cargo.toml`). Assume default settings if no explicit configuration is found.
+
+## Linting
+
+*   Code linting is performed using `clippy`.
+*   Run `cargo clippy` regularly to catch potential issues and improve code quality.
+*   Clippy configuration (e.g., allowed lints) might be present in `clippy.toml` or via attributes in the source code.
+
+## General Conventions
+
+*   Follow the guidelines outlined in the official [Rust API Guidelines](mdc:https:/rust-lang.github.io/api-guidelines).
+*   Use descriptive names for variables, functions, structs, enums, and traits.
+*   Write documentation comments for public APIs.

Cargo.lock

@@ -5,8 +5,14 @@ members = [
     "core",      # Core Gemini API interaction, structs, errors
     "mcp",       # MCP/Tool calling client logic
     "memory",    # Persistent memory storage logic
+    "ipc",       # Inter-process communication definitions
+    "ida",       # Internal Dialogue App daemon
+    "happe",     # Host Application Environment daemon (Placeholder)
 ]
 
+[workspace.lints]
+# Define workspace-wide lint settings here if needed
+
 [workspace.dependencies]
 # Define shared dependencies here
 tokio = { version = "1", features = ["full"] }