Add CLI control for Layer 4 with --enable-layer4 flag

Implemented optional Layer 4 activation via CLI argument,
allowing users to enable relationship features only when needed.

Changes to main.rs:
- Added --enable-layer4 flag to Server command
- Pass flag to BaseMCPServer::new()

Changes to base.rs:
- Added enable_layer4 field to BaseMCPServer
- Updated new() to accept enable_layer4 parameter
- Conditional tool exposure in get_available_tools():
  * Layer 1-3.5 tools: always available
  * Layer 4 tools: only when flag is true
- Added safety check in execute_tool():
  * Returns error if Layer 4 tools called without flag
  * Clear error message guides user to enable flag

Usage:
# Normal mode (Layer 1-3.5 only)
aigpt server

# Game/Companion mode (Layer 1-4)
aigpt server --enable-layer4

Design rationale:
- Layer 4 is optional feature for specific use cases
- Explicit opt-in prevents accidental exposure
- Tools list reflects actual capabilities
- Clear separation between core and optional features

src/main.rs

@@ -16,7 +16,11 @@ struct Cli {
 #[derive(Subcommand)]
 enum Commands {
     /// Start MCP server
-    Server,
+    Server {
+        /// Enable Layer 4 relationship features (for games/companions)
+        #[arg(long)]
+        enable_layer4: bool,
+    },
 
     /// Create a new memory
     Create {
@@ -62,8 +66,8 @@ async fn main() -> Result<()> {
     let cli = Cli::parse();
 
     match cli.command {
-        Commands::Server => {
+        Commands::Server { enable_layer4 } => {
-            let server = BaseMCPServer::new()?;
+            let server = BaseMCPServer::new(enable_layer4)?;
             server.run()?;
         }
 

src/mcp/base.rs

@@ -6,12 +6,13 @@ use crate::core::{Memory, MemoryStore, UserAnalysis, RelationshipInference, infe
 
 pub struct BaseMCPServer {
     store: MemoryStore,
+    enable_layer4: bool,
 }
 
 impl BaseMCPServer {
-    pub fn new() -> Result<Self> {
+    pub fn new(enable_layer4: bool) -> Result<Self> {
         let store = MemoryStore::default()?;
-        Ok(BaseMCPServer { store })
+        Ok(BaseMCPServer { store, enable_layer4 })
     }
 
     pub fn run(&self) -> Result<()> {
@@ -85,7 +86,7 @@ impl BaseMCPServer {
     }
 
     fn get_available_tools(&self) -> Vec<Value> {
-        vec![
+        let mut tools = vec![
             json!({
                 "name": "create_memory",
                 "description": "Create a new memory entry (Layer 1: simple storage)",
@@ -252,6 +253,11 @@ impl BaseMCPServer {
                     "properties": {}
                 }
             }),
+        ];
+
+        // Layer 4 tools (optional - only when enabled)
+        if self.enable_layer4 {
+            tools.extend(vec![
                 json!({
                     "name": "get_relationship",
                     "description": "Get inferred relationship with a specific entity (Layer 4). Analyzes memories and user profile to infer bond strength and relationship type. Use only when game/relationship features are active.",
@@ -279,7 +285,10 @@ impl BaseMCPServer {
                         }
                     }
                 }),
-        ]
+            ]);
+        }
+
+        tools
     }
 
     fn handle_tools_call(&self, request: Value, id: Value) -> Value {
@@ -312,8 +321,23 @@ impl BaseMCPServer {
             "save_user_analysis" => self.tool_save_user_analysis(arguments),
             "get_user_analysis" => self.tool_get_user_analysis(),
             "get_profile" => self.tool_get_profile(),
+
+            // Layer 4 tools (require --enable-layer4 flag)
+            "get_relationship" | "list_relationships" => {
+                if !self.enable_layer4 {
+                    return json!({
+                        "success": false,
+                        "error": "Layer 4 is not enabled. Start server with --enable-layer4 flag to use relationship features."
+                    });
+                }
+
+                match tool_name {
                     "get_relationship" => self.tool_get_relationship(arguments),
                     "list_relationships" => self.tool_list_relationships(arguments),
+                    _ => unreachable!(),
+                }
+            }
+
             _ => json!({
                 "success": false,
                 "error": format!("Unknown tool: {}", tool_name)