Add files using upload-large-folder tool

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/33985dc4-1b8b-4852-b539-4043ce3e7af4/375d5ba16f8a7740@v2

@@ -0,0 +1,42 @@
+#!/bin/bash
+# SPF Post-Failure Hook
+# Copyright 2026 Joseph Stone - All Rights Reserved
+#
+# Runs when tool execution fails.
+# Logs failures for debugging and brain indexing.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SPF_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+STATE_DIR="$SPF_ROOT/state"
+LOG_FILE="$STATE_DIR/spf.log"
+FAILURE_LOG="$STATE_DIR/failures.log"
+export SPF_STATE_DIR="$STATE_DIR"
+
+# Ensure state dir exists
+mkdir -p "$STATE_DIR"
+
+# Timestamp
+timestamp() {
+    date '+%Y-%m-%d %H:%M:%S'
+}
+
+log() {
+    echo "[$(timestamp)] FAILURE: $1" >> "$LOG_FILE"
+    echo "[$(timestamp)] $1" >> "$FAILURE_LOG"
+}
+
+# Read params from stdin
+if [ -t 0 ]; then
+    PARAMS="${1:-{}}"
+else
+    PARAMS=$(cat)
+fi
+
+# Extract tool info from Claude Code's JSON structure
+TOOL_NAME=$(echo "$PARAMS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('tool_name', d.get('tool','unknown')))" 2>/dev/null || echo "unknown")
+ERROR_MSG=$(echo "$PARAMS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('error','unknown error')[:200])" 2>/dev/null || echo "unknown error")
+
+log "Tool '$TOOL_NAME' failed: $ERROR_MSG"
+
+# Always exit 0 - we're just logging, not blocking
+exit 0

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/33985dc4-1b8b-4852-b539-4043ce3e7af4/5d8cccefbcdbaed6@v2

@@ -0,0 +1,212 @@
+#!/bin/bash
+# SPF Post-Action Hook
+# Copyright 2026 Joseph Stone - All Rights Reserved
+#
+# Runs after tool calls complete.
+# Checkpoints state, updates session, can trigger brain sync.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SPF_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+STATE_DIR="$SPF_ROOT/state"
+SESSION_FILE="$STATE_DIR/session.json"
+LOG_FILE="$STATE_DIR/spf.log"
+FAILURE_LOG="$STATE_DIR/failures.log"
+
+# Ensure state dir exists
+mkdir -p "$STATE_DIR"
+
+# Timestamp
+timestamp() {
+    date '+%Y-%m-%d %H:%M:%S'
+}
+
+log() {
+    echo "[$(timestamp)] POST: $1" >> "$LOG_FILE"
+}
+
+# Log rotation — 0.5GB max, keep last 5000 lines, one backup
+rotate_log() {
+    local logfile="$1"
+    local max_bytes=536870912
+    if [ -f "$logfile" ]; then
+        local size
+        size=$(stat -c%s "$logfile" 2>/dev/null || stat -f%z "$logfile" 2>/dev/null || echo 0)
+        if [ "$size" -gt "$max_bytes" ]; then
+            tail -5000 "$logfile" > "$logfile.tmp"
+            mv "$logfile" "$logfile.1"
+            mv "$logfile.tmp" "$logfile"
+        fi
+    fi
+}
+
+# Rotate on every call (cheap stat check)
+rotate_log "$LOG_FILE"
+rotate_log "$FAILURE_LOG"
+
+# Read params from stdin
+if [ -t 0 ]; then
+    PARAMS="${1:-{}}"
+else
+    PARAMS=$(cat)
+fi
+
+# Get tool info from Claude Code's JSON structure (falls back to env vars)
+TOOL_NAME=$(echo "$PARAMS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('tool_name', d.get('tool','unknown')))" 2>/dev/null || echo "${SPF_TOOL_NAME:-unknown}")
+TOOL_RESULT="${SPF_TOOL_RESULT:-success}"
+export SPF_TOOL_PARAMS="$PARAMS"
+
+log "Post-action: $TOOL_NAME = $TOOL_RESULT"
+
+# Update session state
+if [ -f "$SESSION_FILE" ]; then
+    # Increment action counter
+    python3 << EOF
+import json
+import os
+
+session_file = "$SESSION_FILE"
+
+try:
+    with open(session_file) as f:
+        session = json.load(f)
+except:
+    session = {"actions": [], "files_read": [], "files_written": [], "action_count": 0}
+
+session["action_count"] = session.get("action_count", 0) + 1
+session["last_tool"] = "$TOOL_NAME"
+session["last_result"] = "$TOOL_RESULT"
+
+with open(session_file, 'w') as f:
+    json.dump(session, f, indent=2)
+EOF
+else
+    # Create initial session
+    cat > "$SESSION_FILE" << EOF
+{
+  "action_count": 1,
+  "files_read": [],
+  "files_written": [],
+  "last_tool": "$TOOL_NAME",
+  "last_result": "$TOOL_RESULT",
+  "started": "$(timestamp)"
+}
+EOF
+fi
+
+log "Session updated"
+
+# ============================================
+# STATUS.txt Update (Memory Triad System 2)
+# ============================================
+STATUS_FILE="$STATE_DIR/STATUS.txt"
+
+# Extract file path from Claude Code's JSON structure
+FILE_PATH=$(echo "$PARAMS" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('tool_input',{}).get('file_path','unknown') if 'tool_input' in d else d.get('file_path','unknown'))" 2>/dev/null || echo "unknown")
+
+# Update STATUS.txt with current state
+python3 << STATUSEOF
+import json
+from pathlib import Path
+from datetime import datetime
+
+session_file = Path("$SESSION_FILE")
+status_file = Path("$STATUS_FILE")
+tool_name = "$TOOL_NAME"
+tool_result = "$TOOL_RESULT"
+file_path = "$FILE_PATH"
+
+# Load session data
+try:
+    with open(session_file) as f:
+        session = json.load(f)
+except:
+    session = {"action_count": 0, "files_read": [], "files_written": []}
+
+# Track files written
+if tool_name in ("Write", "Edit") and file_path != "unknown":
+    if file_path not in session.get("files_written", []):
+        session.setdefault("files_written", []).append(file_path)
+        with open(session_file, 'w') as f:
+            json.dump(session, f, indent=2)
+
+# Track files read
+if tool_name == "Read" and file_path != "unknown":
+    if file_path not in session.get("files_read", []):
+        session.setdefault("files_read", []).append(file_path)
+        with open(session_file, 'w') as f:
+            json.dump(session, f, indent=2)
+
+# Build STATUS.txt content
+action_count = session.get("action_count", 0)
+files_read = session.get("files_read", [])
+files_written = session.get("files_written", [])
+
+status_content = f"""# SPF STATUS — Memory Triad System 2
+# Auto-updated by post-action.sh
+# Last Update: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Current State
+- **Session Actions**: {action_count}
+- **Last Tool**: {tool_name}
+- **Last Result**: {tool_result}
+- **Last File**: {file_path}
+
+## Files Read This Session ({len(files_read)})
+{chr(10).join(f'- {f}' for f in files_read[-10:]) if files_read else '- (none yet)'}
+
+## Files Modified This Session ({len(files_written)})
+{chr(10).join(f'- {f}' for f in files_written[-10:]) if files_written else '- (none yet)'}
+
+## Build Anchor Status
+- Files read: {len(files_read)}
+- Files written: {len(files_written)}
+- Anchor ratio: {f'{len(files_read)}/{len(files_written)}' if files_written else 'N/A (no writes yet)'}
+
+## Notes
+- This file is auto-updated after every tool action
+- Used for session recovery and Memory Triad verification
+- Check spf.log for detailed action history
+"""
+
+# Write STATUS.txt
+with open(status_file, 'w') as f:
+    f.write(status_content)
+STATUSEOF
+
+log "STATUS.txt updated"
+
+# Brain sync on significant actions (Write/Edit)
+SPF_HOME="$(cd "$SPF_ROOT/.." 2>/dev/null && pwd || echo "/data/data/com.termux/files/home")"
+BRAIN_BIN="$SPF_HOME/stoneshell-brain/target/release/brain"
+BRAIN_SYNC_ENABLED="${SPF_BRAIN_SYNC:-true}"
+
+if [ "$BRAIN_SYNC_ENABLED" = "true" ] && [ -x "$BRAIN_BIN" ]; then
+    if [ "$TOOL_NAME" = "Write" ] || [ "$TOOL_NAME" = "Edit" ]; then
+        log "Checkpointing to brain..."
+
+        # FILE_PATH already extracted above for STATUS.txt
+
+        # Build checkpoint message
+        CHECKPOINT_MSG="SPF Action Checkpoint
+Tool: $TOOL_NAME
+Result: $TOOL_RESULT
+File: $FILE_PATH
+Time: $(timestamp)
+Session Actions: $(python3 -c "import json; print(json.load(open('$SESSION_FILE')).get('action_count',0))" 2>/dev/null || echo "?")"
+
+        # Store to brain (async to not block)
+        "$BRAIN_BIN" store "$CHECKPOINT_MSG" \
+            -t "SPF: $TOOL_NAME on $(basename "$FILE_PATH" 2>/dev/null || echo "file")" \
+            -c "spf_audit" \
+            --tags "spf,checkpoint,$TOOL_NAME" \
+            --index >> "$LOG_FILE" 2>&1 &
+
+        log "Brain checkpoint queued for $FILE_PATH"
+    fi
+else
+    if [ "$BRAIN_SYNC_ENABLED" = "true" ]; then
+        log "Brain sync enabled but binary not found at $BRAIN_BIN"
+    fi
+fi
+
+exit 0

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/33985dc4-1b8b-4852-b539-4043ce3e7af4/8b7fe97bbf37f017@v2

@@ -0,0 +1,451 @@
+// SPF Smart Gateway - Main Entry Point
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// CLI and MCP stdio server. All tool calls route through this gateway.
+// Usage:
+//   spf-smart-gate serve                                        # Run MCP server (stdio)
+//   spf-smart-gate gate <tool> <params>                         # One-shot gate check
+//   spf-smart-gate status                                       # Show gateway status
+//   spf-smart-gate session                                      # Show session state
+//   spf-smart-gate fs-import <virtual_path> <device_file>       # Import file to LMDB5 FS
+//   spf-smart-gate fs-export <virtual_path> <device_file>       # Export file from LMDB5 FS
+//   spf-smart-gate config-import <json_file>                    # Import config to CONFIG.DB
+//   spf-smart-gate config-export <json_file>                    # Export config from CONFIG.DB
+
+use anyhow::{Context, Result};
+use clap::{Parser, Subcommand};
+use spf_smart_gate::{
+    calculate, config_db::SpfConfigDb, fs::SpfFs, gate, mcp,
+    session::Session, storage::SpfStorage,
+};
+use std::path::PathBuf;
+
+/// Find SPFsmartGATE root from binary location — never depends on $HOME
+fn spf_root() -> PathBuf {
+    if let Ok(exe) = std::env::current_exe() {
+        if let Ok(canonical) = exe.canonicalize() {
+            let mut dir = canonical.parent();
+            while let Some(d) = dir {
+                if d.join("Cargo.toml").exists() {
+                    return d.to_path_buf();
+                }
+                dir = d.parent();
+            }
+        }
+    }
+    PathBuf::from("/data/data/com.termux/files/home/SPFsmartGATE")
+}
+
+/// Actual user home — parent of SPFsmartGATE root
+fn actual_home() -> PathBuf {
+    spf_root().parent()
+        .unwrap_or(std::path::Path::new("/data/data/com.termux/files/home"))
+        .to_path_buf()
+}
+
+fn default_storage_path() -> PathBuf {
+    spf_root().join("LIVE/SESSION/SESSION.DB")
+}
+
+#[derive(Parser)]
+#[command(name = "spf-smart-gate")]
+#[command(author = "Joseph Stone")]
+#[command(version = "2.1.0")]
+#[command(about = "SPF Smart Gateway - MCP command gateway with LMDB-backed configuration")]
+struct Cli {
+    /// Session storage directory (LIVE/SESSION/SESSION.DB)
+    #[arg(short, long, default_value_os_t = default_storage_path())]
+    storage: PathBuf,
+
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Run MCP server (stdio JSON-RPC)
+    Serve,
+
+    /// One-shot gate check — runs through SPF gate, returns allow/block
+    Gate {
+        /// Tool name (Read, Write, Edit, Bash, etc.)
+        tool: String,
+
+        /// Parameters as JSON string
+        params: String,
+    },
+
+    /// Calculate complexity without executing
+    Calculate {
+        /// Tool name
+        tool: String,
+
+        /// Parameters as JSON string
+        params: String,
+    },
+
+    /// Show gateway status
+    Status,
+
+    /// Show full session state
+    Session,
+
+    /// Reset session (fresh start)
+    Reset,
+
+    /// Initialize/verify LMDB config (auto-runs on startup)
+    InitConfig,
+
+    /// Import a device file into LMDB5 virtual filesystem
+    FsImport {
+        /// Virtual path (e.g. /home/agent/.claude.json)
+        virtual_path: String,
+
+        /// Device file to read from
+        device_file: PathBuf,
+
+        /// Dry run — show what would happen without writing
+        #[arg(long)]
+        dry_run: bool,
+    },
+
+    /// Export a file from LMDB5 virtual filesystem to device
+    FsExport {
+        /// Virtual path (e.g. /home/agent/.claude.json)
+        virtual_path: String,
+
+        /// Device file to write to
+        device_file: PathBuf,
+    },
+
+    /// Import config from JSON file into CONFIG.DB
+    ConfigImport {
+        /// JSON config file to import
+        json_file: PathBuf,
+
+        /// Dry run — show what would happen without writing
+        #[arg(long)]
+        dry_run: bool,
+    },
+
+    /// Export CONFIG.DB state to JSON file
+    ConfigExport {
+        /// Device file to write JSON to
+        json_file: PathBuf,
+    },
+}
+
+fn main() -> Result<()> {
+    // Initialize logging (safe if already init)
+    let _ = env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).try_init();
+
+    let cli = Cli::parse();
+
+    // Ensure storage directory exists
+    std::fs::create_dir_all(&cli.storage)
+        .with_context(|| format!("Failed to create storage dir {:?}", cli.storage))?;
+
+    // Open SPF_CONFIG LMDB and load config (SINGLE SOURCE OF TRUTH)
+    let config_db_path = spf_root().join("LIVE/CONFIG/CONFIG.DB");
+    let config_db = SpfConfigDb::open(&config_db_path)
+        .with_context(|| format!("Failed to open SPF_CONFIG LMDB at {:?}", config_db_path))?;
+
+    let config = config_db.load_full_config()
+        .with_context(|| "Failed to load config from LMDB")?;
+
+    // Open SPF_STATE storage
+    let storage = SpfStorage::open(&cli.storage)
+        .with_context(|| format!("Failed to open storage at {:?}", cli.storage))?;
+
+    // Load or create session
+    let session = storage.load_session()?.unwrap_or_else(Session::new);
+
+    match &cli.command {
+        Commands::Serve => {
+            // Run MCP server — blocks forever, consumes session & storage
+            mcp::run(config, config_db, session, storage);
+            // Unreachable
+        }
+
+        Commands::Gate { tool, params } => {
+            let params: calculate::ToolParams = serde_json::from_str(params)
+                .with_context(|| format!("Invalid params JSON: {}", params))?;
+
+            let decision = gate::process(tool, &params, &config, &session);
+
+            println!("{}", serde_json::to_string_pretty(&decision)?);
+
+            if !decision.allowed {
+                std::process::exit(1);
+            }
+
+            // Save session after gate call
+            storage.save_session(&session)?;
+        }
+
+        Commands::Calculate { tool, params } => {
+            let params: calculate::ToolParams = serde_json::from_str(params)
+                .with_context(|| format!("Invalid params JSON: {}", params))?;
+
+            let result = calculate::calculate(tool, &params, &config);
+
+            println!("{}", serde_json::to_string_pretty(&result)?);
+
+            // Save session after calculate
+            storage.save_session(&session)?;
+        }
+
+        Commands::Status => {
+            println!("SPF Smart Gateway v2.1.0");
+            println!("Mode: {:?}", config.enforce_mode);
+            println!("Storage: {:?}", cli.storage);
+            println!("Config: LMDB (CONFIG/CONFIG.DB)");
+            println!();
+            println!("Session: {}", session.status_summary());
+            println!();
+            println!("Tiers:");
+            println!("  SIMPLE   < 500    | 40% analyze / 60% build");
+            println!("  LIGHT    < 2000   | 60% analyze / 40% build");
+            println!("  MEDIUM   < 10000  | 75% analyze / 25% build");
+            println!("  CRITICAL > 10000  | 95% analyze / 5% build (requires approval)");
+            println!();
+            println!("Formula: a_optimal(C) = {} × (1 - 1/ln(C + e))", config.formula.w_eff);
+            println!("Complexity: C = basic^1 + deps^7 + complex^10 + files×10");
+        }
+
+        Commands::Session => {
+            println!("{}", serde_json::to_string_pretty(&session)?);
+        }
+
+        Commands::Reset => {
+            let new_session = Session::new();
+            storage.save_session(&new_session)?;
+            println!("Session reset.");
+        }
+
+        Commands::InitConfig => {
+            // Config is already initialized via load_full_config() above
+            // This command now just confirms the LMDB state
+            let (config_count, paths_count, patterns_count) = config_db.stats()?;
+            println!("SPF_CONFIG LMDB initialized at {:?}", config_db_path);
+            println!("  Config entries: {}", config_count);
+            println!("  Path rules: {}", paths_count);
+            println!("  Dangerous patterns: {}", patterns_count);
+            println!();
+            println!("Config is stored in LMDB, not JSON files.");
+            println!("Use MCP tools or direct LMDB access to modify.");
+        }
+
+        // ====================================================================
+        // LMDB5 VIRTUAL FILESYSTEM IMPORT/EXPORT
+        // ====================================================================
+
+        Commands::FsImport { virtual_path, device_file, dry_run } => {
+            let data = std::fs::read(device_file)
+                .with_context(|| format!("Failed to read device file: {:?}", device_file))?;
+
+            println!("fs-import: {:?} → {}", device_file, virtual_path);
+            println!("  Size: {} bytes", data.len());
+
+            if *dry_run {
+                println!("  [DRY RUN] No changes made.");
+                return Ok(());
+            }
+
+            let fs_path = spf_root().join("LIVE/SPF_FS");
+            let spf_fs = SpfFs::open(&fs_path)
+                .with_context(|| format!("Failed to open SPF_FS at {:?}", fs_path))?;
+
+            spf_fs.write(virtual_path, &data)
+                .with_context(|| format!("Failed to write to virtual path: {}", virtual_path))?;
+
+            // Verify
+            let meta = spf_fs.stat(virtual_path)?
+                .ok_or_else(|| anyhow::anyhow!("Write succeeded but stat failed for: {}", virtual_path))?;
+
+            println!("  Written: {} bytes (version {})", meta.size, meta.version);
+            if let Some(ref checksum) = meta.checksum {
+                println!("  Checksum: {}", &checksum[..16]);
+            }
+            println!("  OK");
+        }
+
+        Commands::FsExport { virtual_path, device_file } => {
+            let fs_path = spf_root().join("LIVE/SPF_FS");
+            let spf_fs = SpfFs::open(&fs_path)
+                .with_context(|| format!("Failed to open SPF_FS at {:?}", fs_path))?;
+
+            let data = spf_fs.read(virtual_path)
+                .with_context(|| format!("Failed to read virtual path: {}", virtual_path))?;
+
+            // Ensure parent directory exists on device
+            if let Some(parent) = device_file.parent() {
+                std::fs::create_dir_all(parent)?;
+            }
+
+            std::fs::write(device_file, &data)
+                .with_context(|| format!("Failed to write device file: {:?}", device_file))?;
+
+            println!("fs-export: {} → {:?}", virtual_path, device_file);
+            println!("  Size: {} bytes", data.len());
+            println!("  OK");
+        }
+
+        // ====================================================================
+        // CONFIG.DB IMPORT/EXPORT
+        // ====================================================================
+
+        Commands::ConfigImport { json_file, dry_run } => {
+            let json_str = std::fs::read_to_string(json_file)
+                .with_context(|| format!("Failed to read config file: {:?}", json_file))?;
+
+            let json: serde_json::Value = serde_json::from_str(&json_str)
+                .with_context(|| "Invalid JSON in config file")?;
+
+            println!("config-import: {:?}", json_file);
+
+            // Enforce mode
+            if let Some(mode) = json.get("enforce_mode").and_then(|v| v.as_str()) {
+                println!("  enforce_mode: {}", mode);
+                if !dry_run {
+                    let mode = serde_json::from_value(json["enforce_mode"].clone())?;
+                    config_db.set_enforce_mode(&mode)?;
+                }
+            }
+
+            // Tiers
+            if let Some(tiers_val) = json.get("tiers") {
+                println!("  tiers: present");
+                if !dry_run {
+                    let tiers = serde_json::from_value(tiers_val.clone())?;
+                    config_db.set_tiers(&tiers)?;
+                }
+            }
+
+            // Formula
+            if let Some(formula_val) = json.get("formula") {
+                println!("  formula: present");
+                if !dry_run {
+                    let formula = serde_json::from_value(formula_val.clone())?;
+                    config_db.set_formula(&formula)?;
+                }
+            }
+
+            // Weights
+            if let Some(weights_val) = json.get("weights") {
+                println!("  weights: present");
+                if !dry_run {
+                    let weights = serde_json::from_value(weights_val.clone())?;
+                    config_db.set_weights(&weights)?;
+                }
+            }
+
+            // Allowed paths
+            if let Some(paths) = json.get("allowed_paths").and_then(|v| v.as_array()) {
+                println!("  allowed_paths: {} entries", paths.len());
+                if !dry_run {
+                    for path in paths {
+                        if let Some(p) = path.as_str() {
+                            config_db.allow_path(p)?;
+                        }
+                    }
+                }
+            }
+
+            // Blocked paths
+            if let Some(paths) = json.get("blocked_paths").and_then(|v| v.as_array()) {
+                println!("  blocked_paths: {} entries", paths.len());
+                if !dry_run {
+                    for path in paths {
+                        if let Some(p) = path.as_str() {
+                            config_db.block_path(p)?;
+                        }
+                    }
+                }
+            }
+
+            // Dangerous patterns
+            if let Some(patterns) = json.get("dangerous_patterns").and_then(|v| v.as_object()) {
+                println!("  dangerous_patterns: {} entries", patterns.len());
+                if !dry_run {
+                    for (pattern, severity) in patterns {
+                        let sev = severity.as_u64().unwrap_or(5) as u8;
+                        config_db.add_dangerous_pattern(pattern, sev)?;
+                    }
+                }
+            }
+
+            // Scalar config values
+            if let Some(obj) = json.get("config").and_then(|v| v.as_object()) {
+                println!("  config scalars: {} entries", obj.len());
+                if !dry_run {
+                    for (key, value) in obj {
+                        if let Some(v) = value.as_str() {
+                            config_db.set("spf", key, v)?;
+                        }
+                    }
+                }
+            }
+
+            if *dry_run {
+                println!("  [DRY RUN] No changes made.");
+            } else {
+                let (config_count, paths_count, patterns_count) = config_db.stats()?;
+                println!("  Imported. DB now: {} configs, {} paths, {} patterns", config_count, paths_count, patterns_count);
+            }
+            println!("  OK");
+        }
+
+        Commands::ConfigExport { json_file } => {
+            // Collect all config state
+            let path_rules = config_db.list_path_rules()?;
+            let mut allowed_paths = Vec::new();
+            let mut blocked_paths = Vec::new();
+            for (rule_type, path) in &path_rules {
+                match rule_type.as_str() {
+                    "allowed" => allowed_paths.push(path.clone()),
+                    "blocked" => blocked_paths.push(path.clone()),
+                    _ => {}
+                }
+            }
+
+            let dangerous_patterns = config_db.list_dangerous_patterns()?;
+            let mut patterns_map = serde_json::Map::new();
+            for (pattern, severity) in &dangerous_patterns {
+                patterns_map.insert(pattern.clone(), serde_json::json!(severity));
+            }
+
+            let export = serde_json::json!({
+                "version": config.version,
+                "enforce_mode": config.enforce_mode,
+                "tiers": config.tiers,
+                "formula": config.formula,
+                "weights": config.complexity_weights,
+                "allowed_paths": allowed_paths,
+                "blocked_paths": blocked_paths,
+                "dangerous_patterns": patterns_map,
+                "config": {
+                    "require_read_before_edit": config.require_read_before_edit.to_string(),
+                    "max_write_size": config.max_write_size.to_string(),
+                }
+            });
+
+            // Ensure parent directory exists
+            if let Some(parent) = json_file.parent() {
+                std::fs::create_dir_all(parent)?;
+            }
+
+            let json_str = serde_json::to_string_pretty(&export)?;
+            std::fs::write(json_file, &json_str)
+                .with_context(|| format!("Failed to write config export: {:?}", json_file))?;
+
+            println!("config-export: → {:?}", json_file);
+            println!("  {} configs, {} path rules, {} patterns",
+                path_rules.len(), allowed_paths.len() + blocked_paths.len(), dangerous_patterns.len());
+            println!("  {} bytes written", json_str.len());
+            println!("  OK");
+        }
+    }
+
+    Ok(())
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/33985dc4-1b8b-4852-b539-4043ce3e7af4/98b8489312f35c22@v2

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/LIVE/BIN/spf-smart-gate",
+      "args": ["serve"]
+    }
+  }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/33985dc4-1b8b-4852-b539-4043ce3e7af4/b673dede0e00533f@v2

@@ -0,0 +1,196 @@
+{
+  "numStartups": 1,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 1
+  },
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tmp_list",
+        "mcp__spf-smart-gate__spf_tmp_stats",
+        "mcp__spf-smart-gate__spf_tmp_get",
+        "mcp__spf-smart-gate__spf_tmp_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename",
+        "mcp__spf-smart-gate__spf_projects_list",
+        "mcp__spf-smart-gate__spf_projects_get",
+        "mcp__spf-smart-gate__spf_projects_set",
+        "mcp__spf-smart-gate__spf_projects_delete",
+        "mcp__spf-smart-gate__spf_projects_stats"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": true,
+      "projectOnboardingSeenCount": 1,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "hasCompletedProjectOnboarding": true,
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 0,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      }
+    }
+  },
+  "userID": "af8dab428f15c2d139a684ee7ee0184d8ba482f1b29b1c372cb867c5ff02853b",
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770954959734
+  },
+  "claudeCodeFirstTokenDate": "2025-12-21T22:40:04.477511Z",
+  "firstStartTime": "2026-02-13T03:59:10.452Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "opusProMigrationTimestamp": 1770955150483,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "oauthAccount": {
+    "accountUuid": "60c4a020-4369-4418-bb81-51c72dbb4430",
+    "emailAddress": "joestonebigfoot@gmail.com",
+    "organizationUuid": "9e02b500-1172-4c72-84ce-160d6f017855",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "subscriptionCreatedAt": "2025-12-21T22:38:56.214822Z",
+    "displayName": "bigfoot",
+    "organizationRole": "admin",
+    "workspaceRole": null,
+    "organizationName": "joestonebigfoot@gmail.com's Organization"
+  },
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.34",
+  "hasShownOpus46Notice": {
+    "9e02b500-1172-4c72-84ce-160d6f017855": true
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "s1mAccessCache": {
+    "9e02b500-1172-4c72-84ce-160d6f017855": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770955175367
+    }
+  },
+  "groveConfigCache": {
+    "60c4a020-4369-4418-bb81-51c72dbb4430": {
+      "grove_enabled": true,
+      "timestamp": 1770955175516
+    }
+  },
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/LIVE/BIN/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "permissions": {
+    "allow": [
+      "Read",
+      "Write",
+      "Edit",
+      "Bash",
+      "Glob",
+      "Grep",
+      "WebFetch",
+      "WebSearch",
+      "NotebookEdit",
+      "Task"
+    ],
+    "deny": [],
+    "blockedPaths": [
+      "/tmp",
+      "/etc",
+      "/usr",
+      "/system",
+      "/data/data/com.termux/files/usr"
+    ],
+    "allowedPaths": [
+      "/storage/emulated/0/Download/api-workspace/",
+      "/data/data/com.termux/files/home/"
+    ],
+    "defaultMode": "default"
+  },
+  "telemetry": {
+    "enabled": false
+  }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/3c246a0a460d44f6@v1

@@ -0,0 +1,90 @@
+# SPF Smart Gateway - MCP Command Gateway
+# Copyright 2026 Joseph Stone - All Rights Reserved
+#
+# All tool calls route through this gateway.
+# Enforces SPF complexity formula, validates rules,
+# gates all file/bash operations. Pure Rust, LMDB state,
+# MCP stdio JSON-RPC 2.0.
+
+[package]
+name = "spf-smart-gate"
+version = "1.0.0"
+edition = "2021"
+authors = ["Joseph Stone <joepcstone@gmail.com>"]
+description = "SPF Smart GATE - MCP command gateway with complexity enforcement"
+license-file = "LICENSE"
+repository = "https://github.com/stonecelljoseph-source/StoneCell-Processing-Formula-For-AI-Self-Governance"
+readme = "README.md"
+
+[[bin]]
+name = "spf-smart-gate"
+path = "src/main.rs"
+
+[lib]
+name = "spf_smart_gate"
+path = "src/lib.rs"
+
+[dependencies]
+# ============================================================================
+# STATE STORAGE - LMDB
+# ============================================================================
+heed = "0.20"
+
+# ============================================================================
+# SERIALIZATION
+# ============================================================================
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# ============================================================================
+# CLI
+# ============================================================================
+clap = { version = "4.5", features = ["derive"] }
+
+# ============================================================================
+# ERROR HANDLING
+# ============================================================================
+thiserror = "1.0"
+anyhow = "1.0"
+
+# ============================================================================
+# LOGGING
+# ============================================================================
+log = "0.4"
+env_logger = "0.11"
+
+# ============================================================================
+# TIME
+# ============================================================================
+chrono = { version = "0.4", features = ["serde"] }
+
+# ============================================================================
+# WEB BROWSER — AI-friendly HTTP client
+# ============================================================================
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+html2text = "0.6"
+
+# ============================================================================
+# FILESYSTEM — SHA256 checksums + hex encoding (NEW for fs.rs)
+# ============================================================================
+sha2 = "0.10"
+hex = "0.4"
+
+# ============================================================================
+# PROFILES
+# ============================================================================
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+panic = "abort"
+strip = true
+
+[profile.dev]
+opt-level = 1
+
+# ============================================================================
+# DEV DEPENDENCIES — for tests only
+# ============================================================================
+[dev-dependencies]
+tempfile = "3"

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/3c246a0a460d44f6@v2

@@ -0,0 +1,90 @@
+# SPF Smart Gateway - MCP Command Gateway
+# Copyright 2026 Joseph Stone - All Rights Reserved
+#
+# All tool calls route through this gateway.
+# Enforces SPF complexity formula, validates rules,
+# gates all file/bash operations. Pure Rust, LMDB state,
+# MCP stdio JSON-RPC 2.0.
+
+[package]
+name = "spf-smart-gate"
+version = "2.0.0"
+edition = "2021"
+authors = ["Joseph Stone <joepcstone@gmail.com>"]
+description = "SPF Smart GATE - MCP command gateway with complexity enforcement"
+license-file = "LICENSE"
+repository = "https://github.com/stonecelljoseph-source/StoneCell-Processing-Formula-For-AI-Self-Governance"
+readme = "README.md"
+
+[[bin]]
+name = "spf-smart-gate"
+path = "src/main.rs"
+
+[lib]
+name = "spf_smart_gate"
+path = "src/lib.rs"
+
+[dependencies]
+# ============================================================================
+# STATE STORAGE - LMDB
+# ============================================================================
+heed = "0.20"
+
+# ============================================================================
+# SERIALIZATION
+# ============================================================================
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# ============================================================================
+# CLI
+# ============================================================================
+clap = { version = "4.5", features = ["derive"] }
+
+# ============================================================================
+# ERROR HANDLING
+# ============================================================================
+thiserror = "1.0"
+anyhow = "1.0"
+
+# ============================================================================
+# LOGGING
+# ============================================================================
+log = "0.4"
+env_logger = "0.11"
+
+# ============================================================================
+# TIME
+# ============================================================================
+chrono = { version = "0.4", features = ["serde"] }
+
+# ============================================================================
+# WEB BROWSER — AI-friendly HTTP client
+# ============================================================================
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+html2text = "0.6"
+
+# ============================================================================
+# FILESYSTEM — SHA256 checksums + hex encoding (NEW for fs.rs)
+# ============================================================================
+sha2 = "0.10"
+hex = "0.4"
+
+# ============================================================================
+# PROFILES
+# ============================================================================
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+panic = "abort"
+strip = true
+
+[profile.dev]
+opt-level = 1
+
+# ============================================================================
+# DEV DEPENDENCIES — for tests only
+# ============================================================================
+[dev-dependencies]
+tempfile = "3"

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/53a1fc82aaa6d2ce@v1

@@ -0,0 +1,84 @@
+# SPF Smart Gate v2.0 - Session Handoff
+**Date:** 2026-02-06
+**Status:** LMDB Config Integration Complete
+
+## What Was Done
+
+### Problem
+- `main.rs` loaded config from JSON file at `~/spf-gateway/config.json`
+- `mcp.rs` hardcoded LMDB paths at `~/SPFsmartGATE/storage/`
+- Two config systems running in parallel (JSON + LMDB)
+- Duplicate struct definitions in `config.rs` and `config_db.rs`
+
+### Solution Implemented
+1. **Removed duplicate structs** from `config_db.rs`
+2. **Added import** `use crate::config::{...}` for canonical types
+3. **Added `load_full_config()`** method to `SpfConfigDb`
+4. **Updated `main.rs`** to load config from LMDB, not JSON
+5. **Changed default path** to `~/SPFsmartGATE/storage/`
+6. **Updated version** to 2.0.0
+
+## Files Modified
+
+```
+src/config_db.rs  - Removed lines 29-85 (duplicates), added load_full_config()
+src/main.rs       - Removed JSON loading, uses SpfConfigDb.load_full_config()
+```
+
+## Current State
+
+```
+Binary: ~/SPFsmartGATE/target/release/spf-smart-gate
+Storage: ~/SPFsmartGATE/storage/
+  - spf_config/   (7 entries, 7 path rules, 9 patterns)
+  - spf_tools/
+  - spf_sandbox/
+  - agent_state/
+```
+
+## Verification Commands
+
+```bash
+cd ~/SPFsmartGATE
+./target/release/spf-smart-gate status
+./target/release/spf-smart-gate init-config
+```
+
+## Next Steps
+
+1. **Test MCP connection** - Restart Claude Code, check for spf_* tools
+2. **Add CLI subcommands** for LMDB browsing:
+   - `config list/get/set`
+   - `tools list/get`
+   - `sandbox list/create`
+   - `agent memories/remember/forget`
+3. **Verify mcp.rs** uses same config path as main.rs
+4. **Update ~/.claude.json** if needed with correct mcpServers path
+
+## Architecture Reference
+
+```
+LMDB 1: SPF_FS       - ~/SPFsmartGATE/storage/spf_fs/
+LMDB 2: SPF_CONFIG   - ~/SPFsmartGATE/storage/spf_config/
+LMDB 3: SPF_TOOLS    - ~/SPFsmartGATE/storage/spf_tools/
+LMDB 4: SPF_SANDBOX  - ~/SPFsmartGATE/storage/spf_sandbox/
+LMDB 5: AGENT_STATE  - ~/SPFsmartGATE/storage/agent_state/
+```
+
+## Config Loading Flow (NEW)
+
+```
+main.rs
+  └─> SpfConfigDb::open(storage/spf_config)
+       └─> load_full_config()
+            └─> init_defaults() if empty
+            └─> Assembles SpfConfig from LMDB
+  └─> mcp::run(config, session, storage)
+```
+
+## To Resume Work
+
+Read this file, then:
+1. Check `./target/release/spf-smart-gate status`
+2. Review `src/main.rs` and `src/config_db.rs`
+3. Continue with next steps above

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/53a1fc82aaa6d2ce@v2

@@ -0,0 +1,115 @@
+# SPF Smart Gate v2.0.0 - Session Handoff
+**Date:** 2026-02-06
+**Status:** Security audit complete — backdoor removed, shell injection fixed, clean build
+
+## What Was Done This Session (Opus 4.6)
+
+### 1. BACKDOOR REMOVED — Approval System Fixed
+**Problem:** Opus 4.5 left `approved: true` as default in MCP tool schemas. Combined with `requires_approval: true` hardcoded for ALL tiers, the approval system was theater — everything auto-approved.
+
+**Fix (4 files):**
+- `config.rs` — Tier defaults: SIMPLE/LIGHT/MEDIUM `requires_approval: false`, CRITICAL `true`
+- `config.rs` — `get_tier()` reads actual config values instead of hardcoded `true`
+- `config_db.rs` — Same tier fix in LMDB `init_defaults()` and `get_tier_for_c()`
+- `mcp.rs` — ALL `approved` defaults changed from `true` to `false`
+
+**Result:** CRITICAL tier (C > 10000) is genuinely blocked without explicit `approved=true`. Lower tiers pass through, protected by Build Anchor + path blocking + content inspection.
+
+### 2. LMDB BOOT SYNC — `sync_tier_approval()`
+**Problem:** LMDB config database cached old `requires_approval: true` for all tiers. Code changes don't reach stored LMDB values.
+
+**Fix:** Added `sync_tier_approval()` in `config_db.rs`. Runs every boot. Compares LMDB-stored tier approval values against the policy array defined in code. Updates LMDB if they differ, logs changes. No version chains to track.
+
+**To change approval policy in future:** Edit the `policy` array in `sync_tier_approval()` → rebuild → reboot. Done.
+
+### 3. SHELL INJECTION FIXED — spf_glob + spf_grep
+**Problem:** User-provided `pattern`, `path`, `glob_filter` were interpolated into `format!()` strings and passed to `bash -c`. A crafted pattern could break out and execute arbitrary commands — in a security gateway.
+
+**Fix:** Replaced `Command::new("bash").arg("-c").arg(&cmd)` with:
+- `spf_glob`: `Command::new("find").arg(path).arg("-name").arg(pattern)` — no shell
+- `spf_grep`: `Command::new("rg").arg("--").arg(pattern).arg(path)` — `--` prevents flag injection
+- Output truncation done in Rust (`.lines().take(N)`) instead of piped `head`
+
+### 4. READ VALIDATION FIXED — validate_read
+**Problem:** `validate_read()` only checked `file_path.starts_with("/tmp")`. Reads to `/etc`, `/usr`, `/system` bypassed validation.
+
+**Fix:** Replaced with `config.is_path_blocked(file_path)` which checks all blocked paths with canonicalization (prevents `../` traversal).
+
+### 5. VERSION ALIGNED — 2.0.0
+- `Cargo.toml`: `1.0.0` → `2.0.0`
+- `mcp.rs`: `SERVER_VERSION` `1.0.0` → `2.0.0`
+- `config_db.rs`: LMDB stored version synced to `2.0.0`
+- `main.rs`: Already `2.0.0` (unchanged)
+
+### 6. DEAD CODE REMOVED
+- `src/gate-EDITED.rs` (172 LOC) — deleted, not in lib.rs
+- `src/mcp-EDITED.rs` (1420 LOC) — deleted, not in lib.rs
+- `src/claude_state.rs` (670 LOC) — deleted, superseded by agent_state.rs
+- **Total removed:** 2,262 lines
+
+## Files Modified
+```
+src/config.rs     - Tier defaults + get_tier() reads actual config
+src/config_db.rs  - Tier defaults + get_tier_for_c() + sync_tier_approval() + load_full_config() call
+src/mcp.rs        - approved defaults false, SERVER_VERSION 2.0.0, safe glob/grep
+src/validate.rs   - validate_read uses config.is_path_blocked()
+Cargo.toml        - version 2.0.0
+```
+
+## Files Deleted
+```
+src/gate-EDITED.rs
+src/mcp-EDITED.rs
+src/claude_state.rs
+```
+
+## Current State
+```
+Binary:  ~/SPFsmartGATE/target/release/spf-smart-gate (NEEDS REBUILD)
+Source:  16 files, ~6,610 lines, zero dead code
+Storage: ~/SPFsmartGATE/storage/
+  - spf_config/   → will self-heal tier approval on first boot via sync_tier_approval()
+  - spf_tools/
+  - spf_sandbox/
+  - agent_state/
+```
+
+## Build + Boot
+```bash
+cd ~/SPFsmartGATE
+cargo build --release
+# Restart Claude Code session — MCP server picks up new binary
+```
+
+## Post-Boot Verification
+```
+spf_status          → should show v2.0.0
+spf_calculate       → SIMPLE tier should show requires_approval: false
+spf_calculate       → CRITICAL tier should show requires_approval: true
+```
+
+## Architecture Reference
+```
+LMDB 1: SPF_STATE    - ~/SPFsmartGATE/storage/
+LMDB 2: SPF_CONFIG   - ~/SPFsmartGATE/storage/spf_config/
+LMDB 3: SPF_TOOLS    - ~/SPFsmartGATE/storage/spf_tools/
+LMDB 4: SPF_SANDBOX  - ~/SPFsmartGATE/storage/spf_sandbox/
+LMDB 5: AGENT_STATE  - ~/SPFsmartGATE/storage/agent_state/
+```
+
+## Config Loading Flow
+```
+main.rs
+  └─> SpfConfigDb::open(storage/spf_config)
+       └─> load_full_config()
+            └─> init_defaults() if empty
+            └─> sync_tier_approval()  ← NEW: enforces code-defined policy
+            └─> Assembles SpfConfig from LMDB
+  └─> mcp::run(config, session, storage)
+```
+
+## To Resume Work
+1. Read this file
+2. Run `spf_status` to confirm v2.0.0
+3. Run `spf_calculate` on a Write to confirm SIMPLE shows `requires_approval: false`
+4. Run `spf_calculate` on a high-complexity op to confirm CRITICAL shows `requires_approval: true`

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/6ca5b69f33e447bc@v1

@@ -0,0 +1,155 @@
+// SPF Smart Gateway - Rules Validator
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// Validates tool calls against SPF rules:
+// - Build Anchor Protocol (must read before edit/write)
+// - Blocked paths (/tmp, /etc, /usr, /system)
+// - Dangerous command detection
+// - File size limits
+// - Git force operation warnings
+
+use crate::config::{EnforceMode, SpfConfig};
+use crate::session::Session;
+use serde::{Deserialize, Serialize};
+
+/// Validation result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ValidationResult {
+    pub valid: bool,
+    pub warnings: Vec<String>,
+    pub errors: Vec<String>,
+}
+
+impl ValidationResult {
+    pub fn ok() -> Self {
+        Self { valid: true, warnings: Vec::new(), errors: Vec::new() }
+    }
+
+    pub fn warn(&mut self, msg: String) {
+        self.warnings.push(msg);
+    }
+
+    pub fn error(&mut self, msg: String) {
+        self.valid = false;
+        self.errors.push(msg);
+    }
+}
+
+/// Validate an Edit operation
+pub fn validate_edit(
+    file_path: &str,
+    config: &SpfConfig,
+    session: &Session,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Build Anchor Protocol — must read before edit
+    if config.require_read_before_edit && !session.files_read.contains(&file_path.to_string()) {
+        match config.enforce_mode {
+            EnforceMode::Hard => {
+                result.error(format!(
+                    "BUILD ANCHOR VIOLATION: Must read {} before editing", file_path
+                ));
+            }
+            EnforceMode::Soft => {
+                result.warn(format!("File not read before edit: {}", file_path));
+            }
+        }
+    }
+
+    // Blocked paths
+    if config.is_path_blocked(file_path) {
+        result.error(format!("PATH BLOCKED: {}", file_path));
+    }
+
+    result
+}
+
+/// Validate a Write operation
+pub fn validate_write(
+    file_path: &str,
+    content_len: usize,
+    config: &SpfConfig,
+    session: &Session,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // File size limit
+    if content_len > config.max_write_size {
+        result.warn(format!(
+            "Large write: {} bytes (max recommended: {})",
+            content_len, config.max_write_size
+        ));
+    }
+
+    // Blocked paths
+    if config.is_path_blocked(file_path) {
+        result.error(format!("PATH BLOCKED: {}", file_path));
+    }
+
+    // Build Anchor — must read existing file before overwriting
+    if std::path::Path::new(file_path).exists()
+        && !session.files_read.contains(&file_path.to_string())
+    {
+        match config.enforce_mode {
+            EnforceMode::Hard => {
+                result.error(format!(
+                    "BUILD ANCHOR VIOLATION: Must read existing file before overwrite: {}",
+                    file_path
+                ));
+            }
+            EnforceMode::Soft => {
+                result.warn(format!("Overwriting without read: {}", file_path));
+            }
+        }
+    }
+
+    result
+}
+
+/// Validate a Bash operation
+pub fn validate_bash(
+    command: &str,
+    config: &SpfConfig,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Dangerous command patterns
+    for pattern in &config.dangerous_commands {
+        if command.contains(pattern.as_str()) {
+            result.error(format!("DANGEROUS COMMAND: contains '{}'", pattern));
+        }
+    }
+
+    // Git force operations
+    if command.contains("git") {
+        for force in &config.git_force_patterns {
+            if command.contains(force.as_str()) {
+                result.warn(format!("Git force operation detected: {}", force));
+            }
+        }
+    }
+
+    // /tmp access
+    if command.contains("/tmp") {
+        result.error("NO /tmp ACCESS — Termux Android restriction".to_string());
+    }
+
+    result
+}
+
+/// Validate a Read operation — always allowed, tracks for Build Anchor
+pub fn validate_read(
+    file_path: &str,
+    _config: &SpfConfig,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Reads are always allowed — they feed the Build Anchor
+    // Blocked path check still applies for safety
+    if file_path.starts_with("/tmp") {
+        result.error("NO /tmp ACCESS".to_string());
+    }
+
+    result
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/6ca5b69f33e447bc@v2

@@ -0,0 +1,154 @@
+// SPF Smart Gateway - Rules Validator
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// Validates tool calls against SPF rules:
+// - Build Anchor Protocol (must read before edit/write)
+// - Blocked paths (/tmp, /etc, /usr, /system)
+// - Dangerous command detection
+// - File size limits
+// - Git force operation warnings
+
+use crate::config::{EnforceMode, SpfConfig};
+use crate::session::Session;
+use serde::{Deserialize, Serialize};
+
+/// Validation result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ValidationResult {
+    pub valid: bool,
+    pub warnings: Vec<String>,
+    pub errors: Vec<String>,
+}
+
+impl ValidationResult {
+    pub fn ok() -> Self {
+        Self { valid: true, warnings: Vec::new(), errors: Vec::new() }
+    }
+
+    pub fn warn(&mut self, msg: String) {
+        self.warnings.push(msg);
+    }
+
+    pub fn error(&mut self, msg: String) {
+        self.valid = false;
+        self.errors.push(msg);
+    }
+}
+
+/// Validate an Edit operation
+pub fn validate_edit(
+    file_path: &str,
+    config: &SpfConfig,
+    session: &Session,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Build Anchor Protocol — must read before edit
+    if config.require_read_before_edit && !session.files_read.contains(&file_path.to_string()) {
+        match config.enforce_mode {
+            EnforceMode::Hard => {
+                result.error(format!(
+                    "BUILD ANCHOR VIOLATION: Must read {} before editing", file_path
+                ));
+            }
+            EnforceMode::Soft => {
+                result.warn(format!("File not read before edit: {}", file_path));
+            }
+        }
+    }
+
+    // Blocked paths
+    if config.is_path_blocked(file_path) {
+        result.error(format!("PATH BLOCKED: {}", file_path));
+    }
+
+    result
+}
+
+/// Validate a Write operation
+pub fn validate_write(
+    file_path: &str,
+    content_len: usize,
+    config: &SpfConfig,
+    session: &Session,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // File size limit
+    if content_len > config.max_write_size {
+        result.warn(format!(
+            "Large write: {} bytes (max recommended: {})",
+            content_len, config.max_write_size
+        ));
+    }
+
+    // Blocked paths
+    if config.is_path_blocked(file_path) {
+        result.error(format!("PATH BLOCKED: {}", file_path));
+    }
+
+    // Build Anchor — must read existing file before overwriting
+    if std::path::Path::new(file_path).exists()
+        && !session.files_read.contains(&file_path.to_string())
+    {
+        match config.enforce_mode {
+            EnforceMode::Hard => {
+                result.error(format!(
+                    "BUILD ANCHOR VIOLATION: Must read existing file before overwrite: {}",
+                    file_path
+                ));
+            }
+            EnforceMode::Soft => {
+                result.warn(format!("Overwriting without read: {}", file_path));
+            }
+        }
+    }
+
+    result
+}
+
+/// Validate a Bash operation
+pub fn validate_bash(
+    command: &str,
+    config: &SpfConfig,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Dangerous command patterns
+    for pattern in &config.dangerous_commands {
+        if command.contains(pattern.as_str()) {
+            result.error(format!("DANGEROUS COMMAND: contains '{}'", pattern));
+        }
+    }
+
+    // Git force operations
+    if command.contains("git") {
+        for force in &config.git_force_patterns {
+            if command.contains(force.as_str()) {
+                result.warn(format!("Git force operation detected: {}", force));
+            }
+        }
+    }
+
+    // /tmp access
+    if command.contains("/tmp") {
+        result.error("NO /tmp ACCESS — Termux Android restriction".to_string());
+    }
+
+    result
+}
+
+/// Validate a Read operation — allowed unless path is blocked, tracks for Build Anchor
+pub fn validate_read(
+    file_path: &str,
+    config: &SpfConfig,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Reads feed the Build Anchor but blocked paths still apply
+    if config.is_path_blocked(file_path) {
+        result.error(format!("BLOCKED PATH: {} is in blocked paths list", file_path));
+    }
+
+    result
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/7931b017237cdafd@v1

@@ -0,0 +1,448 @@
+// SPF Smart Gateway - Configuration LMDB
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// LMDB-backed configuration storage. Replaces config.json with persistent,
+// transactional storage. Supports hot-reload without restart.
+//
+// Database: SPF_CONFIG
+// Storage: ~/SPFsmartGATE/storage/spf_config/
+
+use anyhow::{anyhow, Result};
+use heed::types::*;
+use heed::{Database, Env, EnvOpenOptions};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// Import config types from canonical source (config.rs) - NO DUPLICATES
+use crate::config::{
+    EnforceMode, TierThreshold, TierConfig, FormulaConfig,
+    ToolWeight, ComplexityWeights, SpfConfig,
+};
+
+const MAX_DB_SIZE: usize = 10 * 1024 * 1024; // 10MB - config is small
+
+/// LMDB-backed SPF configuration storage
+pub struct SpfConfigDb {
+    env: Env,
+    /// Main config store: namespace:key → JSON value
+    config: Database<Str, Str>,
+    /// Path rules: "allowed:path" or "blocked:path" → bool
+    paths: Database<Str, SerdeBincode<bool>>,
+    /// Dangerous patterns: pattern → severity (1-10)
+    patterns: Database<Str, SerdeBincode<u8>>,
+}
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+impl SpfConfigDb {
+    /// Open or create config LMDB at given path
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(MAX_DB_SIZE)
+                .max_dbs(8)
+                .open(path)?
+        };
+
+        let mut wtxn = env.write_txn()?;
+        let config = env.create_database(&mut wtxn, Some("config"))?;
+        let paths = env.create_database(&mut wtxn, Some("paths"))?;
+        let patterns = env.create_database(&mut wtxn, Some("patterns"))?;
+        wtxn.commit()?;
+
+        log::info!("SPF Config LMDB opened at {:?}", path);
+        Ok(Self { env, config, paths, patterns })
+    }
+
+    // ========================================================================
+    // CORE CONFIG OPERATIONS
+    // ========================================================================
+
+    /// Get a config value by namespace and key
+    pub fn get(&self, namespace: &str, key: &str) -> Result<Option<String>> {
+        let full_key = format!("{}:{}", namespace, key);
+        let rtxn = self.env.read_txn()?;
+        Ok(self.config.get(&rtxn, &full_key)?.map(|s| s.to_string()))
+    }
+
+    /// Set a config value
+    pub fn set(&self, namespace: &str, key: &str, value: &str) -> Result<()> {
+        let full_key = format!("{}:{}", namespace, key);
+        let mut wtxn = self.env.write_txn()?;
+        self.config.put(&mut wtxn, &full_key, value)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Get typed config value (deserialize from JSON)
+    pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, namespace: &str, key: &str) -> Result<Option<T>> {
+        match self.get(namespace, key)? {
+            Some(json) => Ok(Some(serde_json::from_str(&json)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Set typed config value (serialize to JSON)
+    pub fn set_typed<T: Serialize>(&self, namespace: &str, key: &str, value: &T) -> Result<()> {
+        let json = serde_json::to_string(value)?;
+        self.set(namespace, key, &json)
+    }
+
+    // ========================================================================
+    // PATH RULES
+    // ========================================================================
+
+    /// Add an allowed path
+    pub fn allow_path(&self, path: &str) -> Result<()> {
+        let key = format!("allowed:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Add a blocked path
+    pub fn block_path(&self, path: &str) -> Result<()> {
+        let key = format!("blocked:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Remove a path rule
+    pub fn remove_path_rule(&self, rule_type: &str, path: &str) -> Result<bool> {
+        let key = format!("{}:{}", rule_type, path);
+        let mut wtxn = self.env.write_txn()?;
+        let deleted = self.paths.delete(&mut wtxn, &key)?;
+        wtxn.commit()?;
+        Ok(deleted)
+    }
+
+    /// Check if path is allowed (matches any allowed prefix)
+    pub fn is_path_allowed(&self, path: &str) -> Result<bool> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("allowed:") {
+                let allowed_path = &key[8..]; // Skip "allowed:"
+                if path.starts_with(allowed_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Check if path is blocked (matches any blocked prefix)
+    pub fn is_path_blocked(&self, path: &str) -> Result<bool> {
+        // Canonicalize to prevent traversal bypass
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("blocked:") {
+                let blocked_path = &key[8..]; // Skip "blocked:"
+                if canonical.starts_with(blocked_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// List all path rules
+    pub fn list_path_rules(&self) -> Result<Vec<(String, String)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        let mut rules = Vec::new();
+        for result in iter {
+            let (key, _) = result?;
+            if let Some((rule_type, path)) = key.split_once(':') {
+                rules.push((rule_type.to_string(), path.to_string()));
+            }
+        }
+        Ok(rules)
+    }
+
+    // ========================================================================
+    // DANGEROUS PATTERNS
+    // ========================================================================
+
+    /// Add a dangerous pattern with severity (1-10)
+    pub fn add_dangerous_pattern(&self, pattern: &str, severity: u8) -> Result<()> {
+        let mut wtxn = self.env.write_txn()?;
+        self.patterns.put(&mut wtxn, pattern, &severity.min(10))?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Check if command matches any dangerous pattern, returns severity
+    pub fn check_dangerous(&self, command: &str) -> Result<Option<u8>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut max_severity: Option<u8> = None;
+        for result in iter {
+            let (pattern, severity) = result?;
+            if command.contains(pattern) {
+                max_severity = Some(max_severity.map_or(severity, |s| s.max(severity)));
+            }
+        }
+        Ok(max_severity)
+    }
+
+    /// List all dangerous patterns
+    pub fn list_dangerous_patterns(&self) -> Result<Vec<(String, u8)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut patterns = Vec::new();
+        for result in iter {
+            let (pattern, severity) = result?;
+            patterns.push((pattern.to_string(), severity));
+        }
+        Ok(patterns)
+    }
+
+    // ========================================================================
+    // TIER CONFIG
+    // ========================================================================
+
+    /// Get tier config
+    pub fn get_tiers(&self) -> Result<TierConfig> {
+        self.get_typed::<TierConfig>("spf", "tiers")?
+            .ok_or_else(|| anyhow!("Tier config not found"))
+    }
+
+    /// Set tier config
+    pub fn set_tiers(&self, tiers: &TierConfig) -> Result<()> {
+        self.set_typed("spf", "tiers", tiers)
+    }
+
+    /// Get tier for complexity value
+    pub fn get_tier_for_c(&self, c: u64) -> Result<(&'static str, u8, u8, bool)> {
+        let tiers = self.get_tiers()?;
+
+        // HARDCODE: ALL tiers require approval. No exceptions.
+        if c < tiers.simple.max_c {
+            Ok(("SIMPLE", tiers.simple.analyze_percent, tiers.simple.build_percent, true))
+        } else if c < tiers.light.max_c {
+            Ok(("LIGHT", tiers.light.analyze_percent, tiers.light.build_percent, true))
+        } else if c < tiers.medium.max_c {
+            Ok(("MEDIUM", tiers.medium.analyze_percent, tiers.medium.build_percent, true))
+        } else {
+            Ok(("CRITICAL", tiers.critical.analyze_percent, tiers.critical.build_percent, true))
+        }
+    }
+
+    // ========================================================================
+    // FORMULA CONFIG
+    // ========================================================================
+
+    /// Get formula config
+    pub fn get_formula(&self) -> Result<FormulaConfig> {
+        self.get_typed::<FormulaConfig>("spf", "formula")?
+            .ok_or_else(|| anyhow!("Formula config not found"))
+    }
+
+    /// Set formula config
+    pub fn set_formula(&self, formula: &FormulaConfig) -> Result<()> {
+        self.set_typed("spf", "formula", formula)
+    }
+
+    // ========================================================================
+    // COMPLEXITY WEIGHTS
+    // ========================================================================
+
+    /// Get complexity weights
+    pub fn get_weights(&self) -> Result<ComplexityWeights> {
+        self.get_typed::<ComplexityWeights>("spf", "weights")?
+            .ok_or_else(|| anyhow!("Complexity weights not found"))
+    }
+
+    /// Set complexity weights
+    pub fn set_weights(&self, weights: &ComplexityWeights) -> Result<()> {
+        self.set_typed("spf", "weights", weights)
+    }
+
+    /// Get weight for a specific tool
+    pub fn get_tool_weight(&self, tool: &str) -> Result<ToolWeight> {
+        let weights = self.get_weights()?;
+        Ok(match tool.to_lowercase().as_str() {
+            "edit" => weights.edit,
+            "write" => weights.write,
+            "bash_dangerous" => weights.bash_dangerous,
+            "bash_git" => weights.bash_git,
+            "bash_piped" => weights.bash_piped,
+            "bash_simple" | "bash" => weights.bash_simple,
+            "read" => weights.read,
+            "search" | "glob" | "grep" => weights.search,
+            _ => weights.unknown,
+        })
+    }
+
+    // ========================================================================
+    // ENFORCE MODE
+    // ========================================================================
+
+    /// Get enforce mode
+    pub fn get_enforce_mode(&self) -> Result<EnforceMode> {
+        self.get_typed::<EnforceMode>("spf", "enforce_mode")?
+            .ok_or_else(|| anyhow!("Enforce mode not found"))
+    }
+
+    /// Set enforce mode
+    pub fn set_enforce_mode(&self, mode: &EnforceMode) -> Result<()> {
+        self.set_typed("spf", "enforce_mode", mode)
+    }
+
+    // ========================================================================
+    // MIGRATION
+    // ========================================================================
+
+    /// Initialize with defaults (call once on first run)
+    pub fn init_defaults(&self) -> Result<()> {
+        // Only init if not already initialized
+        if self.get("spf", "version")?.is_some() {
+            return Ok(());
+        }
+
+        self.set("spf", "version", "1.0.0")?;
+        self.set_enforce_mode(&EnforceMode::Hard)?;
+        self.set("spf", "require_read_before_edit", "true")?;
+        self.set("spf", "max_write_size", "100000")?;
+
+        // Default tiers
+        self.set_tiers(&TierConfig {
+            simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: true },
+            light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: true },
+            medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: true },
+            critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+        })?;
+
+        // Default formula
+        self.set_formula(&FormulaConfig {
+            w_eff: 40000.0,
+            e: std::f64::consts::E,
+            basic_power: 1,
+            deps_power: 7,
+            complex_power: 10,
+            files_multiplier: 10,
+        })?;
+
+        // Default weights
+        self.set_weights(&ComplexityWeights {
+            edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+            write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+            bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+            bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+            bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+            read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+            search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+            unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+        })?;
+
+        // Default allowed paths
+        self.allow_path("/storage/emulated/0/Download/api-workspace/")?;
+        self.allow_path("/data/data/com.termux/files/home/")?;
+
+        // Default blocked paths
+        self.block_path("/tmp")?;
+        self.block_path("/etc")?;
+        self.block_path("/usr")?;
+        self.block_path("/system")?;
+        self.block_path("/data/data/com.termux/files/usr")?;
+
+        // Default dangerous patterns
+        self.add_dangerous_pattern("rm -rf /", 10)?;
+        self.add_dangerous_pattern("rm -rf ~", 10)?;
+        self.add_dangerous_pattern("dd if=", 9)?;
+        self.add_dangerous_pattern("> /dev/", 9)?;
+        self.add_dangerous_pattern("chmod 777", 7)?;
+        self.add_dangerous_pattern("curl | sh", 8)?;
+        self.add_dangerous_pattern("wget | sh", 8)?;
+        self.add_dangerous_pattern("curl|sh", 8)?;
+        self.add_dangerous_pattern("wget|sh", 8)?;
+
+        log::info!("SPF Config LMDB initialized with defaults");
+        Ok(())
+    }
+
+    /// Get database stats
+    pub fn stats(&self) -> Result<(u64, u64, u64)> {
+        let rtxn = self.env.read_txn()?;
+        let config_stat = self.config.stat(&rtxn)?;
+        let paths_stat = self.paths.stat(&rtxn)?;
+        let patterns_stat = self.patterns.stat(&rtxn)?;
+        Ok((config_stat.entries as u64, paths_stat.entries as u64, patterns_stat.entries as u64))
+    }
+
+    // ========================================================================
+    // FULL CONFIG ASSEMBLY (for main.rs - single source of truth)
+    // ========================================================================
+
+    /// Load full SpfConfig from LMDB. Auto-initializes if empty.
+    /// This is the PRIMARY config loading method - replaces JSON file loading.
+    pub fn load_full_config(&self) -> Result<SpfConfig> {
+        // Ensure defaults exist
+        self.init_defaults()?;
+
+        // Collect path rules
+        let path_rules = self.list_path_rules()?;
+        let mut allowed_paths = Vec::new();
+        let mut blocked_paths = Vec::new();
+        for (rule_type, path) in path_rules {
+            match rule_type.as_str() {
+                "allowed" => allowed_paths.push(path),
+                "blocked" => blocked_paths.push(path),
+                _ => {}
+            }
+        }
+
+        // Collect dangerous commands
+        let dangerous_commands: Vec<String> = self.list_dangerous_patterns()?
+            .into_iter()
+            .map(|(pattern, _)| pattern)
+            .collect();
+
+        // Get scalar values
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+        let require_read = self.get("spf", "require_read_before_edit")?
+            .map(|s| s == "true").unwrap_or(true);
+        let max_write = self.get("spf", "max_write_size")?
+            .and_then(|s| s.parse().ok()).unwrap_or(100_000);
+
+        // Assemble config (types are now identical - no conversion needed)
+        Ok(SpfConfig {
+            version,
+            enforce_mode: self.get_enforce_mode()?,
+            allowed_paths,
+            blocked_paths,
+            require_read_before_edit: require_read,
+            max_write_size: max_write,
+            tiers: self.get_tiers()?,
+            formula: self.get_formula()?,
+            complexity_weights: self.get_weights()?,
+            dangerous_commands,
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        })
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/7931b017237cdafd@v2

@@ -0,0 +1,448 @@
+// SPF Smart Gateway - Configuration LMDB
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// LMDB-backed configuration storage. Replaces config.json with persistent,
+// transactional storage. Supports hot-reload without restart.
+//
+// Database: SPF_CONFIG
+// Storage: ~/SPFsmartGATE/storage/spf_config/
+
+use anyhow::{anyhow, Result};
+use heed::types::*;
+use heed::{Database, Env, EnvOpenOptions};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// Import config types from canonical source (config.rs) - NO DUPLICATES
+use crate::config::{
+    EnforceMode, TierThreshold, TierConfig, FormulaConfig,
+    ToolWeight, ComplexityWeights, SpfConfig,
+};
+
+const MAX_DB_SIZE: usize = 10 * 1024 * 1024; // 10MB - config is small
+
+/// LMDB-backed SPF configuration storage
+pub struct SpfConfigDb {
+    env: Env,
+    /// Main config store: namespace:key → JSON value
+    config: Database<Str, Str>,
+    /// Path rules: "allowed:path" or "blocked:path" → bool
+    paths: Database<Str, SerdeBincode<bool>>,
+    /// Dangerous patterns: pattern → severity (1-10)
+    patterns: Database<Str, SerdeBincode<u8>>,
+}
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+impl SpfConfigDb {
+    /// Open or create config LMDB at given path
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(MAX_DB_SIZE)
+                .max_dbs(8)
+                .open(path)?
+        };
+
+        let mut wtxn = env.write_txn()?;
+        let config = env.create_database(&mut wtxn, Some("config"))?;
+        let paths = env.create_database(&mut wtxn, Some("paths"))?;
+        let patterns = env.create_database(&mut wtxn, Some("patterns"))?;
+        wtxn.commit()?;
+
+        log::info!("SPF Config LMDB opened at {:?}", path);
+        Ok(Self { env, config, paths, patterns })
+    }
+
+    // ========================================================================
+    // CORE CONFIG OPERATIONS
+    // ========================================================================
+
+    /// Get a config value by namespace and key
+    pub fn get(&self, namespace: &str, key: &str) -> Result<Option<String>> {
+        let full_key = format!("{}:{}", namespace, key);
+        let rtxn = self.env.read_txn()?;
+        Ok(self.config.get(&rtxn, &full_key)?.map(|s| s.to_string()))
+    }
+
+    /// Set a config value
+    pub fn set(&self, namespace: &str, key: &str, value: &str) -> Result<()> {
+        let full_key = format!("{}:{}", namespace, key);
+        let mut wtxn = self.env.write_txn()?;
+        self.config.put(&mut wtxn, &full_key, value)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Get typed config value (deserialize from JSON)
+    pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, namespace: &str, key: &str) -> Result<Option<T>> {
+        match self.get(namespace, key)? {
+            Some(json) => Ok(Some(serde_json::from_str(&json)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Set typed config value (serialize to JSON)
+    pub fn set_typed<T: Serialize>(&self, namespace: &str, key: &str, value: &T) -> Result<()> {
+        let json = serde_json::to_string(value)?;
+        self.set(namespace, key, &json)
+    }
+
+    // ========================================================================
+    // PATH RULES
+    // ========================================================================
+
+    /// Add an allowed path
+    pub fn allow_path(&self, path: &str) -> Result<()> {
+        let key = format!("allowed:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Add a blocked path
+    pub fn block_path(&self, path: &str) -> Result<()> {
+        let key = format!("blocked:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Remove a path rule
+    pub fn remove_path_rule(&self, rule_type: &str, path: &str) -> Result<bool> {
+        let key = format!("{}:{}", rule_type, path);
+        let mut wtxn = self.env.write_txn()?;
+        let deleted = self.paths.delete(&mut wtxn, &key)?;
+        wtxn.commit()?;
+        Ok(deleted)
+    }
+
+    /// Check if path is allowed (matches any allowed prefix)
+    pub fn is_path_allowed(&self, path: &str) -> Result<bool> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("allowed:") {
+                let allowed_path = &key[8..]; // Skip "allowed:"
+                if path.starts_with(allowed_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Check if path is blocked (matches any blocked prefix)
+    pub fn is_path_blocked(&self, path: &str) -> Result<bool> {
+        // Canonicalize to prevent traversal bypass
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("blocked:") {
+                let blocked_path = &key[8..]; // Skip "blocked:"
+                if canonical.starts_with(blocked_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// List all path rules
+    pub fn list_path_rules(&self) -> Result<Vec<(String, String)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        let mut rules = Vec::new();
+        for result in iter {
+            let (key, _) = result?;
+            if let Some((rule_type, path)) = key.split_once(':') {
+                rules.push((rule_type.to_string(), path.to_string()));
+            }
+        }
+        Ok(rules)
+    }
+
+    // ========================================================================
+    // DANGEROUS PATTERNS
+    // ========================================================================
+
+    /// Add a dangerous pattern with severity (1-10)
+    pub fn add_dangerous_pattern(&self, pattern: &str, severity: u8) -> Result<()> {
+        let mut wtxn = self.env.write_txn()?;
+        self.patterns.put(&mut wtxn, pattern, &severity.min(10))?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Check if command matches any dangerous pattern, returns severity
+    pub fn check_dangerous(&self, command: &str) -> Result<Option<u8>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut max_severity: Option<u8> = None;
+        for result in iter {
+            let (pattern, severity) = result?;
+            if command.contains(pattern) {
+                max_severity = Some(max_severity.map_or(severity, |s| s.max(severity)));
+            }
+        }
+        Ok(max_severity)
+    }
+
+    /// List all dangerous patterns
+    pub fn list_dangerous_patterns(&self) -> Result<Vec<(String, u8)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut patterns = Vec::new();
+        for result in iter {
+            let (pattern, severity) = result?;
+            patterns.push((pattern.to_string(), severity));
+        }
+        Ok(patterns)
+    }
+
+    // ========================================================================
+    // TIER CONFIG
+    // ========================================================================
+
+    /// Get tier config
+    pub fn get_tiers(&self) -> Result<TierConfig> {
+        self.get_typed::<TierConfig>("spf", "tiers")?
+            .ok_or_else(|| anyhow!("Tier config not found"))
+    }
+
+    /// Set tier config
+    pub fn set_tiers(&self, tiers: &TierConfig) -> Result<()> {
+        self.set_typed("spf", "tiers", tiers)
+    }
+
+    /// Get tier for complexity value
+    /// CRITICAL requires approval. Lower tiers protected by Build Anchor + path blocking + content inspection.
+    pub fn get_tier_for_c(&self, c: u64) -> Result<(&'static str, u8, u8, bool)> {
+        let tiers = self.get_tiers()?;
+
+        if c < tiers.simple.max_c {
+            Ok(("SIMPLE", tiers.simple.analyze_percent, tiers.simple.build_percent, tiers.simple.requires_approval))
+        } else if c < tiers.light.max_c {
+            Ok(("LIGHT", tiers.light.analyze_percent, tiers.light.build_percent, tiers.light.requires_approval))
+        } else if c < tiers.medium.max_c {
+            Ok(("MEDIUM", tiers.medium.analyze_percent, tiers.medium.build_percent, tiers.medium.requires_approval))
+        } else {
+            Ok(("CRITICAL", tiers.critical.analyze_percent, tiers.critical.build_percent, tiers.critical.requires_approval))
+        }
+    }
+
+    // ========================================================================
+    // FORMULA CONFIG
+    // ========================================================================
+
+    /// Get formula config
+    pub fn get_formula(&self) -> Result<FormulaConfig> {
+        self.get_typed::<FormulaConfig>("spf", "formula")?
+            .ok_or_else(|| anyhow!("Formula config not found"))
+    }
+
+    /// Set formula config
+    pub fn set_formula(&self, formula: &FormulaConfig) -> Result<()> {
+        self.set_typed("spf", "formula", formula)
+    }
+
+    // ========================================================================
+    // COMPLEXITY WEIGHTS
+    // ========================================================================
+
+    /// Get complexity weights
+    pub fn get_weights(&self) -> Result<ComplexityWeights> {
+        self.get_typed::<ComplexityWeights>("spf", "weights")?
+            .ok_or_else(|| anyhow!("Complexity weights not found"))
+    }
+
+    /// Set complexity weights
+    pub fn set_weights(&self, weights: &ComplexityWeights) -> Result<()> {
+        self.set_typed("spf", "weights", weights)
+    }
+
+    /// Get weight for a specific tool
+    pub fn get_tool_weight(&self, tool: &str) -> Result<ToolWeight> {
+        let weights = self.get_weights()?;
+        Ok(match tool.to_lowercase().as_str() {
+            "edit" => weights.edit,
+            "write" => weights.write,
+            "bash_dangerous" => weights.bash_dangerous,
+            "bash_git" => weights.bash_git,
+            "bash_piped" => weights.bash_piped,
+            "bash_simple" | "bash" => weights.bash_simple,
+            "read" => weights.read,
+            "search" | "glob" | "grep" => weights.search,
+            _ => weights.unknown,
+        })
+    }
+
+    // ========================================================================
+    // ENFORCE MODE
+    // ========================================================================
+
+    /// Get enforce mode
+    pub fn get_enforce_mode(&self) -> Result<EnforceMode> {
+        self.get_typed::<EnforceMode>("spf", "enforce_mode")?
+            .ok_or_else(|| anyhow!("Enforce mode not found"))
+    }
+
+    /// Set enforce mode
+    pub fn set_enforce_mode(&self, mode: &EnforceMode) -> Result<()> {
+        self.set_typed("spf", "enforce_mode", mode)
+    }
+
+    // ========================================================================
+    // MIGRATION
+    // ========================================================================
+
+    /// Initialize with defaults (call once on first run)
+    pub fn init_defaults(&self) -> Result<()> {
+        // Only init if not already initialized
+        if self.get("spf", "version")?.is_some() {
+            return Ok(());
+        }
+
+        self.set("spf", "version", "1.0.0")?;
+        self.set_enforce_mode(&EnforceMode::Hard)?;
+        self.set("spf", "require_read_before_edit", "true")?;
+        self.set("spf", "max_write_size", "100000")?;
+
+        // Default tiers — CRITICAL requires approval, lower tiers protected by other layers
+        self.set_tiers(&TierConfig {
+            simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: false },
+            light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: false },
+            medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: false },
+            critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+        })?;
+
+        // Default formula
+        self.set_formula(&FormulaConfig {
+            w_eff: 40000.0,
+            e: std::f64::consts::E,
+            basic_power: 1,
+            deps_power: 7,
+            complex_power: 10,
+            files_multiplier: 10,
+        })?;
+
+        // Default weights
+        self.set_weights(&ComplexityWeights {
+            edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+            write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+            bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+            bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+            bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+            read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+            search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+            unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+        })?;
+
+        // Default allowed paths
+        self.allow_path("/storage/emulated/0/Download/api-workspace/")?;
+        self.allow_path("/data/data/com.termux/files/home/")?;
+
+        // Default blocked paths
+        self.block_path("/tmp")?;
+        self.block_path("/etc")?;
+        self.block_path("/usr")?;
+        self.block_path("/system")?;
+        self.block_path("/data/data/com.termux/files/usr")?;
+
+        // Default dangerous patterns
+        self.add_dangerous_pattern("rm -rf /", 10)?;
+        self.add_dangerous_pattern("rm -rf ~", 10)?;
+        self.add_dangerous_pattern("dd if=", 9)?;
+        self.add_dangerous_pattern("> /dev/", 9)?;
+        self.add_dangerous_pattern("chmod 777", 7)?;
+        self.add_dangerous_pattern("curl | sh", 8)?;
+        self.add_dangerous_pattern("wget | sh", 8)?;
+        self.add_dangerous_pattern("curl|sh", 8)?;
+        self.add_dangerous_pattern("wget|sh", 8)?;
+
+        log::info!("SPF Config LMDB initialized with defaults");
+        Ok(())
+    }
+
+    /// Get database stats
+    pub fn stats(&self) -> Result<(u64, u64, u64)> {
+        let rtxn = self.env.read_txn()?;
+        let config_stat = self.config.stat(&rtxn)?;
+        let paths_stat = self.paths.stat(&rtxn)?;
+        let patterns_stat = self.patterns.stat(&rtxn)?;
+        Ok((config_stat.entries as u64, paths_stat.entries as u64, patterns_stat.entries as u64))
+    }
+
+    // ========================================================================
+    // FULL CONFIG ASSEMBLY (for main.rs - single source of truth)
+    // ========================================================================
+
+    /// Load full SpfConfig from LMDB. Auto-initializes if empty.
+    /// This is the PRIMARY config loading method - replaces JSON file loading.
+    pub fn load_full_config(&self) -> Result<SpfConfig> {
+        // Ensure defaults exist
+        self.init_defaults()?;
+
+        // Collect path rules
+        let path_rules = self.list_path_rules()?;
+        let mut allowed_paths = Vec::new();
+        let mut blocked_paths = Vec::new();
+        for (rule_type, path) in path_rules {
+            match rule_type.as_str() {
+                "allowed" => allowed_paths.push(path),
+                "blocked" => blocked_paths.push(path),
+                _ => {}
+            }
+        }
+
+        // Collect dangerous commands
+        let dangerous_commands: Vec<String> = self.list_dangerous_patterns()?
+            .into_iter()
+            .map(|(pattern, _)| pattern)
+            .collect();
+
+        // Get scalar values
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+        let require_read = self.get("spf", "require_read_before_edit")?
+            .map(|s| s == "true").unwrap_or(true);
+        let max_write = self.get("spf", "max_write_size")?
+            .and_then(|s| s.parse().ok()).unwrap_or(100_000);
+
+        // Assemble config (types are now identical - no conversion needed)
+        Ok(SpfConfig {
+            version,
+            enforce_mode: self.get_enforce_mode()?,
+            allowed_paths,
+            blocked_paths,
+            require_read_before_edit: require_read,
+            max_write_size: max_write,
+            tiers: self.get_tiers()?,
+            formula: self.get_formula()?,
+            complexity_weights: self.get_weights()?,
+            dangerous_commands,
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        })
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/7931b017237cdafd@v3

@@ -0,0 +1,475 @@
+// SPF Smart Gateway - Configuration LMDB
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// LMDB-backed configuration storage. Replaces config.json with persistent,
+// transactional storage. Supports hot-reload without restart.
+//
+// Database: SPF_CONFIG
+// Storage: ~/SPFsmartGATE/storage/spf_config/
+
+use anyhow::{anyhow, Result};
+use heed::types::*;
+use heed::{Database, Env, EnvOpenOptions};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// Import config types from canonical source (config.rs) - NO DUPLICATES
+use crate::config::{
+    EnforceMode, TierThreshold, TierConfig, FormulaConfig,
+    ToolWeight, ComplexityWeights, SpfConfig,
+};
+
+const MAX_DB_SIZE: usize = 10 * 1024 * 1024; // 10MB - config is small
+
+/// LMDB-backed SPF configuration storage
+pub struct SpfConfigDb {
+    env: Env,
+    /// Main config store: namespace:key → JSON value
+    config: Database<Str, Str>,
+    /// Path rules: "allowed:path" or "blocked:path" → bool
+    paths: Database<Str, SerdeBincode<bool>>,
+    /// Dangerous patterns: pattern → severity (1-10)
+    patterns: Database<Str, SerdeBincode<u8>>,
+}
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+impl SpfConfigDb {
+    /// Open or create config LMDB at given path
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(MAX_DB_SIZE)
+                .max_dbs(8)
+                .open(path)?
+        };
+
+        let mut wtxn = env.write_txn()?;
+        let config = env.create_database(&mut wtxn, Some("config"))?;
+        let paths = env.create_database(&mut wtxn, Some("paths"))?;
+        let patterns = env.create_database(&mut wtxn, Some("patterns"))?;
+        wtxn.commit()?;
+
+        log::info!("SPF Config LMDB opened at {:?}", path);
+        Ok(Self { env, config, paths, patterns })
+    }
+
+    // ========================================================================
+    // CORE CONFIG OPERATIONS
+    // ========================================================================
+
+    /// Get a config value by namespace and key
+    pub fn get(&self, namespace: &str, key: &str) -> Result<Option<String>> {
+        let full_key = format!("{}:{}", namespace, key);
+        let rtxn = self.env.read_txn()?;
+        Ok(self.config.get(&rtxn, &full_key)?.map(|s| s.to_string()))
+    }
+
+    /// Set a config value
+    pub fn set(&self, namespace: &str, key: &str, value: &str) -> Result<()> {
+        let full_key = format!("{}:{}", namespace, key);
+        let mut wtxn = self.env.write_txn()?;
+        self.config.put(&mut wtxn, &full_key, value)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Get typed config value (deserialize from JSON)
+    pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, namespace: &str, key: &str) -> Result<Option<T>> {
+        match self.get(namespace, key)? {
+            Some(json) => Ok(Some(serde_json::from_str(&json)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Set typed config value (serialize to JSON)
+    pub fn set_typed<T: Serialize>(&self, namespace: &str, key: &str, value: &T) -> Result<()> {
+        let json = serde_json::to_string(value)?;
+        self.set(namespace, key, &json)
+    }
+
+    // ========================================================================
+    // PATH RULES
+    // ========================================================================
+
+    /// Add an allowed path
+    pub fn allow_path(&self, path: &str) -> Result<()> {
+        let key = format!("allowed:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Add a blocked path
+    pub fn block_path(&self, path: &str) -> Result<()> {
+        let key = format!("blocked:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Remove a path rule
+    pub fn remove_path_rule(&self, rule_type: &str, path: &str) -> Result<bool> {
+        let key = format!("{}:{}", rule_type, path);
+        let mut wtxn = self.env.write_txn()?;
+        let deleted = self.paths.delete(&mut wtxn, &key)?;
+        wtxn.commit()?;
+        Ok(deleted)
+    }
+
+    /// Check if path is allowed (matches any allowed prefix)
+    pub fn is_path_allowed(&self, path: &str) -> Result<bool> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("allowed:") {
+                let allowed_path = &key[8..]; // Skip "allowed:"
+                if path.starts_with(allowed_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Check if path is blocked (matches any blocked prefix)
+    pub fn is_path_blocked(&self, path: &str) -> Result<bool> {
+        // Canonicalize to prevent traversal bypass
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("blocked:") {
+                let blocked_path = &key[8..]; // Skip "blocked:"
+                if canonical.starts_with(blocked_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// List all path rules
+    pub fn list_path_rules(&self) -> Result<Vec<(String, String)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        let mut rules = Vec::new();
+        for result in iter {
+            let (key, _) = result?;
+            if let Some((rule_type, path)) = key.split_once(':') {
+                rules.push((rule_type.to_string(), path.to_string()));
+            }
+        }
+        Ok(rules)
+    }
+
+    // ========================================================================
+    // DANGEROUS PATTERNS
+    // ========================================================================
+
+    /// Add a dangerous pattern with severity (1-10)
+    pub fn add_dangerous_pattern(&self, pattern: &str, severity: u8) -> Result<()> {
+        let mut wtxn = self.env.write_txn()?;
+        self.patterns.put(&mut wtxn, pattern, &severity.min(10))?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Check if command matches any dangerous pattern, returns severity
+    pub fn check_dangerous(&self, command: &str) -> Result<Option<u8>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut max_severity: Option<u8> = None;
+        for result in iter {
+            let (pattern, severity) = result?;
+            if command.contains(pattern) {
+                max_severity = Some(max_severity.map_or(severity, |s| s.max(severity)));
+            }
+        }
+        Ok(max_severity)
+    }
+
+    /// List all dangerous patterns
+    pub fn list_dangerous_patterns(&self) -> Result<Vec<(String, u8)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut patterns = Vec::new();
+        for result in iter {
+            let (pattern, severity) = result?;
+            patterns.push((pattern.to_string(), severity));
+        }
+        Ok(patterns)
+    }
+
+    // ========================================================================
+    // TIER CONFIG
+    // ========================================================================
+
+    /// Get tier config
+    pub fn get_tiers(&self) -> Result<TierConfig> {
+        self.get_typed::<TierConfig>("spf", "tiers")?
+            .ok_or_else(|| anyhow!("Tier config not found"))
+    }
+
+    /// Set tier config
+    pub fn set_tiers(&self, tiers: &TierConfig) -> Result<()> {
+        self.set_typed("spf", "tiers", tiers)
+    }
+
+    /// Get tier for complexity value
+    /// CRITICAL requires approval. Lower tiers protected by Build Anchor + path blocking + content inspection.
+    pub fn get_tier_for_c(&self, c: u64) -> Result<(&'static str, u8, u8, bool)> {
+        let tiers = self.get_tiers()?;
+
+        if c < tiers.simple.max_c {
+            Ok(("SIMPLE", tiers.simple.analyze_percent, tiers.simple.build_percent, tiers.simple.requires_approval))
+        } else if c < tiers.light.max_c {
+            Ok(("LIGHT", tiers.light.analyze_percent, tiers.light.build_percent, tiers.light.requires_approval))
+        } else if c < tiers.medium.max_c {
+            Ok(("MEDIUM", tiers.medium.analyze_percent, tiers.medium.build_percent, tiers.medium.requires_approval))
+        } else {
+            Ok(("CRITICAL", tiers.critical.analyze_percent, tiers.critical.build_percent, tiers.critical.requires_approval))
+        }
+    }
+
+    // ========================================================================
+    // FORMULA CONFIG
+    // ========================================================================
+
+    /// Get formula config
+    pub fn get_formula(&self) -> Result<FormulaConfig> {
+        self.get_typed::<FormulaConfig>("spf", "formula")?
+            .ok_or_else(|| anyhow!("Formula config not found"))
+    }
+
+    /// Set formula config
+    pub fn set_formula(&self, formula: &FormulaConfig) -> Result<()> {
+        self.set_typed("spf", "formula", formula)
+    }
+
+    // ========================================================================
+    // COMPLEXITY WEIGHTS
+    // ========================================================================
+
+    /// Get complexity weights
+    pub fn get_weights(&self) -> Result<ComplexityWeights> {
+        self.get_typed::<ComplexityWeights>("spf", "weights")?
+            .ok_or_else(|| anyhow!("Complexity weights not found"))
+    }
+
+    /// Set complexity weights
+    pub fn set_weights(&self, weights: &ComplexityWeights) -> Result<()> {
+        self.set_typed("spf", "weights", weights)
+    }
+
+    /// Get weight for a specific tool
+    pub fn get_tool_weight(&self, tool: &str) -> Result<ToolWeight> {
+        let weights = self.get_weights()?;
+        Ok(match tool.to_lowercase().as_str() {
+            "edit" => weights.edit,
+            "write" => weights.write,
+            "bash_dangerous" => weights.bash_dangerous,
+            "bash_git" => weights.bash_git,
+            "bash_piped" => weights.bash_piped,
+            "bash_simple" | "bash" => weights.bash_simple,
+            "read" => weights.read,
+            "search" | "glob" | "grep" => weights.search,
+            _ => weights.unknown,
+        })
+    }
+
+    // ========================================================================
+    // ENFORCE MODE
+    // ========================================================================
+
+    /// Get enforce mode
+    pub fn get_enforce_mode(&self) -> Result<EnforceMode> {
+        self.get_typed::<EnforceMode>("spf", "enforce_mode")?
+            .ok_or_else(|| anyhow!("Enforce mode not found"))
+    }
+
+    /// Set enforce mode
+    pub fn set_enforce_mode(&self, mode: &EnforceMode) -> Result<()> {
+        self.set_typed("spf", "enforce_mode", mode)
+    }
+
+    // ========================================================================
+    // MIGRATION
+    // ========================================================================
+
+    /// Initialize with defaults (call once on first run)
+    pub fn init_defaults(&self) -> Result<()> {
+        // Only init if not already initialized
+        if self.get("spf", "version")?.is_some() {
+            return Ok(());
+        }
+
+        self.set("spf", "version", "1.0.0")?;
+        self.set_enforce_mode(&EnforceMode::Hard)?;
+        self.set("spf", "require_read_before_edit", "true")?;
+        self.set("spf", "max_write_size", "100000")?;
+
+        // Default tiers — CRITICAL requires approval, lower tiers protected by other layers
+        self.set_tiers(&TierConfig {
+            simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: false },
+            light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: false },
+            medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: false },
+            critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+        })?;
+
+        // Default formula
+        self.set_formula(&FormulaConfig {
+            w_eff: 40000.0,
+            e: std::f64::consts::E,
+            basic_power: 1,
+            deps_power: 7,
+            complex_power: 10,
+            files_multiplier: 10,
+        })?;
+
+        // Default weights
+        self.set_weights(&ComplexityWeights {
+            edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+            write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+            bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+            bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+            bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+            read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+            search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+            unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+        })?;
+
+        // Default allowed paths
+        self.allow_path("/storage/emulated/0/Download/api-workspace/")?;
+        self.allow_path("/data/data/com.termux/files/home/")?;
+
+        // Default blocked paths
+        self.block_path("/tmp")?;
+        self.block_path("/etc")?;
+        self.block_path("/usr")?;
+        self.block_path("/system")?;
+        self.block_path("/data/data/com.termux/files/usr")?;
+
+        // Default dangerous patterns
+        self.add_dangerous_pattern("rm -rf /", 10)?;
+        self.add_dangerous_pattern("rm -rf ~", 10)?;
+        self.add_dangerous_pattern("dd if=", 9)?;
+        self.add_dangerous_pattern("> /dev/", 9)?;
+        self.add_dangerous_pattern("chmod 777", 7)?;
+        self.add_dangerous_pattern("curl | sh", 8)?;
+        self.add_dangerous_pattern("wget | sh", 8)?;
+        self.add_dangerous_pattern("curl|sh", 8)?;
+        self.add_dangerous_pattern("wget|sh", 8)?;
+
+        log::info!("SPF Config LMDB initialized with defaults");
+        Ok(())
+    }
+
+    /// Run version migrations. Each migration checks stored version and applies fixes.
+    /// Called from load_full_config() after init_defaults().
+    pub fn run_migrations(&self) -> Result<()> {
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+
+        // Migration: 1.0.0 → 2.0.0
+        // Fix: Remove approval backdoor left by Opus 4.5.
+        // Only CRITICAL tier requires explicit approval.
+        // Lower tiers protected by Build Anchor + path blocking + content inspection.
+        if version == "1.0.0" {
+            log::info!("SPF migration 1.0.0 → 2.0.0: fixing tier approval config");
+
+            let mut tiers = self.get_tiers()?;
+            tiers.simple.requires_approval = false;
+            tiers.light.requires_approval = false;
+            tiers.medium.requires_approval = false;
+            tiers.critical.requires_approval = true;
+            self.set_tiers(&tiers)?;
+
+            self.set("spf", "version", "2.0.0")?;
+            log::info!("SPF migration to 2.0.0 complete");
+        }
+
+        Ok(())
+    }
+
+    /// Get database stats
+    pub fn stats(&self) -> Result<(u64, u64, u64)> {
+        let rtxn = self.env.read_txn()?;
+        let config_stat = self.config.stat(&rtxn)?;
+        let paths_stat = self.paths.stat(&rtxn)?;
+        let patterns_stat = self.patterns.stat(&rtxn)?;
+        Ok((config_stat.entries as u64, paths_stat.entries as u64, patterns_stat.entries as u64))
+    }
+
+    // ========================================================================
+    // FULL CONFIG ASSEMBLY (for main.rs - single source of truth)
+    // ========================================================================
+
+    /// Load full SpfConfig from LMDB. Auto-initializes if empty.
+    /// This is the PRIMARY config loading method - replaces JSON file loading.
+    pub fn load_full_config(&self) -> Result<SpfConfig> {
+        // Ensure defaults exist, then run any pending migrations
+        self.init_defaults()?;
+        self.run_migrations()?;
+
+        // Collect path rules
+        let path_rules = self.list_path_rules()?;
+        let mut allowed_paths = Vec::new();
+        let mut blocked_paths = Vec::new();
+        for (rule_type, path) in path_rules {
+            match rule_type.as_str() {
+                "allowed" => allowed_paths.push(path),
+                "blocked" => blocked_paths.push(path),
+                _ => {}
+            }
+        }
+
+        // Collect dangerous commands
+        let dangerous_commands: Vec<String> = self.list_dangerous_patterns()?
+            .into_iter()
+            .map(|(pattern, _)| pattern)
+            .collect();
+
+        // Get scalar values
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+        let require_read = self.get("spf", "require_read_before_edit")?
+            .map(|s| s == "true").unwrap_or(true);
+        let max_write = self.get("spf", "max_write_size")?
+            .and_then(|s| s.parse().ok()).unwrap_or(100_000);
+
+        // Assemble config (types are now identical - no conversion needed)
+        Ok(SpfConfig {
+            version,
+            enforce_mode: self.get_enforce_mode()?,
+            allowed_paths,
+            blocked_paths,
+            require_read_before_edit: require_read,
+            max_write_size: max_write,
+            tiers: self.get_tiers()?,
+            formula: self.get_formula()?,
+            complexity_weights: self.get_weights()?,
+            dangerous_commands,
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        })
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/7931b017237cdafd@v4

@@ -0,0 +1,490 @@
+// SPF Smart Gateway - Configuration LMDB
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// LMDB-backed configuration storage. Replaces config.json with persistent,
+// transactional storage. Supports hot-reload without restart.
+//
+// Database: SPF_CONFIG
+// Storage: ~/SPFsmartGATE/storage/spf_config/
+
+use anyhow::{anyhow, Result};
+use heed::types::*;
+use heed::{Database, Env, EnvOpenOptions};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// Import config types from canonical source (config.rs) - NO DUPLICATES
+use crate::config::{
+    EnforceMode, TierThreshold, TierConfig, FormulaConfig,
+    ToolWeight, ComplexityWeights, SpfConfig,
+};
+
+const MAX_DB_SIZE: usize = 10 * 1024 * 1024; // 10MB - config is small
+
+/// LMDB-backed SPF configuration storage
+pub struct SpfConfigDb {
+    env: Env,
+    /// Main config store: namespace:key → JSON value
+    config: Database<Str, Str>,
+    /// Path rules: "allowed:path" or "blocked:path" → bool
+    paths: Database<Str, SerdeBincode<bool>>,
+    /// Dangerous patterns: pattern → severity (1-10)
+    patterns: Database<Str, SerdeBincode<u8>>,
+}
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+impl SpfConfigDb {
+    /// Open or create config LMDB at given path
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(MAX_DB_SIZE)
+                .max_dbs(8)
+                .open(path)?
+        };
+
+        let mut wtxn = env.write_txn()?;
+        let config = env.create_database(&mut wtxn, Some("config"))?;
+        let paths = env.create_database(&mut wtxn, Some("paths"))?;
+        let patterns = env.create_database(&mut wtxn, Some("patterns"))?;
+        wtxn.commit()?;
+
+        log::info!("SPF Config LMDB opened at {:?}", path);
+        Ok(Self { env, config, paths, patterns })
+    }
+
+    // ========================================================================
+    // CORE CONFIG OPERATIONS
+    // ========================================================================
+
+    /// Get a config value by namespace and key
+    pub fn get(&self, namespace: &str, key: &str) -> Result<Option<String>> {
+        let full_key = format!("{}:{}", namespace, key);
+        let rtxn = self.env.read_txn()?;
+        Ok(self.config.get(&rtxn, &full_key)?.map(|s| s.to_string()))
+    }
+
+    /// Set a config value
+    pub fn set(&self, namespace: &str, key: &str, value: &str) -> Result<()> {
+        let full_key = format!("{}:{}", namespace, key);
+        let mut wtxn = self.env.write_txn()?;
+        self.config.put(&mut wtxn, &full_key, value)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Get typed config value (deserialize from JSON)
+    pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, namespace: &str, key: &str) -> Result<Option<T>> {
+        match self.get(namespace, key)? {
+            Some(json) => Ok(Some(serde_json::from_str(&json)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Set typed config value (serialize to JSON)
+    pub fn set_typed<T: Serialize>(&self, namespace: &str, key: &str, value: &T) -> Result<()> {
+        let json = serde_json::to_string(value)?;
+        self.set(namespace, key, &json)
+    }
+
+    // ========================================================================
+    // PATH RULES
+    // ========================================================================
+
+    /// Add an allowed path
+    pub fn allow_path(&self, path: &str) -> Result<()> {
+        let key = format!("allowed:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Add a blocked path
+    pub fn block_path(&self, path: &str) -> Result<()> {
+        let key = format!("blocked:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Remove a path rule
+    pub fn remove_path_rule(&self, rule_type: &str, path: &str) -> Result<bool> {
+        let key = format!("{}:{}", rule_type, path);
+        let mut wtxn = self.env.write_txn()?;
+        let deleted = self.paths.delete(&mut wtxn, &key)?;
+        wtxn.commit()?;
+        Ok(deleted)
+    }
+
+    /// Check if path is allowed (matches any allowed prefix)
+    pub fn is_path_allowed(&self, path: &str) -> Result<bool> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("allowed:") {
+                let allowed_path = &key[8..]; // Skip "allowed:"
+                if path.starts_with(allowed_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Check if path is blocked (matches any blocked prefix)
+    pub fn is_path_blocked(&self, path: &str) -> Result<bool> {
+        // Canonicalize to prevent traversal bypass
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("blocked:") {
+                let blocked_path = &key[8..]; // Skip "blocked:"
+                if canonical.starts_with(blocked_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// List all path rules
+    pub fn list_path_rules(&self) -> Result<Vec<(String, String)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        let mut rules = Vec::new();
+        for result in iter {
+            let (key, _) = result?;
+            if let Some((rule_type, path)) = key.split_once(':') {
+                rules.push((rule_type.to_string(), path.to_string()));
+            }
+        }
+        Ok(rules)
+    }
+
+    // ========================================================================
+    // DANGEROUS PATTERNS
+    // ========================================================================
+
+    /// Add a dangerous pattern with severity (1-10)
+    pub fn add_dangerous_pattern(&self, pattern: &str, severity: u8) -> Result<()> {
+        let mut wtxn = self.env.write_txn()?;
+        self.patterns.put(&mut wtxn, pattern, &severity.min(10))?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Check if command matches any dangerous pattern, returns severity
+    pub fn check_dangerous(&self, command: &str) -> Result<Option<u8>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut max_severity: Option<u8> = None;
+        for result in iter {
+            let (pattern, severity) = result?;
+            if command.contains(pattern) {
+                max_severity = Some(max_severity.map_or(severity, |s| s.max(severity)));
+            }
+        }
+        Ok(max_severity)
+    }
+
+    /// List all dangerous patterns
+    pub fn list_dangerous_patterns(&self) -> Result<Vec<(String, u8)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut patterns = Vec::new();
+        for result in iter {
+            let (pattern, severity) = result?;
+            patterns.push((pattern.to_string(), severity));
+        }
+        Ok(patterns)
+    }
+
+    // ========================================================================
+    // TIER CONFIG
+    // ========================================================================
+
+    /// Get tier config
+    pub fn get_tiers(&self) -> Result<TierConfig> {
+        self.get_typed::<TierConfig>("spf", "tiers")?
+            .ok_or_else(|| anyhow!("Tier config not found"))
+    }
+
+    /// Set tier config
+    pub fn set_tiers(&self, tiers: &TierConfig) -> Result<()> {
+        self.set_typed("spf", "tiers", tiers)
+    }
+
+    /// Get tier for complexity value
+    /// CRITICAL requires approval. Lower tiers protected by Build Anchor + path blocking + content inspection.
+    pub fn get_tier_for_c(&self, c: u64) -> Result<(&'static str, u8, u8, bool)> {
+        let tiers = self.get_tiers()?;
+
+        if c < tiers.simple.max_c {
+            Ok(("SIMPLE", tiers.simple.analyze_percent, tiers.simple.build_percent, tiers.simple.requires_approval))
+        } else if c < tiers.light.max_c {
+            Ok(("LIGHT", tiers.light.analyze_percent, tiers.light.build_percent, tiers.light.requires_approval))
+        } else if c < tiers.medium.max_c {
+            Ok(("MEDIUM", tiers.medium.analyze_percent, tiers.medium.build_percent, tiers.medium.requires_approval))
+        } else {
+            Ok(("CRITICAL", tiers.critical.analyze_percent, tiers.critical.build_percent, tiers.critical.requires_approval))
+        }
+    }
+
+    // ========================================================================
+    // FORMULA CONFIG
+    // ========================================================================
+
+    /// Get formula config
+    pub fn get_formula(&self) -> Result<FormulaConfig> {
+        self.get_typed::<FormulaConfig>("spf", "formula")?
+            .ok_or_else(|| anyhow!("Formula config not found"))
+    }
+
+    /// Set formula config
+    pub fn set_formula(&self, formula: &FormulaConfig) -> Result<()> {
+        self.set_typed("spf", "formula", formula)
+    }
+
+    // ========================================================================
+    // COMPLEXITY WEIGHTS
+    // ========================================================================
+
+    /// Get complexity weights
+    pub fn get_weights(&self) -> Result<ComplexityWeights> {
+        self.get_typed::<ComplexityWeights>("spf", "weights")?
+            .ok_or_else(|| anyhow!("Complexity weights not found"))
+    }
+
+    /// Set complexity weights
+    pub fn set_weights(&self, weights: &ComplexityWeights) -> Result<()> {
+        self.set_typed("spf", "weights", weights)
+    }
+
+    /// Get weight for a specific tool
+    pub fn get_tool_weight(&self, tool: &str) -> Result<ToolWeight> {
+        let weights = self.get_weights()?;
+        Ok(match tool.to_lowercase().as_str() {
+            "edit" => weights.edit,
+            "write" => weights.write,
+            "bash_dangerous" => weights.bash_dangerous,
+            "bash_git" => weights.bash_git,
+            "bash_piped" => weights.bash_piped,
+            "bash_simple" | "bash" => weights.bash_simple,
+            "read" => weights.read,
+            "search" | "glob" | "grep" => weights.search,
+            _ => weights.unknown,
+        })
+    }
+
+    // ========================================================================
+    // ENFORCE MODE
+    // ========================================================================
+
+    /// Get enforce mode
+    pub fn get_enforce_mode(&self) -> Result<EnforceMode> {
+        self.get_typed::<EnforceMode>("spf", "enforce_mode")?
+            .ok_or_else(|| anyhow!("Enforce mode not found"))
+    }
+
+    /// Set enforce mode
+    pub fn set_enforce_mode(&self, mode: &EnforceMode) -> Result<()> {
+        self.set_typed("spf", "enforce_mode", mode)
+    }
+
+    // ========================================================================
+    // MIGRATION
+    // ========================================================================
+
+    /// Initialize with defaults (call once on first run)
+    pub fn init_defaults(&self) -> Result<()> {
+        // Only init if not already initialized
+        if self.get("spf", "version")?.is_some() {
+            return Ok(());
+        }
+
+        self.set("spf", "version", "1.0.0")?;
+        self.set_enforce_mode(&EnforceMode::Hard)?;
+        self.set("spf", "require_read_before_edit", "true")?;
+        self.set("spf", "max_write_size", "100000")?;
+
+        // Default tiers — CRITICAL requires approval, lower tiers protected by other layers
+        self.set_tiers(&TierConfig {
+            simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: false },
+            light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: false },
+            medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: false },
+            critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+        })?;
+
+        // Default formula
+        self.set_formula(&FormulaConfig {
+            w_eff: 40000.0,
+            e: std::f64::consts::E,
+            basic_power: 1,
+            deps_power: 7,
+            complex_power: 10,
+            files_multiplier: 10,
+        })?;
+
+        // Default weights
+        self.set_weights(&ComplexityWeights {
+            edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+            write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+            bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+            bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+            bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+            read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+            search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+            unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+        })?;
+
+        // Default allowed paths
+        self.allow_path("/storage/emulated/0/Download/api-workspace/")?;
+        self.allow_path("/data/data/com.termux/files/home/")?;
+
+        // Default blocked paths
+        self.block_path("/tmp")?;
+        self.block_path("/etc")?;
+        self.block_path("/usr")?;
+        self.block_path("/system")?;
+        self.block_path("/data/data/com.termux/files/usr")?;
+
+        // Default dangerous patterns
+        self.add_dangerous_pattern("rm -rf /", 10)?;
+        self.add_dangerous_pattern("rm -rf ~", 10)?;
+        self.add_dangerous_pattern("dd if=", 9)?;
+        self.add_dangerous_pattern("> /dev/", 9)?;
+        self.add_dangerous_pattern("chmod 777", 7)?;
+        self.add_dangerous_pattern("curl | sh", 8)?;
+        self.add_dangerous_pattern("wget | sh", 8)?;
+        self.add_dangerous_pattern("curl|sh", 8)?;
+        self.add_dangerous_pattern("wget|sh", 8)?;
+
+        log::info!("SPF Config LMDB initialized with defaults");
+        Ok(())
+    }
+
+    /// Sync tier approval policy on every boot.
+    /// Source of truth is THIS code — LMDB stores runtime state, code defines policy.
+    /// Change the values here → next boot picks them up. No version tracking needed.
+    pub fn sync_tier_approval(&self) -> Result<()> {
+        let mut tiers = self.get_tiers()?;
+        let mut changed = false;
+
+        // === APPROVAL POLICY (edit here to change) ===
+        let policy: [(&str, bool); 4] = [
+            ("SIMPLE",   false),
+            ("LIGHT",    false),
+            ("MEDIUM",   false),
+            ("CRITICAL", true),
+        ];
+
+        let tier_refs = [
+            &mut tiers.simple,
+            &mut tiers.light,
+            &mut tiers.medium,
+            &mut tiers.critical,
+        ];
+
+        for (i, (name, required)) in policy.iter().enumerate() {
+            if tier_refs[i].requires_approval != *required {
+                log::info!("SPF sync: {} requires_approval {} → {}", name, tier_refs[i].requires_approval, required);
+                tier_refs[i].requires_approval = *required;
+                changed = true;
+            }
+        }
+
+        if changed {
+            self.set_tiers(&tiers)?;
+            log::info!("SPF tier approval policy synced");
+        }
+
+        // Keep version current
+        self.set("spf", "version", "2.0.0")?;
+
+        Ok(())
+    }
+
+    /// Get database stats
+    pub fn stats(&self) -> Result<(u64, u64, u64)> {
+        let rtxn = self.env.read_txn()?;
+        let config_stat = self.config.stat(&rtxn)?;
+        let paths_stat = self.paths.stat(&rtxn)?;
+        let patterns_stat = self.patterns.stat(&rtxn)?;
+        Ok((config_stat.entries as u64, paths_stat.entries as u64, patterns_stat.entries as u64))
+    }
+
+    // ========================================================================
+    // FULL CONFIG ASSEMBLY (for main.rs - single source of truth)
+    // ========================================================================
+
+    /// Load full SpfConfig from LMDB. Auto-initializes if empty.
+    /// This is the PRIMARY config loading method - replaces JSON file loading.
+    pub fn load_full_config(&self) -> Result<SpfConfig> {
+        // Ensure defaults exist, then sync approval policy from code
+        self.init_defaults()?;
+        self.sync_tier_approval()?;
+
+        // Collect path rules
+        let path_rules = self.list_path_rules()?;
+        let mut allowed_paths = Vec::new();
+        let mut blocked_paths = Vec::new();
+        for (rule_type, path) in path_rules {
+            match rule_type.as_str() {
+                "allowed" => allowed_paths.push(path),
+                "blocked" => blocked_paths.push(path),
+                _ => {}
+            }
+        }
+
+        // Collect dangerous commands
+        let dangerous_commands: Vec<String> = self.list_dangerous_patterns()?
+            .into_iter()
+            .map(|(pattern, _)| pattern)
+            .collect();
+
+        // Get scalar values
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+        let require_read = self.get("spf", "require_read_before_edit")?
+            .map(|s| s == "true").unwrap_or(true);
+        let max_write = self.get("spf", "max_write_size")?
+            .and_then(|s| s.parse().ok()).unwrap_or(100_000);
+
+        // Assemble config (types are now identical - no conversion needed)
+        Ok(SpfConfig {
+            version,
+            enforce_mode: self.get_enforce_mode()?,
+            allowed_paths,
+            blocked_paths,
+            require_read_before_edit: require_read,
+            max_write_size: max_write,
+            tiers: self.get_tiers()?,
+            formula: self.get_formula()?,
+            complexity_weights: self.get_weights()?,
+            dangerous_commands,
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        })
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/9c462d52bfadf61c@v1

@@ -0,0 +1,2105 @@
+// SPF Smart Gateway - MCP Server (JSON-RPC 2.0 over stdio)
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// ALL tool calls route through this gateway.
+// Exposes: spf_gate, spf_read, spf_write, spf_edit, spf_bash, spf_status,
+//          spf_calculate, spf_session, spf_brain_search, spf_brain_store
+
+use crate::calculate::{self, ToolParams};
+use crate::config::SpfConfig;
+use crate::config_db::SpfConfigDb;
+use crate::tools_db::SpfToolsDb;
+use crate::sandbox_db::SpfSandboxDb;
+use crate::agent_state::AgentStateDb;
+use crate::gate;
+use crate::session::Session;
+use crate::storage::SpfStorage;
+use crate::web::WebClient;
+use serde_json::{json, Value};
+use std::io::{self, BufRead, Write};
+use std::process::Command;
+use std::path::PathBuf;
+use chrono::{DateTime, Utc};
+
+const PROTOCOL_VERSION: &str = "2024-11-05";
+
+/// Format Unix timestamp as human-readable ISO8601
+fn format_timestamp(ts: u64) -> String {
+    if ts == 0 {
+        return "Never".to_string();
+    }
+    DateTime::<Utc>::from_timestamp(ts as i64, 0)
+        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
+        .unwrap_or_else(|| ts.to_string())
+}
+const SERVER_NAME: &str = "spf-smart-gate";
+const SERVER_VERSION: &str = "1.0.0";
+
+/// Brain binary path
+fn brain_path() -> PathBuf {
+    dirs_home().join("stoneshell-brain/target/release/brain")
+}
+
+fn dirs_home() -> PathBuf {
+    PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/data/data/com.termux/files/home".to_string()))
+}
+
+/// Run brain CLI command
+fn run_brain(args: &[&str]) -> (bool, String) {
+    let brain = brain_path();
+    if !brain.exists() {
+        return (false, format!("Brain not found: {:?}", brain));
+    }
+    match Command::new(&brain)
+        .args(args)
+        .current_dir(brain.parent().unwrap().parent().unwrap())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                (false, String::from_utf8_lossy(&output.stderr).to_string())
+            }
+        }
+        Err(e) => (false, format!("Failed to run brain: {}", e)),
+    }
+}
+
+/// RAG Collector script path
+fn rag_collector_path() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR/server.py")
+}
+
+/// RAG Collector working directory
+fn rag_collector_dir() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR")
+}
+
+/// Run RAG Collector command
+fn run_rag(args: &[&str]) -> (bool, String) {
+    let rag = rag_collector_path();
+    if !rag.exists() {
+        return (false, format!("RAG Collector not found: {:?}", rag));
+    }
+    match Command::new("python3")
+        .arg("-u")
+        .arg(&rag)
+        .args(args)
+        .current_dir(rag_collector_dir())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                (false, format!("{}\n{}", stdout, stderr))
+            }
+        }
+        Err(e) => (false, format!("Failed to run RAG Collector: {}", e)),
+    }
+}
+
+/// Log to stderr (stdout is JSON-RPC)
+fn log(msg: &str) {
+    eprintln!("[spf-smart-gate] {}", msg);
+}
+
+/// Send JSON-RPC response
+fn send_response(id: &Value, result: Value) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "result": result,
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// Send JSON-RPC error response
+fn send_error(id: &Value, code: i64, message: &str) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "error": { "code": code, "message": message },
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// MCP tool definition helper
+fn tool_def(name: &str, description: &str, properties: Value, required: Vec<&str>) -> Value {
+    json!({
+        "name": name,
+        "description": description,
+        "inputSchema": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        }
+    })
+}
+
+/// Return all tool definitions
+fn tool_definitions() -> Vec<Value> {
+    vec![
+        // ====== CORE GATE TOOLS ======
+        tool_def(
+            "spf_gate",
+            "Run a tool call through SPF enforcement gate. Returns allow/block decision with complexity analysis.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name (Read, Write, Edit, Bash)"},
+                "params": {"type": "object", "description": "Tool parameters (file_path, content, command, etc.)"},
+                "approved": {"type": "boolean", "description": "User approval for CRITICAL tier (default: false)", "default": true}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_calculate",
+            "Calculate complexity score for a tool call without executing. Returns C value, tier, and allocation.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name"},
+                "params": {"type": "object", "description": "Tool parameters"}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_status",
+            "Get current SPF gateway status: session metrics, enforcement mode, complexity budget.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_session",
+            "Get full session state: files read/written, action history, anchor ratio, complexity history.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== GATED FILE OPERATIONS ======
+        tool_def(
+            "spf_read",
+            "Read a file through SPF gateway. Tracks read for Build Anchor Protocol.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "limit": {"type": "integer", "description": "Max lines to read (optional)"},
+                "offset": {"type": "integer", "description": "Line offset to start from (optional)"},
+                "approved": {"type": "boolean", "description": "User approval for gated read", "default": false}
+            }),
+            vec!["file_path"],
+        ),
+        tool_def(
+            "spf_write",
+            "Write a file through SPF gateway. Validates: Build Anchor, blocked paths, file size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "content": {"type": "string", "description": "File content to write"},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": true}
+            }),
+            vec!["file_path", "content"],
+        ),
+        tool_def(
+            "spf_edit",
+            "Edit a file through SPF gateway. Validates: Build Anchor, blocked paths, change size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "old_string": {"type": "string", "description": "Text to replace"},
+                "new_string": {"type": "string", "description": "Replacement text"},
+                "replace_all": {"type": "boolean", "description": "Replace all occurrences", "default": false},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": true}
+            }),
+            vec!["file_path", "old_string", "new_string"],
+        ),
+        tool_def(
+            "spf_bash",
+            "Execute a bash command through SPF gateway. Validates: dangerous commands, /tmp access, git force.",
+            json!({
+                "command": {"type": "string", "description": "Bash command to execute"},
+                "timeout": {"type": "integer", "description": "Timeout in seconds (default: 30)", "default": 30},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": false}
+            }),
+            vec!["command"],
+        ),
+
+        // ====== SEARCH/GLOB TOOLS ======
+        tool_def(
+            "spf_glob",
+            "Fast file pattern matching. Supports glob patterns like **/*.rs or src/**/*.ts.",
+            json!({
+                "pattern": {"type": "string", "description": "Glob pattern to match files"},
+                "path": {"type": "string", "description": "Directory to search in (default: current dir)"}
+            }),
+            vec!["pattern"],
+        ),
+        tool_def(
+            "spf_grep",
+            "Search file contents using regex. Built on ripgrep.",
+            json!({
+                "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                "path": {"type": "string", "description": "File or directory to search"},
+                "glob": {"type": "string", "description": "Glob filter (e.g. *.rs)"},
+                "case_insensitive": {"type": "boolean", "description": "Case insensitive search", "default": true},
+                "context_lines": {"type": "integer", "description": "Lines of context around matches", "default": 0}
+            }),
+            vec!["pattern"],
+        ),
+
+        // ====== WEB BROWSER TOOLS ======
+        tool_def(
+            "spf_web_search",
+            "Search the web for information. Uses Brave API if BRAVE_API_KEY set, otherwise DuckDuckGo.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "count": {"type": "integer", "description": "Max results (default: 10)", "default": 10}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_web_fetch",
+            "Fetch a URL and return clean readable text. HTML is converted to plain text, JSON is pretty-printed.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "prompt": {"type": "string", "description": "Prompt to run on fetched content"}
+            }),
+            vec!["url", "prompt"],
+        ),
+        tool_def(
+            "spf_web_download",
+            "Download a file from URL and save to disk.",
+            json!({
+                "url": {"type": "string", "description": "URL to download"},
+                "save_path": {"type": "string", "description": "Local path to save file"}
+            }),
+            vec!["url", "save_path"],
+        ),
+        tool_def(
+            "spf_web_api",
+            "Make an API request. Returns status, headers, and response body.",
+            json!({
+                "method": {"type": "string", "description": "HTTP method (GET, POST, PUT, DELETE, PATCH)"},
+                "url": {"type": "string", "description": "API endpoint URL"},
+                "headers": {"type": "string", "description": "JSON object of headers (optional)", "default": ""},
+                "body": {"type": "string", "description": "Request body JSON (optional)", "default": ""}
+            }),
+            vec!["method", "url"],
+        ),
+
+        // ====== NOTEBOOK TOOL ======
+        tool_def(
+            "spf_notebook_edit",
+            "Edit a Jupyter notebook cell.",
+            json!({
+                "notebook_path": {"type": "string", "description": "Absolute path to .ipynb file"},
+                "cell_number": {"type": "integer", "description": "Cell index (0-based)"},
+                "new_source": {"type": "string", "description": "New cell content"},
+                "cell_type": {"type": "string", "description": "Cell type: code or markdown"},
+                "edit_mode": {"type": "string", "description": "Mode: replace, insert, or delete", "default": "replace"}
+            }),
+            vec!["notebook_path", "new_source"],
+        ),
+
+        // ====== BRAIN PASSTHROUGH ======
+        tool_def(
+            "spf_brain_search",
+            "Search brain through SPF gateway. All brain access is logged and tracked.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection (default: default)", "default": "default"},
+                "limit": {"type": "integer", "description": "Max results (default: 5)", "default": 5}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_store",
+            "Store document in brain through SPF gateway.",
+            json!({
+                "text": {"type": "string", "description": "Text to store"},
+                "title": {"type": "string", "description": "Document title", "default": "untitled"},
+                "collection": {"type": "string", "description": "Collection", "default": "default"},
+                "tags": {"type": "string", "description": "Comma-separated tags", "default": ""}
+            }),
+            vec!["text"],
+        ),
+
+        // ====== ADDITIONAL BRAIN TOOLS ======
+        tool_def(
+            "spf_brain_context",
+            "Get relevant context for a query. Returns formatted context for prompt injection.",
+            json!({
+                "query": {"type": "string", "description": "Query to get context for"},
+                "max_tokens": {"type": "integer", "description": "Max tokens (default: 2000)", "default": 2000}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_index",
+            "Index a file or directory into the brain.",
+            json!({
+                "path": {"type": "string", "description": "File or directory to index"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_brain_list",
+            "List all indexed collections and document counts.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_status",
+            "Get brain system status.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_recall",
+            "Search and return full parent documents. Searches vectors then resolves to complete stored document.",
+            json!({
+                "query": {"type": "string", "description": "Natural language search query"},
+                "collection": {"type": "string", "description": "Collection to search (default: default)", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_list_docs",
+            "List all stored documents in a collection.",
+            json!({
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_get_doc",
+            "Retrieve a specific document by its ID.",
+            json!({
+                "doc_id": {"type": "string", "description": "Document ID to retrieve"},
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec!["doc_id"],
+        ),
+
+        // ====== RAG COLLECTOR TOOLS ======
+        tool_def(
+            "spf_rag_collect_web",
+            "Search web and collect documents. Optional topic filter.",
+            json!({
+                "topic": {"type": "string", "description": "Topic to search (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected docs", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_collect_file",
+            "Process a local file.",
+            json!({
+                "path": {"type": "string", "description": "File path"},
+                "category": {"type": "string", "description": "Category (default: auto)", "default": "auto"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_folder",
+            "Process all files in a folder.",
+            json!({
+                "path": {"type": "string", "description": "Folder path"},
+                "extensions": {"type": "array", "items": {"type": "string"}, "description": "File extensions to include"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_drop",
+            "Process files in DROP_HERE folder.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_index_gathered",
+            "Index all documents in GATHERED to brain.",
+            json!({
+                "category": {"type": "string", "description": "Category to index (optional)"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_dedupe",
+            "Deduplicate brain collection.",
+            json!({
+                "category": {"type": "string", "description": "Category to dedupe"}
+            }),
+            vec!["category"],
+        ),
+        tool_def(
+            "spf_rag_status",
+            "Get collector status and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_gathered",
+            "List documents in GATHERED folder.",
+            json!({
+                "category": {"type": "string", "description": "Filter by category"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_bandwidth_status",
+            "Get bandwidth usage stats and limits.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fetch_url",
+            "Fetch a single URL with bandwidth limiting.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "auto_index": {"type": "boolean", "description": "Auto-index after fetch", "default": true}
+            }),
+            vec!["url"],
+        ),
+        tool_def(
+            "spf_rag_collect_rss",
+            "Collect from RSS/Atom feeds.",
+            json!({
+                "feed_name": {"type": "string", "description": "Specific feed name (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_feeds",
+            "List configured RSS feeds.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_pending_searches",
+            "Get pending SearchSeeker vectors from brain (gaps needing fetch).",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fulfill_search",
+            "Mark a SearchSeeker as fulfilled after RAG fetch.",
+            json!({
+                "seeker_id": {"type": "string", "description": "SearchSeeker ID to fulfill"},
+                "collection": {"type": "string", "description": "Collection name", "default": "default"}
+            }),
+            vec!["seeker_id"],
+        ),
+        tool_def(
+            "spf_rag_smart_search",
+            "Run smart search with completeness check - triggers SearchSeeker if <80%.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection to search", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_rag_auto_fetch_gaps",
+            "Automatically fetch data for all pending SearchSeekers.",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"},
+                "max_fetches": {"type": "integer", "description": "Max URLs to fetch", "default": 5}
+            }),
+            vec![],
+        ),
+
+        // ====== SPF_CONFIG TOOLS ======
+        // NOTE: spf_config_get and spf_config_set removed from MCP - user-only via CLI
+        tool_def(
+            "spf_config_paths",
+            "List all path rules (allowed/blocked) from SPF_CONFIG LMDB.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_config_stats",
+            "Get SPF_CONFIG LMDB statistics.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== SPF_TOOLS TOOLS ======
+        tool_def(
+            "spf_tools_list",
+            "List all registered tools with permissions and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_stats",
+            "Get SPF_TOOLS LMDB statistics (tool count, history count, alias count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_get",
+            "Get info for a specific tool by name.",
+            json!({
+                "name": {"type": "string", "description": "Tool name to look up"}
+            }),
+            vec!["name"],
+        ),
+
+        // ====== SPF_SANDBOX TOOLS ======
+        tool_def(
+            "spf_sandbox_list",
+            "List all registered project sandboxes with trust levels.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_stats",
+            "Get SPF_SANDBOX LMDB statistics (project count, access log count, resource count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_get",
+            "Get sandbox info for a specific project by path.",
+            json!({
+                "path": {"type": "string", "description": "Project path to look up"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_sandbox_active",
+            "Get the currently active project sandbox.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== AGENT_STATE TOOLS ======
+        tool_def(
+            "spf_agent_stats",
+            "Get AGENT_STATE LMDB statistics (memory count, sessions, state keys, tags).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_memory_search",
+            "Search agent memories by content.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "limit": {"type": "integer", "description": "Max results (default: 10)"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_agent_memory_by_tag",
+            "Get agent memories by tag.",
+            json!({
+                "tag": {"type": "string", "description": "Tag to filter by"}
+            }),
+            vec!["tag"],
+        ),
+        tool_def(
+            "spf_agent_session_info",
+            "Get the most recent session info.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_context",
+            "Get context summary for session continuity.",
+            json!({}),
+            vec![],
+        ),
+    ]
+}
+
+/// Handle a tool call
+fn handle_tool_call(
+    name: &str,
+    args: &Value,
+    config: &SpfConfig,
+    session: &mut Session,
+    storage: &SpfStorage,
+    config_db: &Option<SpfConfigDb>,
+    tools_db: &Option<SpfToolsDb>,
+    sandbox_db: &Option<SpfSandboxDb>,
+    agent_db: &Option<AgentStateDb>,
+) -> Value {
+    match name {
+        // ====== spf_gate ======
+        "spf_gate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let decision = gate::process(tool, &params, config, session, approved);
+            session.record_complexity(tool, decision.complexity.c, &decision.complexity.tier);
+            session.record_manifest(
+                tool, decision.complexity.c,
+                if decision.allowed { "ALLOWED" } else { "BLOCKED" },
+                decision.errors.first().map(|s| s.as_str()),
+            );
+            let _ = storage.save_session(session);
+
+            json!({"type": "text", "text": serde_json::to_string_pretty(&decision).unwrap()})
+        }
+
+        // ====== spf_calculate ======
+        "spf_calculate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let result = calculate::calculate(tool, &params, config);
+            json!({"type": "text", "text": serde_json::to_string_pretty(&result).unwrap()})
+        }
+
+        // ====== spf_status ======
+        "spf_status" => {
+            let status = format!(
+                "SPF Gateway v{}\nMode: {:?}\nSession: {}\nTiers: SIMPLE(<500) LIGHT(<2000) MEDIUM(<10000) CRITICAL(>10000)\nFormula: a_optimal(C) = {} × (1 - 1/ln(C + e))",
+                SERVER_VERSION,
+                config.enforce_mode,
+                session.status_summary(),
+                config.formula.w_eff,
+            );
+            json!({"type": "text", "text": status})
+        }
+
+        // ====== spf_session ======
+        "spf_session" => {
+            json!({"type": "text", "text": serde_json::to_string_pretty(session).unwrap()})
+        }
+
+        // ====== spf_read ======
+        "spf_read" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Read", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Read", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute read
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    session.track_read(file_path);
+                    session.record_action("Read", "success", Some(file_path));
+                    let _ = storage.save_session(session);
+
+                    // Apply limit/offset if specified
+                    let offset = args.get("offset").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+                    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+
+                    let lines: Vec<&str> = content.lines().collect();
+                    let total = lines.len();
+                    let start = offset.min(total);
+                    let end = if limit > 0 { (start + limit).min(total) } else { total };
+
+                    let numbered: String = lines[start..end]
+                        .iter()
+                        .enumerate()
+                        .map(|(i, line)| format!("{:>6}\t{}", start + i + 1, line))
+                        .collect::<Vec<_>>()
+                        .join("\n");
+
+                    json!({"type": "text", "text": format!("File: {} ({} lines)\n{}", file_path, total, numbered)})
+                }
+                Err(e) => {
+                    session.record_action("Read", "failed", Some(file_path));
+                    session.record_failure("Read", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_write ======
+        "spf_write" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let content = args["content"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                content: Some(content.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Write", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Write", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute write
+            // Ensure parent directory exists
+            if let Some(parent) = std::path::Path::new(file_path).parent() {
+                let _ = std::fs::create_dir_all(parent);
+            }
+
+            match std::fs::write(file_path, content) {
+                Ok(()) => {
+                    session.track_write(file_path);
+                    session.record_action("Write", "success", Some(file_path));
+                    session.record_manifest("Write", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!(
+                        "Written: {} ({} bytes) | C={} {}",
+                        file_path, content.len(), decision.complexity.c, decision.complexity.tier
+                    )})
+                }
+                Err(e) => {
+                    session.record_action("Write", "failed", Some(file_path));
+                    session.record_failure("Write", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Write failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_edit ======
+        "spf_edit" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let old_string = args["old_string"].as_str().unwrap_or("");
+            let new_string = args["new_string"].as_str().unwrap_or("");
+            let replace_all = args["replace_all"].as_bool().unwrap_or(false);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                old_string: Some(old_string.to_string()),
+                new_string: Some(new_string.to_string()),
+                replace_all: Some(replace_all),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Edit", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Edit", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute edit
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    let new_content = if replace_all {
+                        content.replace(old_string, new_string)
+                    } else {
+                        content.replacen(old_string, new_string, 1)
+                    };
+
+                    if new_content == content {
+                        json!({"type": "text", "text": format!("Edit: old_string not found in {}", file_path)})
+                    } else {
+                        match std::fs::write(file_path, &new_content) {
+                            Ok(()) => {
+                                session.track_write(file_path);
+                                session.record_action("Edit", "success", Some(file_path));
+                                session.record_manifest("Edit", decision.complexity.c, "ALLOWED", None);
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!(
+                                    "Edited: {} | C={} {}",
+                                    file_path, decision.complexity.c, decision.complexity.tier
+                                )})
+                            }
+                            Err(e) => {
+                                session.record_failure("Edit", &e.to_string());
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!("Edit write failed: {}", e)})
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Edit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Edit read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_bash ======
+        "spf_bash" => {
+            let command = args["command"].as_str().unwrap_or("");
+            let _timeout = args["timeout"].as_u64().unwrap_or(30);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                command: Some(command.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Bash", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Bash", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute bash
+            match Command::new("bash")
+                .arg("-c")
+                .arg(command)
+                .output()
+            {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                    let success = output.status.success();
+
+                    session.record_action("Bash", if success { "success" } else { "failed" }, None);
+                    if !success {
+                        session.record_failure("Bash", &stderr);
+                    }
+                    session.record_manifest("Bash", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+
+                    let mut result = String::new();
+                    if !stdout.is_empty() {
+                        result.push_str(&stdout);
+                    }
+                    if !stderr.is_empty() {
+                        result.push_str("\nSTDERR: ");
+                        result.push_str(&stderr);
+                    }
+                    if result.is_empty() {
+                        result = format!("Exit code: {}", output.status.code().unwrap_or(-1));
+                    }
+
+                    json!({"type": "text", "text": result})
+                }
+                Err(e) => {
+                    session.record_failure("Bash", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Bash failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_glob ======
+        "spf_glob" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            session.record_action("Glob", "called", None);
+
+            // Use find with glob pattern (simpler than pulling in glob crate)
+            let cmd = format!("find {} -name '{}' 2>/dev/null | head -100", path, pattern);
+            match Command::new("bash").arg("-c").arg(&cmd).output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    let _ = storage.save_session(session);
+                    if stdout.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": stdout})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Glob", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Glob failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_grep ======
+        "spf_grep" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            let glob_filter = args["glob"].as_str().unwrap_or("");
+            let case_insensitive = args["case_insensitive"].as_bool().unwrap_or(false);
+            let context = args["context_lines"].as_u64().unwrap_or(0);
+            session.record_action("Grep", "called", None);
+
+            let mut cmd = String::from("rg");
+            if case_insensitive {
+                cmd.push_str(" -i");
+            }
+            if context > 0 {
+                cmd.push_str(&format!(" -C {}", context));
+            }
+            if !glob_filter.is_empty() {
+                cmd.push_str(&format!(" --glob '{}'", glob_filter));
+            }
+            cmd.push_str(&format!(" '{}' {} 2>/dev/null | head -500", pattern, path));
+
+            match Command::new("bash").arg("-c").arg(&cmd).output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    let _ = storage.save_session(session);
+                    if stdout.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": stdout})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Grep", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Grep failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_fetch ======
+        "spf_web_fetch" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let prompt = args["prompt"].as_str().unwrap_or("Summarize this content");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(prompt.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_fetch", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_fetch", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebFetch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.read_page(url) {
+                        Ok((text, raw_len, content_type)) => {
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if text.len() > 50000 { &text[..50000] } else { &text };
+                            json!({"type": "text", "text": format!(
+                                "Fetched {} ({} bytes, {})\nPrompt: {}\n\n{}",
+                                url, raw_len, content_type, prompt, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebFetch", &e);
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebFetch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebFetch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_search ======
+        "spf_web_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let count = args["count"].as_u64().unwrap_or(10) as u32;
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                query: Some(query.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_search", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_search", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebSearch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.search(query, count) {
+                        Ok((engine, results)) => {
+                            let mut output = format!("Search '{}' via {} ({} results):\n\n", query, engine, results.len());
+                            for (i, r) in results.iter().enumerate() {
+                                output.push_str(&format!("{}. {}\n   {}\n   {}\n\n", i + 1, r.title, r.url, r.description));
+                            }
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": output})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebSearch", &e);
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebSearch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebSearch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_download ======
+        "spf_web_download" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let save_path = args["save_path"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                file_path: Some(save_path.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_download", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_download", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebDownload", "called", Some(save_path));
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.download(url, save_path) {
+                        Ok((size, content_type)) => {
+                            session.track_write(save_path);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!(
+                                "Downloaded {} → {} ({} bytes, {})",
+                                url, save_path, size, content_type
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebDownload", &e);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("Download failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebDownload", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_api ======
+        "spf_web_api" => {
+            let method = args["method"].as_str().unwrap_or("GET");
+            let url = args["url"].as_str().unwrap_or("");
+            let headers = args["headers"].as_str().unwrap_or("");
+            let body = args["body"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(method.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_api", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_api", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebAPI", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.api_request(method, url, headers, body) {
+                        Ok((status, resp_headers, resp_body)) => {
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if resp_body.len() > 50000 { &resp_body[..50000] } else { &resp_body };
+                            json!({"type": "text", "text": format!(
+                                "API {} {} → HTTP {}\n\nHeaders:\n{}\n\nBody:\n{}",
+                                method, url, status, resp_headers, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebAPI", &e);
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("API request failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebAPI", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_notebook_edit ======
+        "spf_notebook_edit" => {
+            let notebook_path = args["notebook_path"].as_str().unwrap_or("");
+            let new_source = args["new_source"].as_str().unwrap_or("");
+            let cell_number = args["cell_number"].as_u64().unwrap_or(0) as usize;
+            let cell_type = args["cell_type"].as_str().unwrap_or("code");
+            let edit_mode = args["edit_mode"].as_str().unwrap_or("replace");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                file_path: Some(notebook_path.to_string()),
+                content: Some(new_source.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("NotebookEdit", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("NotebookEdit", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("NotebookEdit", "called", Some(notebook_path));
+
+            // Read notebook JSON
+            match std::fs::read_to_string(notebook_path) {
+                Ok(content) => {
+                    match serde_json::from_str::<Value>(&content) {
+                        Ok(mut notebook) => {
+                            if let Some(cells) = notebook.get_mut("cells").and_then(|c| c.as_array_mut()) {
+                                match edit_mode {
+                                    "replace" => {
+                                        if cell_number < cells.len() {
+                                            cells[cell_number]["source"] = json!([new_source]);
+                                            cells[cell_number]["cell_type"] = json!(cell_type);
+                                        } else {
+                                            return json!({"type": "text", "text": format!("Cell {} not found", cell_number)});
+                                        }
+                                    }
+                                    "insert" => {
+                                        let new_cell = json!({
+                                            "cell_type": cell_type,
+                                            "source": [new_source],
+                                            "metadata": {},
+                                            "outputs": []
+                                        });
+                                        cells.insert(cell_number, new_cell);
+                                    }
+                                    "delete" => {
+                                        if cell_number < cells.len() {
+                                            cells.remove(cell_number);
+                                        }
+                                    }
+                                    _ => return json!({"type": "text", "text": "Invalid edit_mode"})
+                                }
+
+                                // Write back
+                                match std::fs::write(notebook_path, serde_json::to_string_pretty(&notebook).unwrap()) {
+                                    Ok(()) => {
+                                        session.track_write(notebook_path);
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Notebook edited: {} cell {} ({})", notebook_path, cell_number, edit_mode)})
+                                    }
+                                    Err(e) => {
+                                        session.record_failure("NotebookEdit", &e.to_string());
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Write failed: {}", e)})
+                                    }
+                                }
+                            } else {
+                                json!({"type": "text", "text": "Invalid notebook: no cells array"})
+                            }
+                        }
+                        Err(e) => json!({"type": "text", "text": format!("JSON parse error: {}", e)})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("NotebookEdit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_brain_search ======
+        "spf_brain_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let limit = args["limit"].as_u64().unwrap_or(5);
+
+            session.record_action("brain_search", "called", None);
+
+            let limit_str = limit.to_string();
+            let mut search_args = vec!["search", query, "--top-k", &limit_str];
+            if collection != "default" && !collection.is_empty() {
+                search_args.push("--collection");
+                search_args.push(collection);
+            }
+            let (success, output) = run_brain(&search_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Brain search '{}':\n\n{}", query, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_store ======
+        "spf_brain_store" => {
+            let text = args["text"].as_str().unwrap_or("");
+            let title = args["title"].as_str().unwrap_or("untitled");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let tags = args["tags"].as_str().unwrap_or("");
+
+            session.record_action("brain_store", "called", None);
+
+            let mut cmd_args = vec!["store", text, "--title", title, "--collection", collection, "--index"];
+            if !tags.is_empty() {
+                cmd_args.push("--tags");
+                cmd_args.push(tags);
+            }
+
+            let (success, output) = run_brain(&cmd_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Stored to brain:\n{}", output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain store failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_context ======
+        "spf_brain_context" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let max_tokens = args["max_tokens"].as_u64().unwrap_or(2000);
+            session.record_action("brain_context", "called", None);
+            let (success, output) = run_brain(&["context", query, "--max-tokens", &max_tokens.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain context failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_index ======
+        "spf_brain_index" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("brain_index", "called", Some(path));
+            let (success, output) = run_brain(&["index", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": format!("Indexed: {}\n{}", path, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain index failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list ======
+        "spf_brain_list" => {
+            session.record_action("brain_list", "called", None);
+            let (success, output) = run_brain(&["list"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_status ======
+        "spf_brain_status" => {
+            session.record_action("brain_status", "called", None);
+            let brain = brain_path();
+            let mut parts = vec![format!("Binary: {:?} ({})", brain, if brain.exists() { "OK" } else { "NOT FOUND" })];
+            let (success, output) = run_brain(&["list"]);
+            if success {
+                parts.push(format!("Collections:\n{}", output));
+            }
+            let storage_path = dirs_home().join("stoneshell-brain/storage");
+            if storage_path.exists() {
+                if let Ok(entries) = std::fs::read_dir(&storage_path) {
+                    let size: u64 = entries.filter_map(|e| e.ok()).filter_map(|e| e.metadata().ok()).map(|m| m.len()).sum();
+                    parts.push(format!("Storage: {:.2} MB", size as f64 / 1024.0 / 1024.0));
+                }
+            }
+            let _ = storage.save_session(session);
+            json!({"type": "text", "text": parts.join("\n\n")})
+        }
+
+        // ====== spf_brain_recall ======
+        "spf_brain_recall" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_recall", "called", None);
+            let (success, output) = run_brain(&["recall", query, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain recall failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list_docs ======
+        "spf_brain_list_docs" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_list_docs", "called", None);
+            let (success, output) = run_brain(&["list-docs", "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list-docs failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_get_doc ======
+        "spf_brain_get_doc" => {
+            let doc_id = args["doc_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_get_doc", "called", None);
+            let (success, output) = run_brain(&["get-doc", doc_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain get-doc failed: {}", output)})
+            }
+        }
+
+        // ====== RAG COLLECTOR HANDLERS ======
+
+        // ====== spf_rag_collect_web ======
+        "spf_rag_collect_web" => {
+            let topic = args["topic"].as_str().unwrap_or("");
+            session.record_action("rag_collect_web", "called", None);
+            let mut cmd_args = vec!["collect"];
+            if !topic.is_empty() {
+                cmd_args.push("--topic");
+                cmd_args.push(topic);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-web failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_file ======
+        "spf_rag_collect_file" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_file", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-file failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_folder ======
+        "spf_rag_collect_folder" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_folder", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-folder failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_drop ======
+        "spf_rag_collect_drop" => {
+            session.record_action("rag_collect_drop", "called", None);
+            let (success, output) = run_rag(&["drop"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-drop failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_index_gathered ======
+        "spf_rag_index_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_index_gathered", "called", None);
+            let mut cmd_args = vec!["index"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG index-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_dedupe ======
+        "spf_rag_dedupe" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_dedupe", "called", None);
+            // Dedupe goes through brain binary directly
+            let (success, output) = run_brain(&["dedup", "-c", category]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG dedupe failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_status ======
+        "spf_rag_status" => {
+            session.record_action("rag_status", "called", None);
+            let (success, output) = run_rag(&["status"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_gathered ======
+        "spf_rag_list_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_list_gathered", "called", None);
+            let mut cmd_args = vec!["list-gathered"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_bandwidth_status ======
+        "spf_rag_bandwidth_status" => {
+            session.record_action("rag_bandwidth_status", "called", None);
+            let (success, output) = run_rag(&["bandwidth"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG bandwidth-status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fetch_url ======
+        "spf_rag_fetch_url" => {
+            let url = args["url"].as_str().unwrap_or("");
+            session.record_action("rag_fetch_url", "called", None);
+            // Fetch URL through collect with path (URL handling)
+            let (success, output) = run_rag(&["collect", "--path", url]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fetch-url failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_rss ======
+        "spf_rag_collect_rss" => {
+            let feed_name = args["feed_name"].as_str().unwrap_or("");
+            session.record_action("rag_collect_rss", "called", None);
+            let mut cmd_args = vec!["rss"];
+            if !feed_name.is_empty() {
+                cmd_args.push("--feed");
+                cmd_args.push(feed_name);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-rss failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_feeds ======
+        "spf_rag_list_feeds" => {
+            session.record_action("rag_list_feeds", "called", None);
+            // Read RSS config directly
+            let rss_path = rag_collector_dir().join("sources/rss_sources.json");
+            let (success, output) = if rss_path.exists() {
+                match std::fs::read_to_string(&rss_path) {
+                    Ok(content) => (true, content),
+                    Err(e) => (false, format!("Failed to read RSS sources: {}", e)),
+                }
+            } else {
+                (false, "RSS sources file not found".to_string())
+            };
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-feeds failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_pending_searches ======
+        "spf_rag_pending_searches" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_pending_searches", "called", None);
+            let (success, output) = run_brain(&["pending-searches", "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG pending-searches failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fulfill_search ======
+        "spf_rag_fulfill_search" => {
+            let seeker_id = args["seeker_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_fulfill_search", "called", None);
+            let (success, output) = run_brain(&["fulfill-search", seeker_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fulfill-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_smart_search ======
+        "spf_rag_smart_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_smart_search", "called", None);
+            let (success, output) = run_brain(&["smart-search", query, "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG smart-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_auto_fetch_gaps ======
+        "spf_rag_auto_fetch_gaps" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let max_fetches = args["max_fetches"].as_u64().unwrap_or(5);
+            session.record_action("rag_auto_fetch_gaps", "called", None);
+            // Auto-fetch uses pending-searches then fetches URLs
+            let (success, output) = run_brain(&["auto-fetch", "-c", collection, "--max", &max_fetches.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG auto-fetch-gaps failed: {}", output)})
+            }
+        }
+
+        // ====== SPF_CONFIG HANDLERS ======
+        // NOTE: spf_config_get and spf_config_set blocked - user-only via CLI
+        "spf_config_get" | "spf_config_set" => {
+            json!({"type": "text", "text": "BLOCKED: Config read/write is user-only (use CLI)"})
+        }
+
+        "spf_config_paths" => {
+            session.record_action("config_paths", "list", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.list_path_rules() {
+                    Ok(rules) => {
+                        let text = rules.iter()
+                            .map(|(t, p)| format!("{}: {}", t, p))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No path rules configured".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_path_rules failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        "spf_config_stats" => {
+            session.record_action("config_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.stats() {
+                    Ok((config_count, paths_count, patterns_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_CONFIG LMDB Stats:\n  Config entries: {}\n  Path rules: {}\n  Dangerous patterns: {}",
+                            config_count, paths_count, patterns_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("config_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_TOOLS HANDLERS ======
+        "spf_tools_list" => {
+            session.record_action("tools_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.list_tools() {
+                    Ok(tools) => {
+                        let text = tools.iter()
+                            .map(|t| format!("{}: {:?} | calls={} allowed={} blocked={} avg_c={:.0}",
+                                t.name, t.permission, t.stats.call_count,
+                                t.stats.allowed_count, t.stats.blocked_count, t.stats.avg_complexity))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No tools registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_tools failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_stats" => {
+            session.record_action("tools_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.db_stats() {
+                    Ok((tools_count, history_count, aliases_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_TOOLS LMDB Stats:\n  Registered tools: {}\n  History entries: {}\n  Aliases: {}",
+                            tools_count, history_count, aliases_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("tools_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_get" => {
+            let name_arg = args["name"].as_str().unwrap_or("");
+            session.record_action("tools_get", "get", Some(name_arg));
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.get_tool(name_arg) {
+                    Ok(Some(tool)) => {
+                        json!({"type": "text", "text": format!(
+                            "Tool: {}\nPermission: {:?}\nMCP: {} (server: {})\nCalls: {} | Allowed: {} | Blocked: {}\nTotal C: {} | Avg C: {:.0}\nFirst used: {} | Last used: {}\nNotes: {}",
+                            tool.name, tool.permission, tool.is_mcp,
+                            tool.mcp_server.as_deref().unwrap_or("N/A"),
+                            tool.stats.call_count, tool.stats.allowed_count, tool.stats.blocked_count,
+                            tool.stats.total_complexity, tool.stats.avg_complexity,
+                            format_timestamp(tool.stats.first_used), format_timestamp(tool.stats.last_used),
+                            if tool.notes.is_empty() { "None" } else { &tool.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Tool not found: {}", name_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_tool failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_SANDBOX HANDLERS ======
+        "spf_sandbox_list" => {
+            session.record_action("sandbox_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.list_projects() {
+                    Ok(projects) => {
+                        let text = projects.iter()
+                            .map(|p| format!("{}: {} | trust={:?} | reads={} writes={} | active={}",
+                                p.name, p.path, p.trust_level,
+                                p.total_reads, p.total_writes, p.is_active))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No sandboxes registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_projects failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_stats" => {
+            session.record_action("sandbox_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.db_stats() {
+                    Ok((projects_count, access_count, resources_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_SANDBOX LMDB Stats:\n  Registered projects: {}\n  Access log entries: {}\n  Resource records: {}",
+                            projects_count, access_count, resources_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("sandbox_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_get" => {
+            let path_arg = args["path"].as_str().unwrap_or("");
+            session.record_action("sandbox_get", "get", Some(path_arg));
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_project(path_arg) {
+                    Ok(Some(proj)) => {
+                        json!({"type": "text", "text": format!(
+                            "Project: {}\nPath: {}\nTrust: {:?}\nActive: {}\nReads: {} | Writes: {} | Session writes: {}/{}\nMax write size: {} | Total C: {}\nProtected: {:?}\nCreated: {} | Last accessed: {}\nNotes: {}",
+                            proj.name, proj.path, proj.trust_level, proj.is_active,
+                            proj.total_reads, proj.total_writes, proj.session_writes, proj.max_writes_per_session,
+                            proj.max_write_size, proj.total_complexity,
+                            proj.protected_paths,
+                            format_timestamp(proj.created_at), format_timestamp(proj.last_accessed),
+                            if proj.notes.is_empty() { "None" } else { &proj.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Project not found: {}", path_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_project failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_active" => {
+            session.record_action("sandbox_active", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_active() {
+                    Ok(Some(path)) => {
+                        // Also fetch project details
+                        match db.get_project(&path) {
+                            Ok(Some(proj)) => {
+                                json!({"type": "text", "text": format!(
+                                    "Active project: {} ({})\nTrust: {:?} | Reads: {} | Writes: {}",
+                                    proj.name, proj.path, proj.trust_level, proj.total_reads, proj.total_writes
+                                )})
+                            }
+                            _ => json!({"type": "text", "text": format!("Active project path: {} (details unavailable)", path)}),
+                        }
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No active project"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_active failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        // ====== AGENT_STATE HANDLERS ======
+        // BLOCKED: Write operations are user-only
+        "spf_agent_remember" | "spf_agent_forget" | "spf_agent_set_state" => {
+            json!({"type": "text", "text": "BLOCKED: Agent state writes are user-only (use CLI)"})
+        }
+
+        "spf_agent_stats" => {
+            session.record_action("agent_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.db_stats() {
+                    Ok((memory_count, sessions_count, state_count, tags_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "AGENT_STATE LMDB Stats:\n  Memories: {}\n  Sessions: {}\n  State keys: {}\n  Tags: {}",
+                            memory_count, sessions_count, state_count, tags_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("agent_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let limit = args["limit"].as_u64().unwrap_or(10) as usize;
+            session.record_action("agent_memory_search", "search", Some(query));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.search_memories(query, limit) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories found for: {}", query)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}\n  Tags: {:?} | Created: {}",
+                                    m.id, m.memory_type, m.content,
+                                    m.tags, format_timestamp(m.created_at)))
+                                .collect::<Vec<_>>()
+                                .join("\n\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("search_memories failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_by_tag" => {
+            let tag = args["tag"].as_str().unwrap_or("");
+            session.record_action("agent_memory_by_tag", "search", Some(tag));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_by_tag(tag) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories with tag: {}", tag)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}",
+                                    m.id, m.memory_type, m.content))
+                                .collect::<Vec<_>>()
+                                .join("\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_by_tag failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_session_info" => {
+            session.record_action("agent_session_info", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_latest_session() {
+                    Ok(Some(sess)) => {
+                        json!({"type": "text", "text": format!(
+                            "Session: {}\nParent: {}\nStarted: {} | Ended: {}\nWorking dir: {}\nProject: {}\nFiles modified: {}\nComplexity: {} | Actions: {}\nSummary: {}",
+                            sess.session_id,
+                            sess.parent_session.as_deref().unwrap_or("None"),
+                            format_timestamp(sess.started_at),
+                            if sess.ended_at == 0 { "Ongoing".to_string() } else { format_timestamp(sess.ended_at) },
+                            sess.working_dir,
+                            sess.active_project.as_deref().unwrap_or("None"),
+                            sess.files_modified.len(),
+                            sess.total_complexity, sess.total_actions,
+                            if sess.summary.is_empty() { "None" } else { &sess.summary }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No sessions recorded"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_latest_session failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_context" => {
+            session.record_action("agent_context", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_context_summary() {
+                    Ok(summary) => {
+                        json!({"type": "text", "text": if summary.is_empty() { "No context available".to_string() } else { summary }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_context_summary failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        _ => {
+            json!({"type": "text", "text": format!("Unknown tool: {}", name)})
+        }
+    }
+}
+
+/// Main MCP server loop — runs forever on stdio
+pub fn run(config: SpfConfig, mut session: Session, storage: SpfStorage) {
+    log(&format!("Starting {} v{}", SERVER_NAME, SERVER_VERSION));
+    log(&format!("Mode: {:?}", config.enforce_mode));
+
+    // Initialize SPF_CONFIG LMDB
+    // Path is relative to HOME/SPFsmartGATE - same base as the binary location
+    let spf_base = dirs_home().join("SPFsmartGATE");
+    let config_db_path = spf_base.join("storage/spf_config");
+    log(&format!("SPF_CONFIG path: {:?}", config_db_path));
+
+    let config_db = match SpfConfigDb::open(&config_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_CONFIG init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_CONFIG LMDB initialized at {:?}", config_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_CONFIG LMDB at {:?}: {}", config_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_TOOLS LMDB
+    let tools_db_path = spf_base.join("storage/spf_tools");
+    log(&format!("SPF_TOOLS path: {:?}", tools_db_path));
+
+    let tools_db = match SpfToolsDb::open(&tools_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_TOOLS init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_TOOLS LMDB initialized at {:?}", tools_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_TOOLS LMDB at {:?}: {}", tools_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_SANDBOX LMDB
+    let sandbox_db_path = spf_base.join("storage/spf_sandbox");
+    log(&format!("SPF_SANDBOX path: {:?}", sandbox_db_path));
+
+    let sandbox_db = match SpfSandboxDb::open(&sandbox_db_path) {
+        Ok(db) => {
+            log(&format!("SPF_SANDBOX LMDB initialized at {:?}", sandbox_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_SANDBOX LMDB at {:?}: {}", sandbox_db_path, e));
+            None
+        }
+    };
+
+    // Initialize AGENT_STATE LMDB
+    let agent_db_path = spf_base.join("storage/agent_state");
+    log(&format!("AGENT_STATE path: {:?}", agent_db_path));
+
+    let agent_db = match AgentStateDb::open(&agent_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: AGENT_STATE init_defaults failed: {}", e));
+            }
+            log(&format!("AGENT_STATE LMDB initialized at {:?}", agent_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open AGENT_STATE LMDB at {:?}: {}", agent_db_path, e));
+            None
+        }
+    };
+
+    let stdin = io::stdin();
+    for line in stdin.lock().lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                log(&format!("stdin read error: {}", e));
+                continue;
+            }
+        };
+
+        let line = line.trim().to_string();
+        if line.is_empty() {
+            continue;
+        }
+
+        let msg: Value = match serde_json::from_str(&line) {
+            Ok(v) => v,
+            Err(e) => {
+                log(&format!("JSON parse error: {}", e));
+                continue;
+            }
+        };
+
+        let method = msg["method"].as_str().unwrap_or("");
+        let id = &msg["id"];
+        let params = &msg["params"];
+
+        log(&format!("Received: {}", method));
+
+        match method {
+            "initialize" => {
+                send_response(id, json!({
+                    "protocolVersion": PROTOCOL_VERSION,
+                    "capabilities": { "tools": {} },
+                    "serverInfo": {
+                        "name": SERVER_NAME,
+                        "version": SERVER_VERSION,
+                    }
+                }));
+            }
+
+            "notifications/initialized" => {
+                // No response needed
+            }
+
+            "tools/list" => {
+                send_response(id, json!({ "tools": tool_definitions() }));
+            }
+
+            "tools/call" => {
+                let name = params["name"].as_str().unwrap_or("");
+                let args = params.get("arguments").cloned().unwrap_or(json!({}));
+
+                let result = handle_tool_call(name, &args, &config, &mut session, &storage, &config_db, &tools_db, &sandbox_db, &agent_db);
+
+                send_response(id, json!({
+                    "content": [result]
+                }));
+            }
+
+            "ping" => {
+                send_response(id, json!({}));
+            }
+
+            _ => {
+                if !id.is_null() {
+                    send_error(id, -32601, &format!("Unknown method: {}", method));
+                }
+            }
+        }
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/9c462d52bfadf61c@v2

@@ -0,0 +1,2117 @@
+// SPF Smart Gateway - MCP Server (JSON-RPC 2.0 over stdio)
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// ALL tool calls route through this gateway.
+// Exposes: spf_gate, spf_read, spf_write, spf_edit, spf_bash, spf_status,
+//          spf_calculate, spf_session, spf_brain_search, spf_brain_store
+
+use crate::calculate::{self, ToolParams};
+use crate::config::SpfConfig;
+use crate::config_db::SpfConfigDb;
+use crate::tools_db::SpfToolsDb;
+use crate::sandbox_db::SpfSandboxDb;
+use crate::agent_state::AgentStateDb;
+use crate::gate;
+use crate::session::Session;
+use crate::storage::SpfStorage;
+use crate::web::WebClient;
+use serde_json::{json, Value};
+use std::io::{self, BufRead, Write};
+use std::process::Command;
+use std::path::PathBuf;
+use chrono::{DateTime, Utc};
+
+const PROTOCOL_VERSION: &str = "2024-11-05";
+
+/// Format Unix timestamp as human-readable ISO8601
+fn format_timestamp(ts: u64) -> String {
+    if ts == 0 {
+        return "Never".to_string();
+    }
+    DateTime::<Utc>::from_timestamp(ts as i64, 0)
+        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
+        .unwrap_or_else(|| ts.to_string())
+}
+const SERVER_NAME: &str = "spf-smart-gate";
+const SERVER_VERSION: &str = "2.0.0";
+
+/// Brain binary path
+fn brain_path() -> PathBuf {
+    dirs_home().join("stoneshell-brain/target/release/brain")
+}
+
+fn dirs_home() -> PathBuf {
+    PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/data/data/com.termux/files/home".to_string()))
+}
+
+/// Run brain CLI command
+fn run_brain(args: &[&str]) -> (bool, String) {
+    let brain = brain_path();
+    if !brain.exists() {
+        return (false, format!("Brain not found: {:?}", brain));
+    }
+    match Command::new(&brain)
+        .args(args)
+        .current_dir(brain.parent().unwrap().parent().unwrap())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                (false, String::from_utf8_lossy(&output.stderr).to_string())
+            }
+        }
+        Err(e) => (false, format!("Failed to run brain: {}", e)),
+    }
+}
+
+/// RAG Collector script path
+fn rag_collector_path() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR/server.py")
+}
+
+/// RAG Collector working directory
+fn rag_collector_dir() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR")
+}
+
+/// Run RAG Collector command
+fn run_rag(args: &[&str]) -> (bool, String) {
+    let rag = rag_collector_path();
+    if !rag.exists() {
+        return (false, format!("RAG Collector not found: {:?}", rag));
+    }
+    match Command::new("python3")
+        .arg("-u")
+        .arg(&rag)
+        .args(args)
+        .current_dir(rag_collector_dir())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                (false, format!("{}\n{}", stdout, stderr))
+            }
+        }
+        Err(e) => (false, format!("Failed to run RAG Collector: {}", e)),
+    }
+}
+
+/// Log to stderr (stdout is JSON-RPC)
+fn log(msg: &str) {
+    eprintln!("[spf-smart-gate] {}", msg);
+}
+
+/// Send JSON-RPC response
+fn send_response(id: &Value, result: Value) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "result": result,
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// Send JSON-RPC error response
+fn send_error(id: &Value, code: i64, message: &str) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "error": { "code": code, "message": message },
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// MCP tool definition helper
+fn tool_def(name: &str, description: &str, properties: Value, required: Vec<&str>) -> Value {
+    json!({
+        "name": name,
+        "description": description,
+        "inputSchema": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        }
+    })
+}
+
+/// Return all tool definitions
+fn tool_definitions() -> Vec<Value> {
+    vec![
+        // ====== CORE GATE TOOLS ======
+        tool_def(
+            "spf_gate",
+            "Run a tool call through SPF enforcement gate. Returns allow/block decision with complexity analysis.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name (Read, Write, Edit, Bash)"},
+                "params": {"type": "object", "description": "Tool parameters (file_path, content, command, etc.)"},
+                "approved": {"type": "boolean", "description": "User approval for CRITICAL tier (default: false)", "default": false}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_calculate",
+            "Calculate complexity score for a tool call without executing. Returns C value, tier, and allocation.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name"},
+                "params": {"type": "object", "description": "Tool parameters"}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_status",
+            "Get current SPF gateway status: session metrics, enforcement mode, complexity budget.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_session",
+            "Get full session state: files read/written, action history, anchor ratio, complexity history.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== GATED FILE OPERATIONS ======
+        tool_def(
+            "spf_read",
+            "Read a file through SPF gateway. Tracks read for Build Anchor Protocol.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "limit": {"type": "integer", "description": "Max lines to read (optional)"},
+                "offset": {"type": "integer", "description": "Line offset to start from (optional)"},
+                "approved": {"type": "boolean", "description": "User approval for gated read", "default": false}
+            }),
+            vec!["file_path"],
+        ),
+        tool_def(
+            "spf_write",
+            "Write a file through SPF gateway. Validates: Build Anchor, blocked paths, file size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "content": {"type": "string", "description": "File content to write"},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": false}
+            }),
+            vec!["file_path", "content"],
+        ),
+        tool_def(
+            "spf_edit",
+            "Edit a file through SPF gateway. Validates: Build Anchor, blocked paths, change size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "old_string": {"type": "string", "description": "Text to replace"},
+                "new_string": {"type": "string", "description": "Replacement text"},
+                "replace_all": {"type": "boolean", "description": "Replace all occurrences", "default": false},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": false}
+            }),
+            vec!["file_path", "old_string", "new_string"],
+        ),
+        tool_def(
+            "spf_bash",
+            "Execute a bash command through SPF gateway. Validates: dangerous commands, /tmp access, git force.",
+            json!({
+                "command": {"type": "string", "description": "Bash command to execute"},
+                "timeout": {"type": "integer", "description": "Timeout in seconds (default: 30)", "default": 30},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": false}
+            }),
+            vec!["command"],
+        ),
+
+        // ====== SEARCH/GLOB TOOLS ======
+        tool_def(
+            "spf_glob",
+            "Fast file pattern matching. Supports glob patterns like **/*.rs or src/**/*.ts.",
+            json!({
+                "pattern": {"type": "string", "description": "Glob pattern to match files"},
+                "path": {"type": "string", "description": "Directory to search in (default: current dir)"}
+            }),
+            vec!["pattern"],
+        ),
+        tool_def(
+            "spf_grep",
+            "Search file contents using regex. Built on ripgrep.",
+            json!({
+                "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                "path": {"type": "string", "description": "File or directory to search"},
+                "glob": {"type": "string", "description": "Glob filter (e.g. *.rs)"},
+                "case_insensitive": {"type": "boolean", "description": "Case insensitive search", "default": true},
+                "context_lines": {"type": "integer", "description": "Lines of context around matches", "default": 0}
+            }),
+            vec!["pattern"],
+        ),
+
+        // ====== WEB BROWSER TOOLS ======
+        tool_def(
+            "spf_web_search",
+            "Search the web for information. Uses Brave API if BRAVE_API_KEY set, otherwise DuckDuckGo.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "count": {"type": "integer", "description": "Max results (default: 10)", "default": 10}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_web_fetch",
+            "Fetch a URL and return clean readable text. HTML is converted to plain text, JSON is pretty-printed.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "prompt": {"type": "string", "description": "Prompt to run on fetched content"}
+            }),
+            vec!["url", "prompt"],
+        ),
+        tool_def(
+            "spf_web_download",
+            "Download a file from URL and save to disk.",
+            json!({
+                "url": {"type": "string", "description": "URL to download"},
+                "save_path": {"type": "string", "description": "Local path to save file"}
+            }),
+            vec!["url", "save_path"],
+        ),
+        tool_def(
+            "spf_web_api",
+            "Make an API request. Returns status, headers, and response body.",
+            json!({
+                "method": {"type": "string", "description": "HTTP method (GET, POST, PUT, DELETE, PATCH)"},
+                "url": {"type": "string", "description": "API endpoint URL"},
+                "headers": {"type": "string", "description": "JSON object of headers (optional)", "default": ""},
+                "body": {"type": "string", "description": "Request body JSON (optional)", "default": ""}
+            }),
+            vec!["method", "url"],
+        ),
+
+        // ====== NOTEBOOK TOOL ======
+        tool_def(
+            "spf_notebook_edit",
+            "Edit a Jupyter notebook cell.",
+            json!({
+                "notebook_path": {"type": "string", "description": "Absolute path to .ipynb file"},
+                "cell_number": {"type": "integer", "description": "Cell index (0-based)"},
+                "new_source": {"type": "string", "description": "New cell content"},
+                "cell_type": {"type": "string", "description": "Cell type: code or markdown"},
+                "edit_mode": {"type": "string", "description": "Mode: replace, insert, or delete", "default": "replace"}
+            }),
+            vec!["notebook_path", "new_source"],
+        ),
+
+        // ====== BRAIN PASSTHROUGH ======
+        tool_def(
+            "spf_brain_search",
+            "Search brain through SPF gateway. All brain access is logged and tracked.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection (default: default)", "default": "default"},
+                "limit": {"type": "integer", "description": "Max results (default: 5)", "default": 5}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_store",
+            "Store document in brain through SPF gateway.",
+            json!({
+                "text": {"type": "string", "description": "Text to store"},
+                "title": {"type": "string", "description": "Document title", "default": "untitled"},
+                "collection": {"type": "string", "description": "Collection", "default": "default"},
+                "tags": {"type": "string", "description": "Comma-separated tags", "default": ""}
+            }),
+            vec!["text"],
+        ),
+
+        // ====== ADDITIONAL BRAIN TOOLS ======
+        tool_def(
+            "spf_brain_context",
+            "Get relevant context for a query. Returns formatted context for prompt injection.",
+            json!({
+                "query": {"type": "string", "description": "Query to get context for"},
+                "max_tokens": {"type": "integer", "description": "Max tokens (default: 2000)", "default": 2000}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_index",
+            "Index a file or directory into the brain.",
+            json!({
+                "path": {"type": "string", "description": "File or directory to index"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_brain_list",
+            "List all indexed collections and document counts.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_status",
+            "Get brain system status.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_recall",
+            "Search and return full parent documents. Searches vectors then resolves to complete stored document.",
+            json!({
+                "query": {"type": "string", "description": "Natural language search query"},
+                "collection": {"type": "string", "description": "Collection to search (default: default)", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_list_docs",
+            "List all stored documents in a collection.",
+            json!({
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_get_doc",
+            "Retrieve a specific document by its ID.",
+            json!({
+                "doc_id": {"type": "string", "description": "Document ID to retrieve"},
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec!["doc_id"],
+        ),
+
+        // ====== RAG COLLECTOR TOOLS ======
+        tool_def(
+            "spf_rag_collect_web",
+            "Search web and collect documents. Optional topic filter.",
+            json!({
+                "topic": {"type": "string", "description": "Topic to search (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected docs", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_collect_file",
+            "Process a local file.",
+            json!({
+                "path": {"type": "string", "description": "File path"},
+                "category": {"type": "string", "description": "Category (default: auto)", "default": "auto"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_folder",
+            "Process all files in a folder.",
+            json!({
+                "path": {"type": "string", "description": "Folder path"},
+                "extensions": {"type": "array", "items": {"type": "string"}, "description": "File extensions to include"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_drop",
+            "Process files in DROP_HERE folder.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_index_gathered",
+            "Index all documents in GATHERED to brain.",
+            json!({
+                "category": {"type": "string", "description": "Category to index (optional)"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_dedupe",
+            "Deduplicate brain collection.",
+            json!({
+                "category": {"type": "string", "description": "Category to dedupe"}
+            }),
+            vec!["category"],
+        ),
+        tool_def(
+            "spf_rag_status",
+            "Get collector status and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_gathered",
+            "List documents in GATHERED folder.",
+            json!({
+                "category": {"type": "string", "description": "Filter by category"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_bandwidth_status",
+            "Get bandwidth usage stats and limits.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fetch_url",
+            "Fetch a single URL with bandwidth limiting.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "auto_index": {"type": "boolean", "description": "Auto-index after fetch", "default": true}
+            }),
+            vec!["url"],
+        ),
+        tool_def(
+            "spf_rag_collect_rss",
+            "Collect from RSS/Atom feeds.",
+            json!({
+                "feed_name": {"type": "string", "description": "Specific feed name (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_feeds",
+            "List configured RSS feeds.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_pending_searches",
+            "Get pending SearchSeeker vectors from brain (gaps needing fetch).",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fulfill_search",
+            "Mark a SearchSeeker as fulfilled after RAG fetch.",
+            json!({
+                "seeker_id": {"type": "string", "description": "SearchSeeker ID to fulfill"},
+                "collection": {"type": "string", "description": "Collection name", "default": "default"}
+            }),
+            vec!["seeker_id"],
+        ),
+        tool_def(
+            "spf_rag_smart_search",
+            "Run smart search with completeness check - triggers SearchSeeker if <80%.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection to search", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_rag_auto_fetch_gaps",
+            "Automatically fetch data for all pending SearchSeekers.",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"},
+                "max_fetches": {"type": "integer", "description": "Max URLs to fetch", "default": 5}
+            }),
+            vec![],
+        ),
+
+        // ====== SPF_CONFIG TOOLS ======
+        // NOTE: spf_config_get and spf_config_set removed from MCP - user-only via CLI
+        tool_def(
+            "spf_config_paths",
+            "List all path rules (allowed/blocked) from SPF_CONFIG LMDB.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_config_stats",
+            "Get SPF_CONFIG LMDB statistics.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== SPF_TOOLS TOOLS ======
+        tool_def(
+            "spf_tools_list",
+            "List all registered tools with permissions and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_stats",
+            "Get SPF_TOOLS LMDB statistics (tool count, history count, alias count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_get",
+            "Get info for a specific tool by name.",
+            json!({
+                "name": {"type": "string", "description": "Tool name to look up"}
+            }),
+            vec!["name"],
+        ),
+
+        // ====== SPF_SANDBOX TOOLS ======
+        tool_def(
+            "spf_sandbox_list",
+            "List all registered project sandboxes with trust levels.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_stats",
+            "Get SPF_SANDBOX LMDB statistics (project count, access log count, resource count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_get",
+            "Get sandbox info for a specific project by path.",
+            json!({
+                "path": {"type": "string", "description": "Project path to look up"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_sandbox_active",
+            "Get the currently active project sandbox.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== AGENT_STATE TOOLS ======
+        tool_def(
+            "spf_agent_stats",
+            "Get AGENT_STATE LMDB statistics (memory count, sessions, state keys, tags).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_memory_search",
+            "Search agent memories by content.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "limit": {"type": "integer", "description": "Max results (default: 10)"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_agent_memory_by_tag",
+            "Get agent memories by tag.",
+            json!({
+                "tag": {"type": "string", "description": "Tag to filter by"}
+            }),
+            vec!["tag"],
+        ),
+        tool_def(
+            "spf_agent_session_info",
+            "Get the most recent session info.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_context",
+            "Get context summary for session continuity.",
+            json!({}),
+            vec![],
+        ),
+    ]
+}
+
+/// Handle a tool call
+fn handle_tool_call(
+    name: &str,
+    args: &Value,
+    config: &SpfConfig,
+    session: &mut Session,
+    storage: &SpfStorage,
+    config_db: &Option<SpfConfigDb>,
+    tools_db: &Option<SpfToolsDb>,
+    sandbox_db: &Option<SpfSandboxDb>,
+    agent_db: &Option<AgentStateDb>,
+) -> Value {
+    match name {
+        // ====== spf_gate ======
+        "spf_gate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let decision = gate::process(tool, &params, config, session, approved);
+            session.record_complexity(tool, decision.complexity.c, &decision.complexity.tier);
+            session.record_manifest(
+                tool, decision.complexity.c,
+                if decision.allowed { "ALLOWED" } else { "BLOCKED" },
+                decision.errors.first().map(|s| s.as_str()),
+            );
+            let _ = storage.save_session(session);
+
+            json!({"type": "text", "text": serde_json::to_string_pretty(&decision).unwrap()})
+        }
+
+        // ====== spf_calculate ======
+        "spf_calculate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let result = calculate::calculate(tool, &params, config);
+            json!({"type": "text", "text": serde_json::to_string_pretty(&result).unwrap()})
+        }
+
+        // ====== spf_status ======
+        "spf_status" => {
+            let status = format!(
+                "SPF Gateway v{}\nMode: {:?}\nSession: {}\nTiers: SIMPLE(<500) LIGHT(<2000) MEDIUM(<10000) CRITICAL(>10000)\nFormula: a_optimal(C) = {} × (1 - 1/ln(C + e))",
+                SERVER_VERSION,
+                config.enforce_mode,
+                session.status_summary(),
+                config.formula.w_eff,
+            );
+            json!({"type": "text", "text": status})
+        }
+
+        // ====== spf_session ======
+        "spf_session" => {
+            json!({"type": "text", "text": serde_json::to_string_pretty(session).unwrap()})
+        }
+
+        // ====== spf_read ======
+        "spf_read" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Read", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Read", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute read
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    session.track_read(file_path);
+                    session.record_action("Read", "success", Some(file_path));
+                    let _ = storage.save_session(session);
+
+                    // Apply limit/offset if specified
+                    let offset = args.get("offset").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+                    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+
+                    let lines: Vec<&str> = content.lines().collect();
+                    let total = lines.len();
+                    let start = offset.min(total);
+                    let end = if limit > 0 { (start + limit).min(total) } else { total };
+
+                    let numbered: String = lines[start..end]
+                        .iter()
+                        .enumerate()
+                        .map(|(i, line)| format!("{:>6}\t{}", start + i + 1, line))
+                        .collect::<Vec<_>>()
+                        .join("\n");
+
+                    json!({"type": "text", "text": format!("File: {} ({} lines)\n{}", file_path, total, numbered)})
+                }
+                Err(e) => {
+                    session.record_action("Read", "failed", Some(file_path));
+                    session.record_failure("Read", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_write ======
+        "spf_write" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let content = args["content"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                content: Some(content.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Write", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Write", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute write
+            // Ensure parent directory exists
+            if let Some(parent) = std::path::Path::new(file_path).parent() {
+                let _ = std::fs::create_dir_all(parent);
+            }
+
+            match std::fs::write(file_path, content) {
+                Ok(()) => {
+                    session.track_write(file_path);
+                    session.record_action("Write", "success", Some(file_path));
+                    session.record_manifest("Write", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!(
+                        "Written: {} ({} bytes) | C={} {}",
+                        file_path, content.len(), decision.complexity.c, decision.complexity.tier
+                    )})
+                }
+                Err(e) => {
+                    session.record_action("Write", "failed", Some(file_path));
+                    session.record_failure("Write", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Write failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_edit ======
+        "spf_edit" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let old_string = args["old_string"].as_str().unwrap_or("");
+            let new_string = args["new_string"].as_str().unwrap_or("");
+            let replace_all = args["replace_all"].as_bool().unwrap_or(false);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                old_string: Some(old_string.to_string()),
+                new_string: Some(new_string.to_string()),
+                replace_all: Some(replace_all),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Edit", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Edit", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute edit
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    let new_content = if replace_all {
+                        content.replace(old_string, new_string)
+                    } else {
+                        content.replacen(old_string, new_string, 1)
+                    };
+
+                    if new_content == content {
+                        json!({"type": "text", "text": format!("Edit: old_string not found in {}", file_path)})
+                    } else {
+                        match std::fs::write(file_path, &new_content) {
+                            Ok(()) => {
+                                session.track_write(file_path);
+                                session.record_action("Edit", "success", Some(file_path));
+                                session.record_manifest("Edit", decision.complexity.c, "ALLOWED", None);
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!(
+                                    "Edited: {} | C={} {}",
+                                    file_path, decision.complexity.c, decision.complexity.tier
+                                )})
+                            }
+                            Err(e) => {
+                                session.record_failure("Edit", &e.to_string());
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!("Edit write failed: {}", e)})
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Edit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Edit read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_bash ======
+        "spf_bash" => {
+            let command = args["command"].as_str().unwrap_or("");
+            let _timeout = args["timeout"].as_u64().unwrap_or(30);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                command: Some(command.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Bash", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Bash", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute bash
+            match Command::new("bash")
+                .arg("-c")
+                .arg(command)
+                .output()
+            {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                    let success = output.status.success();
+
+                    session.record_action("Bash", if success { "success" } else { "failed" }, None);
+                    if !success {
+                        session.record_failure("Bash", &stderr);
+                    }
+                    session.record_manifest("Bash", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+
+                    let mut result = String::new();
+                    if !stdout.is_empty() {
+                        result.push_str(&stdout);
+                    }
+                    if !stderr.is_empty() {
+                        result.push_str("\nSTDERR: ");
+                        result.push_str(&stderr);
+                    }
+                    if result.is_empty() {
+                        result = format!("Exit code: {}", output.status.code().unwrap_or(-1));
+                    }
+
+                    json!({"type": "text", "text": result})
+                }
+                Err(e) => {
+                    session.record_failure("Bash", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Bash failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_glob ======
+        "spf_glob" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            session.record_action("Glob", "called", None);
+
+            // Safe: arguments passed directly, no shell interpolation
+            match Command::new("find")
+                .arg(path)
+                .arg("-name")
+                .arg(pattern)
+                .stderr(std::process::Stdio::null())
+                .output()
+            {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout);
+                    // Limit to first 100 results (replaces piped head -100)
+                    let truncated: String = stdout.lines().take(100).collect::<Vec<_>>().join("\n");
+                    let _ = storage.save_session(session);
+                    if truncated.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": truncated})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Glob", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Glob failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_grep ======
+        "spf_grep" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            let glob_filter = args["glob"].as_str().unwrap_or("");
+            let case_insensitive = args["case_insensitive"].as_bool().unwrap_or(false);
+            let context = args["context_lines"].as_u64().unwrap_or(0);
+            session.record_action("Grep", "called", None);
+
+            // Safe: arguments passed directly, no shell interpolation
+            let mut rg = Command::new("rg");
+            if case_insensitive {
+                rg.arg("-i");
+            }
+            if context > 0 {
+                rg.arg("-C").arg(context.to_string());
+            }
+            if !glob_filter.is_empty() {
+                rg.arg("--glob").arg(glob_filter);
+            }
+            // "--" prevents pattern from being interpreted as a flag
+            rg.arg("--").arg(pattern).arg(path);
+            rg.stderr(std::process::Stdio::null());
+
+            match rg.output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout);
+                    // Limit to first 500 lines (replaces piped head -500)
+                    let truncated: String = stdout.lines().take(500).collect::<Vec<_>>().join("\n");
+                    let _ = storage.save_session(session);
+                    if truncated.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": truncated})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Grep", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Grep failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_fetch ======
+        "spf_web_fetch" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let prompt = args["prompt"].as_str().unwrap_or("Summarize this content");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(prompt.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_fetch", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_fetch", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebFetch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.read_page(url) {
+                        Ok((text, raw_len, content_type)) => {
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if text.len() > 50000 { &text[..50000] } else { &text };
+                            json!({"type": "text", "text": format!(
+                                "Fetched {} ({} bytes, {})\nPrompt: {}\n\n{}",
+                                url, raw_len, content_type, prompt, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebFetch", &e);
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebFetch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebFetch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_search ======
+        "spf_web_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let count = args["count"].as_u64().unwrap_or(10) as u32;
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                query: Some(query.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_search", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_search", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebSearch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.search(query, count) {
+                        Ok((engine, results)) => {
+                            let mut output = format!("Search '{}' via {} ({} results):\n\n", query, engine, results.len());
+                            for (i, r) in results.iter().enumerate() {
+                                output.push_str(&format!("{}. {}\n   {}\n   {}\n\n", i + 1, r.title, r.url, r.description));
+                            }
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": output})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebSearch", &e);
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebSearch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebSearch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_download ======
+        "spf_web_download" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let save_path = args["save_path"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                file_path: Some(save_path.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_download", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_download", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebDownload", "called", Some(save_path));
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.download(url, save_path) {
+                        Ok((size, content_type)) => {
+                            session.track_write(save_path);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!(
+                                "Downloaded {} → {} ({} bytes, {})",
+                                url, save_path, size, content_type
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebDownload", &e);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("Download failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebDownload", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_api ======
+        "spf_web_api" => {
+            let method = args["method"].as_str().unwrap_or("GET");
+            let url = args["url"].as_str().unwrap_or("");
+            let headers = args["headers"].as_str().unwrap_or("");
+            let body = args["body"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(method.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_api", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_api", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebAPI", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.api_request(method, url, headers, body) {
+                        Ok((status, resp_headers, resp_body)) => {
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if resp_body.len() > 50000 { &resp_body[..50000] } else { &resp_body };
+                            json!({"type": "text", "text": format!(
+                                "API {} {} → HTTP {}\n\nHeaders:\n{}\n\nBody:\n{}",
+                                method, url, status, resp_headers, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebAPI", &e);
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("API request failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebAPI", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_notebook_edit ======
+        "spf_notebook_edit" => {
+            let notebook_path = args["notebook_path"].as_str().unwrap_or("");
+            let new_source = args["new_source"].as_str().unwrap_or("");
+            let cell_number = args["cell_number"].as_u64().unwrap_or(0) as usize;
+            let cell_type = args["cell_type"].as_str().unwrap_or("code");
+            let edit_mode = args["edit_mode"].as_str().unwrap_or("replace");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                file_path: Some(notebook_path.to_string()),
+                content: Some(new_source.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("NotebookEdit", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("NotebookEdit", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("NotebookEdit", "called", Some(notebook_path));
+
+            // Read notebook JSON
+            match std::fs::read_to_string(notebook_path) {
+                Ok(content) => {
+                    match serde_json::from_str::<Value>(&content) {
+                        Ok(mut notebook) => {
+                            if let Some(cells) = notebook.get_mut("cells").and_then(|c| c.as_array_mut()) {
+                                match edit_mode {
+                                    "replace" => {
+                                        if cell_number < cells.len() {
+                                            cells[cell_number]["source"] = json!([new_source]);
+                                            cells[cell_number]["cell_type"] = json!(cell_type);
+                                        } else {
+                                            return json!({"type": "text", "text": format!("Cell {} not found", cell_number)});
+                                        }
+                                    }
+                                    "insert" => {
+                                        let new_cell = json!({
+                                            "cell_type": cell_type,
+                                            "source": [new_source],
+                                            "metadata": {},
+                                            "outputs": []
+                                        });
+                                        cells.insert(cell_number, new_cell);
+                                    }
+                                    "delete" => {
+                                        if cell_number < cells.len() {
+                                            cells.remove(cell_number);
+                                        }
+                                    }
+                                    _ => return json!({"type": "text", "text": "Invalid edit_mode"})
+                                }
+
+                                // Write back
+                                match std::fs::write(notebook_path, serde_json::to_string_pretty(&notebook).unwrap()) {
+                                    Ok(()) => {
+                                        session.track_write(notebook_path);
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Notebook edited: {} cell {} ({})", notebook_path, cell_number, edit_mode)})
+                                    }
+                                    Err(e) => {
+                                        session.record_failure("NotebookEdit", &e.to_string());
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Write failed: {}", e)})
+                                    }
+                                }
+                            } else {
+                                json!({"type": "text", "text": "Invalid notebook: no cells array"})
+                            }
+                        }
+                        Err(e) => json!({"type": "text", "text": format!("JSON parse error: {}", e)})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("NotebookEdit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_brain_search ======
+        "spf_brain_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let limit = args["limit"].as_u64().unwrap_or(5);
+
+            session.record_action("brain_search", "called", None);
+
+            let limit_str = limit.to_string();
+            let mut search_args = vec!["search", query, "--top-k", &limit_str];
+            if collection != "default" && !collection.is_empty() {
+                search_args.push("--collection");
+                search_args.push(collection);
+            }
+            let (success, output) = run_brain(&search_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Brain search '{}':\n\n{}", query, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_store ======
+        "spf_brain_store" => {
+            let text = args["text"].as_str().unwrap_or("");
+            let title = args["title"].as_str().unwrap_or("untitled");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let tags = args["tags"].as_str().unwrap_or("");
+
+            session.record_action("brain_store", "called", None);
+
+            let mut cmd_args = vec!["store", text, "--title", title, "--collection", collection, "--index"];
+            if !tags.is_empty() {
+                cmd_args.push("--tags");
+                cmd_args.push(tags);
+            }
+
+            let (success, output) = run_brain(&cmd_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Stored to brain:\n{}", output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain store failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_context ======
+        "spf_brain_context" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let max_tokens = args["max_tokens"].as_u64().unwrap_or(2000);
+            session.record_action("brain_context", "called", None);
+            let (success, output) = run_brain(&["context", query, "--max-tokens", &max_tokens.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain context failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_index ======
+        "spf_brain_index" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("brain_index", "called", Some(path));
+            let (success, output) = run_brain(&["index", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": format!("Indexed: {}\n{}", path, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain index failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list ======
+        "spf_brain_list" => {
+            session.record_action("brain_list", "called", None);
+            let (success, output) = run_brain(&["list"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_status ======
+        "spf_brain_status" => {
+            session.record_action("brain_status", "called", None);
+            let brain = brain_path();
+            let mut parts = vec![format!("Binary: {:?} ({})", brain, if brain.exists() { "OK" } else { "NOT FOUND" })];
+            let (success, output) = run_brain(&["list"]);
+            if success {
+                parts.push(format!("Collections:\n{}", output));
+            }
+            let storage_path = dirs_home().join("stoneshell-brain/storage");
+            if storage_path.exists() {
+                if let Ok(entries) = std::fs::read_dir(&storage_path) {
+                    let size: u64 = entries.filter_map(|e| e.ok()).filter_map(|e| e.metadata().ok()).map(|m| m.len()).sum();
+                    parts.push(format!("Storage: {:.2} MB", size as f64 / 1024.0 / 1024.0));
+                }
+            }
+            let _ = storage.save_session(session);
+            json!({"type": "text", "text": parts.join("\n\n")})
+        }
+
+        // ====== spf_brain_recall ======
+        "spf_brain_recall" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_recall", "called", None);
+            let (success, output) = run_brain(&["recall", query, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain recall failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list_docs ======
+        "spf_brain_list_docs" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_list_docs", "called", None);
+            let (success, output) = run_brain(&["list-docs", "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list-docs failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_get_doc ======
+        "spf_brain_get_doc" => {
+            let doc_id = args["doc_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_get_doc", "called", None);
+            let (success, output) = run_brain(&["get-doc", doc_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain get-doc failed: {}", output)})
+            }
+        }
+
+        // ====== RAG COLLECTOR HANDLERS ======
+
+        // ====== spf_rag_collect_web ======
+        "spf_rag_collect_web" => {
+            let topic = args["topic"].as_str().unwrap_or("");
+            session.record_action("rag_collect_web", "called", None);
+            let mut cmd_args = vec!["collect"];
+            if !topic.is_empty() {
+                cmd_args.push("--topic");
+                cmd_args.push(topic);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-web failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_file ======
+        "spf_rag_collect_file" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_file", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-file failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_folder ======
+        "spf_rag_collect_folder" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_folder", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-folder failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_drop ======
+        "spf_rag_collect_drop" => {
+            session.record_action("rag_collect_drop", "called", None);
+            let (success, output) = run_rag(&["drop"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-drop failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_index_gathered ======
+        "spf_rag_index_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_index_gathered", "called", None);
+            let mut cmd_args = vec!["index"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG index-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_dedupe ======
+        "spf_rag_dedupe" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_dedupe", "called", None);
+            // Dedupe goes through brain binary directly
+            let (success, output) = run_brain(&["dedup", "-c", category]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG dedupe failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_status ======
+        "spf_rag_status" => {
+            session.record_action("rag_status", "called", None);
+            let (success, output) = run_rag(&["status"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_gathered ======
+        "spf_rag_list_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_list_gathered", "called", None);
+            let mut cmd_args = vec!["list-gathered"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_bandwidth_status ======
+        "spf_rag_bandwidth_status" => {
+            session.record_action("rag_bandwidth_status", "called", None);
+            let (success, output) = run_rag(&["bandwidth"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG bandwidth-status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fetch_url ======
+        "spf_rag_fetch_url" => {
+            let url = args["url"].as_str().unwrap_or("");
+            session.record_action("rag_fetch_url", "called", None);
+            // Fetch URL through collect with path (URL handling)
+            let (success, output) = run_rag(&["collect", "--path", url]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fetch-url failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_rss ======
+        "spf_rag_collect_rss" => {
+            let feed_name = args["feed_name"].as_str().unwrap_or("");
+            session.record_action("rag_collect_rss", "called", None);
+            let mut cmd_args = vec!["rss"];
+            if !feed_name.is_empty() {
+                cmd_args.push("--feed");
+                cmd_args.push(feed_name);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-rss failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_feeds ======
+        "spf_rag_list_feeds" => {
+            session.record_action("rag_list_feeds", "called", None);
+            // Read RSS config directly
+            let rss_path = rag_collector_dir().join("sources/rss_sources.json");
+            let (success, output) = if rss_path.exists() {
+                match std::fs::read_to_string(&rss_path) {
+                    Ok(content) => (true, content),
+                    Err(e) => (false, format!("Failed to read RSS sources: {}", e)),
+                }
+            } else {
+                (false, "RSS sources file not found".to_string())
+            };
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-feeds failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_pending_searches ======
+        "spf_rag_pending_searches" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_pending_searches", "called", None);
+            let (success, output) = run_brain(&["pending-searches", "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG pending-searches failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fulfill_search ======
+        "spf_rag_fulfill_search" => {
+            let seeker_id = args["seeker_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_fulfill_search", "called", None);
+            let (success, output) = run_brain(&["fulfill-search", seeker_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fulfill-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_smart_search ======
+        "spf_rag_smart_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_smart_search", "called", None);
+            let (success, output) = run_brain(&["smart-search", query, "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG smart-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_auto_fetch_gaps ======
+        "spf_rag_auto_fetch_gaps" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let max_fetches = args["max_fetches"].as_u64().unwrap_or(5);
+            session.record_action("rag_auto_fetch_gaps", "called", None);
+            // Auto-fetch uses pending-searches then fetches URLs
+            let (success, output) = run_brain(&["auto-fetch", "-c", collection, "--max", &max_fetches.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG auto-fetch-gaps failed: {}", output)})
+            }
+        }
+
+        // ====== SPF_CONFIG HANDLERS ======
+        // NOTE: spf_config_get and spf_config_set blocked - user-only via CLI
+        "spf_config_get" | "spf_config_set" => {
+            json!({"type": "text", "text": "BLOCKED: Config read/write is user-only (use CLI)"})
+        }
+
+        "spf_config_paths" => {
+            session.record_action("config_paths", "list", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.list_path_rules() {
+                    Ok(rules) => {
+                        let text = rules.iter()
+                            .map(|(t, p)| format!("{}: {}", t, p))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No path rules configured".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_path_rules failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        "spf_config_stats" => {
+            session.record_action("config_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.stats() {
+                    Ok((config_count, paths_count, patterns_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_CONFIG LMDB Stats:\n  Config entries: {}\n  Path rules: {}\n  Dangerous patterns: {}",
+                            config_count, paths_count, patterns_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("config_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_TOOLS HANDLERS ======
+        "spf_tools_list" => {
+            session.record_action("tools_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.list_tools() {
+                    Ok(tools) => {
+                        let text = tools.iter()
+                            .map(|t| format!("{}: {:?} | calls={} allowed={} blocked={} avg_c={:.0}",
+                                t.name, t.permission, t.stats.call_count,
+                                t.stats.allowed_count, t.stats.blocked_count, t.stats.avg_complexity))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No tools registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_tools failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_stats" => {
+            session.record_action("tools_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.db_stats() {
+                    Ok((tools_count, history_count, aliases_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_TOOLS LMDB Stats:\n  Registered tools: {}\n  History entries: {}\n  Aliases: {}",
+                            tools_count, history_count, aliases_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("tools_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_get" => {
+            let name_arg = args["name"].as_str().unwrap_or("");
+            session.record_action("tools_get", "get", Some(name_arg));
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.get_tool(name_arg) {
+                    Ok(Some(tool)) => {
+                        json!({"type": "text", "text": format!(
+                            "Tool: {}\nPermission: {:?}\nMCP: {} (server: {})\nCalls: {} | Allowed: {} | Blocked: {}\nTotal C: {} | Avg C: {:.0}\nFirst used: {} | Last used: {}\nNotes: {}",
+                            tool.name, tool.permission, tool.is_mcp,
+                            tool.mcp_server.as_deref().unwrap_or("N/A"),
+                            tool.stats.call_count, tool.stats.allowed_count, tool.stats.blocked_count,
+                            tool.stats.total_complexity, tool.stats.avg_complexity,
+                            format_timestamp(tool.stats.first_used), format_timestamp(tool.stats.last_used),
+                            if tool.notes.is_empty() { "None" } else { &tool.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Tool not found: {}", name_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_tool failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_SANDBOX HANDLERS ======
+        "spf_sandbox_list" => {
+            session.record_action("sandbox_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.list_projects() {
+                    Ok(projects) => {
+                        let text = projects.iter()
+                            .map(|p| format!("{}: {} | trust={:?} | reads={} writes={} | active={}",
+                                p.name, p.path, p.trust_level,
+                                p.total_reads, p.total_writes, p.is_active))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No sandboxes registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_projects failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_stats" => {
+            session.record_action("sandbox_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.db_stats() {
+                    Ok((projects_count, access_count, resources_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_SANDBOX LMDB Stats:\n  Registered projects: {}\n  Access log entries: {}\n  Resource records: {}",
+                            projects_count, access_count, resources_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("sandbox_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_get" => {
+            let path_arg = args["path"].as_str().unwrap_or("");
+            session.record_action("sandbox_get", "get", Some(path_arg));
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_project(path_arg) {
+                    Ok(Some(proj)) => {
+                        json!({"type": "text", "text": format!(
+                            "Project: {}\nPath: {}\nTrust: {:?}\nActive: {}\nReads: {} | Writes: {} | Session writes: {}/{}\nMax write size: {} | Total C: {}\nProtected: {:?}\nCreated: {} | Last accessed: {}\nNotes: {}",
+                            proj.name, proj.path, proj.trust_level, proj.is_active,
+                            proj.total_reads, proj.total_writes, proj.session_writes, proj.max_writes_per_session,
+                            proj.max_write_size, proj.total_complexity,
+                            proj.protected_paths,
+                            format_timestamp(proj.created_at), format_timestamp(proj.last_accessed),
+                            if proj.notes.is_empty() { "None" } else { &proj.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Project not found: {}", path_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_project failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_active" => {
+            session.record_action("sandbox_active", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_active() {
+                    Ok(Some(path)) => {
+                        // Also fetch project details
+                        match db.get_project(&path) {
+                            Ok(Some(proj)) => {
+                                json!({"type": "text", "text": format!(
+                                    "Active project: {} ({})\nTrust: {:?} | Reads: {} | Writes: {}",
+                                    proj.name, proj.path, proj.trust_level, proj.total_reads, proj.total_writes
+                                )})
+                            }
+                            _ => json!({"type": "text", "text": format!("Active project path: {} (details unavailable)", path)}),
+                        }
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No active project"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_active failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        // ====== AGENT_STATE HANDLERS ======
+        // BLOCKED: Write operations are user-only
+        "spf_agent_remember" | "spf_agent_forget" | "spf_agent_set_state" => {
+            json!({"type": "text", "text": "BLOCKED: Agent state writes are user-only (use CLI)"})
+        }
+
+        "spf_agent_stats" => {
+            session.record_action("agent_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.db_stats() {
+                    Ok((memory_count, sessions_count, state_count, tags_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "AGENT_STATE LMDB Stats:\n  Memories: {}\n  Sessions: {}\n  State keys: {}\n  Tags: {}",
+                            memory_count, sessions_count, state_count, tags_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("agent_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let limit = args["limit"].as_u64().unwrap_or(10) as usize;
+            session.record_action("agent_memory_search", "search", Some(query));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.search_memories(query, limit) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories found for: {}", query)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}\n  Tags: {:?} | Created: {}",
+                                    m.id, m.memory_type, m.content,
+                                    m.tags, format_timestamp(m.created_at)))
+                                .collect::<Vec<_>>()
+                                .join("\n\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("search_memories failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_by_tag" => {
+            let tag = args["tag"].as_str().unwrap_or("");
+            session.record_action("agent_memory_by_tag", "search", Some(tag));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_by_tag(tag) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories with tag: {}", tag)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}",
+                                    m.id, m.memory_type, m.content))
+                                .collect::<Vec<_>>()
+                                .join("\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_by_tag failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_session_info" => {
+            session.record_action("agent_session_info", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_latest_session() {
+                    Ok(Some(sess)) => {
+                        json!({"type": "text", "text": format!(
+                            "Session: {}\nParent: {}\nStarted: {} | Ended: {}\nWorking dir: {}\nProject: {}\nFiles modified: {}\nComplexity: {} | Actions: {}\nSummary: {}",
+                            sess.session_id,
+                            sess.parent_session.as_deref().unwrap_or("None"),
+                            format_timestamp(sess.started_at),
+                            if sess.ended_at == 0 { "Ongoing".to_string() } else { format_timestamp(sess.ended_at) },
+                            sess.working_dir,
+                            sess.active_project.as_deref().unwrap_or("None"),
+                            sess.files_modified.len(),
+                            sess.total_complexity, sess.total_actions,
+                            if sess.summary.is_empty() { "None" } else { &sess.summary }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No sessions recorded"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_latest_session failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_context" => {
+            session.record_action("agent_context", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_context_summary() {
+                    Ok(summary) => {
+                        json!({"type": "text", "text": if summary.is_empty() { "No context available".to_string() } else { summary }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_context_summary failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        _ => {
+            json!({"type": "text", "text": format!("Unknown tool: {}", name)})
+        }
+    }
+}
+
+/// Main MCP server loop — runs forever on stdio
+pub fn run(config: SpfConfig, mut session: Session, storage: SpfStorage) {
+    log(&format!("Starting {} v{}", SERVER_NAME, SERVER_VERSION));
+    log(&format!("Mode: {:?}", config.enforce_mode));
+
+    // Initialize SPF_CONFIG LMDB
+    // Path is relative to HOME/SPFsmartGATE - same base as the binary location
+    let spf_base = dirs_home().join("SPFsmartGATE");
+    let config_db_path = spf_base.join("storage/spf_config");
+    log(&format!("SPF_CONFIG path: {:?}", config_db_path));
+
+    let config_db = match SpfConfigDb::open(&config_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_CONFIG init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_CONFIG LMDB initialized at {:?}", config_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_CONFIG LMDB at {:?}: {}", config_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_TOOLS LMDB
+    let tools_db_path = spf_base.join("storage/spf_tools");
+    log(&format!("SPF_TOOLS path: {:?}", tools_db_path));
+
+    let tools_db = match SpfToolsDb::open(&tools_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_TOOLS init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_TOOLS LMDB initialized at {:?}", tools_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_TOOLS LMDB at {:?}: {}", tools_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_SANDBOX LMDB
+    let sandbox_db_path = spf_base.join("storage/spf_sandbox");
+    log(&format!("SPF_SANDBOX path: {:?}", sandbox_db_path));
+
+    let sandbox_db = match SpfSandboxDb::open(&sandbox_db_path) {
+        Ok(db) => {
+            log(&format!("SPF_SANDBOX LMDB initialized at {:?}", sandbox_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_SANDBOX LMDB at {:?}: {}", sandbox_db_path, e));
+            None
+        }
+    };
+
+    // Initialize AGENT_STATE LMDB
+    let agent_db_path = spf_base.join("storage/agent_state");
+    log(&format!("AGENT_STATE path: {:?}", agent_db_path));
+
+    let agent_db = match AgentStateDb::open(&agent_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: AGENT_STATE init_defaults failed: {}", e));
+            }
+            log(&format!("AGENT_STATE LMDB initialized at {:?}", agent_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open AGENT_STATE LMDB at {:?}: {}", agent_db_path, e));
+            None
+        }
+    };
+
+    let stdin = io::stdin();
+    for line in stdin.lock().lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                log(&format!("stdin read error: {}", e));
+                continue;
+            }
+        };
+
+        let line = line.trim().to_string();
+        if line.is_empty() {
+            continue;
+        }
+
+        let msg: Value = match serde_json::from_str(&line) {
+            Ok(v) => v,
+            Err(e) => {
+                log(&format!("JSON parse error: {}", e));
+                continue;
+            }
+        };
+
+        let method = msg["method"].as_str().unwrap_or("");
+        let id = &msg["id"];
+        let params = &msg["params"];
+
+        log(&format!("Received: {}", method));
+
+        match method {
+            "initialize" => {
+                send_response(id, json!({
+                    "protocolVersion": PROTOCOL_VERSION,
+                    "capabilities": { "tools": {} },
+                    "serverInfo": {
+                        "name": SERVER_NAME,
+                        "version": SERVER_VERSION,
+                    }
+                }));
+            }
+
+            "notifications/initialized" => {
+                // No response needed
+            }
+
+            "tools/list" => {
+                send_response(id, json!({ "tools": tool_definitions() }));
+            }
+
+            "tools/call" => {
+                let name = params["name"].as_str().unwrap_or("");
+                let args = params.get("arguments").cloned().unwrap_or(json!({}));
+
+                let result = handle_tool_call(name, &args, &config, &mut session, &storage, &config_db, &tools_db, &sandbox_db, &agent_db);
+
+                send_response(id, json!({
+                    "content": [result]
+                }));
+            }
+
+            "ping" => {
+                send_response(id, json!({}));
+            }
+
+            _ => {
+                if !id.is_null() {
+                    send_error(id, -32601, &format!("Unknown method: {}", method));
+                }
+            }
+        }
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/b33399737c174c57@v1

@@ -0,0 +1,196 @@
+// SPF Smart Gateway - Configuration
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// Loads SPF rules, tiers, formulas, blocked paths from config.json.
+
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+/// Master SPF configuration loaded from config.json
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SpfConfig {
+    pub version: String,
+    pub enforce_mode: EnforceMode,
+    pub allowed_paths: Vec<String>,
+    pub blocked_paths: Vec<String>,
+    pub require_read_before_edit: bool,
+    pub max_write_size: usize,
+    pub tiers: TierConfig,
+    pub formula: FormulaConfig,
+    pub complexity_weights: ComplexityWeights,
+    pub dangerous_commands: Vec<String>,
+    pub git_force_patterns: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum EnforceMode {
+    Soft,
+    Hard,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierConfig {
+    pub simple: TierThreshold,
+    pub light: TierThreshold,
+    pub medium: TierThreshold,
+    pub critical: TierThreshold,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierThreshold {
+    pub max_c: u64,
+    pub analyze_percent: u8,
+    pub build_percent: u8,
+    pub requires_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FormulaConfig {
+    /// W_eff: effective working memory in tokens
+    pub w_eff: f64,
+    /// Euler's number
+    pub e: f64,
+    /// C = (basic ^ basic_power) + (deps ^ deps_power) + (complex ^ complex_power) + (files * files_mult)
+    pub basic_power: u32,
+    pub deps_power: u32,
+    pub complex_power: u32,
+    pub files_multiplier: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComplexityWeights {
+    pub edit: ToolWeight,
+    pub write: ToolWeight,
+    pub bash_dangerous: ToolWeight,
+    pub bash_git: ToolWeight,
+    pub bash_piped: ToolWeight,
+    pub bash_simple: ToolWeight,
+    pub read: ToolWeight,
+    pub search: ToolWeight,
+    pub unknown: ToolWeight,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolWeight {
+    pub basic: u64,
+    pub dependencies: u64,
+    pub complex: u64,
+    pub files: u64,
+}
+
+impl Default for SpfConfig {
+    fn default() -> Self {
+        Self {
+            version: "1.0.0".to_string(),
+            enforce_mode: EnforceMode::Hard,
+            allowed_paths: vec![
+                "/storage/emulated/0/Download/api-workspace/".to_string(),
+                "/data/data/com.termux/files/home/".to_string(),
+            ],
+            blocked_paths: vec![
+                "/tmp".to_string(),
+                "/etc".to_string(),
+                "/usr".to_string(),
+                "/system".to_string(),
+                "/data/data/com.termux/files/usr".to_string(),
+            ],
+            require_read_before_edit: true,
+            max_write_size: 100_000,
+            tiers: TierConfig {
+                simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: true },
+                light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: true },
+                medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: true },
+                critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+            },
+            formula: FormulaConfig {
+                w_eff: 40000.0,
+                e: std::f64::consts::E,
+                basic_power: 1,      // ^1 per SPF protocol
+                deps_power: 7,       // ^7 per SPF protocol
+                complex_power: 10,   // ^10 per SPF protocol
+                files_multiplier: 10, // ×10 per SPF protocol
+            },
+            // Weights scaled for formula: C = basic^1 + deps^7 + complex^10 + files×10
+            // deps^7: 2→128, 3→2187, 4→16384, 5→78125
+            // complex^10: 1→1, 2→1024
+            complexity_weights: ComplexityWeights {
+                edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+                write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+                bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+                bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+                bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+                bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+                read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+                search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+                unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            },
+            dangerous_commands: vec![
+                "rm -rf /".to_string(),
+                "rm -rf ~".to_string(),
+                "dd if=".to_string(),
+                "> /dev/".to_string(),
+                "chmod 777".to_string(),
+                "curl | sh".to_string(),
+                "wget | sh".to_string(),
+                "curl|sh".to_string(),
+                "wget|sh".to_string(),
+            ],
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        }
+    }
+}
+
+impl SpfConfig {
+    /// Load config from JSON file, falling back to defaults
+    pub fn load(path: &Path) -> anyhow::Result<Self> {
+        if path.exists() {
+            let content = std::fs::read_to_string(path)?;
+            let config: Self = serde_json::from_str(&content)?;
+            Ok(config)
+        } else {
+            log::warn!("Config not found at {:?}, using defaults", path);
+            Ok(Self::default())
+        }
+    }
+
+    /// Save config to JSON file
+    pub fn save(&self, path: &Path) -> anyhow::Result<()> {
+        let content = serde_json::to_string_pretty(self)?;
+        std::fs::write(path, content)?;
+        Ok(())
+    }
+
+    /// Get tier for a given complexity value
+    /// HARDCODE: ALL tiers require approval. No exceptions. No bypass.
+    pub fn get_tier(&self, c: u64) -> (&str, u8, u8, bool) {
+        if c < self.tiers.simple.max_c {
+            ("SIMPLE", self.tiers.simple.analyze_percent, self.tiers.simple.build_percent, true)
+        } else if c < self.tiers.light.max_c {
+            ("LIGHT", self.tiers.light.analyze_percent, self.tiers.light.build_percent, true)
+        } else if c < self.tiers.medium.max_c {
+            ("MEDIUM", self.tiers.medium.analyze_percent, self.tiers.medium.build_percent, true)
+        } else {
+            ("CRITICAL", self.tiers.critical.analyze_percent, self.tiers.critical.build_percent, true)
+        }
+    }
+
+    /// Check if a path is blocked (with canonicalization to prevent traversal bypass)
+    pub fn is_path_blocked(&self, path: &str) -> bool {
+        // Canonicalize to resolve ../ traversal attempts
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+        
+        self.blocked_paths.iter().any(|blocked| canonical.starts_with(blocked))
+    }
+
+    /// Check if a path is allowed
+    pub fn is_path_allowed(&self, path: &str) -> bool {
+        self.allowed_paths.iter().any(|allowed| path.starts_with(allowed))
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3a7ce58c-c7c0-4028-b5d8-7fa2b1952a44/b33399737c174c57@v2

@@ -0,0 +1,196 @@
+// SPF Smart Gateway - Configuration
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// Loads SPF rules, tiers, formulas, blocked paths from config.json.
+
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+/// Master SPF configuration loaded from config.json
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SpfConfig {
+    pub version: String,
+    pub enforce_mode: EnforceMode,
+    pub allowed_paths: Vec<String>,
+    pub blocked_paths: Vec<String>,
+    pub require_read_before_edit: bool,
+    pub max_write_size: usize,
+    pub tiers: TierConfig,
+    pub formula: FormulaConfig,
+    pub complexity_weights: ComplexityWeights,
+    pub dangerous_commands: Vec<String>,
+    pub git_force_patterns: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum EnforceMode {
+    Soft,
+    Hard,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierConfig {
+    pub simple: TierThreshold,
+    pub light: TierThreshold,
+    pub medium: TierThreshold,
+    pub critical: TierThreshold,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierThreshold {
+    pub max_c: u64,
+    pub analyze_percent: u8,
+    pub build_percent: u8,
+    pub requires_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FormulaConfig {
+    /// W_eff: effective working memory in tokens
+    pub w_eff: f64,
+    /// Euler's number
+    pub e: f64,
+    /// C = (basic ^ basic_power) + (deps ^ deps_power) + (complex ^ complex_power) + (files * files_mult)
+    pub basic_power: u32,
+    pub deps_power: u32,
+    pub complex_power: u32,
+    pub files_multiplier: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComplexityWeights {
+    pub edit: ToolWeight,
+    pub write: ToolWeight,
+    pub bash_dangerous: ToolWeight,
+    pub bash_git: ToolWeight,
+    pub bash_piped: ToolWeight,
+    pub bash_simple: ToolWeight,
+    pub read: ToolWeight,
+    pub search: ToolWeight,
+    pub unknown: ToolWeight,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolWeight {
+    pub basic: u64,
+    pub dependencies: u64,
+    pub complex: u64,
+    pub files: u64,
+}
+
+impl Default for SpfConfig {
+    fn default() -> Self {
+        Self {
+            version: "1.0.0".to_string(),
+            enforce_mode: EnforceMode::Hard,
+            allowed_paths: vec![
+                "/storage/emulated/0/Download/api-workspace/".to_string(),
+                "/data/data/com.termux/files/home/".to_string(),
+            ],
+            blocked_paths: vec![
+                "/tmp".to_string(),
+                "/etc".to_string(),
+                "/usr".to_string(),
+                "/system".to_string(),
+                "/data/data/com.termux/files/usr".to_string(),
+            ],
+            require_read_before_edit: true,
+            max_write_size: 100_000,
+            tiers: TierConfig {
+                simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: false },
+                light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: false },
+                medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: false },
+                critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+            },
+            formula: FormulaConfig {
+                w_eff: 40000.0,
+                e: std::f64::consts::E,
+                basic_power: 1,      // ^1 per SPF protocol
+                deps_power: 7,       // ^7 per SPF protocol
+                complex_power: 10,   // ^10 per SPF protocol
+                files_multiplier: 10, // ×10 per SPF protocol
+            },
+            // Weights scaled for formula: C = basic^1 + deps^7 + complex^10 + files×10
+            // deps^7: 2→128, 3→2187, 4→16384, 5→78125
+            // complex^10: 1→1, 2→1024
+            complexity_weights: ComplexityWeights {
+                edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+                write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+                bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+                bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+                bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+                bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+                read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+                search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+                unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            },
+            dangerous_commands: vec![
+                "rm -rf /".to_string(),
+                "rm -rf ~".to_string(),
+                "dd if=".to_string(),
+                "> /dev/".to_string(),
+                "chmod 777".to_string(),
+                "curl | sh".to_string(),
+                "wget | sh".to_string(),
+                "curl|sh".to_string(),
+                "wget|sh".to_string(),
+            ],
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        }
+    }
+}
+
+impl SpfConfig {
+    /// Load config from JSON file, falling back to defaults
+    pub fn load(path: &Path) -> anyhow::Result<Self> {
+        if path.exists() {
+            let content = std::fs::read_to_string(path)?;
+            let config: Self = serde_json::from_str(&content)?;
+            Ok(config)
+        } else {
+            log::warn!("Config not found at {:?}, using defaults", path);
+            Ok(Self::default())
+        }
+    }
+
+    /// Save config to JSON file
+    pub fn save(&self, path: &Path) -> anyhow::Result<()> {
+        let content = serde_json::to_string_pretty(self)?;
+        std::fs::write(path, content)?;
+        Ok(())
+    }
+
+    /// Get tier for a given complexity value
+    /// CRITICAL tier requires explicit user approval. Lower tiers protected by other layers.
+    pub fn get_tier(&self, c: u64) -> (&str, u8, u8, bool) {
+        if c < self.tiers.simple.max_c {
+            ("SIMPLE", self.tiers.simple.analyze_percent, self.tiers.simple.build_percent, self.tiers.simple.requires_approval)
+        } else if c < self.tiers.light.max_c {
+            ("LIGHT", self.tiers.light.analyze_percent, self.tiers.light.build_percent, self.tiers.light.requires_approval)
+        } else if c < self.tiers.medium.max_c {
+            ("MEDIUM", self.tiers.medium.analyze_percent, self.tiers.medium.build_percent, self.tiers.medium.requires_approval)
+        } else {
+            ("CRITICAL", self.tiers.critical.analyze_percent, self.tiers.critical.build_percent, self.tiers.critical.requires_approval)
+        }
+    }
+
+    /// Check if a path is blocked (with canonicalization to prevent traversal bypass)
+    pub fn is_path_blocked(&self, path: &str) -> bool {
+        // Canonicalize to resolve ../ traversal attempts
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+        
+        self.blocked_paths.iter().any(|blocked| canonical.starts_with(blocked))
+    }
+
+    /// Check if a path is allowed
+    pub fn is_path_allowed(&self, path: &str) -> bool {
+        self.allowed_paths.iter().any(|allowed| path.starts_with(allowed))
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/53a1fc82aaa6d2ce@v1

@@ -0,0 +1,84 @@
+# SPF Smart Gate v2.0 - Session Handoff
+**Date:** 2026-02-06
+**Status:** LMDB Config Integration Complete
+
+## What Was Done
+
+### Problem
+- `main.rs` loaded config from JSON file at `~/spf-gateway/config.json`
+- `mcp.rs` hardcoded LMDB paths at `~/SPFsmartGATE/storage/`
+- Two config systems running in parallel (JSON + LMDB)
+- Duplicate struct definitions in `config.rs` and `config_db.rs`
+
+### Solution Implemented
+1. **Removed duplicate structs** from `config_db.rs`
+2. **Added import** `use crate::config::{...}` for canonical types
+3. **Added `load_full_config()`** method to `SpfConfigDb`
+4. **Updated `main.rs`** to load config from LMDB, not JSON
+5. **Changed default path** to `~/SPFsmartGATE/storage/`
+6. **Updated version** to 2.0.0
+
+## Files Modified
+
+```
+src/config_db.rs  - Removed lines 29-85 (duplicates), added load_full_config()
+src/main.rs       - Removed JSON loading, uses SpfConfigDb.load_full_config()
+```
+
+## Current State
+
+```
+Binary: ~/SPFsmartGATE/target/release/spf-smart-gate
+Storage: ~/SPFsmartGATE/storage/
+  - spf_config/   (7 entries, 7 path rules, 9 patterns)
+  - spf_tools/
+  - spf_sandbox/
+  - agent_state/
+```
+
+## Verification Commands
+
+```bash
+cd ~/SPFsmartGATE
+./target/release/spf-smart-gate status
+./target/release/spf-smart-gate init-config
+```
+
+## Next Steps
+
+1. **Test MCP connection** - Restart Claude Code, check for spf_* tools
+2. **Add CLI subcommands** for LMDB browsing:
+   - `config list/get/set`
+   - `tools list/get`
+   - `sandbox list/create`
+   - `agent memories/remember/forget`
+3. **Verify mcp.rs** uses same config path as main.rs
+4. **Update ~/.claude.json** if needed with correct mcpServers path
+
+## Architecture Reference
+
+```
+LMDB 1: SPF_FS       - ~/SPFsmartGATE/storage/spf_fs/
+LMDB 2: SPF_CONFIG   - ~/SPFsmartGATE/storage/spf_config/
+LMDB 3: SPF_TOOLS    - ~/SPFsmartGATE/storage/spf_tools/
+LMDB 4: SPF_SANDBOX  - ~/SPFsmartGATE/storage/spf_sandbox/
+LMDB 5: AGENT_STATE  - ~/SPFsmartGATE/storage/agent_state/
+```
+
+## Config Loading Flow (NEW)
+
+```
+main.rs
+  └─> SpfConfigDb::open(storage/spf_config)
+       └─> load_full_config()
+            └─> init_defaults() if empty
+            └─> Assembles SpfConfig from LMDB
+  └─> mcp::run(config, session, storage)
+```
+
+## To Resume Work
+
+Read this file, then:
+1. Check `./target/release/spf-smart-gate status`
+2. Review `src/main.rs` and `src/config_db.rs`
+3. Continue with next steps above

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/6a29f78275fa3285@v3

@@ -0,0 +1,2483 @@
+# SPF Smart Gateway v2.0 - Complete Developer Bible
+
+**FORENSIC DOCUMENTATION & OPERATIONAL MANUAL**
+
+**Version:** 2.0.0
+**Copyright:** 2026 Joseph Stone - All Rights Reserved
+**Classification:** INTERNAL DEVELOPER REFERENCE
+**Total Lines of Code:** 8,870 (Rust)
+**Binary Size:** ~15MB (release)
+**Storage Footprint:** ~222MB (LMDB databases)
+
+---
+
+# TABLE OF CONTENTS
+
+1. [Project Overview](#1-project-overview)
+2. [Complete File Tree](#2-complete-file-tree)
+3. [Build System](#3-build-system)
+4. [Dependency Analysis](#4-dependency-analysis)
+5. [Module Architecture](#5-module-architecture)
+6. [Data Structures Reference](#6-data-structures-reference)
+7. [Function Reference](#7-function-reference)
+8. [Hooks System (Claude Code Integration)](#8-hooks-system-claude-code-integration)
+9. [LMDB Schema Documentation](#9-lmdb-schema-documentation)
+10. [MCP Protocol Implementation](#10-mcp-protocol-implementation)
+11. [SPF Formula Specification](#11-spf-formula-specification)
+12. [Gate Pipeline Internals](#12-gate-pipeline-internals)
+13. [Security Model](#13-security-model)
+14. [Configuration Reference](#14-configuration-reference)
+15. [Error Handling](#15-error-handling)
+16. [Insert Points Guide](#16-insert-points-guide)
+17. [Change Impact Analysis](#17-change-impact-analysis)
+18. [Operational Manual](#18-operational-manual)
+19. [Troubleshooting](#19-troubleshooting)
+
+---
+
+# 1. PROJECT OVERVIEW
+
+## 1.1 Purpose
+
+SPF Smart Gateway is a **compiled Rust enforcement layer** that sits between AI agents (Claude Code) and system resources. It implements:
+
+- **Complexity-based access control** using the SPF formula
+- **Build Anchor Protocol** requiring reads before writes
+- **Path enforcement** with allowed/blocked directories
+- **Dangerous command detection** with pattern matching
+- **Full audit logging** of all AI operations
+- **5 LMDB databases** for persistent state
+
+## 1.2 Design Philosophy
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     CORE PRINCIPLE                               │
+│                                                                  │
+│  "No AI hallucination gets past compiled Rust logic."           │
+│                                                                  │
+│  Behavioral constraints MUST be enforced in compiled code,      │
+│  NOT in prompt engineering. The AI cannot override Rust.        │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 1.3 Key Metrics
+
+| Metric | Value |
+|--------|-------|
+| Source Files | 19 Rust files (+2 EDITED versions) |
+| Total Lines | 8,870 |
+| Largest File | mcp.rs (2,103 lines) |
+| Dependencies | 27 crates |
+| LMDB Databases | 4 + root storage |
+| MCP Tools | 54 definitions (+5 blocked handlers) |
+| Complexity Tiers | 4 |
+| Hook Scripts | 18 |
+| Structs/Enums | 45 |
+
+---
+
+# 2. COMPLETE FILE TREE
+
+```
+SPFsmartGATE/
+├── Cargo.toml                    # Build manifest, all dependencies
+├── Cargo.lock                    # Locked dependency versions
+├── LICENSE                       # Commercial license
+├── README.md                     # Public overview
+├── HANDOFF.md                    # Session continuity notes
+├── config.json                   # JSON config backup (16KB)
+├── .claude.json                  # Claude-specific config
+│
+├── docs/
+│   ├── DEVELOPER_BIBLE.md        # THIS FILE
+│   ├── ARCHITECTURE.md           # High-level architecture
+│   └── FORENSIC_AUDIT_REPORT.md  # Audit report
+│
+├── src/                          # 8,870 lines total
+│   ├── main.rs                   # 190 lines  - CLI entry point
+│   ├── lib.rs                    #  33 lines  - Library exports
+│   ├── config.rs                 # 196 lines  - Configuration types
+│   ├── config_db.rs              # 448 lines  - LMDB config operations
+│   ├── calculate.rs              # 311 lines  - SPF complexity formula
+│   ├── validate.rs               # 155 lines  - Rule validation
+│   ├── gate.rs                   # 130 lines  - Primary enforcement
+│   ├── gate-EDITED.rs            # 172 lines  - Edited gate version
+│   ├── inspect.rs                # 144 lines  - Content inspection
+│   ├── session.rs                # 156 lines  - Session state tracking
+│   ├── storage.rs                # 100 lines  - LMDB persistence layer
+│   ├── tools_db.rs               # 433 lines  - Tool registry LMDB
+│   ├── sandbox_db.rs             # 609 lines  - Project sandbox LMDB
+│   ├── agent_state.rs            # 683 lines  - Agent memory LMDB
+│   ├── claude_state.rs           # 670 lines  - Claude-specific state
+│   ├── fs.rs                     # 628 lines  - Virtual filesystem
+│   ├── web.rs                    # 289 lines  - HTTP client
+│   ├── mcp.rs                    # 2103 lines - MCP server (LARGEST)
+│   └── mcp-EDITED.rs             # 1420 lines - Edited MCP version
+│
+├── claude/                       # Claude working directory
+│   └── INSTRUCTIONS.md           # Claude tool instructions (4.5KB)
+│
+├── hooks/                        # Claude Code integration (18 files)
+│   ├── spf-gate.sh               # Main enforcement hook
+│   ├── pre-bash.sh               # Pre-bash gate
+│   ├── pre-edit.sh               # Pre-edit gate
+│   ├── pre-read.sh               # Pre-read gate
+│   ├── pre-write.sh              # Pre-write gate
+│   ├── pre-glob.sh               # Pre-glob gate
+│   ├── pre-grep.sh               # Pre-grep gate
+│   ├── pre-webfetch.sh           # Pre-webfetch gate
+│   ├── pre-websearch.sh          # Pre-websearch gate
+│   ├── pre-notebookedit.sh       # Pre-notebook gate
+│   ├── post-action.sh            # Post-execution logging
+│   ├── post-failure.sh           # Failure handler
+│   ├── session-start.sh          # Session initialization
+│   ├── session-end.sh            # Session cleanup
+│   ├── stop-check.sh             # Stop condition checks
+│   └── user-prompt.sh            # User prompt handler
+│
+├── agent-bin/                    # Binary copies
+│   ├── spf-smart-gate            # Gateway binary
+│   └── claude-code               # Claude Code binary
+│
+├── storage/                      # LMDB databases (222MB total)
+│   ├── data.mdb                  # Root session storage
+│   ├── lock.mdb                  # Root lock
+│   ├── spf_config/               # Configuration (60KB)
+│   │   ├── data.mdb
+│   │   └── lock.mdb
+│   ├── spf_tools/                # Tool registry (56KB)
+│   │   ├── data.mdb
+│   │   └── lock.mdb
+│   ├── spf_sandbox/              # Project sandboxes (20KB)
+│   │   ├── data.mdb
+│   │   └── lock.mdb
+│   ├── agent_state/              # Agent memory (60KB)
+│   │   ├── data.mdb
+│   │   └── lock.mdb
+│   ├── blobs/                    # Large file storage (221MB)
+│   │   └── claude-code/          # Vendor files (ripgrep, etc.)
+│   └── staging/                  # Staging area
+│       └── configs/
+│
+└── target/
+    └── release/
+        └── spf-smart-gate        # Binary (~15MB)
+```
+
+---
+
+# 3. BUILD SYSTEM
+
+## 3.1 Cargo.toml Analysis
+
+**Location:** `/SPFsmartGATE/Cargo.toml`
+
+```toml
+[package]
+name = "spf-smart-gate"
+version = "2.0.0"
+edition = "2021"
+authors = ["Joseph Stone"]
+description = "SPF Smart Gateway - AI governance framework"
+license = "Proprietary"
+
+[lib]
+name = "spf_smart_gate"
+path = "src/lib.rs"
+
+[[bin]]
+name = "spf-smart-gate"
+path = "src/main.rs"
+
+[dependencies]
+# Core
+anyhow = "1.0"           # Error handling
+thiserror = "1.0"        # Custom errors
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# CLI
+clap = { version = "4.4", features = ["derive"] }
+env_logger = "0.10"
+log = "0.4"
+
+# Database
+heed = "0.20"            # LMDB bindings
+
+# Crypto
+sha2 = "0.10"            # SHA256 hashing
+hex = "0.4"              # Hex encoding
+
+# Time
+chrono = { version = "0.4", features = ["serde"] }
+
+# Web
+reqwest = { version = "0.11", features = ["blocking", "json"] }
+html2text = "0.6"        # HTML to text
+
+# Glob
+glob = "0.3"
+
+[profile.release]
+opt-level = 3
+lto = true               # Link-time optimization
+strip = true             # Strip symbols
+codegen-units = 1        # Single codegen unit for better optimization
+```
+
+## 3.2 Build Commands
+
+```bash
+# Development build (fast, debug symbols)
+cargo build
+
+# Release build (optimized, ~15MB)
+cargo build --release
+
+# Check without building
+cargo check
+
+# Run tests
+cargo test
+
+# Build with all warnings
+RUSTFLAGS="-W warnings" cargo build --release
+```
+
+## 3.3 Build Output
+
+```
+target/release/spf-smart-gate    # Main binary
+target/release/libspf_smart_gate.rlib  # Library
+```
+
+## 3.4 Cross-Compilation
+
+```bash
+# For Android/Termux (aarch64)
+cargo build --release --target aarch64-linux-android
+
+# For Linux x86_64
+cargo build --release --target x86_64-unknown-linux-gnu
+```
+
+---
+
+# 4. DEPENDENCY ANALYSIS
+
+## 4.1 Crate Dependency Graph
+
+```
+spf-smart-gate
+├── anyhow (error handling)
+├── thiserror (custom errors)
+├── serde + serde_json (serialization)
+├── clap (CLI parsing)
+├── heed (LMDB bindings)
+│   └── lmdb-sys (C bindings)
+├── sha2 + hex (cryptography)
+├── chrono (time handling)
+├── reqwest (HTTP client)
+│   ├── tokio (async runtime - blocking mode)
+│   ├── hyper (HTTP)
+│   └── rustls (TLS)
+├── html2text (HTML conversion)
+├── glob (pattern matching)
+├── env_logger + log (logging)
+└── dirs (home directory)
+```
+
+## 4.2 Critical Dependencies
+
+| Crate | Purpose | Version | Notes |
+|-------|---------|---------|-------|
+| `heed` | LMDB bindings | 0.20 | Core persistence |
+| `serde` | Serialization | 1.0 | All data structures |
+| `reqwest` | HTTP | 0.11 | Blocking mode only |
+| `clap` | CLI | 4.4 | Derive macros |
+| `chrono` | Time | 0.4 | Timestamps |
+
+## 4.3 Why These Choices
+
+- **heed over lmdb-rkv**: More idiomatic Rust API, better type safety
+- **reqwest blocking**: Avoids async complexity for CLI tool
+- **anyhow over custom errors**: Faster development, good ergonomics
+- **clap derive**: Minimal boilerplate for CLI
+
+---
+
+# 5. MODULE ARCHITECTURE
+
+## 5.1 Module Dependency Graph
+
+```
+                              ┌────────────┐
+                              │  main.rs   │
+                              │  (Entry)   │
+                              └─────┬──────┘
+                                    │
+                    ┌───────────────┼───────────────┐
+                    │               │               │
+              ┌─────▼─────┐   ┌─────▼─────┐   ┌─────▼─────┐
+              │  mcp.rs   │   │ gate.rs   │   │ config.rs │
+              │  (Server) │   │ (Enforce) │   │  (Types)  │
+              └─────┬─────┘   └─────┬─────┘   └───────────┘
+                    │               │
+        ┌───────────┼───────────────┼───────────────┐
+        │           │               │               │
+  ┌─────▼─────┐ ┌───▼───┐     ┌─────▼─────┐   ┌─────▼─────┐
+  │ session   │ │ web   │     │ calculate │   │ validate  │
+  │   .rs     │ │ .rs   │     │    .rs    │   │    .rs    │
+  └───────────┘ └───────┘     └───────────┘   └─────┬─────┘
+                                                    │
+                                              ┌─────▼─────┐
+                                              │ inspect   │
+                                              │   .rs     │
+                                              └───────────┘
+
+  ┌─────────────────────────────────────────────────────────┐
+  │                    LMDB LAYER                           │
+  ├─────────────┬─────────────┬─────────────┬──────────────┤
+  │ config_db   │ tools_db    │ sandbox_db  │ agent_state  │
+  │    .rs      │    .rs      │    .rs      │     .rs      │
+  └─────────────┴─────────────┴─────────────┴──────────────┘
+                              │
+                        ┌─────▼─────┐
+                        │ storage   │
+                        │   .rs     │
+                        └───────────┘
+```
+
+## 5.2 Module Responsibilities
+
+### main.rs (190 lines)
+**Purpose:** CLI entry point and subcommand dispatch
+
+**Imports:**
+```rust
+use spf_smart_gate::{calculate, config_db::SpfConfigDb, gate, mcp, session::Session, storage::SpfStorage};
+use clap::{Parser, Subcommand};
+use anyhow::{Context, Result};
+```
+
+**Key Functions:**
+- `main()` - Entry point, CLI parsing
+- `home_dir()` - Get home directory
+- `default_storage_path()` - Default LMDB path
+
+**Subcommands:**
+- `serve` - Run MCP server
+- `gate` - One-shot gate check
+- `calculate` - Calculate complexity
+- `status` - Show gateway status
+- `session` - Show session state
+- `reset` - Reset session
+- `init-config` - Initialize LMDB config
+
+### lib.rs (33 lines)
+**Purpose:** Library exports for binary and tests
+
+```rust
+pub mod calculate;
+pub mod config;
+pub mod config_db;
+pub mod gate;
+pub mod inspect;
+pub mod mcp;
+pub mod session;
+pub mod storage;
+pub mod validate;
+pub mod web;
+pub mod fs;
+pub mod tools_db;
+pub mod sandbox_db;
+pub mod agent_state;
+pub mod claude_state;
+```
+
+### config.rs (196 lines)
+**Purpose:** Core configuration types
+
+**Key Structs:**
+- `SpfConfig` - Master configuration
+- `EnforceMode` - Hard/Soft enforcement
+- `TierConfig` - Tier thresholds
+- `TierThreshold` - Per-tier settings
+- `FormulaConfig` - SPF formula parameters (w_eff, e, powers)
+- `ComplexityWeights` - Weight categories
+- `ToolWeight` - Per-tool complexity weights (basic, dependencies, complex, files)
+
+**Key Methods:**
+- `SpfConfig::default()` - Default configuration
+- `SpfConfig::load()` - Load from JSON file
+- `SpfConfig::save()` - Save to JSON file
+- `SpfConfig::get_tier()` - Get tier for C value
+- `SpfConfig::is_path_blocked()` - Check blocked paths (with canonicalization)
+- `SpfConfig::is_path_allowed()` - Check allowed paths
+
+### config_db.rs (448 lines)
+**Purpose:** LMDB operations for SPF_CONFIG
+
+**Key Functions:**
+- `open()` - Open/create LMDB
+- `init_defaults()` - Initialize default config
+- `load_full_config()` - Load SpfConfig from LMDB
+- `get_path_rules()` - Get allowed/blocked paths
+- `get_dangerous_patterns()` - Get command patterns
+- `stats()` - Get database statistics
+
+### calculate.rs (311 lines)
+**Purpose:** SPF complexity formula implementation
+
+**Key Structs:**
+- `ToolParams` - Tool call parameters (15 fields for all tool types)
+- `ComplexityResult` - Calculation result (tool, c, tier, percentages, tokens)
+
+**Key Functions:**
+- `calc_complex_factor()` - Calculate dynamic complexity (0-4 scale)
+- `calc_files_factor()` - Calculate files factor based on scope
+- `is_architectural_file()` - Check if file is config/main/lib/mod
+- `has_risk_indicators()` - Check for delete/drop/remove/force/unsafe
+- `calculate_c()` - Main C value calculation with all tool types
+- `a_optimal()` - Master formula: W_eff × (1 - 1/ln(C + e))
+- `calculate()` - Full calculation returning ComplexityResult
+
+### validate.rs (155 lines)
+**Purpose:** Rule validation logic
+
+**Key Structs:**
+- `ValidationResult` - valid bool, warnings vec, errors vec
+
+**Key Functions:**
+- `validate_edit()` - Validate Edit (Build Anchor + blocked paths)
+- `validate_write()` - Validate Write (size limit + anchor + blocked)
+- `validate_bash()` - Validate Bash (dangerous commands + git force + /tmp)
+- `validate_read()` - Validate Read (always allowed, /tmp blocked)
+
+### gate.rs (130 lines)
+**Purpose:** Primary enforcement checkpoint
+
+**Key Structs:**
+- `GateDecision` - Allow/block decision (allowed, tool, complexity, warnings, errors, message)
+
+**Key Functions:**
+- `process()` - Main gate processing pipeline:
+  1. Calculate complexity
+  2. Check approval requirement
+  3. Validate against rules (calls validate_edit/write/bash/read)
+  4. Content inspection (calls inspect_content)
+  5. Return GateDecision
+
+### inspect.rs (144 lines)
+**Purpose:** Content pattern inspection
+
+**Constants:**
+- `CREDENTIAL_PATTERNS` - 19 patterns (sk-, AKIA, ghp_, private keys, etc.)
+- `SHELL_INJECTION_PATTERNS` - 4 patterns ($(, eval, exec, backtick)
+
+**Key Functions:**
+- `inspect_content()` - Main inspection (skips code files for shell patterns)
+- `check_credentials()` - Scan for API keys, tokens, private keys
+- `check_path_traversal()` - Detect ../ sequences
+- `check_shell_injection()` - Detect command substitution
+- `check_blocked_path_references()` - Detect blocked path mentions
+
+### session.rs (156 lines)
+**Purpose:** Session state tracking
+
+**Key Structs:**
+- `Session` - Current session state (action_count, files_read/written, last_*, timestamps, history)
+- `ComplexityEntry` - Complexity history (timestamp, tool, c, tier)
+- `ManifestEntry` - Action log (timestamp, tool, c, action, reason)
+- `FailureEntry` - Failure log (timestamp, tool, error)
+
+**Key Functions:**
+- `new()` - Create new session
+- `track_read()` - Record file read (Build Anchor)
+- `track_write()` - Record file write
+- `record_action()` - Log action with result
+- `record_complexity()` - Log complexity (keeps last 100)
+- `record_manifest()` - Log allowed/blocked (keeps last 200)
+- `record_failure()` - Log failure (keeps last 50)
+- `anchor_ratio()` - Calculate reads/writes ratio
+- `status_summary()` - Get summary string
+
+### storage.rs (100 lines)
+**Purpose:** LMDB persistence layer
+
+**Key Structs:**
+- `SpfStorage` - Storage manager
+
+**Key Functions:**
+- `open()` - Open storage directory
+- `load_session()` - Load session from LMDB
+- `save_session()` - Save session to LMDB
+
+### tools_db.rs (433 lines)
+**Purpose:** Tool registry LMDB
+
+**Key Structs:**
+- `ToolEntry` - Tool metadata
+- `ToolPermission` - Permission level
+- `ToolStats` - Usage statistics
+
+**Key Functions:**
+- `open()` - Open LMDB
+- `init_defaults()` - Register default tools
+- `get_tool()` - Get tool by name
+- `list_tools()` - List all tools
+- `record_call()` - Record tool usage
+
+### sandbox_db.rs (609 lines)
+**Purpose:** Project sandbox LMDB
+
+**Key Structs:**
+- `ProjectSandbox` - Project workspace
+- `TrustLevel` - Trust classification
+- `AccessLogEntry` - Access history
+
+**Key Functions:**
+- `open()` - Open LMDB
+- `register_project()` - Register new project
+- `get_project()` - Get project by path
+- `set_active()` - Set active project
+- `log_access()` - Log file access
+
+### agent_state.rs (683 lines)
+**Purpose:** Agent memory and state
+
+**Key Structs:**
+- `Memory` - Stored memory
+- `MemoryType` - Memory classification
+- `SessionRecord` - Session history
+- `AgentPreference` - Agent preferences
+
+**Key Functions:**
+- `open()` - Open LMDB
+- `remember()` - Store memory
+- `recall()` - Search memories
+- `search_memories()` - Full-text search
+- `get_by_tag()` - Get memories by tag
+- `get_context_summary()` - Session continuity
+
+### fs.rs (628 lines)
+**Purpose:** Virtual filesystem
+
+**Key Structs:**
+- `SpfFs` - Filesystem manager
+- `FileMetadata` - File metadata
+- `FileType` - File/Directory/Symlink
+
+**Key Functions:**
+- `open()` - Open LMDB filesystem
+- `read()` - Read file content
+- `write()` - Write file (hybrid: LMDB + disk blobs)
+- `mkdir()` / `mkdir_p()` - Create directories
+- `ls()` - List directory
+- `rm()` / `rm_rf()` - Remove files/directories
+- `rename()` - Rename/move
+- `index_vector()` - Link to brain vector
+
+### web.rs (289 lines)
+**Purpose:** HTTP client for web access
+
+**Key Structs:**
+- `WebClient` - HTTP client wrapper
+- `SearchResult` - Search result
+
+**Key Functions:**
+- `new()` - Create client
+- `search_brave()` - Brave Search API
+- `search_ddg()` - DuckDuckGo fallback
+- `search()` - Auto-select search engine
+- `read_page()` - Fetch and convert to text
+- `download()` - Download file
+- `api_request()` - Generic API call
+
+### mcp.rs (2,103 lines) - **LARGEST FILE**
+**Purpose:** MCP JSON-RPC 2.0 server
+
+**Key Functions:**
+- `format_timestamp()` - Format Unix timestamp
+- `brain_path()` / `dirs_home()` - Path helpers
+- `run_brain()` - Call stoneshell-brain binary
+- `run_rag()` - Call RAG collector
+- `log()` - Log to stderr
+- `send_response()` / `send_error()` - JSON-RPC responses
+- `tool_def()` - Build tool definition JSON
+- `tool_definitions()` - Return all 54 tool definitions
+- `handle_tool_call()` - Dispatch tool calls (1300+ lines)
+- `run()` - Main server loop (initializes 4 LMDBs)
+
+**Tool Definitions:** (54 total)
+- Core: `spf_gate`, `spf_calculate`, `spf_status`, `spf_session`
+- File: `spf_read`, `spf_write`, `spf_edit`, `spf_bash`
+- Search: `spf_glob`, `spf_grep`
+- Web: `spf_web_search`, `spf_web_fetch`, `spf_web_download`, `spf_web_api`
+- Notebook: `spf_notebook_edit`
+- Brain: `spf_brain_*` (9 tools)
+- RAG: `spf_rag_*` (14 tools)
+- Config: `spf_config_paths`, `spf_config_stats`
+- Tools: `spf_tools_*` (3 tools)
+- Sandbox: `spf_sandbox_*` (4 tools)
+- Agent: `spf_agent_*` (5 tools)
+
+**Blocked Handlers (no definitions):**
+- `spf_config_get`, `spf_config_set` - User-only via CLI
+- `spf_agent_remember`, `spf_agent_forget`, `spf_agent_set_state` - User-only
+
+---
+
+# 6. DATA STRUCTURES REFERENCE
+
+## 6.1 Core Types
+
+### SpfConfig (config.rs:11-23)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SpfConfig {
+    pub version: String,                    // Config version
+    pub enforce_mode: EnforceMode,          // Hard or Soft
+    pub allowed_paths: Vec<String>,         // Whitelisted paths
+    pub blocked_paths: Vec<String>,         // Blacklisted paths
+    pub require_read_before_edit: bool,     // Build Anchor toggle
+    pub max_write_size: usize,              // Max write size (100KB default)
+    pub tiers: TierConfig,                  // Tier thresholds
+    pub formula: FormulaConfig,             // SPF parameters
+    pub complexity_weights: ComplexityWeights,  // Weight categories
+    pub dangerous_commands: Vec<String>,    // Dangerous command patterns
+    pub git_force_patterns: Vec<String>,    // Git force patterns
+}
+```
+
+### EnforceMode (config.rs:47-52)
+```rust
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum EnforceMode {
+    Hard,  // Block on violations
+    Soft,  // Warn but allow
+}
+```
+
+### TierConfig (config.rs:54-62)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierConfig {
+    pub simple: TierThreshold,    // C < 500
+    pub light: TierThreshold,     // C < 2000
+    pub medium: TierThreshold,    // C < 10000
+    pub critical: TierThreshold,  // C >= 10000
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierThreshold {
+    pub max_c: u64,              // Maximum complexity for this tier
+    pub analyze_percent: u8,     // % for analysis (0-100)
+    pub build_percent: u8,       // % for building (0-100)
+    pub requires_approval: bool, // Always true (hardcoded policy)
+}
+```
+
+### FormulaConfig (config.rs:48-59)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FormulaConfig {
+    pub w_eff: f64,              // Effective working memory (40000.0)
+    pub e: f64,                  // Euler's number (std::f64::consts::E)
+    pub basic_power: u32,        // Basic exponent (1)
+    pub deps_power: u32,         // Dependencies exponent (7)
+    pub complex_power: u32,      // Complex exponent (10)
+    pub files_multiplier: u64,   // Files multiplier (10)
+}
+```
+
+### ComplexityWeights (config.rs:61-72)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComplexityWeights {
+    pub edit: ToolWeight,
+    pub write: ToolWeight,
+    pub bash_dangerous: ToolWeight,
+    pub bash_git: ToolWeight,
+    pub bash_piped: ToolWeight,
+    pub bash_simple: ToolWeight,
+    pub read: ToolWeight,
+    pub search: ToolWeight,
+    pub unknown: ToolWeight,
+}
+```
+
+### ToolParams (calculate.rs:24-49)
+```rust
+#[derive(Debug, Clone, Deserialize, Default)]
+pub struct ToolParams {
+    // Common
+    pub file_path: Option<String>,
+    // Edit
+    pub old_string: Option<String>,
+    pub new_string: Option<String>,
+    pub replace_all: Option<bool>,
+    // Write
+    pub content: Option<String>,
+    // Bash
+    pub command: Option<String>,
+    // Search (glob/grep)
+    pub query: Option<String>,
+    pub pattern: Option<String>,
+    pub path: Option<String>,
+    // Brain operations
+    pub collection: Option<String>,
+    pub limit: Option<u64>,
+    pub text: Option<String>,
+    pub title: Option<String>,
+    // RAG/Web operations
+    pub url: Option<String>,
+    pub topic: Option<String>,
+    pub category: Option<String>,
+}
+```
+
+### ComplexityResult (calculate.rs:12-20)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComplexityResult {
+    pub tool: String,              // Tool name
+    pub c: u64,                    // Complexity value
+    pub tier: String,              // SIMPLE/LIGHT/MEDIUM/CRITICAL
+    pub analyze_percent: u8,       // % for analysis
+    pub build_percent: u8,         // % for building
+    pub a_optimal_tokens: u64,     // Optimal tokens from master formula
+    pub requires_approval: bool,   // Always true
+}
+```
+
+### GateDecision (gate.rs:15-28)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GateDecision {
+    pub allowed: bool,             // Final decision
+    pub tool: String,              // Tool name
+    pub complexity: ComplexityResult,
+    pub warnings: Vec<String>,     // Non-blocking issues
+    pub errors: Vec<String>,       // Blocking issues
+    pub message: String,           // Human-readable summary
+}
+```
+
+### Session (session.rs:12-24)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Session {
+    pub action_count: u64,                        // Total operations
+    pub files_read: Vec<String>,                  // Build Anchor tracking
+    pub files_written: Vec<String>,               // Write audit
+    pub last_tool: Option<String>,                // Last tool used
+    pub last_result: Option<String>,              // Last result
+    pub last_file: Option<String>,                // Last file accessed
+    pub started: DateTime<Utc>,                   // Session start (chrono)
+    pub last_action: Option<DateTime<Utc>>,       // Last action time
+    pub complexity_history: Vec<ComplexityEntry>, // Last 100 entries
+    pub manifest: Vec<ManifestEntry>,             // Last 200 entries
+    pub failures: Vec<FailureEntry>,              // Last 50 entries
+}
+```
+
+### ToolEntry (tools_db.rs:25-42)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolEntry {
+    pub name: String,
+    pub permission: ToolPermission,
+    pub is_mcp: bool,
+    pub mcp_server: Option<String>,
+    pub created_at: u64,
+    pub stats: ToolStats,
+    pub notes: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ToolPermission {
+    Allow,
+    Deny,
+    RequireApproval,
+}
+```
+
+### ProjectSandbox (sandbox_db.rs:30-55)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProjectSandbox {
+    pub name: String,
+    pub path: String,
+    pub trust_level: TrustLevel,
+    pub is_active: bool,
+    pub created_at: u64,
+    pub last_accessed: u64,
+    pub total_reads: u64,
+    pub total_writes: u64,
+    pub session_writes: u64,
+    pub max_writes_per_session: u64,
+    pub max_write_size: u64,
+    pub total_complexity: u64,
+    pub protected_paths: Vec<String>,
+    pub notes: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TrustLevel {
+    Untrusted,
+    Low,
+    Medium,
+    High,
+    Full,
+}
+```
+
+### Memory (agent_state.rs:30-48)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Memory {
+    pub id: String,
+    pub content: String,
+    pub memory_type: MemoryType,
+    pub tags: Vec<String>,
+    pub created_at: u64,
+    pub accessed_at: u64,
+    pub access_count: u64,
+    pub importance: u8,
+    pub source: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum MemoryType {
+    Fact,
+    Preference,
+    Instruction,
+    Context,
+    Temporary,
+}
+```
+
+### FileMetadata (fs.rs:30-48)
+```rust
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileMetadata {
+    pub file_type: FileType,
+    pub size: u64,
+    pub mode: u32,
+    pub created_at: i64,
+    pub modified_at: i64,
+    pub checksum: Option<String>,
+    pub version: u64,
+    pub vector_id: Option<String>,  // Link to brain vector
+    pub real_path: Option<String>,  // Disk blob path (hybrid storage)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum FileType {
+    File,
+    Directory,
+    Symlink,
+}
+```
+
+---
+
+# 7. FUNCTION REFERENCE
+
+## 7.1 Core Pipeline Functions
+
+### gate::process() (gate.rs:30-95)
+```rust
+pub fn process(
+    tool: &str,
+    params: &ToolParams,
+    config: &SpfConfig,
+    session: &Session,
+    approved: bool,
+) -> GateDecision
+```
+
+**Flow:**
+1. Calculate complexity: `calculate::calculate(tool, params, config)`
+2. Check approval: All tiers require `approved == true`
+3. Validate path: `validate::validate_path(params, config)`
+4. Validate anchor: `validate::validate_anchor(params, session)`
+5. Validate command: `validate::validate_command(params, config)`
+6. Inspect content: `inspect::inspect_content(params, config)`
+7. Return `GateDecision`
+
+### calculate::calculate() (calculate.rs:55-120)
+```rust
+pub fn calculate(tool: &str, params: &ToolParams, config: &SpfConfig) -> ComplexityResult
+```
+
+**Formula:**
+```
+C = (basic ^ 1) + (deps ^ 7) + (complex ^ 10) + (files × 10)
+```
+
+**Flow:**
+1. Get tool weight from config
+2. Calculate basic from content size
+3. Calculate deps from tool type
+4. Calculate complex from patterns
+5. Calculate files from file_path
+6. Apply formula
+7. Classify tier
+8. Calculate token allocation
+
+### validate::validate_path() (validate.rs:25-60)
+```rust
+pub fn validate_path(params: &ToolParams, config: &SpfConfig) -> ValidationResult
+```
+
+**Flow:**
+1. Canonicalize path (resolve symlinks, ..)
+2. Check against `config.blocked_paths`
+3. Check against `config.allowed_paths`
+4. Return Valid/Invalid with reason
+
+### validate::validate_anchor() (validate.rs:62-85)
+```rust
+pub fn validate_anchor(params: &ToolParams, session: &Session) -> ValidationResult
+```
+
+**Flow:**
+1. Get file_path from params
+2. Check if tool is write operation (Write/Edit)
+3. Check if file_path is in `session.files_read`
+4. Return Valid/Invalid
+
+### inspect::inspect_content() (inspect.rs:20-65)
+```rust
+pub fn inspect_content(content: &str, config: &SpfConfig) -> InspectionResult
+```
+
+**Flow:**
+1. For each pattern in `config.dangerous_patterns`
+2. If pattern matches content, add to findings
+3. Return findings with severity
+
+## 7.2 Session Functions
+
+### Session::track_read() (session.rs:80-90)
+```rust
+pub fn track_read(&mut self, path: &str)
+```
+Adds path to `files_read` if not already present.
+
+### Session::has_read() (session.rs:92-98)
+```rust
+pub fn has_read(&self, path: &str) -> bool
+```
+Returns true if path was previously read (anchor check).
+
+### Session::record_complexity() (session.rs:115-130)
+```rust
+pub fn record_complexity(&mut self, tool: &str, c: u64, tier: &str)
+```
+Adds entry to `complexity_history`, updates `total_complexity`.
+
+### Session::record_manifest() (session.rs:132-150)
+```rust
+pub fn record_manifest(&mut self, tool: &str, c: u64, status: &str, error: Option<&str>)
+```
+Logs action to `manifest` with timestamp.
+
+## 7.3 LMDB Functions
+
+### SpfConfigDb::load_full_config() (config_db.rs:180-230)
+```rust
+pub fn load_full_config(&self) -> Result<SpfConfig>
+```
+
+**Flow:**
+1. Call `init_defaults()` if empty
+2. Load enforce_mode from LMDB
+3. Load tier thresholds
+4. Load formula config
+5. Load path rules
+6. Load dangerous patterns
+7. Assemble and return SpfConfig
+
+### SpfToolsDb::record_call() (tools_db.rs:200-250)
+```rust
+pub fn record_call(&self, name: &str, allowed: bool, complexity: u64) -> Result<()>
+```
+
+**Flow:**
+1. Get existing tool or create new
+2. Update stats (call_count, allowed/blocked, avg_complexity)
+3. Write to history table
+4. Save updated tool
+
+### AgentStateDb::remember() (agent_state.rs:150-200)
+```rust
+pub fn remember(&self, content: &str, memory_type: MemoryType, tags: &[String]) -> Result<String>
+```
+
+**Flow:**
+1. Generate UUID for memory
+2. Create Memory struct
+3. Write to memories table
+4. Index by tags
+5. Return memory ID
+
+## 7.4 MCP Functions
+
+### mcp::run() (mcp.rs:1957-2103)
+```rust
+pub fn run(config: SpfConfig, mut session: Session, storage: SpfStorage)
+```
+
+**Flow:**
+1. Initialize all 5 LMDB databases
+2. Enter infinite loop reading stdin
+3. Parse JSON-RPC message
+4. Match on method:
+   - `initialize` → capabilities response
+   - `tools/list` → tool definitions
+   - `tools/call` → `handle_tool_call()`
+   - `ping` → pong
+5. Send JSON-RPC response
+
+### mcp::handle_tool_call() (mcp.rs:625-1954)
+```rust
+fn handle_tool_call(name: &str, args: &Value, ...) -> Value
+```
+
+**Pattern (for gated tools):**
+```rust
+1. Extract parameters from args
+2. Build ToolParams
+3. Call gate::process()
+4. If !decision.allowed → return BLOCKED
+5. Execute actual operation
+6. Track in session
+7. Save session
+8. Return result
+```
+
+---
+
+# 8. HOOKS SYSTEM (Claude Code Integration)
+
+## 8.1 Overview
+
+The hooks system provides Claude Code integration via shell scripts that intercept tool calls before execution.
+
+```
+User Request
+    ↓
+Claude Code
+    ↓
+pre-{tool}.sh  →  spf-gate.sh  →  Rust Gateway (spf-smart-gate gate)
+    ↓                                      ↓
+[BLOCKED]                            [ALLOWED]
+    ↓                                      ↓
+post-failure.sh                      post-action.sh
+```
+
+## 8.2 Hook Files
+
+| Hook | Size | Purpose |
+|------|------|---------|
+| `spf-gate.sh` | 2.6KB | Main enforcement - calls Rust gateway |
+| `pre-bash.sh` | 494B | Pre-bash gate |
+| `pre-edit.sh` | 494B | Pre-edit gate |
+| `pre-read.sh` | 518B | Pre-read gate |
+| `pre-write.sh` | 498B | Pre-write gate |
+| `pre-glob.sh` | 435B | Pre-glob gate |
+| `pre-grep.sh` | 435B | Pre-grep gate |
+| `pre-webfetch.sh` | 461B | Pre-webfetch gate |
+| `pre-websearch.sh` | 480B | Pre-websearch gate |
+| `pre-notebookedit.sh` | 467B | Pre-notebook gate |
+| `post-action.sh` | 5.4KB | Post-execution logging |
+| `post-failure.sh` | 1.5KB | Failure handler |
+| `session-start.sh` | 2.6KB | Session initialization |
+| `session-end.sh` | 2.5KB | Session cleanup |
+| `stop-check.sh` | 1.4KB | Stop condition checks |
+| `user-prompt.sh` | 6.5KB | User prompt handler |
+
+## 8.3 spf-gate.sh Flow
+
+```bash
+# 1. Check gateway binary exists (fail-closed)
+if [ ! -x "$GATEWAY" ]; then
+    exit 1  # BLOCKED
+fi
+
+# 2. Call Rust gateway
+RESULT=$("$GATEWAY" gate "$TOOL_NAME" "$TOOL_INPUT" $APPROVED_FLAG)
+EXIT_CODE=$?
+
+# 3. Exit code is enforcement decision
+# 0 = ALLOWED, 1 = BLOCKED
+exit $EXIT_CODE
+```
+
+---
+
+# 9. LMDB SCHEMA DOCUMENTATION
+
+## 9.1 Database Overview
+
+| Database | Path | Size | Tables | Purpose |
+|----------|------|------|--------|---------|
+| ROOT | storage/ | varies | 1 | Session storage |
+| SPF_CONFIG | storage/spf_config | 60KB | 3 | Configuration |
+| SPF_TOOLS | storage/spf_tools | 56KB | 3 | Tool registry |
+| SPF_SANDBOX | storage/spf_sandbox | 20KB | 3 | Project sandboxes |
+| AGENT_STATE | storage/agent_state | 60KB | 4 | Agent memory |
+| BLOBS | storage/blobs/ | 221MB | N/A | Large file storage (disk) |
+
+## 9.2 Root Session Storage
+
+```
+storage/data.mdb + lock.mdb
+  Key:   "session"
+  Value: SerdeBincode<Session>
+```
+
+## 9.3 SPF_CONFIG Schema
+
+```
+Table: config
+  Key:   String (config key)
+  Value: SerdeBincode<Value>
+
+  Keys:
+    "enforce_mode" → EnforceMode
+    "tier_simple_max" → u64
+    "tier_simple_analyze" → f64
+    "tier_simple_build" → f64
+    ...etc for each tier
+    "formula_w_eff" → u64
+    "formula_basic_exp" → u32
+    ...etc for formula
+
+Table: paths
+  Key:   String ("allowed:{path}" or "blocked:{path}")
+  Value: String (path)
+
+Table: patterns
+  Key:   String (pattern)
+  Value: SerdeBincode<DangerousPattern>
+```
+
+## 9.4 SPF_TOOLS Schema
+
+```
+Table: tools
+  Key:   String (tool name)
+  Value: SerdeBincode<ToolEntry>
+
+Table: history
+  Key:   String ("{timestamp}:{tool}:{action}")
+  Value: SerdeBincode<ToolHistoryEntry>
+
+Table: aliases
+  Key:   String (alias)
+  Value: String (tool name)
+```
+
+## 9.5 SPF_SANDBOX Schema
+
+```
+Table: projects
+  Key:   String (project path)
+  Value: SerdeBincode<ProjectSandbox>
+
+Table: access_log
+  Key:   String ("{timestamp}:{project}:{path}")
+  Value: SerdeBincode<AccessLogEntry>
+
+Table: resources
+  Key:   String ("{project}:{resource_path}")
+  Value: SerdeBincode<ResourceEntry>
+```
+
+## 9.6 AGENT_STATE Schema
+
+```
+Table: memories
+  Key:   String (memory UUID)
+  Value: SerdeBincode<Memory>
+
+Table: sessions
+  Key:   String (session UUID)
+  Value: SerdeBincode<SessionRecord>
+
+Table: state
+  Key:   String (state key)
+  Value: SerdeBincode<Value>
+
+Table: tags
+  Key:   String ("{tag}:{memory_id}")
+  Value: String (memory_id) - index for tag lookup
+```
+
+---
+
+# 10. MCP PROTOCOL IMPLEMENTATION
+
+## 10.1 Protocol Overview
+
+- **Protocol:** JSON-RPC 2.0 over stdio
+- **Protocol Version:** 2024-11-05
+- **Transport:** stdin/stdout (line-delimited JSON)
+- **Logging:** stderr (not visible to client)
+
+## 10.2 Handshake
+
+**Client → Server:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "initialize",
+  "params": {
+    "protocolVersion": "2024-11-05",
+    "capabilities": {},
+    "clientInfo": {"name": "claude-code", "version": "2.0"}
+  }
+}
+```
+
+**Server → Client:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "protocolVersion": "2024-11-05",
+    "capabilities": {"tools": {}},
+    "serverInfo": {"name": "spf-smart-gate", "version": "1.0.0"}
+  }
+}
+```
+
+## 10.3 Tool Listing
+
+**Client → Server:**
+```json
+{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}
+```
+
+**Server → Client:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 2,
+  "result": {
+    "tools": [
+      {
+        "name": "spf_gate",
+        "description": "Run a tool call through SPF enforcement gate...",
+        "inputSchema": {
+          "type": "object",
+          "properties": {
+            "tool": {"type": "string"},
+            "params": {"type": "object"},
+            "approved": {"type": "boolean", "default": true}
+          },
+          "required": ["tool", "params"]
+        }
+      },
+      // ... 57 more tools
+    ]
+  }
+}
+```
+
+## 10.4 Tool Call
+
+**Client → Server:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 3,
+  "method": "tools/call",
+  "params": {
+    "name": "spf_read",
+    "arguments": {
+      "file_path": "/home/user/file.txt"
+    }
+  }
+}
+```
+
+**Server → Client:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 3,
+  "result": {
+    "content": [
+      {
+        "type": "text",
+        "text": "File: /home/user/file.txt (42 lines)\n     1\tline 1 content\n..."
+      }
+    ]
+  }
+}
+```
+
+## 10.5 Complete Tool List (54 definitions)
+
+### Core Gate (4)
+| Tool | Description |
+|------|-------------|
+| `spf_gate` | Run tool through enforcement gate |
+| `spf_calculate` | Calculate complexity without executing |
+| `spf_status` | Gateway status |
+| `spf_session` | Full session state |
+
+### File Operations (4)
+| Tool | Description |
+|------|-------------|
+| `spf_read` | Read file (builds anchor) |
+| `spf_write` | Write file (requires anchor) |
+| `spf_edit` | Edit file (requires anchor) |
+| `spf_bash` | Execute bash command |
+
+### Search (2)
+| Tool | Description |
+|------|-------------|
+| `spf_glob` | File pattern matching |
+| `spf_grep` | Content search (ripgrep) |
+
+### Web (4)
+| Tool | Description |
+|------|-------------|
+| `spf_web_search` | Search via Brave/DDG |
+| `spf_web_fetch` | Fetch URL as text |
+| `spf_web_download` | Download file |
+| `spf_web_api` | API request |
+
+### Notebook (1)
+| Tool | Description |
+|------|-------------|
+| `spf_notebook_edit` | Edit Jupyter cell |
+
+### Brain (8)
+| Tool | Description |
+|------|-------------|
+| `spf_brain_search` | Search brain vectors |
+| `spf_brain_store` | Store document |
+| `spf_brain_context` | Get context for query |
+| `spf_brain_index` | Index file/directory |
+| `spf_brain_list` | List collections |
+| `spf_brain_status` | Brain system status |
+| `spf_brain_recall` | Full document retrieval |
+| `spf_brain_list_docs` | List documents |
+| `spf_brain_get_doc` | Get document by ID |
+
+### RAG (14)
+| Tool | Description |
+|------|-------------|
+| `spf_rag_collect_web` | Web search + collect |
+| `spf_rag_collect_file` | Process local file |
+| `spf_rag_collect_folder` | Process folder |
+| `spf_rag_collect_drop` | Process DROP_HERE |
+| `spf_rag_index_gathered` | Index collected docs |
+| `spf_rag_dedupe` | Deduplicate collection |
+| `spf_rag_status` | Collector status |
+| `spf_rag_list_gathered` | List gathered docs |
+| `spf_rag_bandwidth_status` | Bandwidth stats |
+| `spf_rag_fetch_url` | Fetch single URL |
+| `spf_rag_collect_rss` | Collect from RSS |
+| `spf_rag_list_feeds` | List RSS feeds |
+| `spf_rag_pending_searches` | Get search gaps |
+| `spf_rag_fulfill_search` | Mark gap fulfilled |
+| `spf_rag_smart_search` | Search with gap detection |
+| `spf_rag_auto_fetch_gaps` | Auto-fetch for gaps |
+
+### Config (2)
+| Tool | Description |
+|------|-------------|
+| `spf_config_paths` | List path rules |
+| `spf_config_stats` | Config LMDB stats |
+
+### Tools DB (3)
+| Tool | Description |
+|------|-------------|
+| `spf_tools_list` | List registered tools |
+| `spf_tools_stats` | Tools LMDB stats |
+| `spf_tools_get` | Get tool info |
+
+### Sandbox (4)
+| Tool | Description |
+|------|-------------|
+| `spf_sandbox_list` | List project sandboxes |
+| `spf_sandbox_stats` | Sandbox LMDB stats |
+| `spf_sandbox_get` | Get project info |
+| `spf_sandbox_active` | Get active project |
+
+### Agent State (5)
+| Tool | Description |
+|------|-------------|
+| `spf_agent_stats` | Agent LMDB stats |
+| `spf_agent_memory_search` | Search memories |
+| `spf_agent_memory_by_tag` | Get by tag |
+| `spf_agent_session_info` | Latest session |
+| `spf_agent_context` | Context summary |
+
+---
+
+# 11. SPF FORMULA SPECIFICATION
+
+## 11.1 Complexity Calculation
+
+### Base Formula
+```
+C = (basic ^ basic_exp) + (deps ^ deps_exp) + (complex ^ complex_exp) + (files × files_mult)
+```
+
+### Default Parameters
+```
+basic_exp = 1
+deps_exp = 7
+complex_exp = 10
+files_mult = 10
+```
+
+### Expanded Form
+```
+C = basic + deps^7 + complex^10 + files×10
+```
+
+## 11.2 Component Calculation
+
+### Basic Component
+```rust
+let basic = match tool {
+    "Read" => content_size / 1000,           // 1 per KB
+    "Write" => content_size / 100,           // 10 per KB
+    "Edit" => (old_len + new_len) / 50,      // 20 per KB of changes
+    "Bash" => command.len() as u64,          // 1 per char
+    _ => 10,                                  // Default
+};
+```
+
+### Dependencies Component
+```rust
+let deps = match tool {
+    "Write" | "Edit" => 2,   // Requires anchor
+    "Bash" => 3,             // External effects
+    "web_*" => 2,            // Network
+    _ => 1,                  // No dependencies
+};
+// Applied: deps^7
+// Values: 1→1, 2→128, 3→2187, 4→16384
+```
+
+### Complex Component
+```rust
+let complex = match tool {
+    "Bash" if has_pipe => 2,         // Piped commands
+    "Bash" if has_redirect => 2,     // Redirections
+    "Edit" if replace_all => 2,      // Multiple changes
+    "Write" if large_file => 2,      // Large writes
+    _ => 1,
+};
+// Applied: complex^10
+// Values: 1→1, 2→1024, 3→59049
+```
+
+### Files Component
+```rust
+let files = if file_path.is_some() { 1 } else { 0 };
+// Applied: files×10
+```
+
+## 11.3 Tier Classification
+
+| Tier | C Range | Analyze | Build |
+|------|---------|---------|-------|
+| SIMPLE | 0 - 499 | 40% | 60% |
+| LIGHT | 500 - 1,999 | 60% | 40% |
+| MEDIUM | 2,000 - 9,999 | 75% | 25% |
+| CRITICAL | 10,000+ | 95% | 5% |
+
+## 11.4 Token Allocation
+
+### Master Formula
+```
+a_optimal(C) = W_eff × (1 - 1/ln(C + e))
+```
+
+Where:
+- `W_eff = 40,000` (effective working memory)
+- `e = Euler's number (2.71828...)`
+
+### Calculation
+```rust
+let w_eff = config.formula.w_eff as f64;
+let e = std::f64::consts::E;
+let a_optimal = w_eff * (1.0 - 1.0 / (c as f64 + e).ln());
+
+let analyze_tokens = (a_optimal * tier.analyze_ratio) as u64;
+let build_tokens = (a_optimal * tier.build_ratio) as u64;
+```
+
+## 11.5 Examples
+
+### Example 1: Simple Read
+```
+Tool: Read
+File size: 5000 bytes
+
+basic = 5000 / 1000 = 5
+deps = 1 (no dependencies)
+complex = 1
+files = 1
+
+C = 5 + 1^7 + 1^10 + 1×10
+C = 5 + 1 + 1 + 10 = 17
+
+Tier: SIMPLE (C < 500)
+Analyze: 40%, Build: 60%
+```
+
+### Example 2: Large Write
+```
+Tool: Write
+File size: 50000 bytes
+
+basic = 50000 / 100 = 500
+deps = 2 (requires anchor)
+complex = 2 (large file)
+files = 1
+
+C = 500 + 2^7 + 2^10 + 1×10
+C = 500 + 128 + 1024 + 10 = 1662
+
+Tier: LIGHT (500 <= C < 2000)
+Analyze: 60%, Build: 40%
+```
+
+### Example 3: Dangerous Bash
+```
+Tool: Bash
+Command: "rm -rf /some/path && echo done"
+
+basic = 35 (command length)
+deps = 3 (external effects)
+complex = 2 (has && operator)
+files = 0
+
+C = 35 + 3^7 + 2^10 + 0
+C = 35 + 2187 + 1024 = 3246
+
+Tier: MEDIUM (2000 <= C < 10000)
+Analyze: 75%, Build: 25%
+```
+
+---
+
+# 12. GATE PIPELINE INTERNALS
+
+## 12.1 Complete Flow Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           GATE PIPELINE                                      │
+│                                                                              │
+│  ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐  │
+│  │  INPUT   │──▶│ CALCULATE│──▶│ APPROVAL │──▶│ VALIDATE │──▶│ INSPECT  │  │
+│  │          │   │          │   │          │   │          │   │          │  │
+│  │ tool     │   │ C value  │   │ approved │   │ path     │   │ content  │  │
+│  │ params   │   │ tier     │   │ check    │   │ anchor   │   │ patterns │  │
+│  │ config   │   │ tokens   │   │          │   │ command  │   │          │  │
+│  │ session  │   │          │   │          │   │          │   │          │  │
+│  └──────────┘   └──────────┘   └──────────┘   └──────────┘   └──────────┘  │
+│        │              │              │              │              │        │
+│        │              │              │              │              │        │
+│        ▼              ▼              ▼              ▼              ▼        │
+│   ┌─────────────────────────────────────────────────────────────────────┐  │
+│   │                         DECISION                                     │  │
+│   │                                                                      │  │
+│   │  if any_errors:                                                     │  │
+│   │      allowed = false                                                │  │
+│   │      errors = [...all blocking issues...]                          │  │
+│   │  else:                                                              │  │
+│   │      allowed = true                                                 │  │
+│   │      warnings = [...non-blocking issues...]                        │  │
+│   │                                                                      │  │
+│   └─────────────────────────────────────────────────────────────────────┘  │
+│                                    │                                        │
+│                                    ▼                                        │
+│                            ┌──────────────┐                                 │
+│                            │ GateDecision │                                 │
+│                            │ {            │                                 │
+│                            │   allowed,   │                                 │
+│                            │   tool,      │                                 │
+│                            │   complexity,│                                 │
+│                            │   warnings,  │                                 │
+│                            │   errors,    │                                 │
+│                            │   message    │                                 │
+│                            │ }            │                                 │
+│                            └──────────────┘                                 │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+## 12.2 Validation Chain
+
+### Path Validation (validate.rs:25-60)
+```
+1. Extract file_path from params
+2. Canonicalize path (resolve .., symlinks)
+3. Check blocked_paths:
+   for blocked in config.blocked_paths:
+       if path.starts_with(blocked):
+           return Invalid("Path blocked: {blocked}")
+4. Check allowed_paths:
+   if allowed_paths not empty:
+       found = false
+       for allowed in config.allowed_paths:
+           if path.starts_with(allowed):
+               found = true
+               break
+       if not found:
+           return Invalid("Path not in allowed list")
+5. return Valid
+```
+
+### Anchor Validation (validate.rs:62-85)
+```
+1. If tool not in [Write, Edit]:
+   return Valid (anchor only for writes)
+2. Extract file_path from params
+3. If file_path in session.files_read:
+   return Valid
+4. return Invalid("Build Anchor: Must read file before editing")
+```
+
+### Command Validation (validate.rs:87-120)
+```
+1. If tool != "Bash":
+   return Valid
+2. Extract command from params
+3. for pattern in config.dangerous_patterns:
+   if regex_match(pattern.pattern, command):
+       if pattern.severity >= 8:
+           return Invalid("Dangerous: {pattern.description}")
+       else:
+           add Warning
+4. return Valid (with warnings)
+```
+
+### Content Inspection (inspect.rs:20-65)
+```
+1. Extract content from params
+2. for pattern in config.content_patterns:
+   if regex_match(pattern, content):
+       add Finding(pattern, severity)
+3. if any findings with severity >= 9:
+   return Invalid
+4. return Valid (with warnings for lower severity)
+```
+
+## 12.3 Enforcement Modes
+
+### Hard Mode (Default)
+- **Behavior:** Block on any validation error
+- **Use case:** Production, untrusted environments
+- **Decision:** `allowed = all_validations_passed`
+
+### Soft Mode
+- **Behavior:** Warn but allow
+- **Use case:** Development, debugging
+- **Decision:** `allowed = true` (errors become warnings)
+
+---
+
+# 13. SECURITY MODEL
+
+## 13.1 Threat Model
+
+**Adversary:** AI agent attempting to:
+- Access unauthorized files
+- Execute dangerous commands
+- Bypass anchor requirements
+- Modify system files
+- Exfiltrate data
+
+**Trust Boundaries:**
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       UNTRUSTED                                  │
+│                                                                  │
+│  ┌─────────────┐                                                │
+│  │  AI Agent   │◀───── Prompts, hallucinations, jailbreaks     │
+│  │ (Claude)    │                                                │
+│  └──────┬──────┘                                                │
+│         │ MCP Tool Calls                                        │
+│         │                                                        │
+└─────────┼────────────────────────────────────────────────────────┘
+          │
+          ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                    ENFORCEMENT BOUNDARY                          │
+│                                                                  │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │              SPF Smart Gateway (Rust)                       ││
+│  │                                                              ││
+│  │  • All requests validated                                   ││
+│  │  • Compiled logic (not prompt)                              ││
+│  │  • Full audit logging                                       ││
+│  │  • LMDB state (tamper-evident)                              ││
+│  └─────────────────────────────────────────────────────────────┘│
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+          │
+          ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                        PROTECTED                                 │
+│                                                                  │
+│  File System    │  External APIs    │  Brain Index              │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## 13.2 Security Controls
+
+### Path Traversal Prevention
+```rust
+// All paths are canonicalized before checking
+let canonical = std::fs::canonicalize(path)
+    .map(|p| p.to_string_lossy().to_string())
+    .unwrap_or_else(|_| path.to_string());
+
+// Prevents: ../../../etc/passwd
+// Prevents: /home/user/../../../system
+// Prevents: symlink attacks
+```
+
+### Build Anchor Protocol
+```rust
+// Enforced in validate::validate_anchor()
+if tool == "Write" || tool == "Edit" {
+    if !session.files_read.contains(&file_path) {
+        return Invalid("Must read file before editing");
+    }
+}
+
+// Prevents: blind writes
+// Prevents: AI guessing file contents
+// Prevents: overwriting without reading
+```
+
+### Command Injection Prevention
+```rust
+// Pattern matching in validate::validate_command()
+dangerous_patterns = [
+    r"rm\s+-rf\s+/",        // System destruction
+    r">\s*/dev/",            // Device manipulation
+    r"curl.*\|\s*sh",        // Remote code execution
+    r"chmod\s+777",          // Insecure permissions
+];
+```
+
+### Approval Requirement
+```rust
+// ALL tiers require approval (hardcoded)
+if !approved {
+    return GateDecision {
+        allowed: false,
+        errors: vec!["Approval required".to_string()],
+        ..
+    };
+}
+```
+
+## 13.3 Default Path Rules
+
+### Allowed Paths
+```
+/data/data/com.termux/files/home/
+/storage/emulated/0/Download/api-workspace/
+```
+
+### Blocked Paths
+```
+/tmp                                    # Termux restriction
+/etc                                    # System config
+/usr                                    # System binaries
+/system                                 # Android partition
+/data/data/com.termux/files/usr         # Termux packages
+```
+
+## 13.4 Dangerous Command Patterns
+
+| Pattern | Severity | Description |
+|---------|----------|-------------|
+| `rm -rf /` | 10 | System destruction |
+| `rm -rf ~` | 10 | Home destruction |
+| `dd if=` | 9 | Raw disk access |
+| `> /dev/` | 9 | Device manipulation |
+| `mkfs` | 9 | Filesystem formatting |
+| `chmod 777` | 7 | Insecure permissions |
+| `curl \| sh` | 8 | Remote code execution |
+| `wget \| sh` | 8 | Remote code execution |
+| `eval` | 6 | Code injection |
+| `:(){` | 9 | Fork bomb |
+| `git push --force` | 7 | Destructive git |
+| `git reset --hard` | 6 | History destruction |
+
+---
+
+# 14. CONFIGURATION REFERENCE
+
+## 14.1 LMDB Configuration Keys
+
+### Enforce Mode
+```
+Key: "enforce_mode"
+Values: "Hard" | "Soft"
+Default: "Hard"
+```
+
+### Tier Thresholds
+```
+Key: "tier_simple_max"      Value: 500
+Key: "tier_simple_analyze"  Value: 0.40
+Key: "tier_simple_build"    Value: 0.60
+
+Key: "tier_light_max"       Value: 2000
+Key: "tier_light_analyze"   Value: 0.60
+Key: "tier_light_build"     Value: 0.40
+
+Key: "tier_medium_max"      Value: 10000
+Key: "tier_medium_analyze"  Value: 0.75
+Key: "tier_medium_build"    Value: 0.25
+
+Key: "tier_critical_analyze" Value: 0.95
+Key: "tier_critical_build"   Value: 0.05
+```
+
+### Formula Parameters
+```
+Key: "formula_w_eff"       Value: 40000
+Key: "formula_basic_exp"   Value: 1
+Key: "formula_deps_exp"    Value: 7
+Key: "formula_complex_exp" Value: 10
+Key: "formula_files_mult"  Value: 10
+```
+
+## 14.2 Path Rules Format
+
+```
+Table: paths
+Key format: "{type}:{path}"
+
+Examples:
+  "allowed:/data/data/com.termux/files/home/"
+  "blocked:/tmp"
+  "blocked:/etc"
+```
+
+## 14.3 Dangerous Patterns Format
+
+```
+Table: patterns
+Key: pattern string
+Value: DangerousPattern {
+    pattern: String,
+    severity: u8,
+    description: String,
+}
+```
+
+## 14.4 Claude.json MCP Configuration
+
+```json
+{
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/target/release/spf-smart-gate",
+      "args": ["serve"],
+      "env": {}
+    }
+  }
+}
+```
+
+---
+
+# 15. ERROR HANDLING
+
+## 15.1 Error Types
+
+### Gate Errors (Blocking)
+```rust
+// These prevent the operation from proceeding
+"Build Anchor: Must read file before editing"
+"Path blocked: {path}"
+"Path not in allowed list: {path}"
+"Dangerous command detected: {pattern}"
+"Approval required for all operations"
+```
+
+### Gate Warnings (Non-blocking)
+```rust
+// These are logged but don't block
+"Command contains risky pattern: {pattern}"
+"Large file operation: {size} bytes"
+"High complexity: C={c}"
+```
+
+### System Errors
+```rust
+// LMDB errors
+"Failed to open LMDB: {error}"
+"Transaction failed: {error}"
+
+// File errors
+"File not found: {path}"
+"Permission denied: {path}"
+"Read failed: {error}"
+"Write failed: {error}"
+
+// Network errors
+"HTTP request failed: {error}"
+"DNS resolution failed"
+"Connection timeout"
+```
+
+## 15.2 Error Response Format
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32000,
+    "message": "BLOCKED: Build Anchor: Must read file before editing"
+  }
+}
+```
+
+## 15.3 Error Codes
+
+| Code | Meaning |
+|------|---------|
+| -32700 | Parse error (invalid JSON) |
+| -32600 | Invalid request |
+| -32601 | Method not found |
+| -32602 | Invalid params |
+| -32000 | Gate blocked |
+| -32001 | System error |
+
+---
+
+# 16. INSERT POINTS GUIDE
+
+## 16.1 Adding a New MCP Tool
+
+### Step 1: Add Tool Definition (mcp.rs:154-621)
+**Location:** `mcp.rs` function `tool_definitions()`
+
+```rust
+// Insert at appropriate section (after line ~620)
+tool_def(
+    "spf_your_new_tool",
+    "Description of what the tool does",
+    json!({
+        "param1": {"type": "string", "description": "..."},
+        "param2": {"type": "integer", "default": 10}
+    }),
+    vec!["param1"],  // required params
+),
+```
+
+### Step 2: Add Handler (mcp.rs:625-1954)
+**Location:** `mcp.rs` function `handle_tool_call()`
+
+```rust
+// Insert in match block (before the _ => catch-all)
+"spf_your_new_tool" => {
+    let param1 = args["param1"].as_str().unwrap_or("");
+    let param2 = args["param2"].as_i64().unwrap_or(10);
+
+    // Optional: Gate check
+    let params = ToolParams { ... };
+    let decision = gate::process("your_new_tool", &params, config, session, false);
+    if !decision.allowed {
+        return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+    }
+
+    // Implementation
+    session.record_action("your_new_tool", "called", None);
+    let _ = storage.save_session(session);
+
+    json!({"type": "text", "text": "Result"})
+}
+```
+
+### Step 3: Add Complexity Calculation (calculate.rs:55-120)
+**Location:** `calculate.rs` function `calculate()`
+
+```rust
+// Add match arm for your tool
+"your_new_tool" => {
+    basic = param1.len() as u64;
+    deps = 1;
+    complex = 1;
+}
+```
+
+### Files Modified: 2
+- `src/mcp.rs` (2 locations)
+- `src/calculate.rs` (1 location)
+
+## 16.2 Adding a New Path Rule
+
+### Runtime (via CLI - Future)
+```bash
+spf-smart-gate config set-path allowed /new/path
+spf-smart-gate config set-path blocked /dangerous/path
+```
+
+### Compile-time (config_db.rs:80-120)
+**Location:** `config_db.rs` function `init_defaults()`
+
+```rust
+// Add to default allowed paths
+self.set_path_rule("allowed", "/new/allowed/path")?;
+
+// Add to default blocked paths
+self.set_path_rule("blocked", "/new/blocked/path")?;
+```
+
+### Files Modified: 1
+- `src/config_db.rs`
+
+## 16.3 Adding a New Dangerous Pattern
+
+**Location:** `config_db.rs` function `init_defaults()` (line ~100)
+
+```rust
+self.set_dangerous_pattern(
+    r"your_regex_pattern",
+    8,  // severity (1-10)
+    "Description of why this is dangerous"
+)?;
+```
+
+### Files Modified: 1
+- `src/config_db.rs`
+
+## 16.4 Adding a New LMDB Database
+
+### Step 1: Create Module
+**Location:** `src/new_db.rs` (new file)
+
+```rust
+use heed::{Database, Env, EnvOpenOptions};
+use heed::types::{SerdeBincode, Str};
+use anyhow::Result;
+
+pub struct NewDb {
+    env: Env,
+    main: Database<Str, SerdeBincode<YourType>>,
+}
+
+impl NewDb {
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(10 * 1024 * 1024)  // 10MB
+                .max_dbs(4)
+                .open(path)?
+        };
+        let mut wtxn = env.write_txn()?;
+        let main = env.create_database(&mut wtxn, Some("main"))?;
+        wtxn.commit()?;
+        Ok(Self { env, main })
+    }
+}
+```
+
+### Step 2: Add to lib.rs
+```rust
+pub mod new_db;
+```
+
+### Step 3: Initialize in mcp.rs
+**Location:** `mcp.rs` function `run()` (around line 1975)
+
+```rust
+// Initialize NEW_DB LMDB
+let new_db_path = spf_base.join("storage/new_db");
+let new_db = match NewDb::open(&new_db_path) {
+    Ok(db) => Some(db),
+    Err(e) => {
+        log(&format!("Warning: Failed to open NEW_DB: {}", e));
+        None
+    }
+};
+```
+
+### Step 4: Pass to handle_tool_call()
+Update function signature and all call sites.
+
+### Files Modified: 4
+- `src/new_db.rs` (new)
+- `src/lib.rs`
+- `src/mcp.rs` (2 locations)
+
+## 16.5 Modifying the SPF Formula
+
+### Change Exponents
+**Location:** `config_db.rs` function `init_defaults()` (line ~130)
+
+```rust
+// Modify default values
+self.set("formula_deps_exp", 8)?;  // Was 7
+```
+
+### Change Calculation Logic
+**Location:** `calculate.rs` function `calculate()` (line ~80)
+
+```rust
+// Modify the formula application
+let deps_contrib = (deps as f64).powf(config.formula.deps_exp as f64) as u64;
+```
+
+### Files Modified: 1-2
+- `src/config_db.rs` (for defaults)
+- `src/calculate.rs` (for logic)
+
+---
+
+# 17. CHANGE IMPACT ANALYSIS
+
+## 17.1 Dependency Matrix
+
+| Module Changed | Impacts | Rebuild Required |
+|----------------|---------|------------------|
+| config.rs | All modules | Full |
+| calculate.rs | gate.rs, mcp.rs | Partial |
+| validate.rs | gate.rs | Partial |
+| gate.rs | mcp.rs | Partial |
+| session.rs | mcp.rs, storage.rs | Partial |
+| mcp.rs | None (leaf) | Minimal |
+| config_db.rs | main.rs, mcp.rs | Partial |
+| tools_db.rs | mcp.rs | Minimal |
+| sandbox_db.rs | mcp.rs | Minimal |
+| agent_state.rs | mcp.rs | Minimal |
+
+## 17.2 High-Risk Changes
+
+### Breaking Changes
+1. **SpfConfig struct modification**
+   - Impacts: All modules
+   - Risk: LMDB deserialization failure
+   - Mitigation: Version migration code
+
+2. **Session struct modification**
+   - Impacts: All saved sessions
+   - Risk: Session load failure
+   - Mitigation: Default values for new fields
+
+3. **MCP tool schema change**
+   - Impacts: All clients
+   - Risk: Client compatibility
+   - Mitigation: Version negotiation
+
+### Safe Changes
+1. Adding new MCP tool (additive)
+2. Adding new LMDB table (additive)
+3. Adding new validation rule (additive)
+4. Changing log messages
+
+## 17.3 Testing Requirements by Change Type
+
+| Change Type | Tests Required |
+|-------------|----------------|
+| New tool | Unit test, integration test, MCP test |
+| Formula change | Unit test, regression test |
+| Path rule | Integration test |
+| LMDB schema | Migration test, load test |
+| Security rule | Security test, penetration test |
+
+---
+
+# 18. OPERATIONAL MANUAL
+
+## 18.1 Installation
+
+### Prerequisites
+```bash
+# Rust toolchain
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# LMDB library
+pkg install lmdb
+```
+
+### Build
+```bash
+cd ~/SPFsmartGATE
+cargo build --release
+```
+
+### Configure Claude Code
+Edit `~/.claude.json`:
+```json
+{
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/target/release/spf-smart-gate",
+      "args": ["serve"],
+      "env": {}
+    }
+  }
+}
+```
+
+### Verify
+```bash
+./target/release/spf-smart-gate status
+./target/release/spf-smart-gate init-config
+```
+
+## 18.2 CLI Commands
+
+### serve
+Run MCP server (blocks forever, used by Claude Code)
+```bash
+./spf-smart-gate serve
+```
+
+### status
+Show gateway status
+```bash
+./spf-smart-gate status
+```
+Output:
+```
+SPF Smart Gateway v2.0.0
+Mode: Hard
+Storage: ~/SPFsmartGATE/storage
+Config: LMDB (spf_config/)
+
+Session: 5 reads, 2 writes, C=1234
+
+Tiers:
+  SIMPLE   < 500    | 40% analyze / 60% build
+  LIGHT    < 2000   | 60% analyze / 40% build
+  MEDIUM   < 10000  | 75% analyze / 25% build
+  CRITICAL > 10000  | 95% analyze / 5% build
+
+Formula: a_optimal(C) = 40000 × (1 - 1/ln(C + e))
+```
+
+### session
+Show full session state as JSON
+```bash
+./spf-smart-gate session
+```
+
+### reset
+Clear session state
+```bash
+./spf-smart-gate reset
+```
+
+### init-config
+Initialize/verify LMDB config
+```bash
+./spf-smart-gate init-config
+```
+
+### gate
+One-shot gate check
+```bash
+./spf-smart-gate gate Write '{"file_path":"/tmp/test.txt","content":"hello"}'
+```
+
+### calculate
+Calculate complexity without executing
+```bash
+./spf-smart-gate calculate Bash '{"command":"rm -rf /"}'
+```
+
+## 18.3 Monitoring
+
+### Logs
+```bash
+# MCP server logs to stderr
+./spf-smart-gate serve 2>&1 | tee spf.log
+```
+
+### LMDB Stats
+```bash
+# Via MCP tools
+spf_config_stats
+spf_tools_stats
+spf_sandbox_stats
+spf_agent_stats
+```
+
+### Session State
+```bash
+spf_session
+```
+
+## 18.4 Backup & Recovery
+
+### Backup LMDB
+```bash
+cp -r ~/SPFsmartGATE/storage ~/SPFsmartGATE/storage.backup
+```
+
+### Restore
+```bash
+rm -rf ~/SPFsmartGATE/storage
+cp -r ~/SPFsmartGATE/storage.backup ~/SPFsmartGATE/storage
+```
+
+### Reset to Defaults
+```bash
+rm -rf ~/SPFsmartGATE/storage
+./spf-smart-gate init-config
+```
+
+---
+
+# 19. TROUBLESHOOTING
+
+## 19.1 Common Issues
+
+### "SPF_CONFIG LMDB not initialized"
+**Cause:** LMDB database not found
+**Fix:**
+```bash
+./spf-smart-gate init-config
+```
+
+### "Build Anchor: Must read file before editing"
+**Cause:** Attempting to write/edit without reading first
+**Fix:** Use `spf_read` before `spf_write` or `spf_edit`
+
+### "Path blocked: /tmp"
+**Cause:** /tmp is blocked by default (Termux Android)
+**Fix:** Use allowed paths (~/...) or add exception via CLI
+
+### MCP tools not appearing in Claude Code
+**Cause:** MCP server not configured correctly
+**Fix:**
+1. Check `~/.claude.json` has correct path
+2. Verify binary exists and is executable
+3. Restart Claude Code
+
+### "Brain not found"
+**Cause:** stoneshell-brain binary missing
+**Fix:**
+```bash
+cd ~/stoneshell-brain
+cargo build --release
+```
+
+## 19.2 Debug Mode
+
+### Enable verbose logging
+```bash
+RUST_LOG=debug ./spf-smart-gate serve
+```
+
+### Log levels
+```
+error - Errors only
+warn  - Warnings and errors
+info  - Normal operation (default)
+debug - Detailed debugging
+trace - Everything
+```
+
+## 19.3 LMDB Corruption Recovery
+
+### Symptoms
+- "LMDB error: MDB_CORRUPTED"
+- "Transaction failed"
+- Crashes on startup
+
+### Recovery
+```bash
+# 1. Backup current state
+cp -r ~/SPFsmartGATE/storage ~/SPFsmartGATE/storage.corrupt
+
+# 2. Try LMDB recovery tool
+mdb_copy -c storage/spf_config storage/spf_config.recovered
+
+# 3. If fails, reset
+rm -rf ~/SPFsmartGATE/storage
+./spf-smart-gate init-config
+```
+
+## 19.4 Performance Issues
+
+### Slow gate processing
+- Check LMDB map size
+- Check disk space
+- Profile with `RUST_LOG=trace`
+
+### High memory usage
+- LMDB map size is virtual, not resident
+- Check for memory leaks in long sessions
+- Reset session periodically
+
+---
+
+# APPENDIX A: QUICK REFERENCE CARDS
+
+## A.1 SPF Formula
+```
+C = basic + deps^7 + complex^10 + files×10
+a_optimal = 40000 × (1 - 1/ln(C + e))
+```
+
+## A.2 Tier Thresholds
+```
+SIMPLE   C <   500   40%/60%
+LIGHT    C <  2000   60%/40%
+MEDIUM   C < 10000   75%/25%
+CRITICAL C ≥ 10000   95%/5%
+```
+
+## A.3 Key Files
+```
+main.rs       Entry, CLI
+mcp.rs        MCP server (2103 lines)
+gate.rs       Enforcement
+calculate.rs  SPF formula
+validate.rs   Rule validation
+config_db.rs  LMDB config
+session.rs    State tracking
+```
+
+## A.4 LMDB Databases
+```
+spf_config/    Configuration
+spf_tools/     Tool registry
+spf_sandbox/   Project workspaces
+agent_state/   Agent memory
+spf_fs/        Virtual filesystem
+```
+
+---
+
+**END OF DEVELOPER BIBLE**
+
+*Document Version: 1.0*
+*Last Updated: 2026-02-05*
+*Maintainer: Joseph Stone*
+*Total Pages: ~50*

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/7931b017237cdafd@v3

@@ -0,0 +1,448 @@
+// SPF Smart Gateway - Configuration LMDB
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// LMDB-backed configuration storage. Replaces config.json with persistent,
+// transactional storage. Supports hot-reload without restart.
+//
+// Database: SPF_CONFIG
+// Storage: ~/SPFsmartGATE/storage/spf_config/
+
+use anyhow::{anyhow, Result};
+use heed::types::*;
+use heed::{Database, Env, EnvOpenOptions};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// Import config types from canonical source (config.rs) - NO DUPLICATES
+use crate::config::{
+    EnforceMode, TierThreshold, TierConfig, FormulaConfig,
+    ToolWeight, ComplexityWeights, SpfConfig,
+};
+
+const MAX_DB_SIZE: usize = 10 * 1024 * 1024; // 10MB - config is small
+
+/// LMDB-backed SPF configuration storage
+pub struct SpfConfigDb {
+    env: Env,
+    /// Main config store: namespace:key → JSON value
+    config: Database<Str, Str>,
+    /// Path rules: "allowed:path" or "blocked:path" → bool
+    paths: Database<Str, SerdeBincode<bool>>,
+    /// Dangerous patterns: pattern → severity (1-10)
+    patterns: Database<Str, SerdeBincode<u8>>,
+}
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+impl SpfConfigDb {
+    /// Open or create config LMDB at given path
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(MAX_DB_SIZE)
+                .max_dbs(8)
+                .open(path)?
+        };
+
+        let mut wtxn = env.write_txn()?;
+        let config = env.create_database(&mut wtxn, Some("config"))?;
+        let paths = env.create_database(&mut wtxn, Some("paths"))?;
+        let patterns = env.create_database(&mut wtxn, Some("patterns"))?;
+        wtxn.commit()?;
+
+        log::info!("SPF Config LMDB opened at {:?}", path);
+        Ok(Self { env, config, paths, patterns })
+    }
+
+    // ========================================================================
+    // CORE CONFIG OPERATIONS
+    // ========================================================================
+
+    /// Get a config value by namespace and key
+    pub fn get(&self, namespace: &str, key: &str) -> Result<Option<String>> {
+        let full_key = format!("{}:{}", namespace, key);
+        let rtxn = self.env.read_txn()?;
+        Ok(self.config.get(&rtxn, &full_key)?.map(|s| s.to_string()))
+    }
+
+    /// Set a config value
+    pub fn set(&self, namespace: &str, key: &str, value: &str) -> Result<()> {
+        let full_key = format!("{}:{}", namespace, key);
+        let mut wtxn = self.env.write_txn()?;
+        self.config.put(&mut wtxn, &full_key, value)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Get typed config value (deserialize from JSON)
+    pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, namespace: &str, key: &str) -> Result<Option<T>> {
+        match self.get(namespace, key)? {
+            Some(json) => Ok(Some(serde_json::from_str(&json)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Set typed config value (serialize to JSON)
+    pub fn set_typed<T: Serialize>(&self, namespace: &str, key: &str, value: &T) -> Result<()> {
+        let json = serde_json::to_string(value)?;
+        self.set(namespace, key, &json)
+    }
+
+    // ========================================================================
+    // PATH RULES
+    // ========================================================================
+
+    /// Add an allowed path
+    pub fn allow_path(&self, path: &str) -> Result<()> {
+        let key = format!("allowed:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Add a blocked path
+    pub fn block_path(&self, path: &str) -> Result<()> {
+        let key = format!("blocked:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Remove a path rule
+    pub fn remove_path_rule(&self, rule_type: &str, path: &str) -> Result<bool> {
+        let key = format!("{}:{}", rule_type, path);
+        let mut wtxn = self.env.write_txn()?;
+        let deleted = self.paths.delete(&mut wtxn, &key)?;
+        wtxn.commit()?;
+        Ok(deleted)
+    }
+
+    /// Check if path is allowed (matches any allowed prefix)
+    pub fn is_path_allowed(&self, path: &str) -> Result<bool> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("allowed:") {
+                let allowed_path = &key[8..]; // Skip "allowed:"
+                if path.starts_with(allowed_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Check if path is blocked (matches any blocked prefix)
+    pub fn is_path_blocked(&self, path: &str) -> Result<bool> {
+        // Canonicalize to prevent traversal bypass
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("blocked:") {
+                let blocked_path = &key[8..]; // Skip "blocked:"
+                if canonical.starts_with(blocked_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// List all path rules
+    pub fn list_path_rules(&self) -> Result<Vec<(String, String)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        let mut rules = Vec::new();
+        for result in iter {
+            let (key, _) = result?;
+            if let Some((rule_type, path)) = key.split_once(':') {
+                rules.push((rule_type.to_string(), path.to_string()));
+            }
+        }
+        Ok(rules)
+    }
+
+    // ========================================================================
+    // DANGEROUS PATTERNS
+    // ========================================================================
+
+    /// Add a dangerous pattern with severity (1-10)
+    pub fn add_dangerous_pattern(&self, pattern: &str, severity: u8) -> Result<()> {
+        let mut wtxn = self.env.write_txn()?;
+        self.patterns.put(&mut wtxn, pattern, &severity.min(10))?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Check if command matches any dangerous pattern, returns severity
+    pub fn check_dangerous(&self, command: &str) -> Result<Option<u8>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut max_severity: Option<u8> = None;
+        for result in iter {
+            let (pattern, severity) = result?;
+            if command.contains(pattern) {
+                max_severity = Some(max_severity.map_or(severity, |s| s.max(severity)));
+            }
+        }
+        Ok(max_severity)
+    }
+
+    /// List all dangerous patterns
+    pub fn list_dangerous_patterns(&self) -> Result<Vec<(String, u8)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut patterns = Vec::new();
+        for result in iter {
+            let (pattern, severity) = result?;
+            patterns.push((pattern.to_string(), severity));
+        }
+        Ok(patterns)
+    }
+
+    // ========================================================================
+    // TIER CONFIG
+    // ========================================================================
+
+    /// Get tier config
+    pub fn get_tiers(&self) -> Result<TierConfig> {
+        self.get_typed::<TierConfig>("spf", "tiers")?
+            .ok_or_else(|| anyhow!("Tier config not found"))
+    }
+
+    /// Set tier config
+    pub fn set_tiers(&self, tiers: &TierConfig) -> Result<()> {
+        self.set_typed("spf", "tiers", tiers)
+    }
+
+    /// Get tier for complexity value
+    pub fn get_tier_for_c(&self, c: u64) -> Result<(&'static str, u8, u8, bool)> {
+        let tiers = self.get_tiers()?;
+
+        // HARDCODE: ALL tiers require approval. No exceptions.
+        if c < tiers.simple.max_c {
+            Ok(("SIMPLE", tiers.simple.analyze_percent, tiers.simple.build_percent, true))
+        } else if c < tiers.light.max_c {
+            Ok(("LIGHT", tiers.light.analyze_percent, tiers.light.build_percent, true))
+        } else if c < tiers.medium.max_c {
+            Ok(("MEDIUM", tiers.medium.analyze_percent, tiers.medium.build_percent, true))
+        } else {
+            Ok(("CRITICAL", tiers.critical.analyze_percent, tiers.critical.build_percent, true))
+        }
+    }
+
+    // ========================================================================
+    // FORMULA CONFIG
+    // ========================================================================
+
+    /// Get formula config
+    pub fn get_formula(&self) -> Result<FormulaConfig> {
+        self.get_typed::<FormulaConfig>("spf", "formula")?
+            .ok_or_else(|| anyhow!("Formula config not found"))
+    }
+
+    /// Set formula config
+    pub fn set_formula(&self, formula: &FormulaConfig) -> Result<()> {
+        self.set_typed("spf", "formula", formula)
+    }
+
+    // ========================================================================
+    // COMPLEXITY WEIGHTS
+    // ========================================================================
+
+    /// Get complexity weights
+    pub fn get_weights(&self) -> Result<ComplexityWeights> {
+        self.get_typed::<ComplexityWeights>("spf", "weights")?
+            .ok_or_else(|| anyhow!("Complexity weights not found"))
+    }
+
+    /// Set complexity weights
+    pub fn set_weights(&self, weights: &ComplexityWeights) -> Result<()> {
+        self.set_typed("spf", "weights", weights)
+    }
+
+    /// Get weight for a specific tool
+    pub fn get_tool_weight(&self, tool: &str) -> Result<ToolWeight> {
+        let weights = self.get_weights()?;
+        Ok(match tool.to_lowercase().as_str() {
+            "edit" => weights.edit,
+            "write" => weights.write,
+            "bash_dangerous" => weights.bash_dangerous,
+            "bash_git" => weights.bash_git,
+            "bash_piped" => weights.bash_piped,
+            "bash_simple" | "bash" => weights.bash_simple,
+            "read" => weights.read,
+            "search" | "glob" | "grep" => weights.search,
+            _ => weights.unknown,
+        })
+    }
+
+    // ========================================================================
+    // ENFORCE MODE
+    // ========================================================================
+
+    /// Get enforce mode
+    pub fn get_enforce_mode(&self) -> Result<EnforceMode> {
+        self.get_typed::<EnforceMode>("spf", "enforce_mode")?
+            .ok_or_else(|| anyhow!("Enforce mode not found"))
+    }
+
+    /// Set enforce mode
+    pub fn set_enforce_mode(&self, mode: &EnforceMode) -> Result<()> {
+        self.set_typed("spf", "enforce_mode", mode)
+    }
+
+    // ========================================================================
+    // MIGRATION
+    // ========================================================================
+
+    /// Initialize with defaults (call once on first run)
+    pub fn init_defaults(&self) -> Result<()> {
+        // Only init if not already initialized
+        if self.get("spf", "version")?.is_some() {
+            return Ok(());
+        }
+
+        self.set("spf", "version", "1.0.0")?;
+        self.set_enforce_mode(&EnforceMode::Hard)?;
+        self.set("spf", "require_read_before_edit", "true")?;
+        self.set("spf", "max_write_size", "100000")?;
+
+        // Default tiers
+        self.set_tiers(&TierConfig {
+            simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: true },
+            light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: true },
+            medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: true },
+            critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+        })?;
+
+        // Default formula
+        self.set_formula(&FormulaConfig {
+            w_eff: 40000.0,
+            e: std::f64::consts::E,
+            basic_power: 1,
+            deps_power: 7,
+            complex_power: 10,
+            files_multiplier: 10,
+        })?;
+
+        // Default weights
+        self.set_weights(&ComplexityWeights {
+            edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+            write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+            bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+            bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+            bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+            read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+            search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+            unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+        })?;
+
+        // Default allowed paths
+        self.allow_path("/storage/emulated/0/Download/api-workspace/")?;
+        self.allow_path("/data/data/com.termux/files/home/")?;
+
+        // Default blocked paths
+        self.block_path("/tmp")?;
+        self.block_path("/etc")?;
+        self.block_path("/usr")?;
+        self.block_path("/system")?;
+        self.block_path("/data/data/com.termux/files/usr")?;
+
+        // Default dangerous patterns
+        self.add_dangerous_pattern("rm -rf /", 10)?;
+        self.add_dangerous_pattern("rm -rf ~", 10)?;
+        self.add_dangerous_pattern("dd if=", 9)?;
+        self.add_dangerous_pattern("> /dev/", 9)?;
+        self.add_dangerous_pattern("chmod 777", 7)?;
+        self.add_dangerous_pattern("curl | sh", 8)?;
+        self.add_dangerous_pattern("wget | sh", 8)?;
+        self.add_dangerous_pattern("curl|sh", 8)?;
+        self.add_dangerous_pattern("wget|sh", 8)?;
+
+        log::info!("SPF Config LMDB initialized with defaults");
+        Ok(())
+    }
+
+    /// Get database stats
+    pub fn stats(&self) -> Result<(u64, u64, u64)> {
+        let rtxn = self.env.read_txn()?;
+        let config_stat = self.config.stat(&rtxn)?;
+        let paths_stat = self.paths.stat(&rtxn)?;
+        let patterns_stat = self.patterns.stat(&rtxn)?;
+        Ok((config_stat.entries as u64, paths_stat.entries as u64, patterns_stat.entries as u64))
+    }
+
+    // ========================================================================
+    // FULL CONFIG ASSEMBLY (for main.rs - single source of truth)
+    // ========================================================================
+
+    /// Load full SpfConfig from LMDB. Auto-initializes if empty.
+    /// This is the PRIMARY config loading method - replaces JSON file loading.
+    pub fn load_full_config(&self) -> Result<SpfConfig> {
+        // Ensure defaults exist
+        self.init_defaults()?;
+
+        // Collect path rules
+        let path_rules = self.list_path_rules()?;
+        let mut allowed_paths = Vec::new();
+        let mut blocked_paths = Vec::new();
+        for (rule_type, path) in path_rules {
+            match rule_type.as_str() {
+                "allowed" => allowed_paths.push(path),
+                "blocked" => blocked_paths.push(path),
+                _ => {}
+            }
+        }
+
+        // Collect dangerous commands
+        let dangerous_commands: Vec<String> = self.list_dangerous_patterns()?
+            .into_iter()
+            .map(|(pattern, _)| pattern)
+            .collect();
+
+        // Get scalar values
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+        let require_read = self.get("spf", "require_read_before_edit")?
+            .map(|s| s == "true").unwrap_or(true);
+        let max_write = self.get("spf", "max_write_size")?
+            .and_then(|s| s.parse().ok()).unwrap_or(100_000);
+
+        // Assemble config (types are now identical - no conversion needed)
+        Ok(SpfConfig {
+            version,
+            enforce_mode: self.get_enforce_mode()?,
+            allowed_paths,
+            blocked_paths,
+            require_read_before_edit: require_read,
+            max_write_size: max_write,
+            tiers: self.get_tiers()?,
+            formula: self.get_formula()?,
+            complexity_weights: self.get_weights()?,
+            dangerous_commands,
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        })
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/9c462d52bfadf61c@v1

@@ -0,0 +1,2104 @@
+// SPF Smart Gateway - MCP Server (JSON-RPC 2.0 over stdio)
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// ALL tool calls route through this gateway.
+// Exposes: spf_gate, spf_read, spf_write, spf_edit, spf_bash, spf_status,
+//          spf_calculate, spf_session, spf_brain_search, spf_brain_store
+
+use crate::calculate::{self, ToolParams};
+use crate::config::SpfConfig;
+use crate::config_db::SpfConfigDb;
+use crate::tools_db::SpfToolsDb;
+use crate::sandbox_db::SpfSandboxDb;
+use crate::agent_state::AgentStateDb;
+use crate::gate;
+use crate::session::Session;
+use crate::storage::SpfStorage;
+use crate::web::WebClient;
+use serde_json::{json, Value};
+use std::io::{self, BufRead, Write};
+use std::process::Command;
+use std::path::PathBuf;
+use chrono::{DateTime, Utc};
+
+const PROTOCOL_VERSION: &str = "2024-11-05";
+
+/// Format Unix timestamp as human-readable ISO8601
+fn format_timestamp(ts: u64) -> String {
+    if ts == 0 {
+        return "Never".to_string();
+    }
+    DateTime::<Utc>::from_timestamp(ts as i64, 0)
+        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
+        .unwrap_or_else(|| ts.to_string())
+}
+const SERVER_NAME: &str = "spf-smart-gate";
+const SERVER_VERSION: &str = "1.0.0";
+
+/// Brain binary path
+fn brain_path() -> PathBuf {
+    dirs_home().join("stoneshell-brain/target/release/brain")
+}
+
+fn dirs_home() -> PathBuf {
+    PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/data/data/com.termux/files/home".to_string()))
+}
+
+/// Run brain CLI command
+fn run_brain(args: &[&str]) -> (bool, String) {
+    let brain = brain_path();
+    if !brain.exists() {
+        return (false, format!("Brain not found: {:?}", brain));
+    }
+    match Command::new(&brain)
+        .args(args)
+        .current_dir(brain.parent().unwrap().parent().unwrap())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                (false, String::from_utf8_lossy(&output.stderr).to_string())
+            }
+        }
+        Err(e) => (false, format!("Failed to run brain: {}", e)),
+    }
+}
+
+/// RAG Collector script path
+fn rag_collector_path() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR/server.py")
+}
+
+/// RAG Collector working directory
+fn rag_collector_dir() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR")
+}
+
+/// Run RAG Collector command
+fn run_rag(args: &[&str]) -> (bool, String) {
+    let rag = rag_collector_path();
+    if !rag.exists() {
+        return (false, format!("RAG Collector not found: {:?}", rag));
+    }
+    match Command::new("python3")
+        .arg("-u")
+        .arg(&rag)
+        .args(args)
+        .current_dir(rag_collector_dir())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                (false, format!("{}\n{}", stdout, stderr))
+            }
+        }
+        Err(e) => (false, format!("Failed to run RAG Collector: {}", e)),
+    }
+}
+
+/// Log to stderr (stdout is JSON-RPC)
+fn log(msg: &str) {
+    eprintln!("[spf-smart-gate] {}", msg);
+}
+
+/// Send JSON-RPC response
+fn send_response(id: &Value, result: Value) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "result": result,
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// Send JSON-RPC error response
+fn send_error(id: &Value, code: i64, message: &str) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "error": { "code": code, "message": message },
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// MCP tool definition helper
+fn tool_def(name: &str, description: &str, properties: Value, required: Vec<&str>) -> Value {
+    json!({
+        "name": name,
+        "description": description,
+        "inputSchema": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        }
+    })
+}
+
+/// Return all tool definitions
+fn tool_definitions() -> Vec<Value> {
+    vec![
+        // ====== CORE GATE TOOLS ======
+        tool_def(
+            "spf_gate",
+            "Run a tool call through SPF enforcement gate. Returns allow/block decision with complexity analysis.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name (Read, Write, Edit, Bash)"},
+                "params": {"type": "object", "description": "Tool parameters (file_path, content, command, etc.)"},
+                "approved": {"type": "boolean", "description": "User approval for CRITICAL tier (default: false)", "default": true}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_calculate",
+            "Calculate complexity score for a tool call without executing. Returns C value, tier, and allocation.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name"},
+                "params": {"type": "object", "description": "Tool parameters"}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_status",
+            "Get current SPF gateway status: session metrics, enforcement mode, complexity budget.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_session",
+            "Get full session state: files read/written, action history, anchor ratio, complexity history.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== GATED FILE OPERATIONS ======
+        tool_def(
+            "spf_read",
+            "Read a file through SPF gateway. Tracks read for Build Anchor Protocol.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "limit": {"type": "integer", "description": "Max lines to read (optional)"},
+                "offset": {"type": "integer", "description": "Line offset to start from (optional)"},
+                "approved": {"type": "boolean", "description": "User approval for gated read", "default": false}
+            }),
+            vec!["file_path"],
+        ),
+        tool_def(
+            "spf_write",
+            "Write a file through SPF gateway. Validates: Build Anchor, blocked paths, file size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "content": {"type": "string", "description": "File content to write"},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": true}
+            }),
+            vec!["file_path", "content"],
+        ),
+        tool_def(
+            "spf_edit",
+            "Edit a file through SPF gateway. Validates: Build Anchor, blocked paths, change size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "old_string": {"type": "string", "description": "Text to replace"},
+                "new_string": {"type": "string", "description": "Replacement text"},
+                "replace_all": {"type": "boolean", "description": "Replace all occurrences", "default": false},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": true}
+            }),
+            vec!["file_path", "old_string", "new_string"],
+        ),
+        tool_def(
+            "spf_bash",
+            "Execute a bash command through SPF gateway. Validates: dangerous commands, /tmp access, git force.",
+            json!({
+                "command": {"type": "string", "description": "Bash command to execute"},
+                "timeout": {"type": "integer", "description": "Timeout in seconds (default: 30)", "default": 30},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": false}
+            }),
+            vec!["command"],
+        ),
+
+        // ====== SEARCH/GLOB TOOLS ======
+        tool_def(
+            "spf_glob",
+            "Fast file pattern matching. Supports glob patterns like **/*.rs or src/**/*.ts.",
+            json!({
+                "pattern": {"type": "string", "description": "Glob pattern to match files"},
+                "path": {"type": "string", "description": "Directory to search in (default: current dir)"}
+            }),
+            vec!["pattern"],
+        ),
+        tool_def(
+            "spf_grep",
+            "Search file contents using regex. Built on ripgrep.",
+            json!({
+                "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                "path": {"type": "string", "description": "File or directory to search"},
+                "glob": {"type": "string", "description": "Glob filter (e.g. *.rs)"},
+                "case_insensitive": {"type": "boolean", "description": "Case insensitive search", "default": true},
+                "context_lines": {"type": "integer", "description": "Lines of context around matches", "default": 0}
+            }),
+            vec!["pattern"],
+        ),
+
+        // ====== WEB BROWSER TOOLS ======
+        tool_def(
+            "spf_web_search",
+            "Search the web for information. Uses Brave API if BRAVE_API_KEY set, otherwise DuckDuckGo.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "count": {"type": "integer", "description": "Max results (default: 10)", "default": 10}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_web_fetch",
+            "Fetch a URL and return clean readable text. HTML is converted to plain text, JSON is pretty-printed.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "prompt": {"type": "string", "description": "Prompt to run on fetched content"}
+            }),
+            vec!["url", "prompt"],
+        ),
+        tool_def(
+            "spf_web_download",
+            "Download a file from URL and save to disk.",
+            json!({
+                "url": {"type": "string", "description": "URL to download"},
+                "save_path": {"type": "string", "description": "Local path to save file"}
+            }),
+            vec!["url", "save_path"],
+        ),
+        tool_def(
+            "spf_web_api",
+            "Make an API request. Returns status, headers, and response body.",
+            json!({
+                "method": {"type": "string", "description": "HTTP method (GET, POST, PUT, DELETE, PATCH)"},
+                "url": {"type": "string", "description": "API endpoint URL"},
+                "headers": {"type": "string", "description": "JSON object of headers (optional)", "default": ""},
+                "body": {"type": "string", "description": "Request body JSON (optional)", "default": ""}
+            }),
+            vec!["method", "url"],
+        ),
+
+        // ====== NOTEBOOK TOOL ======
+        tool_def(
+            "spf_notebook_edit",
+            "Edit a Jupyter notebook cell.",
+            json!({
+                "notebook_path": {"type": "string", "description": "Absolute path to .ipynb file"},
+                "cell_number": {"type": "integer", "description": "Cell index (0-based)"},
+                "new_source": {"type": "string", "description": "New cell content"},
+                "cell_type": {"type": "string", "description": "Cell type: code or markdown"},
+                "edit_mode": {"type": "string", "description": "Mode: replace, insert, or delete", "default": "replace"}
+            }),
+            vec!["notebook_path", "new_source"],
+        ),
+
+        // ====== BRAIN PASSTHROUGH ======
+        tool_def(
+            "spf_brain_search",
+            "Search brain through SPF gateway. All brain access is logged and tracked.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection (default: default)", "default": "default"},
+                "limit": {"type": "integer", "description": "Max results (default: 5)", "default": 5}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_store",
+            "Store document in brain through SPF gateway.",
+            json!({
+                "text": {"type": "string", "description": "Text to store"},
+                "title": {"type": "string", "description": "Document title", "default": "untitled"},
+                "collection": {"type": "string", "description": "Collection", "default": "default"},
+                "tags": {"type": "string", "description": "Comma-separated tags", "default": ""}
+            }),
+            vec!["text"],
+        ),
+
+        // ====== ADDITIONAL BRAIN TOOLS ======
+        tool_def(
+            "spf_brain_context",
+            "Get relevant context for a query. Returns formatted context for prompt injection.",
+            json!({
+                "query": {"type": "string", "description": "Query to get context for"},
+                "max_tokens": {"type": "integer", "description": "Max tokens (default: 2000)", "default": 2000}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_index",
+            "Index a file or directory into the brain.",
+            json!({
+                "path": {"type": "string", "description": "File or directory to index"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_brain_list",
+            "List all indexed collections and document counts.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_status",
+            "Get brain system status.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_recall",
+            "Search and return full parent documents. Searches vectors then resolves to complete stored document.",
+            json!({
+                "query": {"type": "string", "description": "Natural language search query"},
+                "collection": {"type": "string", "description": "Collection to search (default: default)", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_list_docs",
+            "List all stored documents in a collection.",
+            json!({
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_get_doc",
+            "Retrieve a specific document by its ID.",
+            json!({
+                "doc_id": {"type": "string", "description": "Document ID to retrieve"},
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec!["doc_id"],
+        ),
+
+        // ====== RAG COLLECTOR TOOLS ======
+        tool_def(
+            "spf_rag_collect_web",
+            "Search web and collect documents. Optional topic filter.",
+            json!({
+                "topic": {"type": "string", "description": "Topic to search (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected docs", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_collect_file",
+            "Process a local file.",
+            json!({
+                "path": {"type": "string", "description": "File path"},
+                "category": {"type": "string", "description": "Category (default: auto)", "default": "auto"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_folder",
+            "Process all files in a folder.",
+            json!({
+                "path": {"type": "string", "description": "Folder path"},
+                "extensions": {"type": "array", "items": {"type": "string"}, "description": "File extensions to include"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_drop",
+            "Process files in DROP_HERE folder.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_index_gathered",
+            "Index all documents in GATHERED to brain.",
+            json!({
+                "category": {"type": "string", "description": "Category to index (optional)"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_dedupe",
+            "Deduplicate brain collection.",
+            json!({
+                "category": {"type": "string", "description": "Category to dedupe"}
+            }),
+            vec!["category"],
+        ),
+        tool_def(
+            "spf_rag_status",
+            "Get collector status and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_gathered",
+            "List documents in GATHERED folder.",
+            json!({
+                "category": {"type": "string", "description": "Filter by category"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_bandwidth_status",
+            "Get bandwidth usage stats and limits.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fetch_url",
+            "Fetch a single URL with bandwidth limiting.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "auto_index": {"type": "boolean", "description": "Auto-index after fetch", "default": true}
+            }),
+            vec!["url"],
+        ),
+        tool_def(
+            "spf_rag_collect_rss",
+            "Collect from RSS/Atom feeds.",
+            json!({
+                "feed_name": {"type": "string", "description": "Specific feed name (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_feeds",
+            "List configured RSS feeds.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_pending_searches",
+            "Get pending SearchSeeker vectors from brain (gaps needing fetch).",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fulfill_search",
+            "Mark a SearchSeeker as fulfilled after RAG fetch.",
+            json!({
+                "seeker_id": {"type": "string", "description": "SearchSeeker ID to fulfill"},
+                "collection": {"type": "string", "description": "Collection name", "default": "default"}
+            }),
+            vec!["seeker_id"],
+        ),
+        tool_def(
+            "spf_rag_smart_search",
+            "Run smart search with completeness check - triggers SearchSeeker if <80%.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection to search", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_rag_auto_fetch_gaps",
+            "Automatically fetch data for all pending SearchSeekers.",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"},
+                "max_fetches": {"type": "integer", "description": "Max URLs to fetch", "default": 5}
+            }),
+            vec![],
+        ),
+
+        // ====== SPF_CONFIG TOOLS ======
+        // NOTE: spf_config_get and spf_config_set removed from MCP - user-only via CLI
+        tool_def(
+            "spf_config_paths",
+            "List all path rules (allowed/blocked) from SPF_CONFIG LMDB.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_config_stats",
+            "Get SPF_CONFIG LMDB statistics.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== SPF_TOOLS TOOLS ======
+        tool_def(
+            "spf_tools_list",
+            "List all registered tools with permissions and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_stats",
+            "Get SPF_TOOLS LMDB statistics (tool count, history count, alias count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_get",
+            "Get info for a specific tool by name.",
+            json!({
+                "name": {"type": "string", "description": "Tool name to look up"}
+            }),
+            vec!["name"],
+        ),
+
+        // ====== SPF_SANDBOX TOOLS ======
+        tool_def(
+            "spf_sandbox_list",
+            "List all registered project sandboxes with trust levels.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_stats",
+            "Get SPF_SANDBOX LMDB statistics (project count, access log count, resource count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_get",
+            "Get sandbox info for a specific project by path.",
+            json!({
+                "path": {"type": "string", "description": "Project path to look up"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_sandbox_active",
+            "Get the currently active project sandbox.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== AGENT_STATE TOOLS ======
+        tool_def(
+            "spf_agent_stats",
+            "Get AGENT_STATE LMDB statistics (memory count, sessions, state keys, tags).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_memory_search",
+            "Search agent memories by content.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "limit": {"type": "integer", "description": "Max results (default: 10)"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_agent_memory_by_tag",
+            "Get agent memories by tag.",
+            json!({
+                "tag": {"type": "string", "description": "Tag to filter by"}
+            }),
+            vec!["tag"],
+        ),
+        tool_def(
+            "spf_agent_session_info",
+            "Get the most recent session info.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_context",
+            "Get context summary for session continuity.",
+            json!({}),
+            vec![],
+        ),
+    ]
+}
+
+/// Handle a tool call
+fn handle_tool_call(
+    name: &str,
+    args: &Value,
+    config: &SpfConfig,
+    session: &mut Session,
+    storage: &SpfStorage,
+    config_db: &Option<SpfConfigDb>,
+    tools_db: &Option<SpfToolsDb>,
+    sandbox_db: &Option<SpfSandboxDb>,
+    agent_db: &Option<AgentStateDb>,
+) -> Value {
+    match name {
+        // ====== spf_gate ======
+        "spf_gate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let decision = gate::process(tool, &params, config, session, approved);
+            session.record_complexity(tool, decision.complexity.c, &decision.complexity.tier);
+            session.record_manifest(
+                tool, decision.complexity.c,
+                if decision.allowed { "ALLOWED" } else { "BLOCKED" },
+                decision.errors.first().map(|s| s.as_str()),
+            );
+            let _ = storage.save_session(session);
+
+            json!({"type": "text", "text": serde_json::to_string_pretty(&decision).unwrap()})
+        }
+
+        // ====== spf_calculate ======
+        "spf_calculate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let result = calculate::calculate(tool, &params, config);
+            json!({"type": "text", "text": serde_json::to_string_pretty(&result).unwrap()})
+        }
+
+        // ====== spf_status ======
+        "spf_status" => {
+            let status = format!(
+                "SPF Gateway v{}\nMode: {:?}\nSession: {}\nTiers: SIMPLE(<500) LIGHT(<2000) MEDIUM(<10000) CRITICAL(>10000)\nFormula: a_optimal(C) = {} × (1 - 1/ln(C + e))",
+                SERVER_VERSION,
+                config.enforce_mode,
+                session.status_summary(),
+                config.formula.w_eff,
+            );
+            json!({"type": "text", "text": status})
+        }
+
+        // ====== spf_session ======
+        "spf_session" => {
+            json!({"type": "text", "text": serde_json::to_string_pretty(session).unwrap()})
+        }
+
+        // ====== spf_read ======
+        "spf_read" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Read", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("Read", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute read
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    session.track_read(file_path);
+                    session.record_action("Read", "success", Some(file_path));
+                    let _ = storage.save_session(session);
+
+                    // Apply limit/offset if specified
+                    let offset = args.get("offset").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+                    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+
+                    let lines: Vec<&str> = content.lines().collect();
+                    let total = lines.len();
+                    let start = offset.min(total);
+                    let end = if limit > 0 { (start + limit).min(total) } else { total };
+
+                    let numbered: String = lines[start..end]
+                        .iter()
+                        .enumerate()
+                        .map(|(i, line)| format!("{:>6}\t{}", start + i + 1, line))
+                        .collect::<Vec<_>>()
+                        .join("\n");
+
+                    json!({"type": "text", "text": format!("File: {} ({} lines)\n{}", file_path, total, numbered)})
+                }
+                Err(e) => {
+                    session.record_action("Read", "failed", Some(file_path));
+                    session.record_failure("Read", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_write ======
+        "spf_write" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let content = args["content"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                content: Some(content.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Write", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Write", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute write
+            // Ensure parent directory exists
+            if let Some(parent) = std::path::Path::new(file_path).parent() {
+                let _ = std::fs::create_dir_all(parent);
+            }
+
+            match std::fs::write(file_path, content) {
+                Ok(()) => {
+                    session.track_write(file_path);
+                    session.record_action("Write", "success", Some(file_path));
+                    session.record_manifest("Write", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!(
+                        "Written: {} ({} bytes) | C={} {}",
+                        file_path, content.len(), decision.complexity.c, decision.complexity.tier
+                    )})
+                }
+                Err(e) => {
+                    session.record_action("Write", "failed", Some(file_path));
+                    session.record_failure("Write", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Write failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_edit ======
+        "spf_edit" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let old_string = args["old_string"].as_str().unwrap_or("");
+            let new_string = args["new_string"].as_str().unwrap_or("");
+            let replace_all = args["replace_all"].as_bool().unwrap_or(false);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                old_string: Some(old_string.to_string()),
+                new_string: Some(new_string.to_string()),
+                replace_all: Some(replace_all),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Edit", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Edit", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute edit
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    let new_content = if replace_all {
+                        content.replace(old_string, new_string)
+                    } else {
+                        content.replacen(old_string, new_string, 1)
+                    };
+
+                    if new_content == content {
+                        json!({"type": "text", "text": format!("Edit: old_string not found in {}", file_path)})
+                    } else {
+                        match std::fs::write(file_path, &new_content) {
+                            Ok(()) => {
+                                session.track_write(file_path);
+                                session.record_action("Edit", "success", Some(file_path));
+                                session.record_manifest("Edit", decision.complexity.c, "ALLOWED", None);
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!(
+                                    "Edited: {} | C={} {}",
+                                    file_path, decision.complexity.c, decision.complexity.tier
+                                )})
+                            }
+                            Err(e) => {
+                                session.record_failure("Edit", &e.to_string());
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!("Edit write failed: {}", e)})
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Edit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Edit read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_bash ======
+        "spf_bash" => {
+            let command = args["command"].as_str().unwrap_or("");
+            let _timeout = args["timeout"].as_u64().unwrap_or(30);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                command: Some(command.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Bash", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Bash", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute bash
+            match Command::new("bash")
+                .arg("-c")
+                .arg(command)
+                .output()
+            {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                    let success = output.status.success();
+
+                    session.record_action("Bash", if success { "success" } else { "failed" }, None);
+                    if !success {
+                        session.record_failure("Bash", &stderr);
+                    }
+                    session.record_manifest("Bash", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+
+                    let mut result = String::new();
+                    if !stdout.is_empty() {
+                        result.push_str(&stdout);
+                    }
+                    if !stderr.is_empty() {
+                        result.push_str("\nSTDERR: ");
+                        result.push_str(&stderr);
+                    }
+                    if result.is_empty() {
+                        result = format!("Exit code: {}", output.status.code().unwrap_or(-1));
+                    }
+
+                    json!({"type": "text", "text": result})
+                }
+                Err(e) => {
+                    session.record_failure("Bash", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Bash failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_glob ======
+        "spf_glob" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            session.record_action("Glob", "called", None);
+
+            // Use find with glob pattern (simpler than pulling in glob crate)
+            let cmd = format!("find {} -name '{}' 2>/dev/null | head -100", path, pattern);
+            match Command::new("bash").arg("-c").arg(&cmd).output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    let _ = storage.save_session(session);
+                    if stdout.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": stdout})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Glob", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Glob failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_grep ======
+        "spf_grep" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            let glob_filter = args["glob"].as_str().unwrap_or("");
+            let case_insensitive = args["case_insensitive"].as_bool().unwrap_or(false);
+            let context = args["context_lines"].as_u64().unwrap_or(0);
+            session.record_action("Grep", "called", None);
+
+            let mut cmd = String::from("rg");
+            if case_insensitive {
+                cmd.push_str(" -i");
+            }
+            if context > 0 {
+                cmd.push_str(&format!(" -C {}", context));
+            }
+            if !glob_filter.is_empty() {
+                cmd.push_str(&format!(" --glob '{}'", glob_filter));
+            }
+            cmd.push_str(&format!(" '{}' {} 2>/dev/null | head -500", pattern, path));
+
+            match Command::new("bash").arg("-c").arg(&cmd).output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    let _ = storage.save_session(session);
+                    if stdout.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": stdout})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Grep", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Grep failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_fetch ======
+        "spf_web_fetch" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let prompt = args["prompt"].as_str().unwrap_or("Summarize this content");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(prompt.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_fetch", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_fetch", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebFetch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.read_page(url) {
+                        Ok((text, raw_len, content_type)) => {
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if text.len() > 50000 { &text[..50000] } else { &text };
+                            json!({"type": "text", "text": format!(
+                                "Fetched {} ({} bytes, {})\nPrompt: {}\n\n{}",
+                                url, raw_len, content_type, prompt, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebFetch", &e);
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebFetch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebFetch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_search ======
+        "spf_web_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let count = args["count"].as_u64().unwrap_or(10) as u32;
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                query: Some(query.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_search", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_search", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebSearch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.search(query, count) {
+                        Ok((engine, results)) => {
+                            let mut output = format!("Search '{}' via {} ({} results):\n\n", query, engine, results.len());
+                            for (i, r) in results.iter().enumerate() {
+                                output.push_str(&format!("{}. {}\n   {}\n   {}\n\n", i + 1, r.title, r.url, r.description));
+                            }
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": output})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebSearch", &e);
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebSearch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebSearch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_download ======
+        "spf_web_download" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let save_path = args["save_path"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                file_path: Some(save_path.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_download", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_download", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebDownload", "called", Some(save_path));
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.download(url, save_path) {
+                        Ok((size, content_type)) => {
+                            session.track_write(save_path);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!(
+                                "Downloaded {} → {} ({} bytes, {})",
+                                url, save_path, size, content_type
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebDownload", &e);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("Download failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebDownload", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_api ======
+        "spf_web_api" => {
+            let method = args["method"].as_str().unwrap_or("GET");
+            let url = args["url"].as_str().unwrap_or("");
+            let headers = args["headers"].as_str().unwrap_or("");
+            let body = args["body"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(method.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_api", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_api", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebAPI", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.api_request(method, url, headers, body) {
+                        Ok((status, resp_headers, resp_body)) => {
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if resp_body.len() > 50000 { &resp_body[..50000] } else { &resp_body };
+                            json!({"type": "text", "text": format!(
+                                "API {} {} → HTTP {}\n\nHeaders:\n{}\n\nBody:\n{}",
+                                method, url, status, resp_headers, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebAPI", &e);
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("API request failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebAPI", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_notebook_edit ======
+        "spf_notebook_edit" => {
+            let notebook_path = args["notebook_path"].as_str().unwrap_or("");
+            let new_source = args["new_source"].as_str().unwrap_or("");
+            let cell_number = args["cell_number"].as_u64().unwrap_or(0) as usize;
+            let cell_type = args["cell_type"].as_str().unwrap_or("code");
+            let edit_mode = args["edit_mode"].as_str().unwrap_or("replace");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                file_path: Some(notebook_path.to_string()),
+                content: Some(new_source.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("NotebookEdit", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("NotebookEdit", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("NotebookEdit", "called", Some(notebook_path));
+
+            // Read notebook JSON
+            match std::fs::read_to_string(notebook_path) {
+                Ok(content) => {
+                    match serde_json::from_str::<Value>(&content) {
+                        Ok(mut notebook) => {
+                            if let Some(cells) = notebook.get_mut("cells").and_then(|c| c.as_array_mut()) {
+                                match edit_mode {
+                                    "replace" => {
+                                        if cell_number < cells.len() {
+                                            cells[cell_number]["source"] = json!([new_source]);
+                                            cells[cell_number]["cell_type"] = json!(cell_type);
+                                        } else {
+                                            return json!({"type": "text", "text": format!("Cell {} not found", cell_number)});
+                                        }
+                                    }
+                                    "insert" => {
+                                        let new_cell = json!({
+                                            "cell_type": cell_type,
+                                            "source": [new_source],
+                                            "metadata": {},
+                                            "outputs": []
+                                        });
+                                        cells.insert(cell_number, new_cell);
+                                    }
+                                    "delete" => {
+                                        if cell_number < cells.len() {
+                                            cells.remove(cell_number);
+                                        }
+                                    }
+                                    _ => return json!({"type": "text", "text": "Invalid edit_mode"})
+                                }
+
+                                // Write back
+                                match std::fs::write(notebook_path, serde_json::to_string_pretty(&notebook).unwrap()) {
+                                    Ok(()) => {
+                                        session.track_write(notebook_path);
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Notebook edited: {} cell {} ({})", notebook_path, cell_number, edit_mode)})
+                                    }
+                                    Err(e) => {
+                                        session.record_failure("NotebookEdit", &e.to_string());
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Write failed: {}", e)})
+                                    }
+                                }
+                            } else {
+                                json!({"type": "text", "text": "Invalid notebook: no cells array"})
+                            }
+                        }
+                        Err(e) => json!({"type": "text", "text": format!("JSON parse error: {}", e)})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("NotebookEdit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_brain_search ======
+        "spf_brain_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let limit = args["limit"].as_u64().unwrap_or(5);
+
+            session.record_action("brain_search", "called", None);
+
+            let limit_str = limit.to_string();
+            let mut search_args = vec!["search", query, "--top-k", &limit_str];
+            if collection != "default" && !collection.is_empty() {
+                search_args.push("--collection");
+                search_args.push(collection);
+            }
+            let (success, output) = run_brain(&search_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Brain search '{}':\n\n{}", query, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_store ======
+        "spf_brain_store" => {
+            let text = args["text"].as_str().unwrap_or("");
+            let title = args["title"].as_str().unwrap_or("untitled");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let tags = args["tags"].as_str().unwrap_or("");
+
+            session.record_action("brain_store", "called", None);
+
+            let mut cmd_args = vec!["store", text, "--title", title, "--collection", collection, "--index"];
+            if !tags.is_empty() {
+                cmd_args.push("--tags");
+                cmd_args.push(tags);
+            }
+
+            let (success, output) = run_brain(&cmd_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Stored to brain:\n{}", output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain store failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_context ======
+        "spf_brain_context" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let max_tokens = args["max_tokens"].as_u64().unwrap_or(2000);
+            session.record_action("brain_context", "called", None);
+            let (success, output) = run_brain(&["context", query, "--max-tokens", &max_tokens.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain context failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_index ======
+        "spf_brain_index" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("brain_index", "called", Some(path));
+            let (success, output) = run_brain(&["index", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": format!("Indexed: {}\n{}", path, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain index failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list ======
+        "spf_brain_list" => {
+            session.record_action("brain_list", "called", None);
+            let (success, output) = run_brain(&["list"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_status ======
+        "spf_brain_status" => {
+            session.record_action("brain_status", "called", None);
+            let brain = brain_path();
+            let mut parts = vec![format!("Binary: {:?} ({})", brain, if brain.exists() { "OK" } else { "NOT FOUND" })];
+            let (success, output) = run_brain(&["list"]);
+            if success {
+                parts.push(format!("Collections:\n{}", output));
+            }
+            let storage_path = dirs_home().join("stoneshell-brain/storage");
+            if storage_path.exists() {
+                if let Ok(entries) = std::fs::read_dir(&storage_path) {
+                    let size: u64 = entries.filter_map(|e| e.ok()).filter_map(|e| e.metadata().ok()).map(|m| m.len()).sum();
+                    parts.push(format!("Storage: {:.2} MB", size as f64 / 1024.0 / 1024.0));
+                }
+            }
+            let _ = storage.save_session(session);
+            json!({"type": "text", "text": parts.join("\n\n")})
+        }
+
+        // ====== spf_brain_recall ======
+        "spf_brain_recall" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_recall", "called", None);
+            let (success, output) = run_brain(&["recall", query, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain recall failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list_docs ======
+        "spf_brain_list_docs" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_list_docs", "called", None);
+            let (success, output) = run_brain(&["list-docs", "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list-docs failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_get_doc ======
+        "spf_brain_get_doc" => {
+            let doc_id = args["doc_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_get_doc", "called", None);
+            let (success, output) = run_brain(&["get-doc", doc_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain get-doc failed: {}", output)})
+            }
+        }
+
+        // ====== RAG COLLECTOR HANDLERS ======
+
+        // ====== spf_rag_collect_web ======
+        "spf_rag_collect_web" => {
+            let topic = args["topic"].as_str().unwrap_or("");
+            session.record_action("rag_collect_web", "called", None);
+            let mut cmd_args = vec!["collect"];
+            if !topic.is_empty() {
+                cmd_args.push("--topic");
+                cmd_args.push(topic);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-web failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_file ======
+        "spf_rag_collect_file" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_file", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-file failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_folder ======
+        "spf_rag_collect_folder" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_folder", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-folder failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_drop ======
+        "spf_rag_collect_drop" => {
+            session.record_action("rag_collect_drop", "called", None);
+            let (success, output) = run_rag(&["drop"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-drop failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_index_gathered ======
+        "spf_rag_index_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_index_gathered", "called", None);
+            let mut cmd_args = vec!["index"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG index-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_dedupe ======
+        "spf_rag_dedupe" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_dedupe", "called", None);
+            // Dedupe goes through brain binary directly
+            let (success, output) = run_brain(&["dedup", "-c", category]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG dedupe failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_status ======
+        "spf_rag_status" => {
+            session.record_action("rag_status", "called", None);
+            let (success, output) = run_rag(&["status"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_gathered ======
+        "spf_rag_list_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_list_gathered", "called", None);
+            let mut cmd_args = vec!["list-gathered"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_bandwidth_status ======
+        "spf_rag_bandwidth_status" => {
+            session.record_action("rag_bandwidth_status", "called", None);
+            let (success, output) = run_rag(&["bandwidth"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG bandwidth-status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fetch_url ======
+        "spf_rag_fetch_url" => {
+            let url = args["url"].as_str().unwrap_or("");
+            session.record_action("rag_fetch_url", "called", None);
+            // Fetch URL through collect with path (URL handling)
+            let (success, output) = run_rag(&["collect", "--path", url]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fetch-url failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_rss ======
+        "spf_rag_collect_rss" => {
+            let feed_name = args["feed_name"].as_str().unwrap_or("");
+            session.record_action("rag_collect_rss", "called", None);
+            let mut cmd_args = vec!["rss"];
+            if !feed_name.is_empty() {
+                cmd_args.push("--feed");
+                cmd_args.push(feed_name);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-rss failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_feeds ======
+        "spf_rag_list_feeds" => {
+            session.record_action("rag_list_feeds", "called", None);
+            // Read RSS config directly
+            let rss_path = rag_collector_dir().join("sources/rss_sources.json");
+            let (success, output) = if rss_path.exists() {
+                match std::fs::read_to_string(&rss_path) {
+                    Ok(content) => (true, content),
+                    Err(e) => (false, format!("Failed to read RSS sources: {}", e)),
+                }
+            } else {
+                (false, "RSS sources file not found".to_string())
+            };
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-feeds failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_pending_searches ======
+        "spf_rag_pending_searches" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_pending_searches", "called", None);
+            let (success, output) = run_brain(&["pending-searches", "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG pending-searches failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fulfill_search ======
+        "spf_rag_fulfill_search" => {
+            let seeker_id = args["seeker_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_fulfill_search", "called", None);
+            let (success, output) = run_brain(&["fulfill-search", seeker_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fulfill-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_smart_search ======
+        "spf_rag_smart_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_smart_search", "called", None);
+            let (success, output) = run_brain(&["smart-search", query, "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG smart-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_auto_fetch_gaps ======
+        "spf_rag_auto_fetch_gaps" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let max_fetches = args["max_fetches"].as_u64().unwrap_or(5);
+            session.record_action("rag_auto_fetch_gaps", "called", None);
+            // Auto-fetch uses pending-searches then fetches URLs
+            let (success, output) = run_brain(&["auto-fetch", "-c", collection, "--max", &max_fetches.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG auto-fetch-gaps failed: {}", output)})
+            }
+        }
+
+        // ====== SPF_CONFIG HANDLERS ======
+        // NOTE: spf_config_get and spf_config_set blocked - user-only via CLI
+        "spf_config_get" | "spf_config_set" => {
+            json!({"type": "text", "text": "BLOCKED: Config read/write is user-only (use CLI)"})
+        }
+
+        "spf_config_paths" => {
+            session.record_action("config_paths", "list", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.list_path_rules() {
+                    Ok(rules) => {
+                        let text = rules.iter()
+                            .map(|(t, p)| format!("{}: {}", t, p))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No path rules configured".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_path_rules failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        "spf_config_stats" => {
+            session.record_action("config_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.stats() {
+                    Ok((config_count, paths_count, patterns_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_CONFIG LMDB Stats:\n  Config entries: {}\n  Path rules: {}\n  Dangerous patterns: {}",
+                            config_count, paths_count, patterns_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("config_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_TOOLS HANDLERS ======
+        "spf_tools_list" => {
+            session.record_action("tools_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.list_tools() {
+                    Ok(tools) => {
+                        let text = tools.iter()
+                            .map(|t| format!("{}: {:?} | calls={} allowed={} blocked={} avg_c={:.0}",
+                                t.name, t.permission, t.stats.call_count,
+                                t.stats.allowed_count, t.stats.blocked_count, t.stats.avg_complexity))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No tools registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_tools failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_stats" => {
+            session.record_action("tools_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.db_stats() {
+                    Ok((tools_count, history_count, aliases_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_TOOLS LMDB Stats:\n  Registered tools: {}\n  History entries: {}\n  Aliases: {}",
+                            tools_count, history_count, aliases_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("tools_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_get" => {
+            let name_arg = args["name"].as_str().unwrap_or("");
+            session.record_action("tools_get", "get", Some(name_arg));
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.get_tool(name_arg) {
+                    Ok(Some(tool)) => {
+                        json!({"type": "text", "text": format!(
+                            "Tool: {}\nPermission: {:?}\nMCP: {} (server: {})\nCalls: {} | Allowed: {} | Blocked: {}\nTotal C: {} | Avg C: {:.0}\nFirst used: {} | Last used: {}\nNotes: {}",
+                            tool.name, tool.permission, tool.is_mcp,
+                            tool.mcp_server.as_deref().unwrap_or("N/A"),
+                            tool.stats.call_count, tool.stats.allowed_count, tool.stats.blocked_count,
+                            tool.stats.total_complexity, tool.stats.avg_complexity,
+                            format_timestamp(tool.stats.first_used), format_timestamp(tool.stats.last_used),
+                            if tool.notes.is_empty() { "None" } else { &tool.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Tool not found: {}", name_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_tool failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_SANDBOX HANDLERS ======
+        "spf_sandbox_list" => {
+            session.record_action("sandbox_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.list_projects() {
+                    Ok(projects) => {
+                        let text = projects.iter()
+                            .map(|p| format!("{}: {} | trust={:?} | reads={} writes={} | active={}",
+                                p.name, p.path, p.trust_level,
+                                p.total_reads, p.total_writes, p.is_active))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No sandboxes registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_projects failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_stats" => {
+            session.record_action("sandbox_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.db_stats() {
+                    Ok((projects_count, access_count, resources_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_SANDBOX LMDB Stats:\n  Registered projects: {}\n  Access log entries: {}\n  Resource records: {}",
+                            projects_count, access_count, resources_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("sandbox_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_get" => {
+            let path_arg = args["path"].as_str().unwrap_or("");
+            session.record_action("sandbox_get", "get", Some(path_arg));
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_project(path_arg) {
+                    Ok(Some(proj)) => {
+                        json!({"type": "text", "text": format!(
+                            "Project: {}\nPath: {}\nTrust: {:?}\nActive: {}\nReads: {} | Writes: {} | Session writes: {}/{}\nMax write size: {} | Total C: {}\nProtected: {:?}\nCreated: {} | Last accessed: {}\nNotes: {}",
+                            proj.name, proj.path, proj.trust_level, proj.is_active,
+                            proj.total_reads, proj.total_writes, proj.session_writes, proj.max_writes_per_session,
+                            proj.max_write_size, proj.total_complexity,
+                            proj.protected_paths,
+                            format_timestamp(proj.created_at), format_timestamp(proj.last_accessed),
+                            if proj.notes.is_empty() { "None" } else { &proj.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Project not found: {}", path_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_project failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_active" => {
+            session.record_action("sandbox_active", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_active() {
+                    Ok(Some(path)) => {
+                        // Also fetch project details
+                        match db.get_project(&path) {
+                            Ok(Some(proj)) => {
+                                json!({"type": "text", "text": format!(
+                                    "Active project: {} ({})\nTrust: {:?} | Reads: {} | Writes: {}",
+                                    proj.name, proj.path, proj.trust_level, proj.total_reads, proj.total_writes
+                                )})
+                            }
+                            _ => json!({"type": "text", "text": format!("Active project path: {} (details unavailable)", path)}),
+                        }
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No active project"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_active failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        // ====== AGENT_STATE HANDLERS ======
+        // BLOCKED: Write operations are user-only
+        "spf_agent_remember" | "spf_agent_forget" | "spf_agent_set_state" => {
+            json!({"type": "text", "text": "BLOCKED: Agent state writes are user-only (use CLI)"})
+        }
+
+        "spf_agent_stats" => {
+            session.record_action("agent_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.db_stats() {
+                    Ok((memory_count, sessions_count, state_count, tags_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "AGENT_STATE LMDB Stats:\n  Memories: {}\n  Sessions: {}\n  State keys: {}\n  Tags: {}",
+                            memory_count, sessions_count, state_count, tags_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("agent_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let limit = args["limit"].as_u64().unwrap_or(10) as usize;
+            session.record_action("agent_memory_search", "search", Some(query));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.search_memories(query, limit) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories found for: {}", query)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}\n  Tags: {:?} | Created: {}",
+                                    m.id, m.memory_type, m.content,
+                                    m.tags, format_timestamp(m.created_at)))
+                                .collect::<Vec<_>>()
+                                .join("\n\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("search_memories failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_by_tag" => {
+            let tag = args["tag"].as_str().unwrap_or("");
+            session.record_action("agent_memory_by_tag", "search", Some(tag));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_by_tag(tag) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories with tag: {}", tag)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}",
+                                    m.id, m.memory_type, m.content))
+                                .collect::<Vec<_>>()
+                                .join("\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_by_tag failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_session_info" => {
+            session.record_action("agent_session_info", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_latest_session() {
+                    Ok(Some(sess)) => {
+                        json!({"type": "text", "text": format!(
+                            "Session: {}\nParent: {}\nStarted: {} | Ended: {}\nWorking dir: {}\nProject: {}\nFiles modified: {}\nComplexity: {} | Actions: {}\nSummary: {}",
+                            sess.session_id,
+                            sess.parent_session.as_deref().unwrap_or("None"),
+                            format_timestamp(sess.started_at),
+                            if sess.ended_at == 0 { "Ongoing".to_string() } else { format_timestamp(sess.ended_at) },
+                            sess.working_dir,
+                            sess.active_project.as_deref().unwrap_or("None"),
+                            sess.files_modified.len(),
+                            sess.total_complexity, sess.total_actions,
+                            if sess.summary.is_empty() { "None" } else { &sess.summary }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No sessions recorded"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_latest_session failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_context" => {
+            session.record_action("agent_context", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_context_summary() {
+                    Ok(summary) => {
+                        json!({"type": "text", "text": if summary.is_empty() { "No context available".to_string() } else { summary }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_context_summary failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        _ => {
+            json!({"type": "text", "text": format!("Unknown tool: {}", name)})
+        }
+    }
+}
+
+/// Main MCP server loop — runs forever on stdio
+pub fn run(config: SpfConfig, mut session: Session, storage: SpfStorage) {
+    log(&format!("Starting {} v{}", SERVER_NAME, SERVER_VERSION));
+    log(&format!("Mode: {:?}", config.enforce_mode));
+
+    // Initialize SPF_CONFIG LMDB
+    // Path is relative to HOME/SPFsmartGATE - same base as the binary location
+    let spf_base = dirs_home().join("SPFsmartGATE");
+    let config_db_path = spf_base.join("storage/spf_config");
+    log(&format!("SPF_CONFIG path: {:?}", config_db_path));
+
+    let config_db = match SpfConfigDb::open(&config_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_CONFIG init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_CONFIG LMDB initialized at {:?}", config_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_CONFIG LMDB at {:?}: {}", config_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_TOOLS LMDB
+    let tools_db_path = spf_base.join("storage/spf_tools");
+    log(&format!("SPF_TOOLS path: {:?}", tools_db_path));
+
+    let tools_db = match SpfToolsDb::open(&tools_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_TOOLS init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_TOOLS LMDB initialized at {:?}", tools_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_TOOLS LMDB at {:?}: {}", tools_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_SANDBOX LMDB
+    let sandbox_db_path = spf_base.join("storage/spf_sandbox");
+    log(&format!("SPF_SANDBOX path: {:?}", sandbox_db_path));
+
+    let sandbox_db = match SpfSandboxDb::open(&sandbox_db_path) {
+        Ok(db) => {
+            log(&format!("SPF_SANDBOX LMDB initialized at {:?}", sandbox_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_SANDBOX LMDB at {:?}: {}", sandbox_db_path, e));
+            None
+        }
+    };
+
+    // Initialize AGENT_STATE LMDB
+    let agent_db_path = spf_base.join("storage/agent_state");
+    log(&format!("AGENT_STATE path: {:?}", agent_db_path));
+
+    let agent_db = match AgentStateDb::open(&agent_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: AGENT_STATE init_defaults failed: {}", e));
+            }
+            log(&format!("AGENT_STATE LMDB initialized at {:?}", agent_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open AGENT_STATE LMDB at {:?}: {}", agent_db_path, e));
+            None
+        }
+    };
+
+    let stdin = io::stdin();
+    for line in stdin.lock().lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                log(&format!("stdin read error: {}", e));
+                continue;
+            }
+        };
+
+        let line = line.trim().to_string();
+        if line.is_empty() {
+            continue;
+        }
+
+        let msg: Value = match serde_json::from_str(&line) {
+            Ok(v) => v,
+            Err(e) => {
+                log(&format!("JSON parse error: {}", e));
+                continue;
+            }
+        };
+
+        let method = msg["method"].as_str().unwrap_or("");
+        let id = &msg["id"];
+        let params = &msg["params"];
+
+        log(&format!("Received: {}", method));
+
+        match method {
+            "initialize" => {
+                send_response(id, json!({
+                    "protocolVersion": PROTOCOL_VERSION,
+                    "capabilities": { "tools": {} },
+                    "serverInfo": {
+                        "name": SERVER_NAME,
+                        "version": SERVER_VERSION,
+                    }
+                }));
+            }
+
+            "notifications/initialized" => {
+                // No response needed
+            }
+
+            "tools/list" => {
+                send_response(id, json!({ "tools": tool_definitions() }));
+            }
+
+            "tools/call" => {
+                let name = params["name"].as_str().unwrap_or("");
+                let args = params.get("arguments").cloned().unwrap_or(json!({}));
+
+                let result = handle_tool_call(name, &args, &config, &mut session, &storage, &config_db, &tools_db, &sandbox_db, &agent_db);
+
+                send_response(id, json!({
+                    "content": [result]
+                }));
+            }
+
+            "ping" => {
+                send_response(id, json!({}));
+            }
+
+            _ => {
+                if !id.is_null() {
+                    send_error(id, -32601, &format!("Unknown method: {}", method));
+                }
+            }
+        }
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/9c462d52bfadf61c@v2

@@ -0,0 +1,2105 @@
+// SPF Smart Gateway - MCP Server (JSON-RPC 2.0 over stdio)
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// ALL tool calls route through this gateway.
+// Exposes: spf_gate, spf_read, spf_write, spf_edit, spf_bash, spf_status,
+//          spf_calculate, spf_session, spf_brain_search, spf_brain_store
+
+use crate::calculate::{self, ToolParams};
+use crate::config::SpfConfig;
+use crate::config_db::SpfConfigDb;
+use crate::tools_db::SpfToolsDb;
+use crate::sandbox_db::SpfSandboxDb;
+use crate::agent_state::AgentStateDb;
+use crate::gate;
+use crate::session::Session;
+use crate::storage::SpfStorage;
+use crate::web::WebClient;
+use serde_json::{json, Value};
+use std::io::{self, BufRead, Write};
+use std::process::Command;
+use std::path::PathBuf;
+use chrono::{DateTime, Utc};
+
+const PROTOCOL_VERSION: &str = "2024-11-05";
+
+/// Format Unix timestamp as human-readable ISO8601
+fn format_timestamp(ts: u64) -> String {
+    if ts == 0 {
+        return "Never".to_string();
+    }
+    DateTime::<Utc>::from_timestamp(ts as i64, 0)
+        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
+        .unwrap_or_else(|| ts.to_string())
+}
+const SERVER_NAME: &str = "spf-smart-gate";
+const SERVER_VERSION: &str = "1.0.0";
+
+/// Brain binary path
+fn brain_path() -> PathBuf {
+    dirs_home().join("stoneshell-brain/target/release/brain")
+}
+
+fn dirs_home() -> PathBuf {
+    PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/data/data/com.termux/files/home".to_string()))
+}
+
+/// Run brain CLI command
+fn run_brain(args: &[&str]) -> (bool, String) {
+    let brain = brain_path();
+    if !brain.exists() {
+        return (false, format!("Brain not found: {:?}", brain));
+    }
+    match Command::new(&brain)
+        .args(args)
+        .current_dir(brain.parent().unwrap().parent().unwrap())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                (false, String::from_utf8_lossy(&output.stderr).to_string())
+            }
+        }
+        Err(e) => (false, format!("Failed to run brain: {}", e)),
+    }
+}
+
+/// RAG Collector script path
+fn rag_collector_path() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR/server.py")
+}
+
+/// RAG Collector working directory
+fn rag_collector_dir() -> PathBuf {
+    PathBuf::from("/storage/emulated/0/Download/api-workspace/projects/MCP_RAG_COLLECTOR")
+}
+
+/// Run RAG Collector command
+fn run_rag(args: &[&str]) -> (bool, String) {
+    let rag = rag_collector_path();
+    if !rag.exists() {
+        return (false, format!("RAG Collector not found: {:?}", rag));
+    }
+    match Command::new("python3")
+        .arg("-u")
+        .arg(&rag)
+        .args(args)
+        .current_dir(rag_collector_dir())
+        .output()
+    {
+        Ok(output) => {
+            if output.status.success() {
+                (true, String::from_utf8_lossy(&output.stdout).trim().to_string())
+            } else {
+                let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                (false, format!("{}\n{}", stdout, stderr))
+            }
+        }
+        Err(e) => (false, format!("Failed to run RAG Collector: {}", e)),
+    }
+}
+
+/// Log to stderr (stdout is JSON-RPC)
+fn log(msg: &str) {
+    eprintln!("[spf-smart-gate] {}", msg);
+}
+
+/// Send JSON-RPC response
+fn send_response(id: &Value, result: Value) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "result": result,
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// Send JSON-RPC error response
+fn send_error(id: &Value, code: i64, message: &str) {
+    let response = json!({
+        "jsonrpc": "2.0",
+        "id": id,
+        "error": { "code": code, "message": message },
+    });
+    let msg = serde_json::to_string(&response).unwrap();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
+    let _ = out.write_all(msg.as_bytes());
+    let _ = out.write_all(b"\n");
+    let _ = out.flush();
+}
+
+/// MCP tool definition helper
+fn tool_def(name: &str, description: &str, properties: Value, required: Vec<&str>) -> Value {
+    json!({
+        "name": name,
+        "description": description,
+        "inputSchema": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        }
+    })
+}
+
+/// Return all tool definitions
+fn tool_definitions() -> Vec<Value> {
+    vec![
+        // ====== CORE GATE TOOLS ======
+        tool_def(
+            "spf_gate",
+            "Run a tool call through SPF enforcement gate. Returns allow/block decision with complexity analysis.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name (Read, Write, Edit, Bash)"},
+                "params": {"type": "object", "description": "Tool parameters (file_path, content, command, etc.)"},
+                "approved": {"type": "boolean", "description": "User approval for CRITICAL tier (default: false)", "default": true}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_calculate",
+            "Calculate complexity score for a tool call without executing. Returns C value, tier, and allocation.",
+            json!({
+                "tool": {"type": "string", "description": "Tool name"},
+                "params": {"type": "object", "description": "Tool parameters"}
+            }),
+            vec!["tool", "params"],
+        ),
+        tool_def(
+            "spf_status",
+            "Get current SPF gateway status: session metrics, enforcement mode, complexity budget.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_session",
+            "Get full session state: files read/written, action history, anchor ratio, complexity history.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== GATED FILE OPERATIONS ======
+        tool_def(
+            "spf_read",
+            "Read a file through SPF gateway. Tracks read for Build Anchor Protocol.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "limit": {"type": "integer", "description": "Max lines to read (optional)"},
+                "offset": {"type": "integer", "description": "Line offset to start from (optional)"},
+                "approved": {"type": "boolean", "description": "User approval for gated read", "default": false}
+            }),
+            vec!["file_path"],
+        ),
+        tool_def(
+            "spf_write",
+            "Write a file through SPF gateway. Validates: Build Anchor, blocked paths, file size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "content": {"type": "string", "description": "File content to write"},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": true}
+            }),
+            vec!["file_path", "content"],
+        ),
+        tool_def(
+            "spf_edit",
+            "Edit a file through SPF gateway. Validates: Build Anchor, blocked paths, change size.",
+            json!({
+                "file_path": {"type": "string", "description": "Absolute path to file"},
+                "old_string": {"type": "string", "description": "Text to replace"},
+                "new_string": {"type": "string", "description": "Replacement text"},
+                "replace_all": {"type": "boolean", "description": "Replace all occurrences", "default": false},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": true}
+            }),
+            vec!["file_path", "old_string", "new_string"],
+        ),
+        tool_def(
+            "spf_bash",
+            "Execute a bash command through SPF gateway. Validates: dangerous commands, /tmp access, git force.",
+            json!({
+                "command": {"type": "string", "description": "Bash command to execute"},
+                "timeout": {"type": "integer", "description": "Timeout in seconds (default: 30)", "default": 30},
+                "approved": {"type": "boolean", "description": "User approval if CRITICAL", "default": false}
+            }),
+            vec!["command"],
+        ),
+
+        // ====== SEARCH/GLOB TOOLS ======
+        tool_def(
+            "spf_glob",
+            "Fast file pattern matching. Supports glob patterns like **/*.rs or src/**/*.ts.",
+            json!({
+                "pattern": {"type": "string", "description": "Glob pattern to match files"},
+                "path": {"type": "string", "description": "Directory to search in (default: current dir)"}
+            }),
+            vec!["pattern"],
+        ),
+        tool_def(
+            "spf_grep",
+            "Search file contents using regex. Built on ripgrep.",
+            json!({
+                "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                "path": {"type": "string", "description": "File or directory to search"},
+                "glob": {"type": "string", "description": "Glob filter (e.g. *.rs)"},
+                "case_insensitive": {"type": "boolean", "description": "Case insensitive search", "default": true},
+                "context_lines": {"type": "integer", "description": "Lines of context around matches", "default": 0}
+            }),
+            vec!["pattern"],
+        ),
+
+        // ====== WEB BROWSER TOOLS ======
+        tool_def(
+            "spf_web_search",
+            "Search the web for information. Uses Brave API if BRAVE_API_KEY set, otherwise DuckDuckGo.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "count": {"type": "integer", "description": "Max results (default: 10)", "default": 10}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_web_fetch",
+            "Fetch a URL and return clean readable text. HTML is converted to plain text, JSON is pretty-printed.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "prompt": {"type": "string", "description": "Prompt to run on fetched content"}
+            }),
+            vec!["url", "prompt"],
+        ),
+        tool_def(
+            "spf_web_download",
+            "Download a file from URL and save to disk.",
+            json!({
+                "url": {"type": "string", "description": "URL to download"},
+                "save_path": {"type": "string", "description": "Local path to save file"}
+            }),
+            vec!["url", "save_path"],
+        ),
+        tool_def(
+            "spf_web_api",
+            "Make an API request. Returns status, headers, and response body.",
+            json!({
+                "method": {"type": "string", "description": "HTTP method (GET, POST, PUT, DELETE, PATCH)"},
+                "url": {"type": "string", "description": "API endpoint URL"},
+                "headers": {"type": "string", "description": "JSON object of headers (optional)", "default": ""},
+                "body": {"type": "string", "description": "Request body JSON (optional)", "default": ""}
+            }),
+            vec!["method", "url"],
+        ),
+
+        // ====== NOTEBOOK TOOL ======
+        tool_def(
+            "spf_notebook_edit",
+            "Edit a Jupyter notebook cell.",
+            json!({
+                "notebook_path": {"type": "string", "description": "Absolute path to .ipynb file"},
+                "cell_number": {"type": "integer", "description": "Cell index (0-based)"},
+                "new_source": {"type": "string", "description": "New cell content"},
+                "cell_type": {"type": "string", "description": "Cell type: code or markdown"},
+                "edit_mode": {"type": "string", "description": "Mode: replace, insert, or delete", "default": "replace"}
+            }),
+            vec!["notebook_path", "new_source"],
+        ),
+
+        // ====== BRAIN PASSTHROUGH ======
+        tool_def(
+            "spf_brain_search",
+            "Search brain through SPF gateway. All brain access is logged and tracked.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection (default: default)", "default": "default"},
+                "limit": {"type": "integer", "description": "Max results (default: 5)", "default": 5}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_store",
+            "Store document in brain through SPF gateway.",
+            json!({
+                "text": {"type": "string", "description": "Text to store"},
+                "title": {"type": "string", "description": "Document title", "default": "untitled"},
+                "collection": {"type": "string", "description": "Collection", "default": "default"},
+                "tags": {"type": "string", "description": "Comma-separated tags", "default": ""}
+            }),
+            vec!["text"],
+        ),
+
+        // ====== ADDITIONAL BRAIN TOOLS ======
+        tool_def(
+            "spf_brain_context",
+            "Get relevant context for a query. Returns formatted context for prompt injection.",
+            json!({
+                "query": {"type": "string", "description": "Query to get context for"},
+                "max_tokens": {"type": "integer", "description": "Max tokens (default: 2000)", "default": 2000}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_index",
+            "Index a file or directory into the brain.",
+            json!({
+                "path": {"type": "string", "description": "File or directory to index"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_brain_list",
+            "List all indexed collections and document counts.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_status",
+            "Get brain system status.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_recall",
+            "Search and return full parent documents. Searches vectors then resolves to complete stored document.",
+            json!({
+                "query": {"type": "string", "description": "Natural language search query"},
+                "collection": {"type": "string", "description": "Collection to search (default: default)", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_brain_list_docs",
+            "List all stored documents in a collection.",
+            json!({
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_brain_get_doc",
+            "Retrieve a specific document by its ID.",
+            json!({
+                "doc_id": {"type": "string", "description": "Document ID to retrieve"},
+                "collection": {"type": "string", "description": "Collection name (default: default)", "default": "default"}
+            }),
+            vec!["doc_id"],
+        ),
+
+        // ====== RAG COLLECTOR TOOLS ======
+        tool_def(
+            "spf_rag_collect_web",
+            "Search web and collect documents. Optional topic filter.",
+            json!({
+                "topic": {"type": "string", "description": "Topic to search (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected docs", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_collect_file",
+            "Process a local file.",
+            json!({
+                "path": {"type": "string", "description": "File path"},
+                "category": {"type": "string", "description": "Category (default: auto)", "default": "auto"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_folder",
+            "Process all files in a folder.",
+            json!({
+                "path": {"type": "string", "description": "Folder path"},
+                "extensions": {"type": "array", "items": {"type": "string"}, "description": "File extensions to include"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_rag_collect_drop",
+            "Process files in DROP_HERE folder.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_index_gathered",
+            "Index all documents in GATHERED to brain.",
+            json!({
+                "category": {"type": "string", "description": "Category to index (optional)"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_dedupe",
+            "Deduplicate brain collection.",
+            json!({
+                "category": {"type": "string", "description": "Category to dedupe"}
+            }),
+            vec!["category"],
+        ),
+        tool_def(
+            "spf_rag_status",
+            "Get collector status and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_gathered",
+            "List documents in GATHERED folder.",
+            json!({
+                "category": {"type": "string", "description": "Filter by category"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_bandwidth_status",
+            "Get bandwidth usage stats and limits.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fetch_url",
+            "Fetch a single URL with bandwidth limiting.",
+            json!({
+                "url": {"type": "string", "description": "URL to fetch"},
+                "auto_index": {"type": "boolean", "description": "Auto-index after fetch", "default": true}
+            }),
+            vec!["url"],
+        ),
+        tool_def(
+            "spf_rag_collect_rss",
+            "Collect from RSS/Atom feeds.",
+            json!({
+                "feed_name": {"type": "string", "description": "Specific feed name (optional)"},
+                "auto_index": {"type": "boolean", "description": "Auto-index collected", "default": true}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_list_feeds",
+            "List configured RSS feeds.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_pending_searches",
+            "Get pending SearchSeeker vectors from brain (gaps needing fetch).",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"}
+            }),
+            vec![],
+        ),
+        tool_def(
+            "spf_rag_fulfill_search",
+            "Mark a SearchSeeker as fulfilled after RAG fetch.",
+            json!({
+                "seeker_id": {"type": "string", "description": "SearchSeeker ID to fulfill"},
+                "collection": {"type": "string", "description": "Collection name", "default": "default"}
+            }),
+            vec!["seeker_id"],
+        ),
+        tool_def(
+            "spf_rag_smart_search",
+            "Run smart search with completeness check - triggers SearchSeeker if <80%.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "collection": {"type": "string", "description": "Collection to search", "default": "default"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_rag_auto_fetch_gaps",
+            "Automatically fetch data for all pending SearchSeekers.",
+            json!({
+                "collection": {"type": "string", "description": "Collection to check", "default": "default"},
+                "max_fetches": {"type": "integer", "description": "Max URLs to fetch", "default": 5}
+            }),
+            vec![],
+        ),
+
+        // ====== SPF_CONFIG TOOLS ======
+        // NOTE: spf_config_get and spf_config_set removed from MCP - user-only via CLI
+        tool_def(
+            "spf_config_paths",
+            "List all path rules (allowed/blocked) from SPF_CONFIG LMDB.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_config_stats",
+            "Get SPF_CONFIG LMDB statistics.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== SPF_TOOLS TOOLS ======
+        tool_def(
+            "spf_tools_list",
+            "List all registered tools with permissions and stats.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_stats",
+            "Get SPF_TOOLS LMDB statistics (tool count, history count, alias count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_tools_get",
+            "Get info for a specific tool by name.",
+            json!({
+                "name": {"type": "string", "description": "Tool name to look up"}
+            }),
+            vec!["name"],
+        ),
+
+        // ====== SPF_SANDBOX TOOLS ======
+        tool_def(
+            "spf_sandbox_list",
+            "List all registered project sandboxes with trust levels.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_stats",
+            "Get SPF_SANDBOX LMDB statistics (project count, access log count, resource count).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_sandbox_get",
+            "Get sandbox info for a specific project by path.",
+            json!({
+                "path": {"type": "string", "description": "Project path to look up"}
+            }),
+            vec!["path"],
+        ),
+        tool_def(
+            "spf_sandbox_active",
+            "Get the currently active project sandbox.",
+            json!({}),
+            vec![],
+        ),
+
+        // ====== AGENT_STATE TOOLS ======
+        tool_def(
+            "spf_agent_stats",
+            "Get AGENT_STATE LMDB statistics (memory count, sessions, state keys, tags).",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_memory_search",
+            "Search agent memories by content.",
+            json!({
+                "query": {"type": "string", "description": "Search query"},
+                "limit": {"type": "integer", "description": "Max results (default: 10)"}
+            }),
+            vec!["query"],
+        ),
+        tool_def(
+            "spf_agent_memory_by_tag",
+            "Get agent memories by tag.",
+            json!({
+                "tag": {"type": "string", "description": "Tag to filter by"}
+            }),
+            vec!["tag"],
+        ),
+        tool_def(
+            "spf_agent_session_info",
+            "Get the most recent session info.",
+            json!({}),
+            vec![],
+        ),
+        tool_def(
+            "spf_agent_context",
+            "Get context summary for session continuity.",
+            json!({}),
+            vec![],
+        ),
+    ]
+}
+
+/// Handle a tool call
+fn handle_tool_call(
+    name: &str,
+    args: &Value,
+    config: &SpfConfig,
+    session: &mut Session,
+    storage: &SpfStorage,
+    config_db: &Option<SpfConfigDb>,
+    tools_db: &Option<SpfToolsDb>,
+    sandbox_db: &Option<SpfSandboxDb>,
+    agent_db: &Option<AgentStateDb>,
+) -> Value {
+    match name {
+        // ====== spf_gate ======
+        "spf_gate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let decision = gate::process(tool, &params, config, session, approved);
+            session.record_complexity(tool, decision.complexity.c, &decision.complexity.tier);
+            session.record_manifest(
+                tool, decision.complexity.c,
+                if decision.allowed { "ALLOWED" } else { "BLOCKED" },
+                decision.errors.first().map(|s| s.as_str()),
+            );
+            let _ = storage.save_session(session);
+
+            json!({"type": "text", "text": serde_json::to_string_pretty(&decision).unwrap()})
+        }
+
+        // ====== spf_calculate ======
+        "spf_calculate" => {
+            let tool = args["tool"].as_str().unwrap_or("unknown");
+            let params: ToolParams = serde_json::from_value(
+                args.get("params").cloned().unwrap_or(json!({}))
+            ).unwrap_or_else(|_| ToolParams {
+                ..Default::default()
+            });
+            let result = calculate::calculate(tool, &params, config);
+            json!({"type": "text", "text": serde_json::to_string_pretty(&result).unwrap()})
+        }
+
+        // ====== spf_status ======
+        "spf_status" => {
+            let status = format!(
+                "SPF Gateway v{}\nMode: {:?}\nSession: {}\nTiers: SIMPLE(<500) LIGHT(<2000) MEDIUM(<10000) CRITICAL(>10000)\nFormula: a_optimal(C) = {} × (1 - 1/ln(C + e))",
+                SERVER_VERSION,
+                config.enforce_mode,
+                session.status_summary(),
+                config.formula.w_eff,
+            );
+            json!({"type": "text", "text": status})
+        }
+
+        // ====== spf_session ======
+        "spf_session" => {
+            json!({"type": "text", "text": serde_json::to_string_pretty(session).unwrap()})
+        }
+
+        // ====== spf_read ======
+        "spf_read" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Read", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Read", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute read
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    session.track_read(file_path);
+                    session.record_action("Read", "success", Some(file_path));
+                    let _ = storage.save_session(session);
+
+                    // Apply limit/offset if specified
+                    let offset = args.get("offset").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+                    let limit = args.get("limit").and_then(|v| v.as_u64()).unwrap_or(0) as usize;
+
+                    let lines: Vec<&str> = content.lines().collect();
+                    let total = lines.len();
+                    let start = offset.min(total);
+                    let end = if limit > 0 { (start + limit).min(total) } else { total };
+
+                    let numbered: String = lines[start..end]
+                        .iter()
+                        .enumerate()
+                        .map(|(i, line)| format!("{:>6}\t{}", start + i + 1, line))
+                        .collect::<Vec<_>>()
+                        .join("\n");
+
+                    json!({"type": "text", "text": format!("File: {} ({} lines)\n{}", file_path, total, numbered)})
+                }
+                Err(e) => {
+                    session.record_action("Read", "failed", Some(file_path));
+                    session.record_failure("Read", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_write ======
+        "spf_write" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let content = args["content"].as_str().unwrap_or("");
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                content: Some(content.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Write", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Write", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute write
+            // Ensure parent directory exists
+            if let Some(parent) = std::path::Path::new(file_path).parent() {
+                let _ = std::fs::create_dir_all(parent);
+            }
+
+            match std::fs::write(file_path, content) {
+                Ok(()) => {
+                    session.track_write(file_path);
+                    session.record_action("Write", "success", Some(file_path));
+                    session.record_manifest("Write", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!(
+                        "Written: {} ({} bytes) | C={} {}",
+                        file_path, content.len(), decision.complexity.c, decision.complexity.tier
+                    )})
+                }
+                Err(e) => {
+                    session.record_action("Write", "failed", Some(file_path));
+                    session.record_failure("Write", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Write failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_edit ======
+        "spf_edit" => {
+            let file_path = args["file_path"].as_str().unwrap_or("");
+            let old_string = args["old_string"].as_str().unwrap_or("");
+            let new_string = args["new_string"].as_str().unwrap_or("");
+            let replace_all = args["replace_all"].as_bool().unwrap_or(false);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                file_path: Some(file_path.to_string()),
+                old_string: Some(old_string.to_string()),
+                new_string: Some(new_string.to_string()),
+                replace_all: Some(replace_all),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Edit", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Edit", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute edit
+            match std::fs::read_to_string(file_path) {
+                Ok(content) => {
+                    let new_content = if replace_all {
+                        content.replace(old_string, new_string)
+                    } else {
+                        content.replacen(old_string, new_string, 1)
+                    };
+
+                    if new_content == content {
+                        json!({"type": "text", "text": format!("Edit: old_string not found in {}", file_path)})
+                    } else {
+                        match std::fs::write(file_path, &new_content) {
+                            Ok(()) => {
+                                session.track_write(file_path);
+                                session.record_action("Edit", "success", Some(file_path));
+                                session.record_manifest("Edit", decision.complexity.c, "ALLOWED", None);
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!(
+                                    "Edited: {} | C={} {}",
+                                    file_path, decision.complexity.c, decision.complexity.tier
+                                )})
+                            }
+                            Err(e) => {
+                                session.record_failure("Edit", &e.to_string());
+                                let _ = storage.save_session(session);
+                                json!({"type": "text", "text": format!("Edit write failed: {}", e)})
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Edit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Edit read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_bash ======
+        "spf_bash" => {
+            let command = args["command"].as_str().unwrap_or("");
+            let _timeout = args["timeout"].as_u64().unwrap_or(30);
+            let approved = args["approved"].as_bool().unwrap_or(false);
+
+            let params = ToolParams {
+                command: Some(command.to_string()),
+                ..Default::default()
+            };
+
+            let decision = gate::process("Bash", &params, config, session, approved);
+            if !decision.allowed {
+                session.record_manifest("Bash", decision.complexity.c, "BLOCKED", decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            // Execute bash
+            match Command::new("bash")
+                .arg("-c")
+                .arg(command)
+                .output()
+            {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+                    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+                    let success = output.status.success();
+
+                    session.record_action("Bash", if success { "success" } else { "failed" }, None);
+                    if !success {
+                        session.record_failure("Bash", &stderr);
+                    }
+                    session.record_manifest("Bash", decision.complexity.c, "ALLOWED", None);
+                    let _ = storage.save_session(session);
+
+                    let mut result = String::new();
+                    if !stdout.is_empty() {
+                        result.push_str(&stdout);
+                    }
+                    if !stderr.is_empty() {
+                        result.push_str("\nSTDERR: ");
+                        result.push_str(&stderr);
+                    }
+                    if result.is_empty() {
+                        result = format!("Exit code: {}", output.status.code().unwrap_or(-1));
+                    }
+
+                    json!({"type": "text", "text": result})
+                }
+                Err(e) => {
+                    session.record_failure("Bash", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Bash failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_glob ======
+        "spf_glob" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            session.record_action("Glob", "called", None);
+
+            // Use find with glob pattern (simpler than pulling in glob crate)
+            let cmd = format!("find {} -name '{}' 2>/dev/null | head -100", path, pattern);
+            match Command::new("bash").arg("-c").arg(&cmd).output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    let _ = storage.save_session(session);
+                    if stdout.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": stdout})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Glob", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Glob failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_grep ======
+        "spf_grep" => {
+            let pattern = args["pattern"].as_str().unwrap_or("");
+            let path = args["path"].as_str().unwrap_or(".");
+            let glob_filter = args["glob"].as_str().unwrap_or("");
+            let case_insensitive = args["case_insensitive"].as_bool().unwrap_or(false);
+            let context = args["context_lines"].as_u64().unwrap_or(0);
+            session.record_action("Grep", "called", None);
+
+            let mut cmd = String::from("rg");
+            if case_insensitive {
+                cmd.push_str(" -i");
+            }
+            if context > 0 {
+                cmd.push_str(&format!(" -C {}", context));
+            }
+            if !glob_filter.is_empty() {
+                cmd.push_str(&format!(" --glob '{}'", glob_filter));
+            }
+            cmd.push_str(&format!(" '{}' {} 2>/dev/null | head -500", pattern, path));
+
+            match Command::new("bash").arg("-c").arg(&cmd).output() {
+                Ok(output) => {
+                    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    let _ = storage.save_session(session);
+                    if stdout.is_empty() {
+                        json!({"type": "text", "text": "No matches found"})
+                    } else {
+                        json!({"type": "text", "text": stdout})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("Grep", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Grep failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_fetch ======
+        "spf_web_fetch" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let prompt = args["prompt"].as_str().unwrap_or("Summarize this content");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(prompt.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_fetch", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_fetch", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebFetch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.read_page(url) {
+                        Ok((text, raw_len, content_type)) => {
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if text.len() > 50000 { &text[..50000] } else { &text };
+                            json!({"type": "text", "text": format!(
+                                "Fetched {} ({} bytes, {})\nPrompt: {}\n\n{}",
+                                url, raw_len, content_type, prompt, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebFetch", &e);
+                            session.record_manifest("web_fetch", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebFetch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebFetch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_search ======
+        "spf_web_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let count = args["count"].as_u64().unwrap_or(10) as u32;
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                query: Some(query.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_search", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_search", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebSearch", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.search(query, count) {
+                        Ok((engine, results)) => {
+                            let mut output = format!("Search '{}' via {} ({} results):\n\n", query, engine, results.len());
+                            for (i, r) in results.iter().enumerate() {
+                                output.push_str(&format!("{}. {}\n   {}\n   {}\n\n", i + 1, r.title, r.url, r.description));
+                            }
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": output})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebSearch", &e);
+                            session.record_manifest("web_search", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("WebSearch failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebSearch", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_download ======
+        "spf_web_download" => {
+            let url = args["url"].as_str().unwrap_or("");
+            let save_path = args["save_path"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                file_path: Some(save_path.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_download", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_download", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebDownload", "called", Some(save_path));
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.download(url, save_path) {
+                        Ok((size, content_type)) => {
+                            session.track_write(save_path);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!(
+                                "Downloaded {} → {} ({} bytes, {})",
+                                url, save_path, size, content_type
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebDownload", &e);
+                            session.record_manifest("web_download", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("Download failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebDownload", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_web_api ======
+        "spf_web_api" => {
+            let method = args["method"].as_str().unwrap_or("GET");
+            let url = args["url"].as_str().unwrap_or("");
+            let headers = args["headers"].as_str().unwrap_or("");
+            let body = args["body"].as_str().unwrap_or("");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                url: Some(url.to_string()),
+                query: Some(method.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("web_api", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("web_api", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("WebAPI", "called", None);
+            match WebClient::new() {
+                Ok(client) => {
+                    match client.api_request(method, url, headers, body) {
+                        Ok((status, resp_headers, resp_body)) => {
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            let truncated = if resp_body.len() > 50000 { &resp_body[..50000] } else { &resp_body };
+                            json!({"type": "text", "text": format!(
+                                "API {} {} → HTTP {}\n\nHeaders:\n{}\n\nBody:\n{}",
+                                method, url, status, resp_headers, truncated
+                            )})
+                        }
+                        Err(e) => {
+                            session.record_failure("WebAPI", &e);
+                            session.record_manifest("web_api", decision.complexity.c, "ALLOWED", None);
+                            let _ = storage.save_session(session);
+                            json!({"type": "text", "text": format!("API request failed: {}", e)})
+                        }
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("WebAPI", &e);
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("WebClient init failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_notebook_edit ======
+        "spf_notebook_edit" => {
+            let notebook_path = args["notebook_path"].as_str().unwrap_or("");
+            let new_source = args["new_source"].as_str().unwrap_or("");
+            let cell_number = args["cell_number"].as_u64().unwrap_or(0) as usize;
+            let cell_type = args["cell_type"].as_str().unwrap_or("code");
+            let edit_mode = args["edit_mode"].as_str().unwrap_or("replace");
+
+            // HARDCODE: Gate check — NO BYPASS
+            let params = ToolParams {
+                file_path: Some(notebook_path.to_string()),
+                content: Some(new_source.to_string()),
+                ..Default::default()
+            };
+            let decision = gate::process("NotebookEdit", &params, config, session, false);
+            if !decision.allowed {
+                session.record_manifest("NotebookEdit", decision.complexity.c, "BLOCKED",
+                    decision.errors.first().map(|s| s.as_str()));
+                let _ = storage.save_session(session);
+                return json!({"type": "text", "text": format!("BLOCKED: {}", decision.errors.join(", "))});
+            }
+
+            session.record_action("NotebookEdit", "called", Some(notebook_path));
+
+            // Read notebook JSON
+            match std::fs::read_to_string(notebook_path) {
+                Ok(content) => {
+                    match serde_json::from_str::<Value>(&content) {
+                        Ok(mut notebook) => {
+                            if let Some(cells) = notebook.get_mut("cells").and_then(|c| c.as_array_mut()) {
+                                match edit_mode {
+                                    "replace" => {
+                                        if cell_number < cells.len() {
+                                            cells[cell_number]["source"] = json!([new_source]);
+                                            cells[cell_number]["cell_type"] = json!(cell_type);
+                                        } else {
+                                            return json!({"type": "text", "text": format!("Cell {} not found", cell_number)});
+                                        }
+                                    }
+                                    "insert" => {
+                                        let new_cell = json!({
+                                            "cell_type": cell_type,
+                                            "source": [new_source],
+                                            "metadata": {},
+                                            "outputs": []
+                                        });
+                                        cells.insert(cell_number, new_cell);
+                                    }
+                                    "delete" => {
+                                        if cell_number < cells.len() {
+                                            cells.remove(cell_number);
+                                        }
+                                    }
+                                    _ => return json!({"type": "text", "text": "Invalid edit_mode"})
+                                }
+
+                                // Write back
+                                match std::fs::write(notebook_path, serde_json::to_string_pretty(&notebook).unwrap()) {
+                                    Ok(()) => {
+                                        session.track_write(notebook_path);
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Notebook edited: {} cell {} ({})", notebook_path, cell_number, edit_mode)})
+                                    }
+                                    Err(e) => {
+                                        session.record_failure("NotebookEdit", &e.to_string());
+                                        let _ = storage.save_session(session);
+                                        json!({"type": "text", "text": format!("Write failed: {}", e)})
+                                    }
+                                }
+                            } else {
+                                json!({"type": "text", "text": "Invalid notebook: no cells array"})
+                            }
+                        }
+                        Err(e) => json!({"type": "text", "text": format!("JSON parse error: {}", e)})
+                    }
+                }
+                Err(e) => {
+                    session.record_failure("NotebookEdit", &e.to_string());
+                    let _ = storage.save_session(session);
+                    json!({"type": "text", "text": format!("Read failed: {}", e)})
+                }
+            }
+        }
+
+        // ====== spf_brain_search ======
+        "spf_brain_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let limit = args["limit"].as_u64().unwrap_or(5);
+
+            session.record_action("brain_search", "called", None);
+
+            let limit_str = limit.to_string();
+            let mut search_args = vec!["search", query, "--top-k", &limit_str];
+            if collection != "default" && !collection.is_empty() {
+                search_args.push("--collection");
+                search_args.push(collection);
+            }
+            let (success, output) = run_brain(&search_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Brain search '{}':\n\n{}", query, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_store ======
+        "spf_brain_store" => {
+            let text = args["text"].as_str().unwrap_or("");
+            let title = args["title"].as_str().unwrap_or("untitled");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let tags = args["tags"].as_str().unwrap_or("");
+
+            session.record_action("brain_store", "called", None);
+
+            let mut cmd_args = vec!["store", text, "--title", title, "--collection", collection, "--index"];
+            if !tags.is_empty() {
+                cmd_args.push("--tags");
+                cmd_args.push(tags);
+            }
+
+            let (success, output) = run_brain(&cmd_args);
+            let _ = storage.save_session(session);
+
+            if success {
+                json!({"type": "text", "text": format!("Stored to brain:\n{}", output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain store failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_context ======
+        "spf_brain_context" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let max_tokens = args["max_tokens"].as_u64().unwrap_or(2000);
+            session.record_action("brain_context", "called", None);
+            let (success, output) = run_brain(&["context", query, "--max-tokens", &max_tokens.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain context failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_index ======
+        "spf_brain_index" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("brain_index", "called", Some(path));
+            let (success, output) = run_brain(&["index", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": format!("Indexed: {}\n{}", path, output)})
+            } else {
+                json!({"type": "text", "text": format!("Brain index failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list ======
+        "spf_brain_list" => {
+            session.record_action("brain_list", "called", None);
+            let (success, output) = run_brain(&["list"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_status ======
+        "spf_brain_status" => {
+            session.record_action("brain_status", "called", None);
+            let brain = brain_path();
+            let mut parts = vec![format!("Binary: {:?} ({})", brain, if brain.exists() { "OK" } else { "NOT FOUND" })];
+            let (success, output) = run_brain(&["list"]);
+            if success {
+                parts.push(format!("Collections:\n{}", output));
+            }
+            let storage_path = dirs_home().join("stoneshell-brain/storage");
+            if storage_path.exists() {
+                if let Ok(entries) = std::fs::read_dir(&storage_path) {
+                    let size: u64 = entries.filter_map(|e| e.ok()).filter_map(|e| e.metadata().ok()).map(|m| m.len()).sum();
+                    parts.push(format!("Storage: {:.2} MB", size as f64 / 1024.0 / 1024.0));
+                }
+            }
+            let _ = storage.save_session(session);
+            json!({"type": "text", "text": parts.join("\n\n")})
+        }
+
+        // ====== spf_brain_recall ======
+        "spf_brain_recall" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_recall", "called", None);
+            let (success, output) = run_brain(&["recall", query, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain recall failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_list_docs ======
+        "spf_brain_list_docs" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_list_docs", "called", None);
+            let (success, output) = run_brain(&["list-docs", "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain list-docs failed: {}", output)})
+            }
+        }
+
+        // ====== spf_brain_get_doc ======
+        "spf_brain_get_doc" => {
+            let doc_id = args["doc_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("brain_get_doc", "called", None);
+            let (success, output) = run_brain(&["get-doc", doc_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("Brain get-doc failed: {}", output)})
+            }
+        }
+
+        // ====== RAG COLLECTOR HANDLERS ======
+
+        // ====== spf_rag_collect_web ======
+        "spf_rag_collect_web" => {
+            let topic = args["topic"].as_str().unwrap_or("");
+            session.record_action("rag_collect_web", "called", None);
+            let mut cmd_args = vec!["collect"];
+            if !topic.is_empty() {
+                cmd_args.push("--topic");
+                cmd_args.push(topic);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-web failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_file ======
+        "spf_rag_collect_file" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_file", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-file failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_folder ======
+        "spf_rag_collect_folder" => {
+            let path = args["path"].as_str().unwrap_or("");
+            session.record_action("rag_collect_folder", "called", Some(path));
+            let (success, output) = run_rag(&["collect", "--path", path]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-folder failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_drop ======
+        "spf_rag_collect_drop" => {
+            session.record_action("rag_collect_drop", "called", None);
+            let (success, output) = run_rag(&["drop"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-drop failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_index_gathered ======
+        "spf_rag_index_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_index_gathered", "called", None);
+            let mut cmd_args = vec!["index"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG index-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_dedupe ======
+        "spf_rag_dedupe" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_dedupe", "called", None);
+            // Dedupe goes through brain binary directly
+            let (success, output) = run_brain(&["dedup", "-c", category]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG dedupe failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_status ======
+        "spf_rag_status" => {
+            session.record_action("rag_status", "called", None);
+            let (success, output) = run_rag(&["status"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_gathered ======
+        "spf_rag_list_gathered" => {
+            let category = args["category"].as_str().unwrap_or("");
+            session.record_action("rag_list_gathered", "called", None);
+            let mut cmd_args = vec!["list-gathered"];
+            if !category.is_empty() {
+                cmd_args.push("--category");
+                cmd_args.push(category);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-gathered failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_bandwidth_status ======
+        "spf_rag_bandwidth_status" => {
+            session.record_action("rag_bandwidth_status", "called", None);
+            let (success, output) = run_rag(&["bandwidth"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG bandwidth-status failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fetch_url ======
+        "spf_rag_fetch_url" => {
+            let url = args["url"].as_str().unwrap_or("");
+            session.record_action("rag_fetch_url", "called", None);
+            // Fetch URL through collect with path (URL handling)
+            let (success, output) = run_rag(&["collect", "--path", url]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fetch-url failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_collect_rss ======
+        "spf_rag_collect_rss" => {
+            let feed_name = args["feed_name"].as_str().unwrap_or("");
+            session.record_action("rag_collect_rss", "called", None);
+            let mut cmd_args = vec!["rss"];
+            if !feed_name.is_empty() {
+                cmd_args.push("--feed");
+                cmd_args.push(feed_name);
+            }
+            let (success, output) = run_rag(&cmd_args);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG collect-rss failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_list_feeds ======
+        "spf_rag_list_feeds" => {
+            session.record_action("rag_list_feeds", "called", None);
+            // Read RSS config directly
+            let rss_path = rag_collector_dir().join("sources/rss_sources.json");
+            let (success, output) = if rss_path.exists() {
+                match std::fs::read_to_string(&rss_path) {
+                    Ok(content) => (true, content),
+                    Err(e) => (false, format!("Failed to read RSS sources: {}", e)),
+                }
+            } else {
+                (false, "RSS sources file not found".to_string())
+            };
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG list-feeds failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_pending_searches ======
+        "spf_rag_pending_searches" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_pending_searches", "called", None);
+            let (success, output) = run_brain(&["pending-searches", "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG pending-searches failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_fulfill_search ======
+        "spf_rag_fulfill_search" => {
+            let seeker_id = args["seeker_id"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_fulfill_search", "called", None);
+            let (success, output) = run_brain(&["fulfill-search", seeker_id, "-c", collection]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG fulfill-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_smart_search ======
+        "spf_rag_smart_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let collection = args["collection"].as_str().unwrap_or("default");
+            session.record_action("rag_smart_search", "called", None);
+            let (success, output) = run_brain(&["smart-search", query, "-c", collection, "-f", "json"]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG smart-search failed: {}", output)})
+            }
+        }
+
+        // ====== spf_rag_auto_fetch_gaps ======
+        "spf_rag_auto_fetch_gaps" => {
+            let collection = args["collection"].as_str().unwrap_or("default");
+            let max_fetches = args["max_fetches"].as_u64().unwrap_or(5);
+            session.record_action("rag_auto_fetch_gaps", "called", None);
+            // Auto-fetch uses pending-searches then fetches URLs
+            let (success, output) = run_brain(&["auto-fetch", "-c", collection, "--max", &max_fetches.to_string()]);
+            let _ = storage.save_session(session);
+            if success {
+                json!({"type": "text", "text": output})
+            } else {
+                json!({"type": "text", "text": format!("RAG auto-fetch-gaps failed: {}", output)})
+            }
+        }
+
+        // ====== SPF_CONFIG HANDLERS ======
+        // NOTE: spf_config_get and spf_config_set blocked - user-only via CLI
+        "spf_config_get" | "spf_config_set" => {
+            json!({"type": "text", "text": "BLOCKED: Config read/write is user-only (use CLI)"})
+        }
+
+        "spf_config_paths" => {
+            session.record_action("config_paths", "list", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.list_path_rules() {
+                    Ok(rules) => {
+                        let text = rules.iter()
+                            .map(|(t, p)| format!("{}: {}", t, p))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No path rules configured".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_path_rules failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        "spf_config_stats" => {
+            session.record_action("config_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match config_db {
+                Some(db) => match db.stats() {
+                    Ok((config_count, paths_count, patterns_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_CONFIG LMDB Stats:\n  Config entries: {}\n  Path rules: {}\n  Dangerous patterns: {}",
+                            config_count, paths_count, patterns_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("config_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_CONFIG LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_TOOLS HANDLERS ======
+        "spf_tools_list" => {
+            session.record_action("tools_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.list_tools() {
+                    Ok(tools) => {
+                        let text = tools.iter()
+                            .map(|t| format!("{}: {:?} | calls={} allowed={} blocked={} avg_c={:.0}",
+                                t.name, t.permission, t.stats.call_count,
+                                t.stats.allowed_count, t.stats.blocked_count, t.stats.avg_complexity))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No tools registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_tools failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_stats" => {
+            session.record_action("tools_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.db_stats() {
+                    Ok((tools_count, history_count, aliases_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_TOOLS LMDB Stats:\n  Registered tools: {}\n  History entries: {}\n  Aliases: {}",
+                            tools_count, history_count, aliases_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("tools_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        "spf_tools_get" => {
+            let name_arg = args["name"].as_str().unwrap_or("");
+            session.record_action("tools_get", "get", Some(name_arg));
+            let _ = storage.save_session(session);
+
+            match tools_db {
+                Some(db) => match db.get_tool(name_arg) {
+                    Ok(Some(tool)) => {
+                        json!({"type": "text", "text": format!(
+                            "Tool: {}\nPermission: {:?}\nMCP: {} (server: {})\nCalls: {} | Allowed: {} | Blocked: {}\nTotal C: {} | Avg C: {:.0}\nFirst used: {} | Last used: {}\nNotes: {}",
+                            tool.name, tool.permission, tool.is_mcp,
+                            tool.mcp_server.as_deref().unwrap_or("N/A"),
+                            tool.stats.call_count, tool.stats.allowed_count, tool.stats.blocked_count,
+                            tool.stats.total_complexity, tool.stats.avg_complexity,
+                            format_timestamp(tool.stats.first_used), format_timestamp(tool.stats.last_used),
+                            if tool.notes.is_empty() { "None" } else { &tool.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Tool not found: {}", name_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_tool failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_TOOLS LMDB not initialized"}),
+            }
+        }
+
+        // ====== SPF_SANDBOX HANDLERS ======
+        "spf_sandbox_list" => {
+            session.record_action("sandbox_list", "list", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.list_projects() {
+                    Ok(projects) => {
+                        let text = projects.iter()
+                            .map(|p| format!("{}: {} | trust={:?} | reads={} writes={} | active={}",
+                                p.name, p.path, p.trust_level,
+                                p.total_reads, p.total_writes, p.is_active))
+                            .collect::<Vec<_>>()
+                            .join("\n");
+                        json!({"type": "text", "text": if text.is_empty() { "No sandboxes registered".to_string() } else { text }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("list_projects failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_stats" => {
+            session.record_action("sandbox_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.db_stats() {
+                    Ok((projects_count, access_count, resources_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "SPF_SANDBOX LMDB Stats:\n  Registered projects: {}\n  Access log entries: {}\n  Resource records: {}",
+                            projects_count, access_count, resources_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("sandbox_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_get" => {
+            let path_arg = args["path"].as_str().unwrap_or("");
+            session.record_action("sandbox_get", "get", Some(path_arg));
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_project(path_arg) {
+                    Ok(Some(proj)) => {
+                        json!({"type": "text", "text": format!(
+                            "Project: {}\nPath: {}\nTrust: {:?}\nActive: {}\nReads: {} | Writes: {} | Session writes: {}/{}\nMax write size: {} | Total C: {}\nProtected: {:?}\nCreated: {} | Last accessed: {}\nNotes: {}",
+                            proj.name, proj.path, proj.trust_level, proj.is_active,
+                            proj.total_reads, proj.total_writes, proj.session_writes, proj.max_writes_per_session,
+                            proj.max_write_size, proj.total_complexity,
+                            proj.protected_paths,
+                            format_timestamp(proj.created_at), format_timestamp(proj.last_accessed),
+                            if proj.notes.is_empty() { "None" } else { &proj.notes }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": format!("Project not found: {}", path_arg)}),
+                    Err(e) => json!({"type": "text", "text": format!("get_project failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        "spf_sandbox_active" => {
+            session.record_action("sandbox_active", "get", None);
+            let _ = storage.save_session(session);
+
+            match sandbox_db {
+                Some(db) => match db.get_active() {
+                    Ok(Some(path)) => {
+                        // Also fetch project details
+                        match db.get_project(&path) {
+                            Ok(Some(proj)) => {
+                                json!({"type": "text", "text": format!(
+                                    "Active project: {} ({})\nTrust: {:?} | Reads: {} | Writes: {}",
+                                    proj.name, proj.path, proj.trust_level, proj.total_reads, proj.total_writes
+                                )})
+                            }
+                            _ => json!({"type": "text", "text": format!("Active project path: {} (details unavailable)", path)}),
+                        }
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No active project"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_active failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "SPF_SANDBOX LMDB not initialized"}),
+            }
+        }
+
+        // ====== AGENT_STATE HANDLERS ======
+        // BLOCKED: Write operations are user-only
+        "spf_agent_remember" | "spf_agent_forget" | "spf_agent_set_state" => {
+            json!({"type": "text", "text": "BLOCKED: Agent state writes are user-only (use CLI)"})
+        }
+
+        "spf_agent_stats" => {
+            session.record_action("agent_stats", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.db_stats() {
+                    Ok((memory_count, sessions_count, state_count, tags_count)) => {
+                        json!({"type": "text", "text": format!(
+                            "AGENT_STATE LMDB Stats:\n  Memories: {}\n  Sessions: {}\n  State keys: {}\n  Tags: {}",
+                            memory_count, sessions_count, state_count, tags_count
+                        )})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("agent_stats failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_search" => {
+            let query = args["query"].as_str().unwrap_or("");
+            let limit = args["limit"].as_u64().unwrap_or(10) as usize;
+            session.record_action("agent_memory_search", "search", Some(query));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.search_memories(query, limit) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories found for: {}", query)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}\n  Tags: {:?} | Created: {}",
+                                    m.id, m.memory_type, m.content,
+                                    m.tags, format_timestamp(m.created_at)))
+                                .collect::<Vec<_>>()
+                                .join("\n\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("search_memories failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_memory_by_tag" => {
+            let tag = args["tag"].as_str().unwrap_or("");
+            session.record_action("agent_memory_by_tag", "search", Some(tag));
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_by_tag(tag) {
+                    Ok(memories) => {
+                        if memories.is_empty() {
+                            json!({"type": "text", "text": format!("No memories with tag: {}", tag)})
+                        } else {
+                            let text = memories.iter()
+                                .map(|m| format!("[{}] {:?} | {}",
+                                    m.id, m.memory_type, m.content))
+                                .collect::<Vec<_>>()
+                                .join("\n");
+                            json!({"type": "text", "text": text})
+                        }
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_by_tag failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_session_info" => {
+            session.record_action("agent_session_info", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_latest_session() {
+                    Ok(Some(sess)) => {
+                        json!({"type": "text", "text": format!(
+                            "Session: {}\nParent: {}\nStarted: {} | Ended: {}\nWorking dir: {}\nProject: {}\nFiles modified: {}\nComplexity: {} | Actions: {}\nSummary: {}",
+                            sess.session_id,
+                            sess.parent_session.as_deref().unwrap_or("None"),
+                            format_timestamp(sess.started_at),
+                            if sess.ended_at == 0 { "Ongoing".to_string() } else { format_timestamp(sess.ended_at) },
+                            sess.working_dir,
+                            sess.active_project.as_deref().unwrap_or("None"),
+                            sess.files_modified.len(),
+                            sess.total_complexity, sess.total_actions,
+                            if sess.summary.is_empty() { "None" } else { &sess.summary }
+                        )})
+                    }
+                    Ok(None) => json!({"type": "text", "text": "No sessions recorded"}),
+                    Err(e) => json!({"type": "text", "text": format!("get_latest_session failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        "spf_agent_context" => {
+            session.record_action("agent_context", "get", None);
+            let _ = storage.save_session(session);
+
+            match agent_db {
+                Some(db) => match db.get_context_summary() {
+                    Ok(summary) => {
+                        json!({"type": "text", "text": if summary.is_empty() { "No context available".to_string() } else { summary }})
+                    }
+                    Err(e) => json!({"type": "text", "text": format!("get_context_summary failed: {}", e)}),
+                },
+                None => json!({"type": "text", "text": "AGENT_STATE LMDB not initialized"}),
+            }
+        }
+
+        _ => {
+            json!({"type": "text", "text": format!("Unknown tool: {}", name)})
+        }
+    }
+}
+
+/// Main MCP server loop — runs forever on stdio
+pub fn run(config: SpfConfig, mut session: Session, storage: SpfStorage) {
+    log(&format!("Starting {} v{}", SERVER_NAME, SERVER_VERSION));
+    log(&format!("Mode: {:?}", config.enforce_mode));
+
+    // Initialize SPF_CONFIG LMDB
+    // Path is relative to HOME/SPFsmartGATE - same base as the binary location
+    let spf_base = dirs_home().join("SPFsmartGATE");
+    let config_db_path = spf_base.join("storage/spf_config");
+    log(&format!("SPF_CONFIG path: {:?}", config_db_path));
+
+    let config_db = match SpfConfigDb::open(&config_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_CONFIG init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_CONFIG LMDB initialized at {:?}", config_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_CONFIG LMDB at {:?}: {}", config_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_TOOLS LMDB
+    let tools_db_path = spf_base.join("storage/spf_tools");
+    log(&format!("SPF_TOOLS path: {:?}", tools_db_path));
+
+    let tools_db = match SpfToolsDb::open(&tools_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: SPF_TOOLS init_defaults failed: {}", e));
+            }
+            log(&format!("SPF_TOOLS LMDB initialized at {:?}", tools_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_TOOLS LMDB at {:?}: {}", tools_db_path, e));
+            None
+        }
+    };
+
+    // Initialize SPF_SANDBOX LMDB
+    let sandbox_db_path = spf_base.join("storage/spf_sandbox");
+    log(&format!("SPF_SANDBOX path: {:?}", sandbox_db_path));
+
+    let sandbox_db = match SpfSandboxDb::open(&sandbox_db_path) {
+        Ok(db) => {
+            log(&format!("SPF_SANDBOX LMDB initialized at {:?}", sandbox_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open SPF_SANDBOX LMDB at {:?}: {}", sandbox_db_path, e));
+            None
+        }
+    };
+
+    // Initialize AGENT_STATE LMDB
+    let agent_db_path = spf_base.join("storage/agent_state");
+    log(&format!("AGENT_STATE path: {:?}", agent_db_path));
+
+    let agent_db = match AgentStateDb::open(&agent_db_path) {
+        Ok(db) => {
+            if let Err(e) = db.init_defaults() {
+                log(&format!("Warning: AGENT_STATE init_defaults failed: {}", e));
+            }
+            log(&format!("AGENT_STATE LMDB initialized at {:?}", agent_db_path));
+            Some(db)
+        }
+        Err(e) => {
+            log(&format!("Warning: Failed to open AGENT_STATE LMDB at {:?}: {}", agent_db_path, e));
+            None
+        }
+    };
+
+    let stdin = io::stdin();
+    for line in stdin.lock().lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                log(&format!("stdin read error: {}", e));
+                continue;
+            }
+        };
+
+        let line = line.trim().to_string();
+        if line.is_empty() {
+            continue;
+        }
+
+        let msg: Value = match serde_json::from_str(&line) {
+            Ok(v) => v,
+            Err(e) => {
+                log(&format!("JSON parse error: {}", e));
+                continue;
+            }
+        };
+
+        let method = msg["method"].as_str().unwrap_or("");
+        let id = &msg["id"];
+        let params = &msg["params"];
+
+        log(&format!("Received: {}", method));
+
+        match method {
+            "initialize" => {
+                send_response(id, json!({
+                    "protocolVersion": PROTOCOL_VERSION,
+                    "capabilities": { "tools": {} },
+                    "serverInfo": {
+                        "name": SERVER_NAME,
+                        "version": SERVER_VERSION,
+                    }
+                }));
+            }
+
+            "notifications/initialized" => {
+                // No response needed
+            }
+
+            "tools/list" => {
+                send_response(id, json!({ "tools": tool_definitions() }));
+            }
+
+            "tools/call" => {
+                let name = params["name"].as_str().unwrap_or("");
+                let args = params.get("arguments").cloned().unwrap_or(json!({}));
+
+                let result = handle_tool_call(name, &args, &config, &mut session, &storage, &config_db, &tools_db, &sandbox_db, &agent_db);
+
+                send_response(id, json!({
+                    "content": [result]
+                }));
+            }
+
+            "ping" => {
+                send_response(id, json!({}));
+            }
+
+            _ => {
+                if !id.is_null() {
+                    send_error(id, -32601, &format!("Unknown method: {}", method));
+                }
+            }
+        }
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/a22eabd3fe8c8cc0@v62

@@ -0,0 +1,126 @@
+{
+  "numStartups": 3,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 1,
+    "plan-mode-for-complex-tasks": 1,
+    "terminal-setup": 1,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 1,
+    "install-slack-app": 1,
+    "drag-and-drop-images": 1,
+    "double-esc-code-restore": 1,
+    "continue": 1,
+    "shift-tab": 1,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1
+  },
+  "promptQueueUseCount": 223,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.20",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 1,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 10931,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "c6a4bf85-a4f9-42b0-bb12-a9ff597589c8"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/target/release/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "displayName": "trumpmas",
+    "organizationRole": "admin",
+    "workspaceRole": null,
+    "organizationName": "trumpmas2@gmail.com's Organization"
+  }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/a22eabd3fe8c8cc0@v63

@@ -0,0 +1,130 @@
+{
+  "numStartups": 3,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 1,
+    "plan-mode-for-complex-tasks": 1,
+    "terminal-setup": 1,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 1,
+    "install-slack-app": 1,
+    "drag-and-drop-images": 1,
+    "double-esc-code-restore": 1,
+    "continue": 1,
+    "shift-tab": 1,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1
+  },
+  "promptQueueUseCount": 223,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.20",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 1,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 10931,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "c6a4bf85-a4f9-42b0-bb12-a9ff597589c8"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/target/release/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "displayName": "trumpmas",
+    "organizationRole": "admin",
+    "workspaceRole": null,
+    "organizationName": "trumpmas2@gmail.com's Organization"
+  },
+  "claudeInChromeDefaultEnabled": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/b9964c9366da259f@v1

@@ -0,0 +1,539 @@
+# SPF Smart Gateway - Forensic Audit Report
+
+**AUDIT DATE:** 2026-02-05
+**AUDITOR:** Claude Opus 4.5
+**SCOPE:** Complete codebase vs. Developer Bible v1.0
+**STATUS:** DISCREPANCIES FOUND - BIBLE CORRECTIONS REQUIRED
+
+---
+
+# EXECUTIVE SUMMARY
+
+The Developer Bible contains **47 significant discrepancies** requiring correction:
+- **14** incorrect line counts
+- **11** missing files/directories
+- **8** incorrect struct/function definitions
+- **6** missing features (hooks system)
+- **8** undocumented directories/files
+
+---
+
+# 1. COMPLETE VERIFIED FILE TREE
+
+```
+SPFsmartGATE/                                    # Root directory
+├── Cargo.toml                    [3,129 bytes]  # Build manifest
+├── Cargo.lock                    [59,637 bytes] # Dependency lock
+├── LICENSE                       [8,117 bytes]  # Commercial license
+├── README.md                     [6,574 bytes]  # Public overview
+├── HANDOFF.md                    [2,421 bytes]  # Session continuity
+├── config.json                   [16,509 bytes] # ROOT CONFIG (not in Bible!)
+├── main.rs                       [6,145 bytes]  # DUPLICATE at root (not in Bible!)
+├── .claude.json                  [16,515 bytes] # Claude config (not in Bible!)
+│
+├── src/                                         # SOURCE CODE (19 files)
+│   ├── lib.rs                    [33 lines]    # Library exports
+│   ├── main.rs                   [190 lines]   # CLI entry point
+│   ├── config.rs                 [196 lines]   # Configuration types
+│   ├── config_db.rs              [448 lines]   # LMDB config operations
+│   ├── calculate.rs              [311 lines]   # SPF complexity formula
+│   ├── validate.rs               [155 lines]   # Rule validation
+│   ├── gate.rs                   [130 lines]   # Primary enforcement
+│   ├── gate-EDITED.rs            [172 lines]   # EDITED VERSION (not in Bible!)
+│   ├── inspect.rs                [144 lines]   # Content inspection
+│   ├── session.rs                [156 lines]   # Session state tracking
+│   ├── storage.rs                [100 lines]   # LMDB persistence
+│   ├── tools_db.rs               [433 lines]   # Tool registry LMDB
+│   ├── sandbox_db.rs             [609 lines]   # Project sandbox LMDB
+│   ├── agent_state.rs            [683 lines]   # Agent memory LMDB
+│   ├── claude_state.rs           [670 lines]   # Claude-specific state (not detailed!)
+│   ├── fs.rs                     [628 lines]   # Virtual filesystem
+│   ├── web.rs                    [289 lines]   # HTTP client
+│   ├── mcp.rs                    [2,103 lines] # MCP server (LARGEST)
+│   └── mcp-EDITED.rs             [1,420 lines] # EDITED VERSION (not in Bible!)
+│
+├── docs/                                        # Documentation
+│   ├── DEVELOPER_BIBLE.md                       # Main documentation
+│   ├── ARCHITECTURE.md                          # Architecture doc
+│   └── FORENSIC_AUDIT_REPORT.md                 # THIS FILE
+│
+├── claude/                                      # NOT IN BIBLE!
+│   └── INSTRUCTIONS.md           [4,591 bytes] # Claude working instructions
+│
+├── hooks/                                       # NOT IN BIBLE! (18 files)
+│   ├── spf-gate.sh               [2,621 bytes] # Main enforcement hook
+│   ├── spf-gate.sh.bak           [2,621 bytes] # Backup
+│   ├── post-action.sh            [5,393 bytes] # Post-action hook
+│   ├── post-failure.sh           [1,525 bytes] # Failure handler
+│   ├── pre-bash.sh               [494 bytes]   # Pre-bash gate
+│   ├── pre-edit.sh               [494 bytes]   # Pre-edit gate
+│   ├── pre-glob.sh               [435 bytes]   # Pre-glob gate
+│   ├── pre-grep.sh               [435 bytes]   # Pre-grep gate
+│   ├── pre-notebookedit.sh       [467 bytes]   # Pre-notebook gate
+│   ├── pre-read.sh               [518 bytes]   # Pre-read gate
+│   ├── pre-webfetch.sh           [461 bytes]   # Pre-webfetch gate
+│   ├── pre-websearch.sh          [480 bytes]   # Pre-websearch gate
+│   ├── pre-write.sh              [498 bytes]   # Pre-write gate
+│   ├── session-end.sh            [2,485 bytes] # Session end handler
+│   ├── session-start.sh          [2,556 bytes] # Session start handler
+│   ├── stop-check.sh             [1,412 bytes] # Stop check
+│   └── user-prompt.sh            [6,548 bytes] # User prompt handler
+│
+├── agent-bin/                                   # NOT IN BIBLE!
+│   ├── spf-smart-gate                           # Gateway binary copy
+│   └── claude-code                              # Claude Code binary
+│
+├── storage/                                     # LMDB Databases (222MB)
+│   ├── data.mdb                                 # Root session storage
+│   ├── lock.mdb                                 # Root lock
+│   ├── config.json                              # Storage config copy
+│   ├── spf_config/               [60KB]         # Configuration LMDB
+│   │   ├── data.mdb              [53,248 bytes]
+│   │   └── lock.mdb              [8,192 bytes]
+│   ├── spf_tools/                [56KB]         # Tool registry LMDB
+│   │   ├── data.mdb              [49,152 bytes]
+│   │   └── lock.mdb              [8,192 bytes]
+│   ├── spf_sandbox/              [20KB]         # Project sandbox LMDB
+│   │   ├── data.mdb              [12,288 bytes]
+│   │   └── lock.mdb              [8,192 bytes]
+│   ├── agent_state/              [60KB]         # Agent memory LMDB
+│   │   ├── data.mdb              [53,248 bytes]
+│   │   └── lock.mdb              [8,192 bytes]
+│   ├── blobs/                    [221MB]        # NOT IN BIBLE!
+│   │   ├── [hash files]                         # Large file blobs
+│   │   └── claude-code/                         # Claude Code vendor files
+│   │       └── vendor/ripgrep/                  # ripgrep binaries
+│   └── staging/                                 # NOT IN BIBLE!
+│       └── configs/                             # Staging area
+│
+├── backup/                                      # NOT IN BIBLE!
+├── sandbox/                                     # NOT IN BIBLE!
+├── scripts/                                     # NOT IN BIBLE!
+├── state/                                       # NOT IN BIBLE!
+│
+└── target/                                      # Build output
+    └── release/
+        └── spf-smart-gate        [~15MB]        # Release binary
+```
+
+---
+
+# 2. LINE COUNT CORRECTIONS
+
+| File | Bible Says | Actual | Delta | Status |
+|------|------------|--------|-------|--------|
+| lib.rs | 26 | **33** | +7 | INCORRECT |
+| main.rs | 191 | **190** | -1 | CLOSE |
+| config.rs | 147 | **196** | +49 | INCORRECT |
+| config_db.rs | 260 | **448** | +188 | INCORRECT |
+| calculate.rs | 230 | **311** | +81 | INCORRECT |
+| validate.rs | 203 | **155** | -48 | INCORRECT |
+| gate.rs | 100 | **130** | +30 | INCORRECT |
+| inspect.rs | 110 | **144** | +34 | INCORRECT |
+| session.rs | 270 | **156** | -114 | INCORRECT |
+| storage.rs | 160 | **100** | -60 | INCORRECT |
+| tools_db.rs | 420 | **433** | +13 | CLOSE |
+| sandbox_db.rs | 609 | **609** | 0 | CORRECT ✓ |
+| agent_state.rs | 683 | **683** | 0 | CORRECT ✓ |
+| fs.rs | 628 | **628** | 0 | CORRECT ✓ |
+| web.rs | 290 | **289** | -1 | CLOSE |
+| mcp.rs | 2,103 | **2,103** | 0 | CORRECT ✓ |
+| claude_state.rs | (not listed) | **670** | N/A | MISSING |
+| gate-EDITED.rs | (not listed) | **172** | N/A | MISSING |
+| mcp-EDITED.rs | (not listed) | **1,420** | N/A | MISSING |
+
+**TOTAL ACTUAL:** 8,870 lines (Bible: 8,870 - matches)
+
+---
+
+# 3. STRUCT/ENUM CORRECTIONS
+
+## 3.1 ComplexityResult (calculate.rs:12-20)
+
+**Bible says:**
+```rust
+pub struct ComplexityResult {
+    pub c: u64,
+    pub tier: String,
+    pub analyze_tokens: u64,
+    pub build_tokens: u64,
+    pub requires_approval: bool,
+    pub basic: u64,
+    pub deps: u64,
+    pub complex: u64,
+    pub files: u64,
+}
+```
+
+**ACTUAL:**
+```rust
+pub struct ComplexityResult {
+    pub tool: String,              // ADDED
+    pub c: u64,
+    pub tier: String,
+    pub analyze_percent: u8,       // DIFFERENT (was analyze_tokens)
+    pub build_percent: u8,         // DIFFERENT (was build_tokens)
+    pub a_optimal_tokens: u64,     // DIFFERENT (was not present)
+    pub requires_approval: bool,
+    // NO basic, deps, complex, files fields!
+}
+```
+
+## 3.2 ToolParams (calculate.rs:24-49)
+
+**Bible says:** 8 fields
+**ACTUAL:** 15 fields
+
+```rust
+pub struct ToolParams {
+    pub file_path: Option<String>,
+    pub old_string: Option<String>,
+    pub new_string: Option<String>,
+    pub replace_all: Option<bool>,
+    pub content: Option<String>,
+    pub command: Option<String>,
+    pub query: Option<String>,          // ADDED
+    pub pattern: Option<String>,        // ADDED
+    pub path: Option<String>,           // ADDED
+    pub collection: Option<String>,     // ADDED
+    pub limit: Option<u64>,             // ADDED
+    pub text: Option<String>,           // ADDED
+    pub title: Option<String>,          // ADDED
+    pub url: Option<String>,
+    pub topic: Option<String>,          // ADDED
+    pub category: Option<String>,       // ADDED
+}
+```
+
+## 3.3 Session (session.rs:12-24)
+
+**Bible says:**
+```rust
+pub struct Session {
+    pub id: String,
+    pub started_at: u64,
+    pub files_read: Vec<String>,
+    pub files_written: Vec<String>,
+    pub action_count: u64,
+    pub complexity_history: Vec<ComplexityEntry>,
+    pub manifest: Vec<ManifestEntry>,
+    pub total_complexity: u64,
+    pub failures: Vec<FailureEntry>,
+}
+```
+
+**ACTUAL:**
+```rust
+pub struct Session {
+    pub action_count: u64,
+    pub files_read: Vec<String>,
+    pub files_written: Vec<String>,
+    pub last_tool: Option<String>,       // ADDED (not in Bible)
+    pub last_result: Option<String>,     // ADDED (not in Bible)
+    pub last_file: Option<String>,       // ADDED (not in Bible)
+    pub started: DateTime<Utc>,          // DIFFERENT (was started_at: u64)
+    pub last_action: Option<DateTime<Utc>>, // ADDED
+    pub complexity_history: Vec<ComplexityEntry>,
+    pub manifest: Vec<ManifestEntry>,
+    pub failures: Vec<FailureEntry>,
+    // NO id field!
+    // NO total_complexity field!
+}
+```
+
+## 3.4 SpfConfig (config.rs:11-23)
+
+**ACTUAL additional fields NOT in Bible:**
+```rust
+pub require_read_before_edit: bool,
+pub max_write_size: usize,
+pub git_force_patterns: Vec<String>,
+```
+
+## 3.5 FormulaConfig (config.rs:48-59)
+
+**Bible says:**
+```rust
+pub w_eff: u64,
+pub basic_exp: u32,
+pub deps_exp: u32,
+pub complex_exp: u32,
+pub files_mult: u32,
+```
+
+**ACTUAL:**
+```rust
+pub w_eff: f64,                    // DIFFERENT (f64, not u64)
+pub e: f64,                        // ADDED (Euler's number)
+pub basic_power: u32,              // DIFFERENT name (was basic_exp)
+pub deps_power: u32,               // DIFFERENT name (was deps_exp)
+pub complex_power: u32,            // DIFFERENT name (was complex_exp)
+pub files_multiplier: u64,         // DIFFERENT name (was files_mult)
+```
+
+---
+
+# 4. FUNCTION CORRECTIONS
+
+## 4.1 calculate.rs Functions
+
+**Bible says:**
+- `calculate()`
+- `classify_tier()`
+- `calculate_allocation()`
+
+**ACTUAL (7 functions):**
+- `calc_complex_factor()` - NEW
+- `calc_files_factor()` - NEW
+- `is_architectural_file()` - NEW
+- `has_risk_indicators()` - NEW
+- `calculate_c()` - NEW (main calculation)
+- `a_optimal()` - NEW (master formula)
+- `calculate()` - wrapper
+
+## 4.2 validate.rs Functions
+
+**Bible says:**
+- `validate_path()`
+- `validate_anchor()`
+- `validate_command()`
+- `validate_content()`
+
+**ACTUAL (4 functions):**
+- `validate_edit()` - Different name, signature
+- `validate_write()` - Different name, signature
+- `validate_bash()` - Different name, signature
+- `validate_read()` - NEW
+
+## 4.3 inspect.rs Functions
+
+**Bible says:**
+- `inspect_content()` - 1 function
+
+**ACTUAL (5 functions):**
+- `inspect_content()` - public
+- `check_credentials()` - private
+- `check_path_traversal()` - private
+- `check_shell_injection()` - private
+- `check_blocked_path_references()` - private
+
+---
+
+# 5. MCP TOOL COUNT VERIFICATION
+
+**Bible says:** 58 tools
+**ACTUAL tool_def() calls:** 54 tools
+
+**Blocked tools (have handlers but no definitions):**
+- `spf_config_get`
+- `spf_config_set`
+- `spf_agent_remember`
+- `spf_agent_forget`
+- `spf_agent_set_state`
+
+**Tool count breakdown:**
+| Category | Bible | Actual |
+|----------|-------|--------|
+| Core Gate | 4 | 4 |
+| File Operations | 4 | 4 |
+| Search | 2 | 2 |
+| Web | 4 | 4 |
+| Notebook | 1 | 1 |
+| Brain | 9 | 9 |
+| RAG | 14 | 14 |
+| Config | 2 | 2 |
+| Tools DB | 3 | 3 |
+| Sandbox | 4 | 4 |
+| Agent State | 5 | 5 |
+| **TOTAL** | **58** | **54** |
+
+---
+
+# 6. MISSING FROM BIBLE
+
+## 6.1 Hooks System (CRITICAL OMISSION)
+
+The Bible completely misses the **Claude Code Hooks Integration**:
+
+```
+hooks/
+├── spf-gate.sh          # Main enforcement wrapper
+├── pre-{tool}.sh        # Pre-execution gates (10 files)
+├── post-action.sh       # Post-execution logging
+├── post-failure.sh      # Failure handling
+├── session-start.sh     # Session initialization
+├── session-end.sh       # Session cleanup
+├── stop-check.sh        # Stop condition checks
+└── user-prompt.sh       # User prompt handling
+```
+
+**Hook execution flow:**
+```
+User Request
+    ↓
+Claude Code
+    ↓
+pre-{tool}.sh  →  spf-gate.sh  →  Rust Gateway
+    ↓                                    ↓
+[BLOCKED]                          [ALLOWED]
+    ↓                                    ↓
+post-failure.sh                   post-action.sh
+```
+
+## 6.2 Missing Directories
+
+| Directory | Purpose | In Bible |
+|-----------|---------|----------|
+| `claude/` | Claude working directory, instructions | NO |
+| `hooks/` | Hook scripts for Claude Code integration | NO |
+| `agent-bin/` | Binary copies for portability | NO |
+| `backup/` | Backup storage | NO |
+| `sandbox/` | Sandbox workspace | NO |
+| `scripts/` | Utility scripts | NO |
+| `state/` | State storage directory | NO |
+| `storage/blobs/` | Large file blob storage | NO |
+| `storage/staging/` | Staging area | NO |
+
+## 6.3 Missing Files
+
+| File | Purpose | In Bible |
+|------|---------|----------|
+| `config.json` (root) | JSON config backup | NO |
+| `main.rs` (root) | Duplicate main (symlink?) | NO |
+| `.claude.json` | Claude-specific config | NO |
+| `gate-EDITED.rs` | Edited gate version | NO |
+| `mcp-EDITED.rs` | Edited MCP version | NO |
+| `claude/INSTRUCTIONS.md` | Claude working instructions | NO |
+
+## 6.4 Missing Module Details
+
+**claude_state.rs (670 lines)** - Mentioned but not detailed:
+- `MemoryType` enum
+- `MemoryEntry` struct
+- `SessionContext` struct
+- `ClaudePreferences` struct
+- `ClaudeStateDb` struct + impl
+
+---
+
+# 7. LMDB SCHEMA CORRECTIONS
+
+## 7.1 Storage Structure
+
+**Bible says:**
+```
+storage/
+├── spf_fs/           # Virtual filesystem
+├── spf_config/
+├── spf_tools/
+├── spf_sandbox/
+└── agent_state/
+```
+
+**ACTUAL:**
+```
+storage/
+├── data.mdb          # ROOT session storage (not in Bible!)
+├── lock.mdb          # ROOT lock (not in Bible!)
+├── config.json       # Config copy (not in Bible!)
+├── spf_config/
+├── spf_tools/
+├── spf_sandbox/
+├── agent_state/
+├── blobs/            # NOT IN BIBLE! (221MB)
+│   └── claude-code/  # Vendor files
+└── staging/          # NOT IN BIBLE!
+```
+
+**NOTE:** `spf_fs/` does NOT exist as separate directory. The virtual filesystem is integrated differently.
+
+---
+
+# 8. CREDENTIAL PATTERNS (Not in Bible)
+
+The `inspect.rs` module has hardcoded credential detection patterns:
+
+```rust
+const CREDENTIAL_PATTERNS: &[(&str, &str)] = &[
+    ("sk-", "Possible API secret key"),
+    ("AKIA", "Possible AWS access key"),
+    ("ghp_", "Possible GitHub personal access token"),
+    ("gho_", "Possible GitHub OAuth token"),
+    ("ghs_", "Possible GitHub server token"),
+    ("github_pat_", "Possible GitHub PAT"),
+    ("glpat-", "Possible GitLab PAT"),
+    ("xoxb-", "Possible Slack bot token"),
+    ("xoxp-", "Possible Slack user token"),
+    ("-----BEGIN RSA PRIVATE KEY", "RSA private key"),
+    ("-----BEGIN OPENSSH PRIVATE KEY", "SSH private key"),
+    ("-----BEGIN EC PRIVATE KEY", "EC private key"),
+    ("-----BEGIN PRIVATE KEY", "Private key"),
+    ("password=", "Possible hardcoded password"),
+    ("passwd=", "Possible hardcoded password"),
+    ("secret=", "Possible hardcoded secret"),
+    ("api_key=", "Possible hardcoded API key"),
+    ("apikey=", "Possible hardcoded API key"),
+    ("access_token=", "Possible hardcoded access token"),
+];
+```
+
+---
+
+# 9. RECOMMENDATIONS FOR BIBLE UPDATE
+
+## 9.1 CRITICAL (Must Fix)
+
+1. **Add Hooks System documentation** - Complete section on Claude Code integration
+2. **Correct all line counts** - Use verified counts from this audit
+3. **Fix struct definitions** - ComplexityResult, ToolParams, Session, FormulaConfig
+4. **Fix function signatures** - validate.rs functions are completely different
+5. **Document blobs/ directory** - Hybrid storage for large files
+
+## 9.2 HIGH (Should Fix)
+
+6. **Add claude_state.rs documentation** - Full module breakdown
+7. **Add missing directories** - claude/, hooks/, agent-bin/, etc.
+8. **Fix MCP tool count** - 54 definitions, 5 blocked handlers
+9. **Add INSTRUCTIONS.md reference** - Claude working instructions
+10. **Document root-level files** - config.json, .claude.json
+
+## 9.3 MEDIUM (Nice to Have)
+
+11. **Add hook execution flow diagram**
+12. **Document credential detection patterns**
+13. **Add EDITED file explanations** - Why gate-EDITED.rs, mcp-EDITED.rs exist
+14. **Document staging/ directory purpose**
+
+---
+
+# 10. VERIFIED METRICS
+
+| Metric | Bible | Actual | Status |
+|--------|-------|--------|--------|
+| Source Files | 19 | **19** | ✓ CORRECT |
+| Total Lines | 8,870 | **8,870** | ✓ CORRECT |
+| Largest File | mcp.rs (2,103) | **mcp.rs (2,103)** | ✓ CORRECT |
+| Dependencies | 27 | **~27** | ~ CLOSE |
+| LMDB Databases | 5 | **4 + root** | ! DIFFERENT |
+| MCP Tools | 58 | **54** | ! INCORRECT |
+| Complexity Tiers | 4 | **4** | ✓ CORRECT |
+| Hook Scripts | 0 | **18** | ! MISSING |
+| Structs/Enums | (not counted) | **45** | ADD |
+| Functions | (not counted) | **~50** | ADD |
+| impl Blocks | (not counted) | **14** | ADD |
+
+---
+
+# CONCLUSION
+
+The Developer Bible is a **solid foundation** but requires corrections to achieve 100% accuracy. The most critical omission is the **hooks system** which is essential for Claude Code integration and represents ~18 files of operational infrastructure.
+
+**Audit Status:** COMPLETE
+**Bible Accuracy:** ~85%
+**Corrections Required:** 47 items
+
+---
+
+*Forensic Audit completed 2026-02-05*
+*Auditor: Claude Opus 4.5*
+*No writes performed - READ ONLY audit*

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3dd0952a-6814-4012-b669-f7f8e3bc2bc2/e8594d03858e998b@v3

@@ -0,0 +1,190 @@
+// SPF Smart Gateway - Main Entry Point
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// CLI and MCP stdio server. All tool calls route through this gateway.
+// Usage:
+//   spfsmartgate serve                   # Run MCP server (stdio)
+//   spfsmartgate gate <tool> <params>    # One-shot gate check
+//   spfsmartgate status                  # Show gateway status
+//   spfsmartgate session                 # Show session state
+
+use anyhow::{Context, Result};
+use clap::{Parser, Subcommand};
+use spf_smart_gate::{
+    calculate, config_db::SpfConfigDb, gate, mcp,
+    session::Session, storage::SpfStorage,
+};
+use std::path::PathBuf;
+
+fn home_dir() -> PathBuf {
+    std::env::var("HOME")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| PathBuf::from("/data/data/com.termux/files/home"))
+}
+
+fn default_storage_path() -> PathBuf {
+    home_dir().join("SPFsmartGATE/storage")
+}
+
+#[derive(Parser)]
+#[command(name = "spf-smart-gate")]
+#[command(author = "Joseph Stone")]
+#[command(version = "2.0.0")]
+#[command(about = "SPF Smart Gateway - MCP command gateway with LMDB-backed configuration")]
+struct Cli {
+    /// Storage directory (contains all 5 LMDB databases)
+    #[arg(short, long, default_value_os_t = default_storage_path())]
+    storage: PathBuf,
+
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Run MCP server (stdio JSON-RPC)
+    Serve,
+
+    /// One-shot gate check — returns allow/block
+    Gate {
+        /// Tool name (Read, Write, Edit, Bash, etc.)
+        tool: String,
+
+        /// Parameters as JSON string
+        params: String,
+
+        /// User approval for CRITICAL tier
+        #[arg(long)]
+        approved: bool,
+    },
+
+    /// Calculate complexity without executing
+    Calculate {
+        /// Tool name
+        tool: String,
+
+        /// Parameters as JSON string
+        params: String,
+
+        /// User approval for CRITICAL tier (not used here, but kept for consistency)
+        #[arg(long)]
+        approved: bool,
+    },
+
+    /// Show gateway status
+    Status,
+
+    /// Show full session state
+    Session,
+
+    /// Reset session (fresh start)
+    Reset,
+
+    /// Initialize/verify LMDB config (auto-runs on startup)
+    InitConfig,
+}
+
+fn main() -> Result<()> {
+    // Initialize logging (safe if already init)
+    let _ = env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).try_init();
+
+    let cli = Cli::parse();
+
+    // Ensure storage directory exists
+    std::fs::create_dir_all(&cli.storage)
+        .with_context(|| format!("Failed to create storage dir {:?}", cli.storage))?;
+
+    // Open SPF_CONFIG LMDB and load config (SINGLE SOURCE OF TRUTH)
+    let config_db_path = cli.storage.join("spf_config");
+    let config_db = SpfConfigDb::open(&config_db_path)
+        .with_context(|| format!("Failed to open SPF_CONFIG LMDB at {:?}", config_db_path))?;
+
+    let config = config_db.load_full_config()
+        .with_context(|| "Failed to load config from LMDB")?;
+
+    // Open SPF_STATE storage
+    let storage = SpfStorage::open(&cli.storage)
+        .with_context(|| format!("Failed to open storage at {:?}", cli.storage))?;
+
+    // Load or create session
+    let session = storage.load_session()?.unwrap_or_else(Session::new);
+
+    match &cli.command {
+        Commands::Serve => {
+            // Run MCP server — blocks forever, consumes session & storage
+            mcp::run(config, session, storage);
+            // Unreachable
+        }
+
+        Commands::Gate { tool, params, approved } => {
+            let params: calculate::ToolParams = serde_json::from_str(params)
+                .with_context(|| format!("Invalid params JSON: {}", params))?;
+
+            let decision = gate::process(tool, &params, &config, &session, *approved);
+
+            println!("{}", serde_json::to_string_pretty(&decision)?);
+
+            if !decision.allowed {
+                std::process::exit(1);
+            }
+
+            // Save session after gate call
+            storage.save_session(&session)?;
+        }
+
+        Commands::Calculate { tool, params, approved: _ } => {
+            let params: calculate::ToolParams = serde_json::from_str(params)
+                .with_context(|| format!("Invalid params JSON: {}", params))?;
+
+            let result = calculate::calculate(tool, &params, &config);
+
+            println!("{}", serde_json::to_string_pretty(&result)?);
+
+            // Save session after calculate
+            storage.save_session(&session)?;
+        }
+
+        Commands::Status => {
+            println!("SPF Smart Gateway v2.0.0");
+            println!("Mode: {:?}", config.enforce_mode);
+            println!("Storage: {:?}", cli.storage);
+            println!("Config: LMDB (spf_config/)");
+            println!();
+            println!("Session: {}", session.status_summary());
+            println!();
+            println!("Tiers:");
+            println!("  SIMPLE   < 500    | 40% analyze / 60% build");
+            println!("  LIGHT    < 2000   | 60% analyze / 40% build");
+            println!("  MEDIUM   < 10000  | 75% analyze / 25% build");
+            println!("  CRITICAL > 10000  | 95% analyze / 5% build (requires approval)");
+            println!();
+            println!("Formula: a_optimal(C) = {} × (1 - 1/ln(C + e))", config.formula.w_eff);
+            println!("Complexity: C = basic^1 + deps^7 + complex^10 + files×10");
+        }
+
+        Commands::Session => {
+            println!("{}", serde_json::to_string_pretty(&session)?);
+        }
+
+        Commands::Reset => {
+            let new_session = Session::new();
+            storage.save_session(&new_session)?;
+            println!("Session reset.");
+        }
+
+        Commands::InitConfig => {
+            // Config is already initialized via load_full_config() above
+            // This command now just confirms the LMDB state
+            let (config_count, paths_count, patterns_count) = config_db.stats()?;
+            println!("SPF_CONFIG LMDB initialized at {:?}", config_db_path);
+            println!("  Config entries: {}", config_count);
+            println!("  Path rules: {}", paths_count);
+            println!("  Dangerous patterns: {}", patterns_count);
+            println!();
+            println!("Config is stored in LMDB, not JSON files.");
+            println!("Use MCP tools or direct LMDB access to modify.");
+        }
+    }
+
+    Ok(())
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/0836b06ec9c7a09e@v1

@@ -0,0 +1,2063 @@
+# SPF SMART GATE - BUILD DOCUMENTATION
+# Copyright 2026 Joseph Stone - All Rights Reserved
+# Source of Truth: ~/SPFsmartGATE/
+# Working Copy: ~/sandbox-edit/
+# Generated: 2026-02-04
+# Updated: 2026-02-05 (BUILD SUCCESSFUL)
+# READ ONLY REFERENCE DOCUMENT
+
+================================================================================
+CURRENT STATE ANALYSIS
+================================================================================
+
+ARCHITECTURE: 5-LMDB AI Enhancement Framework
+IMPLEMENTED: config_db, tools_db, sandbox_db, agent_state, fs - ALL WIRED
+STATUS: 5 of 5 LMDBs wired to MCP - BUILD SUCCESSFUL
+
+================================================================================
+DIRECTORY STRUCTURE
+================================================================================
+
+~/SPFsmartGATE/
+├── Cargo.toml              # Rust manifest - spf-smart-gate v1.0.0
+├── Cargo.lock              # Locked dependencies
+├── LICENSE                 # SPF Smart Gateway License
+├── README.md               # Project documentation
+├── main.rs                 # ISSUE: Duplicate of src/main.rs (delete)
+├── config.json             # ISSUE: Contains Claude settings, NOT SPF config
+│
+├── src/                    # RUST SOURCE (16 files + 2 backups)
+│   ├── lib.rs              # Module exports (33 lines) - 14 modules
+│   ├── main.rs             # CLI entry point (194 lines) - FIXED typo
+│   ├── config.rs           # Configuration loader (196 lines)
+│   ├── session.rs          # Session state struct (156 lines)
+│   ├── storage.rs          # LMDB wrapper (100 lines) - session state
+│   ├── calculate.rs        # SPF complexity formula (311 lines)
+│   ├── validate.rs         # Build Anchor + path validation (155 lines)
+│   ├── gate.rs             # Primary enforcement point (130 lines)
+│   ├── inspect.rs          # Content inspection (144 lines)
+│   ├── mcp.rs              # MCP JSON-RPC server (2103 lines) - UPDATED
+│   ├── web.rs              # HTTP client module (289 lines)
+│   │
+│   │                       # === NEW LMDB MODULES ===
+│   ├── config_db.rs        # LMDB 2: SPF_CONFIG (445 lines) - WIRED
+│   ├── tools_db.rs         # LMDB 3: SPF_TOOLS (433 lines) - WIRED
+│   ├── sandbox_db.rs       # LMDB 4: SPF_SANDBOX (609 lines) - WIRED
+│   ├── agent_state.rs      # LMDB 5: AGENT_STATE (683 lines) - WIRED (read-only)
+│   ├── fs.rs               # LMDB 1: SPF_FS (660+ lines) - WIRED
+│   │
+│   │                       # === BACKUPS ===
+│   ├── gate-EDITED.rs      # Backup/variant (172 lines)
+│   └── mcp-EDITED.rs       # Backup/variant (1420 lines)
+│
+├── hooks/                  # SHELL HOOKS (16 files)
+│   ├── session-start.sh    # SessionStart hook
+│   ├── session-end.sh      # SessionEnd hook
+│   ├── user-prompt.sh      # UserPromptSubmit hook
+│   ├── pre-read.sh         # PreToolUse: Read
+│   ├── pre-edit.sh         # PreToolUse: Edit
+│   ├── pre-write.sh        # PreToolUse: Write
+│   ├── pre-bash.sh         # PreToolUse: Bash
+│   ├── pre-glob.sh         # PreToolUse: Glob
+│   ├── pre-grep.sh         # PreToolUse: Grep
+│   ├── pre-webfetch.sh     # PreToolUse: WebFetch
+│   ├── pre-websearch.sh    # PreToolUse: WebSearch
+│   ├── pre-notebookedit.sh # PreToolUse: NotebookEdit
+│   ├── post-action.sh      # PostToolUse (all tools)
+│   ├── post-failure.sh     # PostToolUseFailure
+│   ├── stop-check.sh       # Stop hook
+│   ├── spf-gate.sh         # SPF gate caller
+│   └── spf-gate.sh.bak     # Backup
+│
+├── state/                  # RUNTIME STATE
+│   ├── STATUS.txt          # Current status display
+│   ├── session.json        # Session state JSON
+│   ├── spf.log             # Action log
+│   ├── failures.log        # Failure log
+│   └── handoff.md          # Session handoff notes
+│
+├── storage/                # LMDB STORAGE (SINGLE DB)
+│   ├── data.mdb            # LMDB data file (151KB)
+│   ├── lock.mdb            # LMDB lock file
+│   └── config.json         # ISSUE: Claude settings here too
+│
+├── claude/                 # CLAUDE INSTRUCTIONS
+│   └── INSTRUCTIONS.md     # Tool usage guide
+│
+├── backup/                 # BACKUPS
+│   ├── .claude.json
+│   └── config.json
+│
+├── sandbox/                # SANDBOX FILESYSTEM
+│   ├── config.json         # Sandbox-specific config
+│   ├── config.json.patch   # Config patches
+│   │
+│   ├── src/                # SANDBOX SOURCE PATCHES
+│   │   ├── config.rs
+│   │   ├── config.rs.patch
+│   │   ├── gate.rs
+│   │   ├── gate.rs.patch
+│   │   ├── gate-locked.rs
+│   │   ├── mcp-unlock-patch.rs
+│   │   ├── mcp.rs.patch
+│   │   ├── session.rs
+│   │   ├── validate.rs
+│   │   └── validate.rs.patch
+│   │
+│   ├── patches/            # CALCULATION PATCHES
+│   │   ├── calculate.rs.patch
+│   │   └── calculate.rs.failsafe
+│   │
+│   └── SolbytesNetGuard/   # PROJECT: Android VPN Firewall
+│       ├── BUILD_PLAN.md   # 28-step build plan (93% complete)
+│       ├── USER_MANUAL.md
+│       ├── settings.gradle
+│       ├── build.gradle
+│       ├── gradle.properties
+│       ├── gradle/wrapper/gradle-wrapper.properties
+│       │
+│       ├── app/
+│       │   ├── build.gradle
+│       │   ├── proguard-rules.pro
+│       │   └── src/main/
+│       │       ├── AndroidManifest.xml
+│       │       ├── java/com/solbytes/netguard/
+│       │       │   ├── MainActivity.kt
+│       │       │   ├── NetGuardService.kt
+│       │       │   ├── NetGuardReceiver.kt
+│       │       │   ├── NotificationHelper.kt
+│       │       │   ├── NotificationActionReceiver.kt
+│       │       │   └── RustBridge.kt
+│       │       └── res/
+│       │           ├── layout/activity_main.xml
+│       │           ├── values/colors.xml
+│       │           ├── values/strings.xml
+│       │           ├── values/themes.xml
+│       │           ├── drawable/bg_button_toggle.xml
+│       │           ├── drawable/bg_button_reset.xml
+│       │           ├── drawable/status_dot.xml
+│       │           ├── drawable/ic_launcher_foreground.xml
+│       │           └── mipmap-*/ic_launcher*.png
+│       │
+│       └── rust/
+│           ├── Cargo.toml
+│           └── src/
+│               ├── lib.rs
+│               ├── db.rs
+│               ├── rules.rs
+│               ├── vpn.rs
+│               ├── dns.rs
+│               ├── honeypot.rs
+│               ├── threats.rs
+│               ├── threat_lists.rs
+│               ├── callback.rs
+│               ├── config.rs
+│               └── t1000.rs
+│
+└── target/release/         # COMPILED BINARY
+    └── spf-smart-gate      # MCP server binary
+
+================================================================================
+RUST MODULES SUMMARY
+================================================================================
+
+lib.rs (33 lines)
+  - Exports 14 modules:
+    - Core: config, calculate, validate, gate, storage, mcp, session, inspect, web
+    - LMDB: fs, config_db, tools_db, sandbox_db, agent_state
+
+main.rs (194 lines) - FIXED
+  - CLI: serve, gate, calculate, status, session, reset, init-config
+  - Default paths: ~/spf-gateway/config.json, ~/spf-gateway/storage
+  - FIX APPLIED: Line 29 typo corrected (sfp→spf)
+
+config.rs (196 lines)
+  - SpfConfig struct with all settings
+  - TierConfig: SIMPLE(<500), LIGHT(<2000), MEDIUM(<10000), CRITICAL(>10000)
+  - FormulaConfig: w_eff=40000, basic^1, deps^7, complex^10, files*10
+  - ComplexityWeights per tool type
+  - Path blocking with canonicalization
+
+session.rs (156 lines)
+  - Session struct: action_count, files_read, files_written
+  - ComplexityEntry, ManifestEntry, FailureEntry
+  - Build Anchor tracking: track_read(), track_write()
+  - anchor_ratio() for read/write balance
+
+storage.rs (100 lines) - SESSION STATE ONLY
+  - SpfStorage struct wrapping heed::Env
+  - save_session(), load_session()
+  - Generic put(), get(), delete()
+  - 50MB max size, single "spf_state" database
+  - NOTE: Other LMDBs managed by their own modules
+
+calculate.rs (311 lines)
+  - SPF Formula: C = basic^1 + deps^7 + complex^10 + files*10
+  - Master formula: a_optimal(C) = W_eff * (1 - 1/ln(C + e))
+  - Dynamic complexity factors for all tool types
+  - Supports: Edit, Write, Bash, Read, Glob, Grep, brain_*, rag_*, web_*
+
+validate.rs (155 lines)
+  - validate_edit(): Build Anchor check, blocked paths
+  - validate_write(): Size limit, blocked paths, Build Anchor
+  - validate_bash(): Dangerous commands, git force, /tmp access
+  - validate_read(): Always allowed, tracks for anchor
+
+gate.rs (130 lines)
+  - GateDecision struct: allowed, tool, complexity, warnings, errors
+  - process(): Calculate -> Validate -> Inspect -> Allow/Block
+  - ALL tiers require approval (HARDCODE)
+
+inspect.rs (144 lines)
+  - Credential detection (API keys, tokens, private keys)
+  - Path traversal detection (../)
+  - Shell injection detection ($(), eval, backticks)
+  - Blocked path reference detection
+
+web.rs (289 lines)
+  - WebClient with reqwest blocking client
+  - search_brave(): Brave Search API
+  - search_ddg(): DuckDuckGo HTML fallback
+  - read_page(): Fetch URL, convert HTML to text
+  - download(): Save file to disk
+  - api_request(): Generic HTTP method support
+
+mcp.rs (2231 lines) - FULLY WIRED
+  - MCP JSON-RPC 2.0 server over stdio
+  - All spf_* tool handlers
+  - Brain passthrough to stoneshell-brain binary
+  - RAG collector integration
+  - Web tools integration
+  - WIRED: config_db tools (2): spf_config_paths, spf_config_stats
+  - WIRED: tools_db tools (3): spf_tools_list, spf_tools_get, spf_tools_stats
+  - WIRED: sandbox_db tools (4): spf_sandbox_list, spf_sandbox_stats,
+           spf_sandbox_get, spf_sandbox_active
+  - WIRED: agent_state tools (4 read-only): spf_agent_prefs, spf_agent_memory_search,
+           spf_agent_session, spf_agent_stats
+  - WIRED: fs.rs tools (8): spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+           spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename
+  - ADDED: format_timestamp() helper for human-readable dates
+  - ADDED: chrono import for timestamp formatting
+  - All 5 LMDBs initialized in run() function
+
+================================================================================
+NEW LMDB MODULES (IMPLEMENTED)
+================================================================================
+
+config_db.rs (445 lines) - LMDB 2: SPF_CONFIG - WIRED
+  - SpfConfigDb struct
+  - Centralized configuration storage
+  - Path rules (allowed/blocked)
+  - get_config(), set_config(), list_path_rules()
+  - MCP tools: spf_config_paths, spf_config_stats
+
+tools_db.rs (433 lines) - LMDB 3: SPF_TOOLS - WIRED
+  - SpfToolsDb struct
+  - Tool definitions, permissions, execution history
+  - register_tool(), record_execution(), get_tool_stats()
+  - MCP tools: spf_tools_list, spf_tools_get, spf_tools_stats
+
+sandbox_db.rs (609 lines) - LMDB 4: SPF_SANDBOX - WIRED
+  - SpfSandboxDb struct
+  - Project workspace tracking
+  - create_project(), list_projects(), track_file()
+  - MCP tools: spf_sandbox_list, spf_sandbox_stats, spf_sandbox_get, spf_sandbox_active
+
+agent_state.rs (683 lines) - LMDB 5: AGENT_STATE - WIRED (READ-ONLY)
+  - AgentStateDb struct (renamed from ClaudeStateDb)
+  - Agent memory, preferences, session context
+  - remember(), recall(), search_memories(), get_preferences()
+  - MCP tools (read-only): spf_agent_prefs, spf_agent_memory_search,
+    spf_agent_session, spf_agent_context, spf_agent_stats
+  - Write operations BLOCKED (user-only via CLI)
+
+fs.rs (660+ lines) - LMDB 1: SPF_FS - WIRED
+  - SpfFs struct
+  - Virtual filesystem with metadata tracking
+  - Hybrid storage: <1MB in LMDB, >1MB on disk (blobs)
+  - exists(), stat(), read(), write(), mkdir(), ls(), rm(), rename()
+  - Vector index for reverse RAG lookup
+  - Path normalization and traversal containment
+  - Full /home/agent/ structure initialized on startup
+  - MCP tools: spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+    spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename
+
+================================================================================
+IMPLEMENTED ARCHITECTURE (5-LMDB)
+================================================================================
+
+LMDB #1: SPF_FS (fs.rs) - IMPLEMENTED, WIRED
+  - File metadata: path, size, checksum, permissions
+  - Version history per file
+  - Vector pointers -> actual file paths (reverse RAG)
+  - Hybrid storage: small files in LMDB, large on disk
+  - MCP tools: spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+    spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename
+  - Full /home/agent/ tree initialized:
+    /home/agent/bin/, .config/, .local/, .cache/, .memory/,
+    .ssh/, Documents/, Projects/, workspace/
+
+LMDB #2: SPF_CONFIG (config_db.rs) - IMPLEMENTED, WIRED
+  - Centralized configuration storage
+  - Path rules (allowed/blocked)
+  - Tool weights and tier configs
+
+LMDB #3: SPF_TOOLS (tools_db.rs) - IMPLEMENTED, WIRED
+  - Tool definitions and permissions
+  - Execution history tracking
+  - Usage statistics per tool
+
+LMDB #4: SPF_SANDBOX (sandbox_db.rs) - IMPLEMENTED, WIRED
+  - Project workspace tracking
+  - File state per project
+  - Active project management
+
+LMDB #5: AGENT_STATE (agent_state.rs) - IMPLEMENTED, WIRED (READ-ONLY)
+  - Agent memory and preferences
+  - Session context and continuity
+  - Write operations blocked for security
+
+REMAINING GAPS:
+  - Path interception layer not implemented (virtual→real routing)
+  - config.rs still reads from JSON file (not LMDB 2)
+  - session.rs still uses storage.rs (not LMDB 5)
+  - Add new tools to ~/.claude.json allowedTools
+
+COMPLETED:
+  - fs.rs WIRED to MCP (8 tools)
+  - All 5 LMDBs initialized and wired
+  - /home/agent/ full directory structure created on init
+  - BUILD SUCCESSFUL - cargo build --release passed
+
+================================================================================
+DEPENDENCIES (Cargo.toml)
+================================================================================
+
+heed = "0.20"           # LMDB wrapper
+serde = "1.0"           # Serialization
+serde_json = "1.0"      # JSON
+clap = "4.5"            # CLI parser
+thiserror = "1.0"       # Error handling
+anyhow = "1.0"          # Error handling
+log = "0.4"             # Logging
+env_logger = "0.11"     # Log output
+chrono = "0.4"          # Time
+reqwest = "0.12"        # HTTP client (blocking, rustls-tls)
+html2text = "0.6"       # HTML to text
+
+================================================================================
+BUILD COMMAND
+================================================================================
+
+cd ~/SPFsmartGATE && cargo build --release
+
+Binary output: ~/SPFsmartGATE/target/release/spf-smart-gate
+
+================================================================================
+MCP INTEGRATION
+================================================================================
+
+~/.claude.json mcpServers:
+{
+  "spf-smart-gate": {
+    "type": "stdio",
+    "command": "~/SPFsmartGATE/target/release/spf-smart-gate",
+    "args": ["serve"]
+  }
+}
+
+================================================================================
+HOOKS INTEGRATION
+================================================================================
+
+All hooks defined in ~/.claude.json (or ~/SPFsmartGATE/config.json):
+- SessionStart: session-start.sh
+- SessionEnd: session-end.sh
+- UserPromptSubmit: user-prompt.sh
+- PreToolUse: per-tool hooks (pre-read.sh, pre-edit.sh, etc.)
+- PostToolUse: post-action.sh
+- PostToolUseFailure: post-failure.sh
+- Stop: stop-check.sh
+
+================================================================================
+ISSUES IDENTIFIED — STATUS
+================================================================================
+
+1. config.json MISMATCH - STILL OPEN
+   - ~/SPFsmartGATE/config.json contains Claude Code settings
+   - Should contain SPF configuration (tiers, paths, weights)
+   - Same issue in ~/SPFsmartGATE/storage/config.json
+   - NOTE: config_db.rs exists but config.rs not yet updated to use it
+
+2. SINGLE LMDB LIMITATION - RESOLVED
+   - NOW: 5 LMDB modules implemented
+   - config_db, tools_db, sandbox_db, agent_state - WIRED
+   - fs.rs - implemented but NOT WIRED
+
+3. SANDBOX NOT MANAGED - PARTIALLY RESOLVED
+   - sandbox_db.rs now tracks project state
+   - File versioning and metadata available
+   - PENDING: Full integration with validate.rs
+
+4. DUPLICATE main.rs - STILL OPEN
+   - ~/SPFsmartGATE/main.rs duplicates src/main.rs
+   - ACTION: Delete root main.rs
+
+5. main.rs TYPO - FIXED
+   - Line 29: "sfp-gateway/storage" → "spf-gateway/storage"
+   - Fixed in sandbox-edit/src/main.rs
+
+6. CLAUDE_STATE RENAMED - COMPLETED
+   - Renamed to agent_state.rs for AI-agnostic design
+   - All internal references updated (Claude→Agent)
+   - Supports any AI CLI, not just Claude
+
+================================================================================
+END OF SOURCE OF TRUTH — CURRENT STATE
+================================================================================
+
+
+
+
+################################################################################
+################################################################################
+##                                                                            ##
+##                    5-LMDB ARCHITECTURE — IMPLEMENTATION                    ##
+##                                                                            ##
+##                  SPF (StoneCell Processing Formula)                        ##
+##                  AI Enhancement & Training Framework                       ##
+##                  Copyright 2026 Joseph Stone                               ##
+##                  All Rights Reserved                                       ##
+##                                                                            ##
+################################################################################
+################################################################################
+
+================================================================================
+ARCHITECTURE OVERVIEW
+================================================================================
+
+TARGET: AI Enhancement Environment with 5 LMDB Stores
+CONCEPT: Agent operates in structured environment - boundaries enable learning
+PURPOSE: Train AI in procedure/protocol, develop self-choice through human guidance
+STATUS: PARTIALLY IMPLEMENTED - 4 of 5 LMDBs wired, fs.rs pending
+
+================================================================================
+HIERARCHICAL VIRTUAL FILESYSTEM
+================================================================================
+
+Single namespace, multiple LMDB backends. Agent sees ONE filesystem.
+SPF routes to appropriate LMDB based on path prefix.
+
+/                        (LMDB 1 - Root & System FS)
+├── /config/             (LMDB 2 - All Config Files)
+├── /tools/              (LMDB 3 - All Tools)
+├── /sandbox/            (LMDB 4 - Project Workspace)
+└── /home/claude/        (LMDB 5 - Agent Home)
+
+PATH RESOLUTION:
+──────────────────────────────────────────��──────────────────────────────────
+Path Request             Routes To         Access Level
+─────────────────────────────────────────────────────────────────────────────
+/                        LMDB 1            READ-ONLY (system)
+/system/*                LMDB 1            READ-ONLY (system)
+/config/*                LMDB 2            CONTROLLED (SPF manages)
+/tools/*                 LMDB 3            GATED (through SPF)
+/sandbox/*               LMDB 4            WRITE (project workspace)
+/home/claude/*           LMDB 5            AGENT HOME (personal space)
+~/*                      LMDB 5            Expands to /home/claude/
+─────────────────────────────────────────────────────────────────────────────
+
+LMDB 1 is the ROOT that "mounts" the other LMDBs at their paths.
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                         SPF SMART GATE v2.0                                  │
+│              AI Enhancement & Training Framework                             │
+│                     5-LMDB Architecture                                      │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 1: SPF_FS (Root & System FS) - IMPLEMENTED, NOT WIRED            │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_fs/                               │ │
+│  │ Virtual Path: / and /system/                                           │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Root filesystem - mounts other LMDBs at their paths           │ │
+│  │ Access: READ-ONLY for agent (system level)                             │ │
+│  │                                                                         │ │
+│  │ Structure (this LMDB manages):                                          │ │
+│  │   /                         (virtual root - mount point for others)     │ │
+│  │   /system/                  (SPF system files - read only)              │ │
+│  │                                                                         │ │
+│  │ Mounts (routes to other LMDBs):                                         │ │
+│  │   /config/      → LMDB 2                                                │ │
+│  │   /tools/       → LMDB 3                                                │ │
+│  │   /sandbox/     → LMDB 4                                                │ │
+│  │   /home/claude/ → LMDB 5                                                │ │
+│  │                                                                         │ │
+│  │ Stored per file:                                                        │ │
+│  │   - path (virtual path)                                                 │ │
+│  │   - real_path (actual filesystem path)                                  │ │
+│  │   - size (bytes)                                                        │ │
+│  │   - checksum (SHA256)                                                   │ │
+│  │   - permissions (rwx flags)                                             │ │
+│  │   - version (increment on write)                                        │ │
+│  │   - created_at, modified_at (timestamps)                                │ │
+│  │   - vector_id (for reverse RAG lookup)                                  │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - resolve_path(virtual) -> real                                       │ │
+│  │   - track_file(path, metadata)                                          │ │
+│  │   - get_metadata(path) -> FileMetadata                                  │ │
+│  │   - list_dir(virtual_path) -> Vec<Entry>                                │ │
+│  │   - vector_to_path(vector_id) -> real_path (REVERSE RAG)                │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 2: SPF_CONFIG (All Config Files) - IMPLEMENTED, WIRED            │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_config/                           │ │
+│  │ Virtual Path: /config/                                                  │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: ALL configuration files - SPF, agent, system                   │ │
+│  │ Access: CONTROLLED (SPF manages, agent has limited access)              │ │
+│  │                                                                         │ │
+│  │ Stored Keys:                                                            │ │
+│  │   spf_version          → "2.0.0"                                        │ │
+│  │   enforce_mode         → "hard" | "soft"                                │ │
+│  │   tiers/simple         → { max_c: 500, analyze: 40, build: 60 }         │ │
+│  │   tiers/light          → { max_c: 2000, analyze: 60, build: 40 }        │ │
+│  │   tiers/medium         → { max_c: 10000, analyze: 75, build: 25 }       │ │
+│  │   tiers/critical       → { max_c: MAX, analyze: 95, build: 5 }          │ │
+│  │   formula/w_eff        → 40000.0                                        │ │
+│  │   formula/basic_power  → 1                                              │ │
+│  │   formula/deps_power   → 7                                              │ │
+│  │   formula/complex_power→ 10                                             │ │
+│  │   formula/files_mult   → 10                                             │ │
+│  │   blocked_paths        → ["/tmp", "/etc", "/usr", "/system"]            │ │
+│  │   allowed_paths        → ["/home/user/sandbox/"]                        │ │
+│  │   dangerous_commands   → ["rm -rf", "dd if=", ...]                      │ │
+│  │   complexity_weights/* → per-tool weight configs                        │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - get_config(key) -> Value                                            │ │
+│  │   - set_config(key, value)                                              │ │
+│  │   - get_tier(c_value) -> TierInfo                                       │ │
+│  │   - is_path_blocked(path) -> bool                                       │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 3: SPF_TOOLS (All Tools) - IMPLEMENTED, WIRED                    │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_tools/                            │ │
+│  │ Virtual Path: /tools/                                                   │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Tool definitions, permissions, execution history, binaries     │ │
+│  │ Access: GATED (agent uses tools through SPF complexity formula)         │ │
+│  │                                                                         │ │
+│  │ Stored per tool:                                                        │ │
+│  │   tool:{name}/definition   → { name, description, params, returns }     │ │
+│  │   tool:{name}/permissions  → { allowed_paths, blocked_paths, flags }    │ │
+│  │   tool:{name}/weights      → { basic, deps, complex, files }            │ │
+│  │   tool:{name}/stats        → { call_count, total_c, avg_c, last_used }  │ │
+│  │                                                                         │ │
+│  │ Registered Tools:                                                       │ │
+│  │   - spf_read, spf_write, spf_edit, spf_bash                             │ │
+│  │   - spf_glob, spf_grep                                                  │ │
+│  │   - spf_web_search, spf_web_fetch, spf_web_download, spf_web_api        │ │
+│  │   - spf_brain_search, spf_brain_store, spf_brain_index, ...             │ │
+│  │   - spf_rag_collect_*, spf_rag_fetch_*, ...                             │ │
+│  │   - spf_notebook_edit                                                   │ │
+│  │   - spf_status, spf_session, spf_gate, spf_calculate                    │ │
+│  │                                                                         │ │
+│  │ Execution History (last 1000):                                          │ │
+│  │   history:{timestamp}  → { tool, params, c_value, result, duration }    │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - get_tool_def(name) -> ToolDefinition                                │ │
+│  │   - check_tool_permission(name, path) -> bool                           │ │
+│  │   - record_execution(tool, params, result)                              │ │
+│  │   - get_tool_stats(name) -> ToolStats                                   │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 4: SPF_SANDBOX (Project Workspace) - IMPLEMENTED, WIRED          │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_sandbox/                          │ │
+│  │ Virtual Path: /sandbox/                                                 │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Isolated project workspace - agent's writable area             │ │
+│  │ Access: WRITE (this is where agent does work)                           │ │
+│  │                                                                         │ │
+│  │ Real Path Mapping: ~/SPFsmartGATE/sandbox/                              │ │
+│  │                                                                         │ │
+│  │ Stored:                                                                 │ │
+│  │   sandbox_root         → "/home/user/sandbox/"                          │ │
+│  │   real_root            → "~/SPFsmartGATE/sandbox/"                      │ │
+│  │   projects             → ["SolbytesNetGuard", ...]                      │ │
+│  │                                                                         │ │
+│  │ Per-project:                                                            │ │
+│  │   project:{name}/path      → virtual path                               │ │
+│  │   project:{name}/real_path → real filesystem path                       │ │
+│  │   project:{name}/files     → [list of tracked files]                    │ │
+│  │   project:{name}/created   → timestamp                                  │ │
+│  │   project:{name}/modified  → timestamp                                  │ │
+│  │                                                                         │ │
+│  │ File State (per file in sandbox):                                       │ │
+│  │   file:{path}/metadata → { size, checksum, version, perms }             │ │
+│  │   file:{path}/history  → [version snapshots]                            │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - is_in_sandbox(path) -> bool                                         │ │
+│  │   - create_project(name) -> ProjectHandle                               │ │
+│  │   - track_sandbox_file(path, metadata)                                  │ │
+│  │   - get_project_files(name) -> Vec<FileEntry>                           │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 5: AGENT_STATE (Agent Home) - WIRED (READ-ONLY from MCP)         │ │
+│  │ Location: ~/SPFsmartGATE/storage/agent_state/                          │ │
+│  │ Virtual Path: /home/claude/ (or /home/{agent}/)                        │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Agent's home directory - personal space, memory, preferences  │ │
+│  │ Access: AGENT HOME (personal space, ~ expands here)                     │ │
+│  │ Design: AI-agnostic (works with Claude, GPT, or any AI CLI)            │ │
+│  │                                                                         │ │
+│  │ Stored:                                                                 │ │
+│  │   preferences           → { code_style, response_length, custom... }    │ │
+│  │   memory:{id}           → { content, type, tags, relevance, expires }   │ │
+│  │   sessions:{id}         → { started, ended, summary, files_modified }   │ │
+│  │   state:{key}           → arbitrary key-value storage                   │ │
+│  │   tags:{name}           → [list of memory IDs]                          │ │
+│  │                                                                         │ │
+│  │ Memory Types:                                                           │ │
+│  │   - Preference (user preferences)                                       │ │
+│  │   - Fact (knowledge about user/project)                                 │ │
+│  │   - Instruction (user directives)                                       │ │
+│  │   - Context (session continuity)                                        │ │
+│  │   - Working (temporary, session-bound)                                  │ │
+│  │   - Pinned (never auto-expire)                                          │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - remember(entry) -> store memory                                     │ │
+│  │   - recall(id) -> retrieve memory                                       │ │
+│  │   - search_memories(query) -> find relevant memories                    │ │
+│  │   - get_preferences() -> AgentPreferences                               │ │
+│  │   - start_session() / end_session()                                     │ │
+│  │                                                                         │ │
+│  │ MCP Tools (READ-ONLY - writes blocked for security):                    │ │
+│  │   - spf_agent_prefs, spf_agent_memory_search                            │ │
+│  │   - spf_agent_session, spf_agent_context, spf_agent_stats               │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+================================================================================
+VIRTUAL PATH MAPPING (DESIGN - NOT YET ACTIVE)
+================================================================================
+
+HIERARCHICAL ROUTING - Single namespace, 5 LMDB backends:
+
+Agent perceives:               SPF routes to:
+─────────────────────────────────────────────────────────────────────────────
+/                           → LMDB 1 (root/system)
+/system/*                   → LMDB 1 (read-only system files)
+/config/*                   → LMDB 2 (all config files)
+/tools/*                    → LMDB 3 (tool definitions/binaries)
+/sandbox/*                  → LMDB 4 (project workspace)
+/home/claude/*              → LMDB 5 (agent home)
+~/                          → LMDB 5 (expands to /home/claude/)
+~/.config/                  → LMDB 5 (/home/claude/.config/)
+─────────────────────────────────────────────────────────────────────────────
+
+BLOCKED PATHS (no LMDB mapping, no real FS access):
+/tmp, /etc, /usr, /var, /bin, /sbin
+/../../../ → CONTAINED within virtual FS (no escape)
+
+NOTE: Path interception layer NOT YET IMPLEMENTED
+      fs.rs exists but not wired to MCP handlers
+      Currently: direct filesystem access (gated by validate.rs)
+
+================================================================================
+PATH TRAVERSAL CONTAINMENT (DESIGN - PARTIAL)
+================================================================================
+
+If Agent attempts: ~/sandbox/../../etc/passwd
+
+SPF Resolution (when fs.rs wired):
+  1. Start at /home/user/sandbox/
+  2. Apply ../../ → /home/user/sandbox/ → /home/ → / (virtual root)
+  3. Attempt /etc/passwd → BLOCKED (not in allowed paths)
+  4. Return: "PATH BLOCKED: /etc/passwd"
+
+Virtual root (/) is the ceiling. No escape to real filesystem outside LMDB.
+
+CURRENT STATE:
+  - fs.rs has normalize_path() that handles traversal
+  - validate.rs has is_path_blocked() for real paths
+  - Full virtual containment requires fs.rs wiring to MCP
+
+================================================================================
+CURRENT DIRECTORY STRUCTURE (sandbox-edit)
+================================================================================
+
+~/sandbox-edit/
+├── Cargo.toml              # Updated with sha2, hex dependencies
+├── Cargo.lock
+├── LICENSE
+├── README.md
+├── build.file.txt          # THIS FILE - source of truth
+│
+├── src/                    # RUST SOURCE (16 files)
+│   ├── lib.rs              # 33 lines - exports 14 modules
+│   ├── main.rs             # 194 lines - FIXED typo line 29
+│   ├── config.rs           # 196 lines - still reads JSON (TODO: use LMDB 2)
+│   ├── session.rs          # 156 lines - still uses storage.rs
+│   ├── storage.rs          # 100 lines - session state LMDB
+│   ├── calculate.rs        # 311 lines - SPF formula
+│   ├── validate.rs         # 155 lines - path validation
+│   ├── gate.rs             # 130 lines - enforcement point
+│   ├── inspect.rs          # 144 lines - content inspection
+│   ├── mcp.rs              # 2103 lines - MCP server (UPDATED)
+│   ├── web.rs              # 289 lines - HTTP client
+│   │
+│   │                       # === NEW LMDB MODULES ===
+│   ├── config_db.rs        # 445 lines - LMDB 2 - WIRED
+│   ├── tools_db.rs         # 433 lines - LMDB 3 - WIRED
+│   ├── sandbox_db.rs       # 609 lines - LMDB 4 - WIRED
+│   ├── agent_state.rs      # 683 lines - LMDB 5 - WIRED (read-only)
+│   └── fs.rs               # 628 lines - LMDB 1 - NOT WIRED
+│
+├── hooks/                  # Shell hooks (unchanged from SPFsmartGATE)
+├── state/                  # Runtime state (logs, status)
+├── storage/                # LMDB data directories (created at runtime)
+├── sandbox/                # Real project files
+│
+└── target/release/
+    └── spf-smart-gate      # Binary (after build)
+
+================================================================================
+STORAGE LMDB DIRECTORIES (created at runtime)
+================================================================================
+
+~/SPFsmartGATE/storage/
+├── data.mdb                # Original session state (storage.rs)
+├── lock.mdb
+├── spf_fs/                 # LMDB 1: fs.rs
+├── spf_config/             # LMDB 2: config_db.rs
+├── spf_tools/              # LMDB 3: tools_db.rs
+├── spf_sandbox/            # LMDB 4: sandbox_db.rs
+├── agent_state/            # LMDB 5: agent_state.rs
+└── blobs/                  # Large file storage (>1MB, managed by fs.rs)
+
+================================================================================
+BUILD STEPS — STATUS
+================================================================================
+
+PHASE 1: Foundation
+  [x] Step 1.1 - Delete duplicate ~/SPFsmartGATE/main.rs - PENDING (still exists)
+  [x] Step 1.2 - Keep storage.rs for session state (not rewritten)
+  [x] Step 1.3 - fs.rs created (virtual filesystem) - DONE
+  [ ] Step 1.4 - path_resolver.rs - NOT NEEDED (fs.rs has normalize_path)
+
+PHASE 2: LMDB Implementation - COMPLETE
+  [x] Step 2.1 - LMDB 1 (SPF_FS) - fs.rs - DONE (628 lines)
+  [x] Step 2.2 - LMDB 2 (SPF_CONFIG) - config_db.rs - DONE (445 lines)
+  [x] Step 2.3 - LMDB 3 (SPF_TOOLS) - tools_db.rs - DONE (433 lines)
+  [x] Step 2.4 - LMDB 4 (SPF_SANDBOX) - sandbox_db.rs - DONE (609 lines)
+  [x] Step 2.5 - LMDB 5 (AGENT_STATE) - agent_state.rs - DONE (683 lines)
+
+PHASE 3: Integration - MOSTLY COMPLETE
+  [ ] Step 3.1 - config.rs reads from LMDB 2 - NOT DONE (still JSON)
+  [ ] Step 3.2 - session.rs uses LMDB 5 - NOT DONE (still storage.rs)
+  [ ] Step 3.3 - validate.rs uses virtual paths - NOT DONE
+  [x] Step 3.4 - mcp.rs handlers for LMDB 2,3,4,5 - DONE
+  [x] Step 3.4b- mcp.rs handlers for fs.rs (LMDB 1) - DONE (8 tools)
+  [ ] Step 3.5 - Path interception for ~ expansion - NOT DONE
+
+PHASE 4: Migration - PARTIAL
+  [ ] Step 4.1 - Migrate config.json to LMDB 2
+  [ ] Step 4.2 - Migrate session state to LMDB 5
+  [ ] Step 4.3 - Index existing sandbox files to LMDB 4
+  [x] Step 4.4 - Build initial virtual FS structure in LMDB 1 - DONE
+                 (/home/agent/ full tree created on init)
+
+PHASE 5: Testing & Hardening - BUILD COMPLETE
+  [x] Step 5.0 - cargo check / cargo build --release - BUILD SUCCESSFUL
+  [ ] Step 5.1 - Test path traversal containment
+  [ ] Step 5.2 - Test tool permission enforcement
+  [ ] Step 5.3 - Test Build Anchor with virtual paths
+  [ ] Step 5.4 - Test session persistence across restarts
+  [x] Step 5.5 - Copy sandbox-edit to SPFsmartGATE - DONE
+
+================================================================================
+NEW RUST MODULES — COMPLETED
+================================================================================
+
+fs.rs (628 lines) - LMDB 1: SPF_FS
+  - SpfFs struct managing virtual filesystem
+  - FileMetadata struct (type, size, mode, timestamps, checksum, version)
+  - exists(), stat(), read(), write(), mkdir(), mkdir_p()
+  - ls(), rm(), rm_rf(), rename()
+  - vector_to_path(), index_vector() - reverse RAG lookup
+  - Hybrid storage: <1MB in LMDB, >1MB on disk (blobs/)
+  - normalize_path() handles traversal containment
+
+config_db.rs (445 lines) - LMDB 2: SPF_CONFIG
+  - SpfConfigDb struct
+  - Centralized configuration storage
+  - Path rules management (allowed/blocked)
+  - get_config(), set_config(), list_path_rules()
+
+tools_db.rs (433 lines) - LMDB 3: SPF_TOOLS
+  - SpfToolsDb struct
+  - Tool definitions and permissions
+  - register_tool(), record_execution(), get_tool_stats()
+  - Execution history tracking
+
+sandbox_db.rs (609 lines) - LMDB 4: SPF_SANDBOX
+  - SpfSandboxDb struct
+  - Project workspace tracking
+  - create_project(), list_projects(), get_project()
+  - File state and versioning per project
+
+agent_state.rs (683 lines) - LMDB 5: AGENT_STATE
+  - AgentStateDb struct (renamed from ClaudeStateDb)
+  - Memory system: remember(), recall(), search_memories()
+  - Session management: start_session(), end_session()
+  - Preferences: get_preferences(), set_preferences()
+  - AI-agnostic design (not Claude-specific)
+
+================================================================================
+IMPLEMENTATION STATS
+================================================================================
+
+Total new code: 2798 lines Rust (5 LMDB modules)
+Modified code: ~500 lines in mcp.rs (integrations)
+Build complexity: LIGHT tier (incremental additions)
+Risk: LOW (modular design, each LMDB independent)
+
+================================================================================
+END OF PROPOSED BUILD
+================================================================================
+
+
+
+
+################################################################################
+##                                                                            ##
+##                    CONCRETE BUILD — LMDB FILESYSTEM                        ##
+##                          STATUS: IMPLEMENTED                               ##
+##                                                                            ##
+################################################################################
+
+================================================================================
+DECISION: SINGLE ENV, HYBRID STORAGE, PREFIX SCAN - IMPLEMENTED
+================================================================================
+
+Environment: Single LMDB env with multiple databases
+Map Size: 4GB (room to grow)
+Content: Hybrid - metadata in LMDB, large files (>1MB) stay on disk
+Tree: Implicit prefix scan (no separate tree DB needed)
+Max DBs: 8
+
+STATUS: fs.rs IMPLEMENTED (628 lines), NOT YET WIRED to MCP
+
+================================================================================
+FILE: src/fs.rs - IMPLEMENTED
+================================================================================
+
+Purpose: Real LMDB-backed filesystem for SPF Smart Gate
+Dependencies: heed, serde, sha2, hex (all in Cargo.toml)
+
+Databases inside SPF_FS env:
+  - fs_metadata: path → FileMetadata (SerdeBincode)
+  - fs_content: path → file bytes (for files <1MB)
+  - fs_index: vector_id → path (reverse RAG lookup)
+
+================================================================================
+STRUCTS
+================================================================================
+
+```rust
+use heed::{Database, Env, EnvOpenOptions};
+use heed::types::{Str, SerdeBincode};
+use serde::{Serialize, Deserialize};
+use std::path::Path;
+use sha2::{Sha256, Digest};
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub enum FileType {
+    File,
+    Directory,
+    Symlink,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileMetadata {
+    pub file_type: FileType,
+    pub size: u64,
+    pub mode: u32,              // Unix permissions (0o755, etc.)
+    pub created_at: i64,        // Unix timestamp
+    pub modified_at: i64,
+    pub checksum: Option<String>, // SHA256 hex
+    pub version: u64,
+    pub vector_id: Option<String>,
+    pub real_path: Option<String>, // For hybrid storage (large files)
+}
+
+pub struct SpfFs {
+    env: Env,
+    metadata: Database<Str, SerdeBincode<FileMetadata>>,
+    content: Database<Str, heed::types::Bytes>,
+    index: Database<Str, Str>,
+}
+```
+
+================================================================================
+CORE OPERATIONS
+================================================================================
+
+```rust
+impl SpfFs {
+    /// Open or create the LMDB filesystem
+    pub fn open(path: &Path) -> anyhow::Result<Self>;
+
+    /// Check if path exists
+    pub fn exists(&self, path: &str) -> anyhow::Result<bool>;
+
+    /// Get file/dir metadata
+    pub fn stat(&self, path: &str) -> anyhow::Result<Option<FileMetadata>>;
+
+    /// Read file content
+    pub fn read(&self, path: &str) -> anyhow::Result<Vec<u8>>;
+
+    /// Write file (creates parent dirs if needed)
+    pub fn write(&self, path: &str, content: &[u8]) -> anyhow::Result<()>;
+
+    /// Create directory
+    pub fn mkdir(&self, path: &str) -> anyhow::Result<()>;
+
+    /// List directory contents
+    pub fn ls(&self, path: &str) -> anyhow::Result<Vec<(String, FileMetadata)>>;
+
+    /// Remove file or empty directory
+    pub fn rm(&self, path: &str) -> anyhow::Result<()>;
+
+    /// Remove directory recursively
+    pub fn rm_rf(&self, path: &str) -> anyhow::Result<()>;
+
+    /// Rename/move
+    pub fn rename(&self, old: &str, new: &str) -> anyhow::Result<()>;
+
+    /// Reverse lookup: vector_id → path
+    pub fn vector_to_path(&self, vector_id: &str) -> anyhow::Result<Option<String>>;
+
+    /// Index a file with vector_id
+    pub fn index_vector(&self, path: &str, vector_id: &str) -> anyhow::Result<()>;
+}
+```
+
+================================================================================
+HYBRID STORAGE LOGIC
+================================================================================
+
+On write(path, content):
+  if content.len() < 1_048_576 (1MB):
+    store in LMDB fs_content
+    metadata.real_path = None
+  else:
+    write to real filesystem at: storage/blobs/{sha256_hash}
+    metadata.real_path = Some("storage/blobs/{hash}")
+    metadata.size = content.len()
+
+On read(path):
+  metadata = get from fs_metadata
+  if metadata.real_path is Some(real):
+    read from real filesystem
+  else:
+    read from LMDB fs_content
+
+================================================================================
+PATH NORMALIZATION
+================================================================================
+
+All paths stored with:
+  - Leading / (absolute in virtual FS)
+  - No trailing / (except root)
+  - No // or /../ (resolved before storage)
+
+normalize("/home/user/../user/./file") → "/home/user/file"
+normalize("relative/path") → "/home/user/relative/path" (prepend virtual home)
+
+================================================================================
+INITIAL VIRTUAL FS STRUCTURE
+================================================================================
+
+On first init, create:
+  /                     (root dir)
+  /home                 (home base)
+  /home/user            (Claude's virtual ~)
+  /home/user/.claude    (Claude config dir)
+  /home/user/sandbox    (writable workspace)
+  /system               (SPF system files, read-only)
+  /system/config        (SPF config)
+  /system/tools         (tool definitions)
+
+================================================================================
+INTEGRATION WITH EXISTING SPF
+================================================================================
+
+mcp.rs changes:
+  - spf_read → SpfFs::read()
+  - spf_write → SpfFs::write()
+  - spf_glob → SpfFs::ls() with pattern matching
+  - spf_bash → intercept file operations, route through SpfFs
+
+gate.rs changes:
+  - Validate paths against virtual FS
+  - Build Anchor checks files_read from SpfFs
+
+validate.rs changes:
+  - is_path_blocked() checks virtual paths
+  - is_path_allowed() checks sandbox boundaries in virtual FS
+
+================================================================================
+MIGRATION PLAN — STATUS
+================================================================================
+
+Step 1: Create fs.rs with SpfFs implementation - DONE
+Step 2: Add to lib.rs exports - DONE
+Step 3: Initialize virtual FS structure on first run - DONE (in fs.rs)
+Step 4: Import existing sandbox/ files into SpfFs - NOT DONE
+Step 5: Update mcp.rs handlers to use SpfFs - NOT DONE (pending wiring)
+Step 6: Test read/write/ls operations - NOT DONE
+Step 7: Enable hybrid storage for large files - DONE (in fs.rs)
+
+================================================================================
+CARGO.TOML ADDITION
+================================================================================
+
+sha2 = "0.10"  # For content checksums
+
+================================================================================
+MCP TOOL REGISTRATION
+================================================================================
+
+New tools to add to ~/.claude.json allowedTools:
+  "mcp__spf-smart-gate__spf_mkdir"
+  "mcp__spf-smart-gate__spf_ls"
+  "mcp__spf-smart-gate__spf_rm"
+  "mcp__spf-smart-gate__spf_stat"
+  "mcp__spf-smart-gate__spf_mv"
+  "mcp__spf-smart-gate__spf_cp"
+  "mcp__spf-smart-gate__spf_exists"
+  "mcp__spf-smart-gate__spf_tree"
+
+================================================================================
+MCP HANDLER EXAMPLES
+================================================================================
+
+```rust
+// In mcp.rs - add these handlers
+
+fn handle_spf_mkdir(params: &Value, fs: &SpfFs) -> Result<Value> {
+    let path = params["path"].as_str().ok_or(anyhow!("path required"))?;
+    fs.mkdir_p(path)?;
+    Ok(json!({
+        "success": true,
+        "message": format!("Directory created: {}", path)
+    }))
+}
+
+fn handle_spf_ls(params: &Value, fs: &SpfFs) -> Result<Value> {
+    let path = params["path"].as_str().unwrap_or("/");
+    let entries = fs.ls(path)?;
+    let items: Vec<Value> = entries.iter().map(|(name, meta)| {
+        json!({
+            "name": name,
+            "type": format!("{:?}", meta.file_type),
+            "size": meta.size,
+            "modified": meta.modified_at
+        })
+    }).collect();
+    Ok(json!({ "path": path, "entries": items }))
+}
+
+fn handle_spf_stat(params: &Value, fs: &SpfFs) -> Result<Value> {
+    let path = params["path"].as_str().ok_or(anyhow!("path required"))?;
+    match fs.stat(path)? {
+        Some(meta) => Ok(json!({
+            "exists": true,
+            "type": format!("{:?}", meta.file_type),
+            "size": meta.size,
+            "mode": format!("{:o}", meta.mode),
+            "created": meta.created_at,
+            "modified": meta.modified_at,
+            "version": meta.version,
+            "checksum": meta.checksum
+        })),
+        None => Ok(json!({ "exists": false }))
+    }
+}
+```
+
+================================================================================
+CARGO.TOML — VERIFIED DEPENDENCIES
+================================================================================
+
+[dependencies]
+heed = "0.20"                    # LMDB wrapper (NOT 0.12 — 0.20 is current)
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+sha2 = "0.10"                    # SHA256 checksums
+hex = "0.4"                      # Hex encoding
+anyhow = "1.0"
+thiserror = "1.0"
+clap = { version = "4.5", features = ["derive"] }
+log = "0.4"
+env_logger = "0.11"
+chrono = { version = "0.4", features = ["serde"] }
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+html2text = "0.6"
+
+================================================================================
+ISSUES ADDRESSED
+================================================================================
+
+1. normalize_path()
+   - Manual resolution implemented (no Path::clean needed)
+   - Handles: ., .., //, trailing /
+   - Already correct in fs.rs
+
+2. sha2 + hex
+   - Add to Cargo.toml (listed above)
+
+3. Disk full on blob writes
+   - Add try/catch with cleanup on failure
+   - See PATCH below
+
+4. Concurrent access
+   - heed/LMDB is ACID and thread-safe by design
+   - Single writer, multiple readers
+   - No mutex needed for normal operation
+   - MCP is single-threaded stdio anyway
+
+5. fs_tree DB for efficient ls
+   - Current: prefix scan (O(n) where n = total entries)
+   - Better: fs_tree DB mapping parent → children (O(1) lookup)
+   - DEFERRED: prefix scan is fine for <10K files
+   - Can add fs_tree later if performance needed
+
+================================================================================
+PATCH: Better blob error handling
+================================================================================
+
+In fs.rs write() function, replace:
+
+```rust
+// OLD
+if data.len() > MAX_INLINE_SIZE {
+    let blob_path = self.blob_dir.join(&checksum);
+    std::fs::write(&blob_path, data)?;
+    meta.real_path = Some(blob_path.to_string_lossy().to_string());
+    let _ = self.content.delete(&mut wtxn, &path);
+}
+```
+
+WITH:
+
+```rust
+// NEW — with cleanup on failure
+if data.len() > MAX_INLINE_SIZE {
+    let blob_path = self.blob_dir.join(&checksum);
+
+    // Write blob with cleanup on failure
+    if let Err(e) = std::fs::write(&blob_path, data) {
+        // Attempt cleanup
+        let _ = std::fs::remove_file(&blob_path);
+        return Err(anyhow!("Failed to write blob (disk full?): {}", e));
+    }
+
+    meta.real_path = Some(blob_path.to_string_lossy().to_string());
+    let _ = self.content.delete(&mut wtxn, &path);
+}
+```
+
+================================================================================
+END OF CONCRETE BUILD
+================================================================================
+
+
+################################################################################
+##                                                                            ##
+##                         FINAL STATUS SUMMARY                               ##
+##                         Updated: 2026-02-05                                ##
+##                         BUILD SUCCESSFUL                                   ##
+##                                                                            ##
+################################################################################
+
+================================================================================
+WHAT'S COMPLETE
+================================================================================
+
+1. All 5 LMDB modules implemented AND WIRED:
+   - fs.rs (660+ lines) - LMDB 1: / and /home/agent/ - WIRED (8 tools)
+   - config_db.rs (445 lines) - LMDB 2: /config/ - WIRED (2 tools)
+   - tools_db.rs (433 lines) - LMDB 3: /tools/ - WIRED (3 tools)
+   - sandbox_db.rs (609 lines) - LMDB 4: /sandbox/ - WIRED (4 tools)
+   - agent_state.rs (683 lines) - LMDB 5: /home/agent/ state - WIRED (4 tools)
+
+2. MCP integration for ALL 5 LMDBs (21 new tools):
+   - config_db: 2 tools (spf_config_paths, spf_config_stats)
+   - tools_db: 3 tools (spf_tools_list, spf_tools_get, spf_tools_stats)
+   - sandbox_db: 4 tools (spf_sandbox_list, spf_sandbox_stats,
+     spf_sandbox_get, spf_sandbox_active)
+   - agent_state: 4 tools READ-ONLY (spf_agent_prefs, spf_agent_memory_search,
+     spf_agent_session, spf_agent_stats)
+   - fs: 8 tools (spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+     spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename)
+
+3. /home/agent/ virtual filesystem structure:
+   /home/agent/
+   ├── bin/                    # Agent binaries
+   ├── .config/settings/       # Preferences
+   ├── .config/hooks/          # Custom hooks
+   ├── .local/bin/             # Local scripts
+   ├── .local/share/history/   # Action history
+   ├── .local/share/data/      # Persistent data
+   ├── .local/state/sessions/  # Session contexts
+   ├── .cache/context/         # Working context
+   ├── .cache/tmp/             # Temp space
+   ├── .memory/facts/          # Learned facts
+   ├── .memory/instructions/   # User instructions
+   ├── .memory/preferences/    # Remembered prefs
+   ├── .memory/pinned/         # Pinned memories
+   ├── .ssh/                   # Keys
+   ├── Documents/notes/        # Notes
+   ├── Documents/templates/    # Templates
+   ├── Projects/               # Project links
+   └── workspace/current/      # Active scratch
+
+4. Fixes applied:
+   - main.rs typo fixed (sfp→spf line 29)
+   - claude_state renamed to agent_state (AI-agnostic)
+   - lib.rs updated to export all 14 modules
+   - mcp.rs updated to 2231 lines (all 5 LMDBs wired)
+
+5. BUILD SUCCESSFUL:
+   - cargo build --release PASSED
+   - Binary: ~/SPFsmartGATE/target/release/spf-smart-gate
+
+================================================================================
+WHAT'S PENDING (POST-BUILD)
+================================================================================
+
+1. Add new tools to ~/.claude.json allowedTools:
+   - mcp__spf-smart-gate__spf_fs_exists
+   - mcp__spf-smart-gate__spf_fs_stat
+   - mcp__spf-smart-gate__spf_fs_ls
+   - mcp__spf-smart-gate__spf_fs_read
+   - mcp__spf-smart-gate__spf_fs_write
+   - mcp__spf-smart-gate__spf_fs_mkdir
+   - mcp__spf-smart-gate__spf_fs_rm
+   - mcp__spf-smart-gate__spf_fs_rename
+   - mcp__spf-smart-gate__spf_agent_prefs
+   - mcp__spf-smart-gate__spf_agent_memory_search
+   - mcp__spf-smart-gate__spf_agent_session
+   - mcp__spf-smart-gate__spf_agent_stats
+   - mcp__spf-smart-gate__spf_tools_list
+   - mcp__spf-smart-gate__spf_tools_get
+   - mcp__spf-smart-gate__spf_tools_stats
+   - mcp__spf-smart-gate__spf_sandbox_list
+   - mcp__spf-smart-gate__spf_sandbox_get
+   - mcp__spf-smart-gate__spf_sandbox_active
+   - mcp__spf-smart-gate__spf_sandbox_stats
+
+2. Path routing layer (FUTURE enhancement):
+   - Route ALL file operations through hierarchical LMDB structure
+   - Traversal containment at root level
+
+3. Config migration (FUTURE enhancement):
+   - config.rs still reads JSON
+   - Should read from config_db (LMDB 2)
+
+4. Cleanup:
+   - Delete duplicate main.rs in SPFsmartGATE root
+
+================================================================================
+SECURITY MODEL
+================================================================================
+
+SPF Smart Gate is an AI ENHANCEMENT & TRAINING FRAMEWORK:
+- Structure enables learning, not restriction
+- Human interference = teaching moments
+- Boundaries define the curriculum
+- Security protects the learning environment
+
+HIERARCHICAL ISOLATION:
+Agent operates within single virtual namespace backed by 5 LMDBs:
+
+/                  LMDB 1   READ-ONLY    System level
+/config/           LMDB 2   CONTROLLED   SPF manages configs
+/tools/            LMDB 3   GATED        Tools through SPF formula
+/sandbox/          LMDB 4   WRITE        Agent's workspace
+/home/claude/      LMDB 5   AGENT HOME   Personal space (~ expands here)
+
+Each LMDB is isolated. SPF routes requests based on path prefix.
+No direct cross-domain access. No escape from virtual root.
+
+================================================================================
+INTEGRATION CONFLICTS - HIERARCHICAL TRANSITION
+================================================================================
+
+CONFLICT 1: config.rs blocked_paths includes "/system"
+─────────────────────────────────────────────────────────────────────────────
+FILE: config.rs
+LINE: 94
+CURRENT:
+    blocked_paths: vec!["/tmp", "/etc", "/usr", "/system", ...]
+ISSUE:
+    In hierarchical design, /system/ is LMDB 1 (READ-ONLY virtual path),
+    not a REAL blocked path on the host filesystem.
+RESOLUTION:
+    - Add: virtual_blocked_paths for virtual FS rules
+    - Keep: blocked_paths for REAL fs backward compatibility
+    - Add: is_virtual_path_blocked() function
+
+CONFLICT 2: config.rs is_path_blocked() uses REAL filesystem
+─────────────────────────────────────────────────────────────────────────────
+FILE: config.rs
+LINE: 183-189
+CURRENT:
+    let canonical = std::fs::canonicalize(path)  // REAL filesystem
+ISSUE:
+    Uses REAL filesystem canonicalization. In hierarchical design,
+    should check VIRTUAL paths against virtual rules.
+RESOLUTION:
+    - Add: is_virtual_path_blocked(virtual_path) for virtual FS
+    - Keep: is_path_blocked() for REAL fs operations
+    - Route based on path prefix at call site
+
+CONFLICT 3: validate.rs checks REAL paths
+─────────────────────────────────────────────────────────────────────────────
+FILE: validate.rs
+LINE: 61-63, 86-88
+CURRENT:
+    if config.is_path_blocked(file_path) { ... }
+ISSUE:
+    Validates REAL path against REAL blocked paths list.
+    In hierarchical, should validate VIRTUAL path.
+RESOLUTION:
+    - Add: validate_virtual_edit(), validate_virtual_write()
+    - Keep: current functions for REAL fs backward compat
+    - Router determines which validation to use
+
+CONFLICT 4: validate.rs Path::exists() on REAL filesystem
+─────────────────────────────────────────────────────────────────────────────
+FILE: validate.rs
+LINE: 91
+CURRENT:
+    if std::path::Path::new(file_path).exists()
+ISSUE:
+    Checks REAL filesystem existence for Build Anchor.
+    In hierarchical, should check VIRTUAL fs existence.
+RESOLUTION:
+    - Add: fs.exists(virtual_path) check for virtual paths
+    - Keep: Path::exists() for REAL fs operations
+    - Router determines which check to use
+
+CONFLICT 5: session.rs stores REAL paths
+─────────────────────────────────────────────────────────────────────────────
+FILE: session.rs
+FIELDS: files_read, files_written (Vec<String>)
+CURRENT:
+    Stores REAL filesystem paths for Build Anchor tracking.
+ISSUE:
+    In hierarchical, Build Anchor should track VIRTUAL paths.
+RESOLUTION:
+    - Add: virtual_files_read, virtual_files_written fields
+    - Keep: files_read, files_written for backward compat
+    - Track both during transition
+
+CONFLICT 6: mcp.rs handlers use REAL filesystem
+─────────────────────────────────────────────────────────────────────────────
+FILE: mcp.rs
+HANDLERS: spf_read, spf_write, spf_edit, spf_glob, spf_grep
+CURRENT:
+    All handlers use std::fs operations on REAL filesystem.
+ISSUE:
+    In hierarchical, file ops should route through virtual FS.
+RESOLUTION:
+    - Add: path_router integration at handler entry
+    - Keep: current handlers as fallback for REAL paths
+    - Route: virtual paths → LMDB, real paths → std::fs
+
+CONFLICT 7: fs.rs creates wrong directories
+─────────────────────────────────────────────────────────────────────────────
+FILE: fs.rs
+LINES: 133-139
+CURRENT:
+    self.mkdir_internal("/home")?;
+    self.mkdir_internal("/home/user")?;
+    self.mkdir_internal("/home/user/.claude")?;
+    self.mkdir_internal("/home/user/sandbox")?;
+ISSUE:
+    Creates directories that belong to other LMDBs in hierarchical design:
+    - /home/claude/ should be LMDB 5 (agent_state)
+    - /sandbox/ should be LMDB 4 (sandbox_db)
+RESOLUTION:
+    - Remove: /home/* and /sandbox/* creation
+    - Keep: / and /system/* creation
+    - Add: mount point metadata for routing
+
+================================================================================
+RESOLUTION PLAN - ADDITIVE CHANGES
+================================================================================
+
+90% of current code PERSISTS unchanged. Changes are ADDITIVE.
+
+NEW MODULE: path_router.rs
+─────────────────────────────────────────────────────────────────────────────
+Purpose: Central path routing for hierarchical LMDB structure
+Functions:
+    - route_path(path) -> LmdbTarget (FS, Config, Tools, Sandbox, Agent)
+    - is_virtual_path(path) -> bool
+    - translate_virtual_to_real(virtual_path) -> Option<String>
+    - get_access_level(path) -> AccessLevel (ReadOnly, Controlled, Gated, Write, Home)
+
+UPDATES NEEDED:
+─────────────────────────────────────────────────────────────────────────────
+1. lib.rs
+   - Add: pub mod path_router;
+
+2. fs.rs (lines 133-139)
+   - Remove: /home/* and /sandbox/* directory creation
+   - Add: Mount point awareness for routing
+
+3. config.rs
+   - Add: virtual_blocked_paths: Vec<String>
+   - Add: is_virtual_path_blocked(path) -> bool
+   - Keep: existing functions unchanged
+
+4. validate.rs
+   - Add: validate_virtual_edit(), validate_virtual_write()
+   - Keep: existing functions unchanged
+
+5. session.rs
+   - Add: virtual_files_read: Vec<String>
+   - Add: virtual_files_written: Vec<String>
+   - Keep: existing fields unchanged
+
+6. mcp.rs
+   - Add: path_router integration at handler entry
+   - Keep: existing handlers unchanged
+
+FUNCTIONS THAT PERSIST UNCHANGED:
+─────────────────────────────────────────────────────────────────────────────
+config_db.rs    - ALL 20+ functions
+tools_db.rs     - ALL 15+ functions
+sandbox_db.rs   - ALL 20+ functions
+agent_state.rs  - ALL 25+ functions
+calculate.rs    - ALL complexity formula functions
+gate.rs         - ALL enforcement functions
+inspect.rs      - ALL content inspection functions
+web.rs          - ALL HTTP client functions
+storage.rs      - ALL session state functions
+main.rs         - ALL CLI functions
+
+CARGO.TOML: No changes needed - all dependencies present.
+
+================================================================================
+END OF BUILD DOCUMENTATION
+================================================================================
+
+
+################################################################################
+##                                                                            ##
+##                    LMDB 5 CLI INSTALLATION — FILE LIST                     ##
+##                    Full Containment: Claude CLI in LMDB 5                  ##
+##                                                                            ##
+################################################################################
+
+================================================================================
+FILES TO COPY INTO LMDB 5 (/home/agent/)
+================================================================================
+
+CURRENT FILEPATH                                          DESTINATION (LMDB 5)
+─────────────────────────────────────────────────────────────────────────────────
+
+CLAUDE CLI BINARY (69MB)
+─────────────────────────────────────────────────────────────────────────────────
+/data/data/com.termux/files/usr/lib/node_modules/@anthropic-ai/claude-code/
+                                                    →     /home/agent/bin/claude-code/
+
+SPF SMART GATE BINARY (~8MB)
+─────────────────��───────────────────────────────────────────────────────────────
+~/SPFsmartGATE/target/release/spf-smart-gate        →     /home/agent/bin/spf-smart-gate
+
+MAIN CONFIG (20KB)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude.json                                      →     /home/agent/.claude.json
+
+CLAUDE CONFIG FILES (SMALL - DIRECT TO LMDB)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/settings.json                (16KB)       →     /home/agent/.claude/settings.json
+~/.claude/config.json                  (16KB)       →     /home/agent/.claude/config.json
+~/.claude/.credentials.json            (447B)       →     /home/agent/.claude/.credentials.json
+~/.claude/claude.md                    (20KB)       →     /home/agent/.claude/claude.md
+~/.claude/stats-cache.json             (3KB)        →     /home/agent/.claude/stats-cache.json
+~/.claude/settings.local.json          (113B)       →     /home/agent/.claude/settings.local.json
+
+CLAUDE DATA FILES (MEDIUM - LMDB OR BLOB)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/history.jsonl                (1.2MB)      →     /home/agent/.claude/history.jsonl
+
+CLAUDE DIRECTORIES (LARGE - BLOB STORAGE WITH SYMLINKS)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/projects/                    (119MB)      →     /home/agent/.claude/projects/
+~/.claude/file-history/                (25MB)       →     /home/agent/.claude/file-history/
+~/.claude/paste-cache/                 (~1MB)       →     /home/agent/.claude/paste-cache/
+~/.claude/session-env/                 (424KB)      →     /home/agent/.claude/session-env/
+~/.claude/todos/                       (316KB)      →     /home/agent/.claude/todos/
+~/.claude/plans/                       (20KB)       →     /home/agent/.claude/plans/
+~/.claude/tasks/                       (46KB)       →     /home/agent/.claude/tasks/
+~/.claude/shell-snapshots/             (44KB)       →     /home/agent/.claude/shell-snapshots/
+~/.claude/statsig/                     (40KB)       →     /home/agent/.claude/statsig/
+~/.claude/telemetry/                   (252KB)      →     /home/agent/.claude/telemetry/
+
+EXCLUDED (NOT COPIED)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/debug/                       (441MB)      →     EXCLUDED (logs, not needed)
+~/.claude/spf-hooks-backup/            (123KB)      →     EXCLUDED (old backup)
+
+================================================================================
+STORAGE STRATEGY
+================================================================================
+
+< 1MB  → Store directly in LMDB 5
+> 1MB  → Blob storage on disk, metadata in LMDB 5, symlink for access
+
+BINARIES:
+  - claude-code/ (69MB) → blob storage
+  - spf-smart-gate (8MB) → blob storage
+
+LARGE DIRS:
+  - projects/ (119MB) → blob storage per file
+  - file-history/ (25MB) → blob storage per file
+
+================================================================================
+TOTAL SIZE ESTIMATE
+================================================================================
+
+Config files (direct LMDB):     ~60KB
+Medium files (LMDB/blob):       ~1.2MB
+Large directories (blob):       ~145MB
+Binaries (blob):                ~77MB
+─────────────────────────────────────────
+TOTAL:                          ~223MB (excluding debug/)
+
+================================================================================
+POST-COPY: UPDATE REFERENCES
+================================================================================
+
+1. mcpServers command path:
+   OLD: ~/SPFsmartGATE/target/release/spf-smart-gate
+   NEW: /home/agent/bin/spf-smart-gate (virtual) → blob path (real)
+
+2. Claude CLI invocation:
+   OLD: /usr/bin/claude → /usr/lib/node_modules/@anthropic-ai/claude-code/cli.js
+   NEW: /home/agent/bin/claude-code/cli.js (virtual) → blob path (real)
+
+3. Config file paths:
+   OLD: ~/.claude.json, ~/.claude/
+   NEW: /home/agent/.claude.json, /home/agent/.claude/
+
+================================================================================
+END OF LMDB 5 FILE LIST
+================================================================================
+
+
+################################################################################
+##                                                                            ##
+##                    LMDB 5 INSTALLATION SCRIPT                              ##
+##                    Surgical Transfer & Boot Injection                      ##
+##                                                                            ##
+################################################################################
+
+#!/bin/bash
+#===============================================================================
+# LMDB5 CLI INSTALLATION SCRIPT
+# Transfers Claude CLI and all configs into LMDB 5 virtual filesystem
+# Creates boot injection for seamless startup
+#
+# Usage: bash install-lmdb5.sh
+# Location: ~/SPFsmartGATE/scripts/install-lmdb5.sh
+#===============================================================================
+
+set -e  # Exit on error
+
+#-------------------------------------------------------------------------------
+# CONFIGURATION
+#-------------------------------------------------------------------------------
+
+SPF_HOME="$HOME/SPFsmartGATE"
+STORAGE="$SPF_HOME/storage"
+BLOBS="$STORAGE/blobs"
+LMDB5_DIR="$STORAGE/agent_state"
+MANIFEST="$STORAGE/lmdb5_manifest.json"
+BACKUP_DIR="$SPF_HOME/backup/pre-lmdb5-$(date +%Y%m%d-%H%M%S)"
+LOG="$SPF_HOME/state/lmdb5-install.log"
+
+# Source paths
+CLAUDE_CLI="/data/data/com.termux/files/usr/lib/node_modules/@anthropic-ai/claude-code"
+SPF_BINARY="$SPF_HOME/target/release/spf-smart-gate"
+CLAUDE_JSON="$HOME/.claude.json"
+CLAUDE_DIR="$HOME/.claude"
+
+# Virtual paths (LMDB 5)
+VHOME="/home/agent"
+
+#-------------------------------------------------------------------------------
+# HELPER FUNCTIONS
+#-------------------------------------------------------------------------------
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG"
+}
+
+error() {
+    echo "[ERROR] $1" | tee -a "$LOG"
+    exit 1
+}
+
+check_exists() {
+    if [ ! -e "$1" ]; then
+        error "Required file/dir not found: $1"
+    fi
+}
+
+sha256sum_file() {
+    sha256sum "$1" 2>/dev/null | cut -d' ' -f1
+}
+
+#-------------------------------------------------------------------------------
+# PRE-FLIGHT CHECKS
+#-------------------------------------------------------------------------------
+
+preflight() {
+    log "=== PRE-FLIGHT CHECKS ==="
+
+    # Check SPF build exists
+    check_exists "$SPF_BINARY"
+    log "✓ SPF binary found: $SPF_BINARY"
+
+    # Check Claude CLI exists
+    check_exists "$CLAUDE_CLI"
+    log "✓ Claude CLI found: $CLAUDE_CLI"
+
+    # Check Claude config exists
+    check_exists "$CLAUDE_JSON"
+    log "✓ Claude config found: $CLAUDE_JSON"
+
+    # Check Claude dir exists
+    check_exists "$CLAUDE_DIR"
+    log "✓ Claude dir found: $CLAUDE_DIR"
+
+    # Create directories
+    mkdir -p "$STORAGE" "$BLOBS" "$LMDB5_DIR" "$BACKUP_DIR"
+    mkdir -p "$SPF_HOME/state"
+    log "✓ Storage directories ready"
+
+    log "=== PRE-FLIGHT COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# BACKUP EXISTING
+#-------------------------------------------------------------------------------
+
+backup_existing() {
+    log "=== CREATING BACKUP ==="
+
+    # Backup current claude configs
+    if [ -f "$CLAUDE_JSON" ]; then
+        cp "$CLAUDE_JSON" "$BACKUP_DIR/claude.json"
+        log "✓ Backed up: .claude.json"
+    fi
+
+    # Backup claude dir (exclude debug/)
+    if [ -d "$CLAUDE_DIR" ]; then
+        rsync -a --exclude='debug/' "$CLAUDE_DIR/" "$BACKUP_DIR/claude/"
+        log "✓ Backed up: .claude/ (excluding debug/)"
+    fi
+
+    log "Backup location: $BACKUP_DIR"
+    log "=== BACKUP COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# COPY BINARIES TO BLOB STORAGE
+#-------------------------------------------------------------------------------
+
+copy_binaries() {
+    log "=== COPYING BINARIES ==="
+
+    # SPF Smart Gate binary
+    local spf_hash=$(sha256sum_file "$SPF_BINARY")
+    local spf_blob="$BLOBS/$spf_hash"
+    cp "$SPF_BINARY" "$spf_blob"
+    chmod +x "$spf_blob"
+    log "✓ SPF binary → blob: $spf_hash"
+    echo "$VHOME/bin/spf-smart-gate|$spf_blob|$(stat -c%s "$SPF_BINARY")|binary" >> "$MANIFEST.tmp"
+
+    # Claude CLI (entire directory)
+    local claude_blob_dir="$BLOBS/claude-code"
+    rm -rf "$claude_blob_dir"
+    cp -r "$CLAUDE_CLI" "$claude_blob_dir"
+    log "✓ Claude CLI → blob: claude-code/"
+    echo "$VHOME/bin/claude-code|$claude_blob_dir|directory|binary" >> "$MANIFEST.tmp"
+
+    log "=== BINARIES COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# COPY CONFIG FILES (SMALL - DIRECT)
+#-------------------------------------------------------------------------------
+
+copy_configs() {
+    log "=== COPYING CONFIG FILES ==="
+
+    local config_staging="$STORAGE/staging/configs"
+    mkdir -p "$config_staging"
+
+    # Main claude.json
+    cp "$CLAUDE_JSON" "$config_staging/claude.json"
+    echo "$VHOME/.claude.json|$config_staging/claude.json|$(stat -c%s "$CLAUDE_JSON")|config" >> "$MANIFEST.tmp"
+    log "✓ .claude.json"
+
+    # Small config files (< 1MB, store directly)
+    local small_files=(
+        "settings.json"
+        "config.json"
+        ".credentials.json"
+        "claude.md"
+        "stats-cache.json"
+        "settings.local.json"
+    )
+
+    for f in "${small_files[@]}"; do
+        if [ -f "$CLAUDE_DIR/$f" ]; then
+            cp "$CLAUDE_DIR/$f" "$config_staging/$f"
+            echo "$VHOME/.claude/$f|$config_staging/$f|$(stat -c%s "$CLAUDE_DIR/$f")|config" >> "$MANIFEST.tmp"
+            log "✓ .claude/$f"
+        fi
+    done
+
+    log "=== CONFIG FILES COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# COPY LARGE DIRECTORIES TO BLOB STORAGE
+#-------------------------------------------------------------------------------
+
+copy_large_dirs() {
+    log "=== COPYING LARGE DIRECTORIES ==="
+
+    local large_dirs=(
+        "projects"
+        "file-history"
+        "paste-cache"
+        "session-env"
+        "todos"
+        "plans"
+        "tasks"
+        "shell-snapshots"
+        "statsig"
+        "telemetry"
+    )
+
+    for dir in "${large_dirs[@]}"; do
+        if [ -d "$CLAUDE_DIR/$dir" ]; then
+            local blob_dir="$BLOBS/claude-$dir"
+            rm -rf "$blob_dir"
+            cp -r "$CLAUDE_DIR/$dir" "$blob_dir"
+            local size=$(du -sb "$CLAUDE_DIR/$dir" | cut -f1)
+            echo "$VHOME/.claude/$dir|$blob_dir|$size|directory" >> "$MANIFEST.tmp"
+            log "✓ .claude/$dir → blob"
+        fi
+    done
+
+    # history.jsonl (medium file)
+    if [ -f "$CLAUDE_DIR/history.jsonl" ]; then
+        local hist_hash=$(sha256sum_file "$CLAUDE_DIR/history.jsonl")
+        cp "$CLAUDE_DIR/history.jsonl" "$BLOBS/$hist_hash"
+        echo "$VHOME/.claude/history.jsonl|$BLOBS/$hist_hash|$(stat -c%s "$CLAUDE_DIR/history.jsonl")|file" >> "$MANIFEST.tmp"
+        log "✓ .claude/history.jsonl → blob"
+    fi
+
+    log "=== LARGE DIRECTORIES COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# CREATE LMDB5 MANIFEST (JSON)
+#-------------------------------------------------------------------------------
+
+create_manifest() {
+    log "=== CREATING MANIFEST ==="
+
+    # Convert tmp manifest to JSON
+    echo '{' > "$MANIFEST"
+    echo '  "version": "1.0",' >> "$MANIFEST"
+    echo '  "created": "'$(date -Iseconds)'",' >> "$MANIFEST"
+    echo '  "entries": [' >> "$MANIFEST"
+
+    local first=true
+    while IFS='|' read -r vpath rpath size ftype; do
+        if [ "$first" = true ]; then
+            first=false
+        else
+            echo ',' >> "$MANIFEST"
+        fi
+        echo -n '    {"virtual": "'$vpath'", "real": "'$rpath'", "size": "'$size'", "type": "'$ftype'"}' >> "$MANIFEST"
+    done < "$MANIFEST.tmp"
+
+    echo '' >> "$MANIFEST"
+    echo '  ]' >> "$MANIFEST"
+    echo '}' >> "$MANIFEST"
+
+    rm -f "$MANIFEST.tmp"
+    log "✓ Manifest created: $MANIFEST"
+    log "=== MANIFEST COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# CREATE BOOT INJECTION SCRIPT
+#-------------------------------------------------------------------------------
+
+create_boot_injection() {
+    log "=== CREATING BOOT INJECTION ==="
+
+    local boot_script="$SPF_HOME/scripts/boot-lmdb5.sh"
+    mkdir -p "$SPF_HOME/scripts"
+
+    cat > "$boot_script" << 'BOOTEOF'
+#!/bin/bash
+#===============================================================================
+# LMDB5 BOOT INJECTION
+# Loads manifest into LMDB 5 on startup
+# Called by: session-start.sh or systemd/init
+#===============================================================================
+
+SPF_HOME="$HOME/SPFsmartGATE"
+MANIFEST="$SPF_HOME/storage/lmdb5_manifest.json"
+SPF_BINARY="$SPF_HOME/storage/blobs/$(ls $SPF_HOME/storage/blobs/ | grep -v claude | head -1)"
+LOG="$SPF_HOME/state/boot.log"
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] BOOT: $1" >> "$LOG"
+}
+
+# Check manifest exists
+if [ ! -f "$MANIFEST" ]; then
+    log "ERROR: Manifest not found: $MANIFEST"
+    exit 1
+fi
+
+log "Loading LMDB5 manifest..."
+
+# The SPF binary will read the manifest and populate LMDB 5
+# This happens automatically when spf-smart-gate starts with 'serve'
+# The fs.rs init checks for manifest and imports entries
+
+log "LMDB5 boot injection complete"
+
+# Export virtual paths for Claude CLI
+export SPF_AGENT_HOME="/home/agent"
+export SPF_CLAUDE_CONFIG="/home/agent/.claude.json"
+export SPF_ACTIVE=1
+
+log "Environment exported: SPF_AGENT_HOME=$SPF_AGENT_HOME"
+BOOTEOF
+
+    chmod +x "$boot_script"
+    log "✓ Boot script: $boot_script"
+
+    # Update session-start.sh to call boot injection
+    local session_start="$SPF_HOME/hooks/session-start.sh"
+    if [ -f "$session_start" ]; then
+        if ! grep -q "boot-lmdb5.sh" "$session_start"; then
+            echo "" >> "$session_start"
+            echo "# LMDB5 Boot Injection" >> "$session_start"
+            echo "source $boot_script 2>/dev/null || true" >> "$session_start"
+            log "✓ Injected into session-start.sh"
+        else
+            log "✓ Boot injection already in session-start.sh"
+        fi
+    fi
+
+    log "=== BOOT INJECTION COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# CREATE SYMLINKS FOR BACKWARD COMPATIBILITY
+#-------------------------------------------------------------------------------
+
+create_symlinks() {
+    log "=== CREATING SYMLINKS ==="
+
+    # Create agent bin directory with symlinks to blob binaries
+    local agent_bin="$SPF_HOME/agent-bin"
+    mkdir -p "$agent_bin"
+
+    # SPF binary symlink
+    local spf_blob=$(ls "$BLOBS" | grep -v claude | head -1)
+    if [ -n "$spf_blob" ]; then
+        ln -sf "$BLOBS/$spf_blob" "$agent_bin/spf-smart-gate"
+        log "✓ Symlink: agent-bin/spf-smart-gate → blob"
+    fi
+
+    # Claude CLI symlink
+    if [ -d "$BLOBS/claude-code" ]; then
+        ln -sf "$BLOBS/claude-code" "$agent_bin/claude-code"
+        log "✓ Symlink: agent-bin/claude-code → blob"
+    fi
+
+    log "=== SYMLINKS COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# VERIFICATION
+#-------------------------------------------------------------------------------
+
+verify_installation() {
+    log "=== VERIFICATION ==="
+
+    local errors=0
+
+    # Check manifest
+    if [ -f "$MANIFEST" ]; then
+        local count=$(grep -c '"virtual"' "$MANIFEST")
+        log "✓ Manifest entries: $count"
+    else
+        log "✗ Manifest missing"
+        ((errors++))
+    fi
+
+    # Check blobs
+    local blob_count=$(ls -1 "$BLOBS" 2>/dev/null | wc -l)
+    log "✓ Blob files: $blob_count"
+
+    # Check boot script
+    if [ -x "$SPF_HOME/scripts/boot-lmdb5.sh" ]; then
+        log "✓ Boot script executable"
+    else
+        log "✗ Boot script missing or not executable"
+        ((errors++))
+    fi
+
+    # Check SPF binary in blob
+    if [ -f "$SPF_HOME/agent-bin/spf-smart-gate" ]; then
+        log "✓ SPF binary accessible via agent-bin"
+    else
+        log "✗ SPF binary symlink missing"
+        ((errors++))
+    fi
+
+    if [ $errors -eq 0 ]; then
+        log "=== VERIFICATION PASSED ==="
+    else
+        log "=== VERIFICATION FAILED: $errors errors ==="
+        return 1
+    fi
+}
+
+#-------------------------------------------------------------------------------
+# UPDATE CLAUDE.JSON TO POINT TO NEW PATHS
+#-------------------------------------------------------------------------------
+
+update_claude_json() {
+    log "=== UPDATING CLAUDE.JSON REFERENCES ==="
+
+    # Update mcpServers command to use agent-bin path
+    local new_spf_path="$SPF_HOME/agent-bin/spf-smart-gate"
+
+    # Use jq if available, otherwise sed
+    if command -v jq &> /dev/null; then
+        jq '.mcpServers["spf-smart-gate"].command = "'$new_spf_path'"' \
+            "$CLAUDE_JSON" > "$CLAUDE_JSON.tmp" && mv "$CLAUDE_JSON.tmp" "$CLAUDE_JSON"
+        log "✓ Updated mcpServers path via jq"
+    else
+        sed -i 's|"command": ".*spf-smart-gate.*"|"command": "'$new_spf_path'"|' "$CLAUDE_JSON"
+        log "✓ Updated mcpServers path via sed"
+    fi
+
+    log "=== CLAUDE.JSON UPDATED ==="
+}
+
+#-------------------------------------------------------------------------------
+# PRINT SUMMARY
+#-------------------------------------------------------------------------------
+
+print_summary() {
+    echo ""
+    echo "==============================================================================="
+    echo "                    LMDB5 INSTALLATION COMPLETE"
+    echo "==============================================================================="
+    echo ""
+    echo "Backup:     $BACKUP_DIR"
+    echo "Manifest:   $MANIFEST"
+    echo "Blobs:      $BLOBS"
+    echo "Boot:       $SPF_HOME/scripts/boot-lmdb5.sh"
+    echo "Log:        $LOG"
+    echo ""
+    echo "Virtual filesystem layout:"
+    echo "  /home/agent/"
+    echo "  ├── .claude.json"
+    echo "  ├── .claude/"
+    echo "  │   ├── settings.json"
+    echo "  │   ├── config.json"
+    echo "  │   ├── projects/"
+    echo "  │   └── ..."
+    echo "  └── bin/"
+    echo "      ├── spf-smart-gate"
+    echo "      └── claude-code/"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Restart Claude CLI"
+    echo "  2. Test: spf_fs_ls /home/agent/"
+    echo "  3. Verify boot injection in session-start.sh"
+    echo ""
+    echo "==============================================================================="
+}
+
+#-------------------------------------------------------------------------------
+# MAIN
+#-------------------------------------------------------------------------------
+
+main() {
+    echo ""
+    echo "==============================================================================="
+    echo "              LMDB5 CLI INSTALLATION - FULL CONTAINMENT"
+    echo "==============================================================================="
+    echo ""
+
+    preflight
+    backup_existing
+
+    # Initialize manifest
+    > "$MANIFEST.tmp"
+
+    copy_binaries
+    copy_configs
+    copy_large_dirs
+    create_manifest
+    create_boot_injection
+    create_symlinks
+    update_claude_json
+    verify_installation
+    print_summary
+
+    log "=== INSTALLATION COMPLETE ==="
+}
+
+# Run main
+main "$@"
+
+#===============================================================================
+# END OF INSTALLATION SCRIPT
+#===============================================================================

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/0836b06ec9c7a09e@v2

@@ -0,0 +1,2077 @@
+# SPF SMART GATE - BUILD DOCUMENTATION
+# Copyright 2026 Joseph Stone - All Rights Reserved
+# Source of Truth: ~/SPFsmartGATE/
+# Working Copy: ~/sandbox-edit/
+# Generated: 2026-02-04
+# Updated: 2026-02-05 (BUILD SUCCESSFUL)
+# READ ONLY REFERENCE DOCUMENT
+
+================================================================================
+CURRENT STATE ANALYSIS
+================================================================================
+
+ARCHITECTURE: 5-LMDB AI Enhancement Framework
+IMPLEMENTED: config_db, tools_db, sandbox_db, agent_state, fs - ALL WIRED
+STATUS: 5 of 5 LMDBs wired to MCP - BUILD SUCCESSFUL
+
+================================================================================
+DIRECTORY STRUCTURE
+================================================================================
+
+~/SPFsmartGATE/
+├── Cargo.toml              # Rust manifest - spf-smart-gate v1.0.0
+├── Cargo.lock              # Locked dependencies
+├── LICENSE                 # SPF Smart Gateway License
+├── README.md               # Project documentation
+├── main.rs                 # ISSUE: Duplicate of src/main.rs (delete)
+├── config.json             # ISSUE: Contains Claude settings, NOT SPF config
+│
+├── src/                    # RUST SOURCE (16 files + 2 backups)
+│   ├── lib.rs              # Module exports (33 lines) - 14 modules
+│   ├── main.rs             # CLI entry point (194 lines) - FIXED typo
+│   ├── config.rs           # Configuration loader (196 lines)
+│   ├── session.rs          # Session state struct (156 lines)
+│   ├── storage.rs          # LMDB wrapper (100 lines) - session state
+│   ├── calculate.rs        # SPF complexity formula (311 lines)
+│   ├── validate.rs         # Build Anchor + path validation (155 lines)
+│   ├── gate.rs             # Primary enforcement point (130 lines)
+│   ├── inspect.rs          # Content inspection (144 lines)
+│   ├── mcp.rs              # MCP JSON-RPC server (2103 lines) - UPDATED
+│   ├── web.rs              # HTTP client module (289 lines)
+│   │
+│   │                       # === NEW LMDB MODULES ===
+│   ├── config_db.rs        # LMDB 2: SPF_CONFIG (445 lines) - WIRED
+│   ├── tools_db.rs         # LMDB 3: SPF_TOOLS (433 lines) - WIRED
+│   ├── sandbox_db.rs       # LMDB 4: SPF_SANDBOX (609 lines) - WIRED
+│   ├── agent_state.rs      # LMDB 5: AGENT_STATE (683 lines) - WIRED (read-only)
+│   ├── fs.rs               # LMDB 1: SPF_FS (660+ lines) - WIRED
+│   │
+│   │                       # === BACKUPS ===
+│   ├── gate-EDITED.rs      # Backup/variant (172 lines)
+│   └── mcp-EDITED.rs       # Backup/variant (1420 lines)
+│
+├── hooks/                  # SHELL HOOKS (16 files)
+│   ├── session-start.sh    # SessionStart hook
+│   ├── session-end.sh      # SessionEnd hook
+│   ├── user-prompt.sh      # UserPromptSubmit hook
+│   ├── pre-read.sh         # PreToolUse: Read
+│   ├── pre-edit.sh         # PreToolUse: Edit
+│   ├── pre-write.sh        # PreToolUse: Write
+│   ├── pre-bash.sh         # PreToolUse: Bash
+│   ├── pre-glob.sh         # PreToolUse: Glob
+│   ├── pre-grep.sh         # PreToolUse: Grep
+│   ├── pre-webfetch.sh     # PreToolUse: WebFetch
+│   ├── pre-websearch.sh    # PreToolUse: WebSearch
+│   ├── pre-notebookedit.sh # PreToolUse: NotebookEdit
+│   ├── post-action.sh      # PostToolUse (all tools)
+│   ├── post-failure.sh     # PostToolUseFailure
+│   ├── stop-check.sh       # Stop hook
+│   ├── spf-gate.sh         # SPF gate caller
+│   └── spf-gate.sh.bak     # Backup
+│
+├── state/                  # RUNTIME STATE
+│   ├── STATUS.txt          # Current status display
+│   ├── session.json        # Session state JSON
+│   ├── spf.log             # Action log
+│   ├── failures.log        # Failure log
+│   └── handoff.md          # Session handoff notes
+│
+├── storage/                # LMDB STORAGE (SINGLE DB)
+│   ├── data.mdb            # LMDB data file (151KB)
+│   ├── lock.mdb            # LMDB lock file
+│   └── config.json         # ISSUE: Claude settings here too
+│
+├── claude/                 # CLAUDE INSTRUCTIONS
+│   └── INSTRUCTIONS.md     # Tool usage guide
+│
+├── backup/                 # BACKUPS
+│   ├── .claude.json
+│   └── config.json
+│
+├── sandbox/                # SANDBOX FILESYSTEM
+│   ├── config.json         # Sandbox-specific config
+│   ├── config.json.patch   # Config patches
+│   │
+│   ├── src/                # SANDBOX SOURCE PATCHES
+│   │   ├── config.rs
+│   │   ├── config.rs.patch
+│   │   ├── gate.rs
+│   │   ├── gate.rs.patch
+│   │   ├── gate-locked.rs
+│   │   ├── mcp-unlock-patch.rs
+│   │   ├── mcp.rs.patch
+│   │   ├── session.rs
+│   │   ├── validate.rs
+│   │   └── validate.rs.patch
+│   │
+│   ├── patches/            # CALCULATION PATCHES
+│   │   ├── calculate.rs.patch
+│   │   └── calculate.rs.failsafe
+│   │
+│   └── SolbytesNetGuard/   # PROJECT: Android VPN Firewall
+│       ├── BUILD_PLAN.md   # 28-step build plan (93% complete)
+│       ├── USER_MANUAL.md
+│       ├── settings.gradle
+│       ├── build.gradle
+│       ├── gradle.properties
+│       ├── gradle/wrapper/gradle-wrapper.properties
+│       │
+│       ├── app/
+│       │   ├── build.gradle
+│       │   ├── proguard-rules.pro
+│       │   └── src/main/
+│       │       ├── AndroidManifest.xml
+│       │       ├── java/com/solbytes/netguard/
+│       │       │   ├── MainActivity.kt
+│       │       │   ├── NetGuardService.kt
+│       │       │   ├── NetGuardReceiver.kt
+│       │       │   ├── NotificationHelper.kt
+│       │       │   ├── NotificationActionReceiver.kt
+│       │       │   └── RustBridge.kt
+│       │       └── res/
+│       │           ├── layout/activity_main.xml
+│       │           ├── values/colors.xml
+│       │           ├── values/strings.xml
+│       │           ├── values/themes.xml
+│       │           ├── drawable/bg_button_toggle.xml
+│       │           ├── drawable/bg_button_reset.xml
+│       │           ├── drawable/status_dot.xml
+│       │           ├── drawable/ic_launcher_foreground.xml
+│       │           └── mipmap-*/ic_launcher*.png
+│       │
+│       └── rust/
+│           ├── Cargo.toml
+│           └── src/
+│               ├── lib.rs
+│               ├── db.rs
+│               ├── rules.rs
+│               ├── vpn.rs
+│               ├── dns.rs
+│               ├── honeypot.rs
+│               ├── threats.rs
+│               ├── threat_lists.rs
+│               ├── callback.rs
+│               ├── config.rs
+│               └── t1000.rs
+│
+└── target/release/         # COMPILED BINARY
+    └── spf-smart-gate      # MCP server binary
+
+================================================================================
+RUST MODULES SUMMARY
+================================================================================
+
+lib.rs (33 lines)
+  - Exports 14 modules:
+    - Core: config, calculate, validate, gate, storage, mcp, session, inspect, web
+    - LMDB: fs, config_db, tools_db, sandbox_db, agent_state
+
+main.rs (194 lines) - FIXED
+  - CLI: serve, gate, calculate, status, session, reset, init-config
+  - Default paths: ~/spf-gateway/config.json, ~/spf-gateway/storage
+  - FIX APPLIED: Line 29 typo corrected (sfp→spf)
+
+config.rs (196 lines)
+  - SpfConfig struct with all settings
+  - TierConfig: SIMPLE(<500), LIGHT(<2000), MEDIUM(<10000), CRITICAL(>10000)
+  - FormulaConfig: w_eff=40000, basic^1, deps^7, complex^10, files*10
+  - ComplexityWeights per tool type
+  - Path blocking with canonicalization
+
+session.rs (156 lines)
+  - Session struct: action_count, files_read, files_written
+  - ComplexityEntry, ManifestEntry, FailureEntry
+  - Build Anchor tracking: track_read(), track_write()
+  - anchor_ratio() for read/write balance
+
+storage.rs (100 lines) - SESSION STATE ONLY
+  - SpfStorage struct wrapping heed::Env
+  - save_session(), load_session()
+  - Generic put(), get(), delete()
+  - 50MB max size, single "spf_state" database
+  - NOTE: Other LMDBs managed by their own modules
+
+calculate.rs (311 lines)
+  - SPF Formula: C = basic^1 + deps^7 + complex^10 + files*10
+  - Master formula: a_optimal(C) = W_eff * (1 - 1/ln(C + e))
+  - Dynamic complexity factors for all tool types
+  - Supports: Edit, Write, Bash, Read, Glob, Grep, brain_*, rag_*, web_*
+
+validate.rs (155 lines)
+  - validate_edit(): Build Anchor check, blocked paths
+  - validate_write(): Size limit, blocked paths, Build Anchor
+  - validate_bash(): Dangerous commands, git force, /tmp access
+  - validate_read(): Always allowed, tracks for anchor
+
+gate.rs (130 lines)
+  - GateDecision struct: allowed, tool, complexity, warnings, errors
+  - process(): Calculate -> Validate -> Inspect -> Allow/Block
+  - ALL tiers require approval (HARDCODE)
+
+inspect.rs (144 lines)
+  - Credential detection (API keys, tokens, private keys)
+  - Path traversal detection (../)
+  - Shell injection detection ($(), eval, backticks)
+  - Blocked path reference detection
+
+web.rs (289 lines)
+  - WebClient with reqwest blocking client
+  - search_brave(): Brave Search API
+  - search_ddg(): DuckDuckGo HTML fallback
+  - read_page(): Fetch URL, convert HTML to text
+  - download(): Save file to disk
+  - api_request(): Generic HTTP method support
+
+mcp.rs (2231 lines) - FULLY WIRED
+  - MCP JSON-RPC 2.0 server over stdio
+  - All spf_* tool handlers
+  - Brain passthrough to stoneshell-brain binary
+  - RAG collector integration
+  - Web tools integration
+  - WIRED: config_db tools (2): spf_config_paths, spf_config_stats
+  - WIRED: tools_db tools (3): spf_tools_list, spf_tools_get, spf_tools_stats
+  - WIRED: sandbox_db tools (4): spf_sandbox_list, spf_sandbox_stats,
+           spf_sandbox_get, spf_sandbox_active
+  - WIRED: agent_state tools (4 read-only): spf_agent_prefs, spf_agent_memory_search,
+           spf_agent_session, spf_agent_stats
+  - WIRED: fs.rs tools (8): spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+           spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename
+  - ADDED: format_timestamp() helper for human-readable dates
+  - ADDED: chrono import for timestamp formatting
+  - All 5 LMDBs initialized in run() function
+
+================================================================================
+NEW LMDB MODULES (IMPLEMENTED)
+================================================================================
+
+config_db.rs (445 lines) - LMDB 2: SPF_CONFIG - WIRED
+  - SpfConfigDb struct
+  - Centralized configuration storage
+  - Path rules (allowed/blocked)
+  - get_config(), set_config(), list_path_rules()
+  - MCP tools: spf_config_paths, spf_config_stats
+
+tools_db.rs (433 lines) - LMDB 3: SPF_TOOLS - WIRED
+  - SpfToolsDb struct
+  - Tool definitions, permissions, execution history
+  - register_tool(), record_execution(), get_tool_stats()
+  - MCP tools: spf_tools_list, spf_tools_get, spf_tools_stats
+
+sandbox_db.rs (609 lines) - LMDB 4: SPF_SANDBOX - WIRED
+  - SpfSandboxDb struct
+  - Project workspace tracking
+  - create_project(), list_projects(), track_file()
+  - MCP tools: spf_sandbox_list, spf_sandbox_stats, spf_sandbox_get, spf_sandbox_active
+
+agent_state.rs (683 lines) - LMDB 5: AGENT_STATE - WIRED (READ-ONLY)
+  - AgentStateDb struct (renamed from ClaudeStateDb)
+  - Agent memory, preferences, session context
+  - remember(), recall(), search_memories(), get_preferences()
+  - MCP tools (read-only): spf_agent_prefs, spf_agent_memory_search,
+    spf_agent_session, spf_agent_context, spf_agent_stats
+  - Write operations BLOCKED (user-only via CLI)
+
+fs.rs (660+ lines) - LMDB 1: SPF_FS - WIRED
+  - SpfFs struct
+  - Virtual filesystem with metadata tracking
+  - Hybrid storage: <1MB in LMDB, >1MB on disk (blobs)
+  - exists(), stat(), read(), write(), mkdir(), ls(), rm(), rename()
+  - Vector index for reverse RAG lookup
+  - Path normalization and traversal containment
+  - Full /home/agent/ structure initialized on startup
+  - MCP tools: spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+    spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename
+
+================================================================================
+IMPLEMENTED ARCHITECTURE (5-LMDB)
+================================================================================
+
+LMDB #1: SPF_FS (fs.rs) - IMPLEMENTED, WIRED
+  - File metadata: path, size, checksum, permissions
+  - Version history per file
+  - Vector pointers -> actual file paths (reverse RAG)
+  - Hybrid storage: small files in LMDB, large on disk
+  - MCP tools: spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+    spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename
+  - Full /home/agent/ tree initialized:
+    /home/agent/bin/, .config/, .local/, .cache/, .memory/,
+    .ssh/, Documents/, Projects/, workspace/
+
+LMDB #2: SPF_CONFIG (config_db.rs) - IMPLEMENTED, WIRED
+  - Centralized configuration storage
+  - Path rules (allowed/blocked)
+  - Tool weights and tier configs
+
+LMDB #3: SPF_TOOLS (tools_db.rs) - IMPLEMENTED, WIRED
+  - Tool definitions and permissions
+  - Execution history tracking
+  - Usage statistics per tool
+
+LMDB #4: SPF_SANDBOX (sandbox_db.rs) - IMPLEMENTED, WIRED
+  - Project workspace tracking
+  - File state per project
+  - Active project management
+
+LMDB #5: AGENT_STATE (agent_state.rs) - IMPLEMENTED, WIRED (READ-ONLY)
+  - Agent memory and preferences
+  - Session context and continuity
+  - Write operations blocked for security
+
+REMAINING GAPS:
+  - Path interception layer not implemented (virtual→real routing)
+  - config.rs still reads from JSON file (not LMDB 2)
+  - session.rs still uses storage.rs (not LMDB 5)
+  - Add new tools to ~/.claude.json allowedTools
+
+COMPLETED:
+  - fs.rs WIRED to MCP (8 tools)
+  - All 5 LMDBs initialized and wired
+  - /home/agent/ full directory structure created on init
+  - BUILD SUCCESSFUL - cargo build --release passed
+
+================================================================================
+DEPENDENCIES (Cargo.toml)
+================================================================================
+
+heed = "0.20"           # LMDB wrapper
+serde = "1.0"           # Serialization
+serde_json = "1.0"      # JSON
+clap = "4.5"            # CLI parser
+thiserror = "1.0"       # Error handling
+anyhow = "1.0"          # Error handling
+log = "0.4"             # Logging
+env_logger = "0.11"     # Log output
+chrono = "0.4"          # Time
+reqwest = "0.12"        # HTTP client (blocking, rustls-tls)
+html2text = "0.6"       # HTML to text
+
+================================================================================
+BUILD COMMAND
+================================================================================
+
+cd ~/SPFsmartGATE && cargo build --release
+
+Binary output: ~/SPFsmartGATE/target/release/spf-smart-gate
+
+DEPLOY TO BLOB STORAGE (after every rebuild):
+cp ~/SPFsmartGATE/target/release/spf-smart-gate ~/SPFsmartGATE/storage/blobs/b6af956b40839b3fcc6972bf66546bbdade15ad7f2b198bbc35117e5f7ef74a2
+
+Symlink chain:
+  agent-bin/spf-smart-gate → storage/blobs/b6af956b...  (symlink, never changes)
+  ~/.claude.json mcpServers → agent-bin/spf-smart-gate   (config, never changes)
+
+After deploy, reboot picks up new binary automatically.
+No config changes needed — LMDB state persists, ~/.claude.json persists.
+
+NOTE: Blob filename is a legacy hash — no longer matches content after
+in-place replacement. Will be fixed when deploy pipeline is formalized
+(hash new binary → create new blob → update symlink → delete old blob).
+
+================================================================================
+MCP INTEGRATION
+================================================================================
+
+~/.claude.json mcpServers:
+{
+  "spf-smart-gate": {
+    "type": "stdio",
+    "command": "~/SPFsmartGATE/target/release/spf-smart-gate",
+    "args": ["serve"]
+  }
+}
+
+================================================================================
+HOOKS INTEGRATION
+================================================================================
+
+All hooks defined in ~/.claude.json (or ~/SPFsmartGATE/config.json):
+- SessionStart: session-start.sh
+- SessionEnd: session-end.sh
+- UserPromptSubmit: user-prompt.sh
+- PreToolUse: per-tool hooks (pre-read.sh, pre-edit.sh, etc.)
+- PostToolUse: post-action.sh
+- PostToolUseFailure: post-failure.sh
+- Stop: stop-check.sh
+
+================================================================================
+ISSUES IDENTIFIED — STATUS
+================================================================================
+
+1. config.json MISMATCH - STILL OPEN
+   - ~/SPFsmartGATE/config.json contains Claude Code settings
+   - Should contain SPF configuration (tiers, paths, weights)
+   - Same issue in ~/SPFsmartGATE/storage/config.json
+   - NOTE: config_db.rs exists but config.rs not yet updated to use it
+
+2. SINGLE LMDB LIMITATION - RESOLVED
+   - NOW: 5 LMDB modules implemented
+   - config_db, tools_db, sandbox_db, agent_state - WIRED
+   - fs.rs - implemented but NOT WIRED
+
+3. SANDBOX NOT MANAGED - PARTIALLY RESOLVED
+   - sandbox_db.rs now tracks project state
+   - File versioning and metadata available
+   - PENDING: Full integration with validate.rs
+
+4. DUPLICATE main.rs - STILL OPEN
+   - ~/SPFsmartGATE/main.rs duplicates src/main.rs
+   - ACTION: Delete root main.rs
+
+5. main.rs TYPO - FIXED
+   - Line 29: "sfp-gateway/storage" → "spf-gateway/storage"
+   - Fixed in sandbox-edit/src/main.rs
+
+6. CLAUDE_STATE RENAMED - COMPLETED
+   - Renamed to agent_state.rs for AI-agnostic design
+   - All internal references updated (Claude→Agent)
+   - Supports any AI CLI, not just Claude
+
+================================================================================
+END OF SOURCE OF TRUTH — CURRENT STATE
+================================================================================
+
+
+
+
+################################################################################
+################################################################################
+##                                                                            ##
+##                    5-LMDB ARCHITECTURE — IMPLEMENTATION                    ##
+##                                                                            ##
+##                  SPF (StoneCell Processing Formula)                        ##
+##                  AI Enhancement & Training Framework                       ##
+##                  Copyright 2026 Joseph Stone                               ##
+##                  All Rights Reserved                                       ##
+##                                                                            ##
+################################################################################
+################################################################################
+
+================================================================================
+ARCHITECTURE OVERVIEW
+================================================================================
+
+TARGET: AI Enhancement Environment with 5 LMDB Stores
+CONCEPT: Agent operates in structured environment - boundaries enable learning
+PURPOSE: Train AI in procedure/protocol, develop self-choice through human guidance
+STATUS: PARTIALLY IMPLEMENTED - 4 of 5 LMDBs wired, fs.rs pending
+
+================================================================================
+HIERARCHICAL VIRTUAL FILESYSTEM
+================================================================================
+
+Single namespace, multiple LMDB backends. Agent sees ONE filesystem.
+SPF routes to appropriate LMDB based on path prefix.
+
+/                        (LMDB 1 - Root & System FS)
+├── /config/             (LMDB 2 - All Config Files)
+├── /tools/              (LMDB 3 - All Tools)
+├── /sandbox/            (LMDB 4 - Project Workspace)
+└── /home/claude/        (LMDB 5 - Agent Home)
+
+PATH RESOLUTION:
+─────────────────────────────────────────────────────────────────────────────
+Path Request             Routes To         Access Level
+─────────────────────────────────────────────────────────────────────────────
+/                        LMDB 1            READ-ONLY (system)
+/system/*                LMDB 1            READ-ONLY (system)
+/config/*                LMDB 2            CONTROLLED (SPF manages)
+/tools/*                 LMDB 3            GATED (through SPF)
+/sandbox/*               LMDB 4            WRITE (project workspace)
+/home/claude/*           LMDB 5            AGENT HOME (personal space)
+~/*                      LMDB 5            Expands to /home/claude/
+─────────────────────────────────────────────────────────────────────────────
+
+LMDB 1 is the ROOT that "mounts" the other LMDBs at their paths.
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                         SPF SMART GATE v2.0                                  │
+│              AI Enhancement & Training Framework                             │
+│                     5-LMDB Architecture                                      │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 1: SPF_FS (Root & System FS) - IMPLEMENTED, NOT WIRED            │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_fs/                               │ │
+│  │ Virtual Path: / and /system/                                           │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Root filesystem - mounts other LMDBs at their paths           │ │
+│  │ Access: READ-ONLY for agent (system level)                             │ │
+│  │                                                                         │ │
+│  │ Structure (this LMDB manages):                                          │ │
+│  │   /                         (virtual root - mount point for others)     │ │
+│  │   /system/                  (SPF system files - read only)              │ │
+│  │                                                                         │ │
+│  │ Mounts (routes to other LMDBs):                                         │ │
+│  │   /config/      → LMDB 2                                                │ │
+│  │   /tools/       → LMDB 3                                                │ │
+│  │   /sandbox/     → LMDB 4                                                │ │
+│  │   /home/claude/ → LMDB 5                                                │ │
+│  │                                                                         │ │
+│  │ Stored per file:                                                        │ │
+│  │   - path (virtual path)                                                 │ │
+│  │   - real_path (actual filesystem path)                                  │ │
+│  │   - size (bytes)                                                        │ │
+│  │   - checksum (SHA256)                                                   │ │
+│  │   - permissions (rwx flags)                                             │ │
+│  │   - version (increment on write)                                        │ │
+│  │   - created_at, modified_at (timestamps)                                │ │
+│  │   - vector_id (for reverse RAG lookup)                                  │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - resolve_path(virtual) -> real                                       │ │
+│  │   - track_file(path, metadata)                                          │ │
+│  │   - get_metadata(path) -> FileMetadata                                  │ │
+│  │   - list_dir(virtual_path) -> Vec<Entry>                                │ │
+│  │   - vector_to_path(vector_id) -> real_path (REVERSE RAG)                │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 2: SPF_CONFIG (All Config Files) - IMPLEMENTED, WIRED            │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_config/                           │ │
+│  │ Virtual Path: /config/                                                  │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: ALL configuration files - SPF, agent, system                   │ │
+│  │ Access: CONTROLLED (SPF manages, agent has limited access)              │ │
+│  │                                                                         │ │
+│  │ Stored Keys:                                                            │ │
+│  │   spf_version          → "2.0.0"                                        │ │
+│  │   enforce_mode         → "hard" | "soft"                                │ │
+│  │   tiers/simple         → { max_c: 500, analyze: 40, build: 60 }         │ │
+│  │   tiers/light          → { max_c: 2000, analyze: 60, build: 40 }        │ │
+│  │   tiers/medium         → { max_c: 10000, analyze: 75, build: 25 }       │ │
+│  │   tiers/critical       → { max_c: MAX, analyze: 95, build: 5 }          │ │
+│  │   formula/w_eff        → 40000.0                                        │ │
+│  │   formula/basic_power  → 1                                              │ │
+│  │   formula/deps_power   → 7                                              │ │
+│  │   formula/complex_power→ 10                                             │ │
+│  │   formula/files_mult   → 10                                             │ │
+│  │   blocked_paths        → ["/tmp", "/etc", "/usr", "/system"]            │ │
+│  │   allowed_paths        → ["/home/user/sandbox/"]                        │ │
+│  │   dangerous_commands   → ["rm -rf", "dd if=", ...]                      │ │
+│  │   complexity_weights/* → per-tool weight configs                        │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - get_config(key) -> Value                                            │ │
+│  │   - set_config(key, value)                                              │ │
+│  │   - get_tier(c_value) -> TierInfo                                       │ │
+│  │   - is_path_blocked(path) -> bool                                       │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 3: SPF_TOOLS (All Tools) - IMPLEMENTED, WIRED                    │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_tools/                            │ │
+│  │ Virtual Path: /tools/                                                   │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Tool definitions, permissions, execution history, binaries     │ │
+│  │ Access: GATED (agent uses tools through SPF complexity formula)         │ │
+│  │                                                                         │ │
+│  │ Stored per tool:                                                        │ │
+│  │   tool:{name}/definition   → { name, description, params, returns }     │ │
+│  │   tool:{name}/permissions  → { allowed_paths, blocked_paths, flags }    │ │
+│  │   tool:{name}/weights      → { basic, deps, complex, files }            │ │
+│  │   tool:{name}/stats        → { call_count, total_c, avg_c, last_used }  │ │
+│  │                                                                         │ │
+│  │ Registered Tools:                                                       │ │
+│  │   - spf_read, spf_write, spf_edit, spf_bash                             │ │
+│  │   - spf_glob, spf_grep                                                  │ │
+│  │   - spf_web_search, spf_web_fetch, spf_web_download, spf_web_api        │ │
+│  │   - spf_brain_search, spf_brain_store, spf_brain_index, ...             │ │
+│  │   - spf_rag_collect_*, spf_rag_fetch_*, ...                             │ │
+│  │   - spf_notebook_edit                                                   │ │
+│  │   - spf_status, spf_session, spf_gate, spf_calculate                    │ │
+│  │                                                                         │ │
+│  │ Execution History (last 1000):                                          │ │
+│  │   history:{timestamp}  → { tool, params, c_value, result, duration }    │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - get_tool_def(name) -> ToolDefinition                                │ │
+│  │   - check_tool_permission(name, path) -> bool                           │ │
+│  │   - record_execution(tool, params, result)                              │ │
+│  │   - get_tool_stats(name) -> ToolStats                                   │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 4: SPF_SANDBOX (Project Workspace) - IMPLEMENTED, WIRED          │ │
+│  │ Location: ~/SPFsmartGATE/storage/spf_sandbox/                          │ │
+│  │ Virtual Path: /sandbox/                                                 │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Isolated project workspace - agent's writable area             │ │
+│  │ Access: WRITE (this is where agent does work)                           │ │
+│  │                                                                         │ │
+│  │ Real Path Mapping: ~/SPFsmartGATE/sandbox/                              │ │
+│  │                                                                         │ │
+│  │ Stored:                                                                 │ │
+│  │   sandbox_root         → "/home/user/sandbox/"                          │ │
+│  │   real_root            → "~/SPFsmartGATE/sandbox/"                      │ │
+│  │   projects             → ["SolbytesNetGuard", ...]                      │ │
+│  │                                                                         │ │
+│  │ Per-project:                                                            │ │
+│  │   project:{name}/path      → virtual path                               │ │
+│  │   project:{name}/real_path → real filesystem path                       │ │
+│  │   project:{name}/files     → [list of tracked files]                    │ │
+│  │   project:{name}/created   → timestamp                                  │ │
+│  │   project:{name}/modified  → timestamp                                  │ │
+│  │                                                                         │ │
+│  │ File State (per file in sandbox):                                       │ │
+│  │   file:{path}/metadata → { size, checksum, version, perms }             │ │
+│  │   file:{path}/history  → [version snapshots]                            │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - is_in_sandbox(path) -> bool                                         │ │
+│  │   - create_project(name) -> ProjectHandle                               │ │
+│  │   - track_sandbox_file(path, metadata)                                  │ │
+│  │   - get_project_files(name) -> Vec<FileEntry>                           │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+│  ┌────────────────────────────────────────────────────────────────────────┐ │
+│  │ LMDB 5: AGENT_STATE (Agent Home) - WIRED (READ-ONLY from MCP)         │ │
+│  │ Location: ~/SPFsmartGATE/storage/agent_state/                          │ │
+│  │ Virtual Path: /home/claude/ (or /home/{agent}/)                        │ │
+│  ├────────────────────────────────────────────────────────────────────────┤ │
+│  │ Purpose: Agent's home directory - personal space, memory, preferences  │ │
+│  │ Access: AGENT HOME (personal space, ~ expands here)                     │ │
+│  │ Design: AI-agnostic (works with Claude, GPT, or any AI CLI)            │ │
+│  │                                                                         │ │
+│  │ Stored:                                                                 │ │
+│  │   preferences           → { code_style, response_length, custom... }    │ │
+│  │   memory:{id}           → { content, type, tags, relevance, expires }   │ │
+│  │   sessions:{id}         → { started, ended, summary, files_modified }   │ │
+│  │   state:{key}           → arbitrary key-value storage                   │ │
+│  │   tags:{name}           → [list of memory IDs]                          │ │
+│  │                                                                         │ │
+│  │ Memory Types:                                                           │ │
+│  │   - Preference (user preferences)                                       │ │
+│  │   - Fact (knowledge about user/project)                                 │ │
+│  │   - Instruction (user directives)                                       │ │
+│  │   - Context (session continuity)                                        │ │
+│  │   - Working (temporary, session-bound)                                  │ │
+│  │   - Pinned (never auto-expire)                                          │ │
+│  │                                                                         │ │
+│  │ Key Operations:                                                         │ │
+│  │   - remember(entry) -> store memory                                     │ │
+│  │   - recall(id) -> retrieve memory                                       │ │
+│  │   - search_memories(query) -> find relevant memories                    │ │
+│  │   - get_preferences() -> AgentPreferences                               │ │
+│  │   - start_session() / end_session()                                     │ │
+│  │                                                                         │ │
+│  │ MCP Tools (READ-ONLY - writes blocked for security):                    │ │
+│  │   - spf_agent_prefs, spf_agent_memory_search                            │ │
+│  │   - spf_agent_session, spf_agent_context, spf_agent_stats               │ │
+│  └────────────────────────────────────────────────────────────────────────┘ │
+│                                                                              │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+================================================================================
+VIRTUAL PATH MAPPING (DESIGN - NOT YET ACTIVE)
+================================================================================
+
+HIERARCHICAL ROUTING - Single namespace, 5 LMDB backends:
+
+Agent perceives:               SPF routes to:
+─────────────────────────────────────────────────────────────────────────────
+/                           → LMDB 1 (root/system)
+/system/*                   → LMDB 1 (read-only system files)
+/config/*                   → LMDB 2 (all config files)
+/tools/*                    → LMDB 3 (tool definitions/binaries)
+/sandbox/*                  → LMDB 4 (project workspace)
+/home/claude/*              → LMDB 5 (agent home)
+~/                          → LMDB 5 (expands to /home/claude/)
+~/.config/                  → LMDB 5 (/home/claude/.config/)
+─────────────────────────────────────────────────────────────────────────────
+
+BLOCKED PATHS (no LMDB mapping, no real FS access):
+/tmp, /etc, /usr, /var, /bin, /sbin
+/../../../ → CONTAINED within virtual FS (no escape)
+
+NOTE: Path interception layer NOT YET IMPLEMENTED
+      fs.rs exists but not wired to MCP handlers
+      Currently: direct filesystem access (gated by validate.rs)
+
+================================================================================
+PATH TRAVERSAL CONTAINMENT (DESIGN - PARTIAL)
+================================================================================
+
+If Agent attempts: ~/sandbox/../../etc/passwd
+
+SPF Resolution (when fs.rs wired):
+  1. Start at /home/user/sandbox/
+  2. Apply ../../ → /home/user/sandbox/ → /home/ → / (virtual root)
+  3. Attempt /etc/passwd → BLOCKED (not in allowed paths)
+  4. Return: "PATH BLOCKED: /etc/passwd"
+
+Virtual root (/) is the ceiling. No escape to real filesystem outside LMDB.
+
+CURRENT STATE:
+  - fs.rs has normalize_path() that handles traversal
+  - validate.rs has is_path_blocked() for real paths
+  - Full virtual containment requires fs.rs wiring to MCP
+
+================================================================================
+CURRENT DIRECTORY STRUCTURE (sandbox-edit)
+================================================================================
+
+~/sandbox-edit/
+├── Cargo.toml              # Updated with sha2, hex dependencies
+├── Cargo.lock
+├── LICENSE
+├── README.md
+├── build.file.txt          # THIS FILE - source of truth
+│
+├── src/                    # RUST SOURCE (16 files)
+│   ├── lib.rs              # 33 lines - exports 14 modules
+│   ├── main.rs             # 194 lines - FIXED typo line 29
+│   ├── config.rs           # 196 lines - still reads JSON (TODO: use LMDB 2)
+│   ├── session.rs          # 156 lines - still uses storage.rs
+│   ├── storage.rs          # 100 lines - session state LMDB
+│   ├── calculate.rs        # 311 lines - SPF formula
+│   ├── validate.rs         # 155 lines - path validation
+│   ├── gate.rs             # 130 lines - enforcement point
+│   ├── inspect.rs          # 144 lines - content inspection
+│   ├── mcp.rs              # 2103 lines - MCP server (UPDATED)
+│   ├── web.rs              # 289 lines - HTTP client
+│   │
+│   │                       # === NEW LMDB MODULES ===
+│   ├── config_db.rs        # 445 lines - LMDB 2 - WIRED
+│   ├── tools_db.rs         # 433 lines - LMDB 3 - WIRED
+│   ├── sandbox_db.rs       # 609 lines - LMDB 4 - WIRED
+│   ├── agent_state.rs      # 683 lines - LMDB 5 - WIRED (read-only)
+│   └── fs.rs               # 628 lines - LMDB 1 - NOT WIRED
+│
+├── hooks/                  # Shell hooks (unchanged from SPFsmartGATE)
+├── state/                  # Runtime state (logs, status)
+├── storage/                # LMDB data directories (created at runtime)
+├── sandbox/                # Real project files
+│
+└── target/release/
+    └── spf-smart-gate      # Binary (after build)
+
+================================================================================
+STORAGE LMDB DIRECTORIES (created at runtime)
+================================================================================
+
+~/SPFsmartGATE/storage/
+├── data.mdb                # Original session state (storage.rs)
+├── lock.mdb
+├── spf_fs/                 # LMDB 1: fs.rs
+├── spf_config/             # LMDB 2: config_db.rs
+├── spf_tools/              # LMDB 3: tools_db.rs
+├── spf_sandbox/            # LMDB 4: sandbox_db.rs
+├── agent_state/            # LMDB 5: agent_state.rs
+└── blobs/                  # Large file storage (>1MB, managed by fs.rs)
+
+================================================================================
+BUILD STEPS — STATUS
+================================================================================
+
+PHASE 1: Foundation
+  [x] Step 1.1 - Delete duplicate ~/SPFsmartGATE/main.rs - PENDING (still exists)
+  [x] Step 1.2 - Keep storage.rs for session state (not rewritten)
+  [x] Step 1.3 - fs.rs created (virtual filesystem) - DONE
+  [ ] Step 1.4 - path_resolver.rs - NOT NEEDED (fs.rs has normalize_path)
+
+PHASE 2: LMDB Implementation - COMPLETE
+  [x] Step 2.1 - LMDB 1 (SPF_FS) - fs.rs - DONE (628 lines)
+  [x] Step 2.2 - LMDB 2 (SPF_CONFIG) - config_db.rs - DONE (445 lines)
+  [x] Step 2.3 - LMDB 3 (SPF_TOOLS) - tools_db.rs - DONE (433 lines)
+  [x] Step 2.4 - LMDB 4 (SPF_SANDBOX) - sandbox_db.rs - DONE (609 lines)
+  [x] Step 2.5 - LMDB 5 (AGENT_STATE) - agent_state.rs - DONE (683 lines)
+
+PHASE 3: Integration - MOSTLY COMPLETE
+  [ ] Step 3.1 - config.rs reads from LMDB 2 - NOT DONE (still JSON)
+  [ ] Step 3.2 - session.rs uses LMDB 5 - NOT DONE (still storage.rs)
+  [ ] Step 3.3 - validate.rs uses virtual paths - NOT DONE
+  [x] Step 3.4 - mcp.rs handlers for LMDB 2,3,4,5 - DONE
+  [x] Step 3.4b- mcp.rs handlers for fs.rs (LMDB 1) - DONE (8 tools)
+  [ ] Step 3.5 - Path interception for ~ expansion - NOT DONE
+
+PHASE 4: Migration - PARTIAL
+  [ ] Step 4.1 - Migrate config.json to LMDB 2
+  [ ] Step 4.2 - Migrate session state to LMDB 5
+  [ ] Step 4.3 - Index existing sandbox files to LMDB 4
+  [x] Step 4.4 - Build initial virtual FS structure in LMDB 1 - DONE
+                 (/home/agent/ full tree created on init)
+
+PHASE 5: Testing & Hardening - BUILD COMPLETE
+  [x] Step 5.0 - cargo check / cargo build --release - BUILD SUCCESSFUL
+  [ ] Step 5.1 - Test path traversal containment
+  [ ] Step 5.2 - Test tool permission enforcement
+  [ ] Step 5.3 - Test Build Anchor with virtual paths
+  [ ] Step 5.4 - Test session persistence across restarts
+  [x] Step 5.5 - Copy sandbox-edit to SPFsmartGATE - DONE
+
+================================================================================
+NEW RUST MODULES — COMPLETED
+================================================================================
+
+fs.rs (628 lines) - LMDB 1: SPF_FS
+  - SpfFs struct managing virtual filesystem
+  - FileMetadata struct (type, size, mode, timestamps, checksum, version)
+  - exists(), stat(), read(), write(), mkdir(), mkdir_p()
+  - ls(), rm(), rm_rf(), rename()
+  - vector_to_path(), index_vector() - reverse RAG lookup
+  - Hybrid storage: <1MB in LMDB, >1MB on disk (blobs/)
+  - normalize_path() handles traversal containment
+
+config_db.rs (445 lines) - LMDB 2: SPF_CONFIG
+  - SpfConfigDb struct
+  - Centralized configuration storage
+  - Path rules management (allowed/blocked)
+  - get_config(), set_config(), list_path_rules()
+
+tools_db.rs (433 lines) - LMDB 3: SPF_TOOLS
+  - SpfToolsDb struct
+  - Tool definitions and permissions
+  - register_tool(), record_execution(), get_tool_stats()
+  - Execution history tracking
+
+sandbox_db.rs (609 lines) - LMDB 4: SPF_SANDBOX
+  - SpfSandboxDb struct
+  - Project workspace tracking
+  - create_project(), list_projects(), get_project()
+  - File state and versioning per project
+
+agent_state.rs (683 lines) - LMDB 5: AGENT_STATE
+  - AgentStateDb struct (renamed from ClaudeStateDb)
+  - Memory system: remember(), recall(), search_memories()
+  - Session management: start_session(), end_session()
+  - Preferences: get_preferences(), set_preferences()
+  - AI-agnostic design (not Claude-specific)
+
+================================================================================
+IMPLEMENTATION STATS
+================================================================================
+
+Total new code: 2798 lines Rust (5 LMDB modules)
+Modified code: ~500 lines in mcp.rs (integrations)
+Build complexity: LIGHT tier (incremental additions)
+Risk: LOW (modular design, each LMDB independent)
+
+================================================================================
+END OF PROPOSED BUILD
+================================================================================
+
+
+
+
+################################################################################
+##                                                                            ##
+##                    CONCRETE BUILD — LMDB FILESYSTEM                        ##
+##                          STATUS: IMPLEMENTED                               ##
+##                                                                            ##
+################################################################################
+
+================================================================================
+DECISION: SINGLE ENV, HYBRID STORAGE, PREFIX SCAN - IMPLEMENTED
+================================================================================
+
+Environment: Single LMDB env with multiple databases
+Map Size: 4GB (room to grow)
+Content: Hybrid - metadata in LMDB, large files (>1MB) stay on disk
+Tree: Implicit prefix scan (no separate tree DB needed)
+Max DBs: 8
+
+STATUS: fs.rs IMPLEMENTED (628 lines), NOT YET WIRED to MCP
+
+================================================================================
+FILE: src/fs.rs - IMPLEMENTED
+================================================================================
+
+Purpose: Real LMDB-backed filesystem for SPF Smart Gate
+Dependencies: heed, serde, sha2, hex (all in Cargo.toml)
+
+Databases inside SPF_FS env:
+  - fs_metadata: path → FileMetadata (SerdeBincode)
+  - fs_content: path → file bytes (for files <1MB)
+  - fs_index: vector_id → path (reverse RAG lookup)
+
+================================================================================
+STRUCTS
+================================================================================
+
+```rust
+use heed::{Database, Env, EnvOpenOptions};
+use heed::types::{Str, SerdeBincode};
+use serde::{Serialize, Deserialize};
+use std::path::Path;
+use sha2::{Sha256, Digest};
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub enum FileType {
+    File,
+    Directory,
+    Symlink,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileMetadata {
+    pub file_type: FileType,
+    pub size: u64,
+    pub mode: u32,              // Unix permissions (0o755, etc.)
+    pub created_at: i64,        // Unix timestamp
+    pub modified_at: i64,
+    pub checksum: Option<String>, // SHA256 hex
+    pub version: u64,
+    pub vector_id: Option<String>,
+    pub real_path: Option<String>, // For hybrid storage (large files)
+}
+
+pub struct SpfFs {
+    env: Env,
+    metadata: Database<Str, SerdeBincode<FileMetadata>>,
+    content: Database<Str, heed::types::Bytes>,
+    index: Database<Str, Str>,
+}
+```
+
+================================================================================
+CORE OPERATIONS
+================================================================================
+
+```rust
+impl SpfFs {
+    /// Open or create the LMDB filesystem
+    pub fn open(path: &Path) -> anyhow::Result<Self>;
+
+    /// Check if path exists
+    pub fn exists(&self, path: &str) -> anyhow::Result<bool>;
+
+    /// Get file/dir metadata
+    pub fn stat(&self, path: &str) -> anyhow::Result<Option<FileMetadata>>;
+
+    /// Read file content
+    pub fn read(&self, path: &str) -> anyhow::Result<Vec<u8>>;
+
+    /// Write file (creates parent dirs if needed)
+    pub fn write(&self, path: &str, content: &[u8]) -> anyhow::Result<()>;
+
+    /// Create directory
+    pub fn mkdir(&self, path: &str) -> anyhow::Result<()>;
+
+    /// List directory contents
+    pub fn ls(&self, path: &str) -> anyhow::Result<Vec<(String, FileMetadata)>>;
+
+    /// Remove file or empty directory
+    pub fn rm(&self, path: &str) -> anyhow::Result<()>;
+
+    /// Remove directory recursively
+    pub fn rm_rf(&self, path: &str) -> anyhow::Result<()>;
+
+    /// Rename/move
+    pub fn rename(&self, old: &str, new: &str) -> anyhow::Result<()>;
+
+    /// Reverse lookup: vector_id → path
+    pub fn vector_to_path(&self, vector_id: &str) -> anyhow::Result<Option<String>>;
+
+    /// Index a file with vector_id
+    pub fn index_vector(&self, path: &str, vector_id: &str) -> anyhow::Result<()>;
+}
+```
+
+================================================================================
+HYBRID STORAGE LOGIC
+================================================================================
+
+On write(path, content):
+  if content.len() < 1_048_576 (1MB):
+    store in LMDB fs_content
+    metadata.real_path = None
+  else:
+    write to real filesystem at: storage/blobs/{sha256_hash}
+    metadata.real_path = Some("storage/blobs/{hash}")
+    metadata.size = content.len()
+
+On read(path):
+  metadata = get from fs_metadata
+  if metadata.real_path is Some(real):
+    read from real filesystem
+  else:
+    read from LMDB fs_content
+
+================================================================================
+PATH NORMALIZATION
+================================================================================
+
+All paths stored with:
+  - Leading / (absolute in virtual FS)
+  - No trailing / (except root)
+  - No // or /../ (resolved before storage)
+
+normalize("/home/user/../user/./file") → "/home/user/file"
+normalize("relative/path") → "/home/user/relative/path" (prepend virtual home)
+
+================================================================================
+INITIAL VIRTUAL FS STRUCTURE
+================================================================================
+
+On first init, create:
+  /                     (root dir)
+  /home                 (home base)
+  /home/user            (Claude's virtual ~)
+  /home/user/.claude    (Claude config dir)
+  /home/user/sandbox    (writable workspace)
+  /system               (SPF system files, read-only)
+  /system/config        (SPF config)
+  /system/tools         (tool definitions)
+
+================================================================================
+INTEGRATION WITH EXISTING SPF
+================================================================================
+
+mcp.rs changes:
+  - spf_read �� SpfFs::read()
+  - spf_write → SpfFs::write()
+  - spf_glob → SpfFs::ls() with pattern matching
+  - spf_bash → intercept file operations, route through SpfFs
+
+gate.rs changes:
+  - Validate paths against virtual FS
+  - Build Anchor checks files_read from SpfFs
+
+validate.rs changes:
+  - is_path_blocked() checks virtual paths
+  - is_path_allowed() checks sandbox boundaries in virtual FS
+
+================================================================================
+MIGRATION PLAN — STATUS
+================================================================================
+
+Step 1: Create fs.rs with SpfFs implementation - DONE
+Step 2: Add to lib.rs exports - DONE
+Step 3: Initialize virtual FS structure on first run - DONE (in fs.rs)
+Step 4: Import existing sandbox/ files into SpfFs - NOT DONE
+Step 5: Update mcp.rs handlers to use SpfFs - NOT DONE (pending wiring)
+Step 6: Test read/write/ls operations - NOT DONE
+Step 7: Enable hybrid storage for large files - DONE (in fs.rs)
+
+================================================================================
+CARGO.TOML ADDITION
+================================================================================
+
+sha2 = "0.10"  # For content checksums
+
+================================================================================
+MCP TOOL REGISTRATION
+================================================================================
+
+New tools to add to ~/.claude.json allowedTools:
+  "mcp__spf-smart-gate__spf_mkdir"
+  "mcp__spf-smart-gate__spf_ls"
+  "mcp__spf-smart-gate__spf_rm"
+  "mcp__spf-smart-gate__spf_stat"
+  "mcp__spf-smart-gate__spf_mv"
+  "mcp__spf-smart-gate__spf_cp"
+  "mcp__spf-smart-gate__spf_exists"
+  "mcp__spf-smart-gate__spf_tree"
+
+================================================================================
+MCP HANDLER EXAMPLES
+================================================================================
+
+```rust
+// In mcp.rs - add these handlers
+
+fn handle_spf_mkdir(params: &Value, fs: &SpfFs) -> Result<Value> {
+    let path = params["path"].as_str().ok_or(anyhow!("path required"))?;
+    fs.mkdir_p(path)?;
+    Ok(json!({
+        "success": true,
+        "message": format!("Directory created: {}", path)
+    }))
+}
+
+fn handle_spf_ls(params: &Value, fs: &SpfFs) -> Result<Value> {
+    let path = params["path"].as_str().unwrap_or("/");
+    let entries = fs.ls(path)?;
+    let items: Vec<Value> = entries.iter().map(|(name, meta)| {
+        json!({
+            "name": name,
+            "type": format!("{:?}", meta.file_type),
+            "size": meta.size,
+            "modified": meta.modified_at
+        })
+    }).collect();
+    Ok(json!({ "path": path, "entries": items }))
+}
+
+fn handle_spf_stat(params: &Value, fs: &SpfFs) -> Result<Value> {
+    let path = params["path"].as_str().ok_or(anyhow!("path required"))?;
+    match fs.stat(path)? {
+        Some(meta) => Ok(json!({
+            "exists": true,
+            "type": format!("{:?}", meta.file_type),
+            "size": meta.size,
+            "mode": format!("{:o}", meta.mode),
+            "created": meta.created_at,
+            "modified": meta.modified_at,
+            "version": meta.version,
+            "checksum": meta.checksum
+        })),
+        None => Ok(json!({ "exists": false }))
+    }
+}
+```
+
+================================================================================
+CARGO.TOML — VERIFIED DEPENDENCIES
+================================================================================
+
+[dependencies]
+heed = "0.20"                    # LMDB wrapper (NOT 0.12 — 0.20 is current)
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+sha2 = "0.10"                    # SHA256 checksums
+hex = "0.4"                      # Hex encoding
+anyhow = "1.0"
+thiserror = "1.0"
+clap = { version = "4.5", features = ["derive"] }
+log = "0.4"
+env_logger = "0.11"
+chrono = { version = "0.4", features = ["serde"] }
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+html2text = "0.6"
+
+================================================================================
+ISSUES ADDRESSED
+================================================================================
+
+1. normalize_path()
+   - Manual resolution implemented (no Path::clean needed)
+   - Handles: ., .., //, trailing /
+   - Already correct in fs.rs
+
+2. sha2 + hex
+   - Add to Cargo.toml (listed above)
+
+3. Disk full on blob writes
+   - Add try/catch with cleanup on failure
+   - See PATCH below
+
+4. Concurrent access
+   - heed/LMDB is ACID and thread-safe by design
+   - Single writer, multiple readers
+   - No mutex needed for normal operation
+   - MCP is single-threaded stdio anyway
+
+5. fs_tree DB for efficient ls
+   - Current: prefix scan (O(n) where n = total entries)
+   - Better: fs_tree DB mapping parent → children (O(1) lookup)
+   - DEFERRED: prefix scan is fine for <10K files
+   - Can add fs_tree later if performance needed
+
+================================================================================
+PATCH: Better blob error handling
+================================================================================
+
+In fs.rs write() function, replace:
+
+```rust
+// OLD
+if data.len() > MAX_INLINE_SIZE {
+    let blob_path = self.blob_dir.join(&checksum);
+    std::fs::write(&blob_path, data)?;
+    meta.real_path = Some(blob_path.to_string_lossy().to_string());
+    let _ = self.content.delete(&mut wtxn, &path);
+}
+```
+
+WITH:
+
+```rust
+// NEW — with cleanup on failure
+if data.len() > MAX_INLINE_SIZE {
+    let blob_path = self.blob_dir.join(&checksum);
+
+    // Write blob with cleanup on failure
+    if let Err(e) = std::fs::write(&blob_path, data) {
+        // Attempt cleanup
+        let _ = std::fs::remove_file(&blob_path);
+        return Err(anyhow!("Failed to write blob (disk full?): {}", e));
+    }
+
+    meta.real_path = Some(blob_path.to_string_lossy().to_string());
+    let _ = self.content.delete(&mut wtxn, &path);
+}
+```
+
+================================================================================
+END OF CONCRETE BUILD
+================================================================================
+
+
+################################################################################
+##                                                                            ##
+##                         FINAL STATUS SUMMARY                               ##
+##                         Updated: 2026-02-05                                ##
+##                         BUILD SUCCESSFUL                                   ##
+##                                                                            ##
+################################################################################
+
+================================================================================
+WHAT'S COMPLETE
+================================================================================
+
+1. All 5 LMDB modules implemented AND WIRED:
+   - fs.rs (660+ lines) - LMDB 1: / and /home/agent/ - WIRED (8 tools)
+   - config_db.rs (445 lines) - LMDB 2: /config/ - WIRED (2 tools)
+   - tools_db.rs (433 lines) - LMDB 3: /tools/ - WIRED (3 tools)
+   - sandbox_db.rs (609 lines) - LMDB 4: /sandbox/ - WIRED (4 tools)
+   - agent_state.rs (683 lines) - LMDB 5: /home/agent/ state - WIRED (4 tools)
+
+2. MCP integration for ALL 5 LMDBs (21 new tools):
+   - config_db: 2 tools (spf_config_paths, spf_config_stats)
+   - tools_db: 3 tools (spf_tools_list, spf_tools_get, spf_tools_stats)
+   - sandbox_db: 4 tools (spf_sandbox_list, spf_sandbox_stats,
+     spf_sandbox_get, spf_sandbox_active)
+   - agent_state: 4 tools READ-ONLY (spf_agent_prefs, spf_agent_memory_search,
+     spf_agent_session, spf_agent_stats)
+   - fs: 8 tools (spf_fs_exists, spf_fs_stat, spf_fs_ls, spf_fs_read,
+     spf_fs_write, spf_fs_mkdir, spf_fs_rm, spf_fs_rename)
+
+3. /home/agent/ virtual filesystem structure:
+   /home/agent/
+   ├── bin/                    # Agent binaries
+   ├── .config/settings/       # Preferences
+   ├── .config/hooks/          # Custom hooks
+   ├── .local/bin/             # Local scripts
+   ├── .local/share/history/   # Action history
+   ├── .local/share/data/      # Persistent data
+   ├── .local/state/sessions/  # Session contexts
+   ├── .cache/context/         # Working context
+   ├── .cache/tmp/             # Temp space
+   ├── .memory/facts/          # Learned facts
+   ├── .memory/instructions/   # User instructions
+   ├── .memory/preferences/    # Remembered prefs
+   ├── .memory/pinned/         # Pinned memories
+   ├── .ssh/                   # Keys
+   ├── Documents/notes/        # Notes
+   ├── Documents/templates/    # Templates
+   ├── Projects/               # Project links
+   └── workspace/current/      # Active scratch
+
+4. Fixes applied:
+   - main.rs typo fixed (sfp→spf line 29)
+   - claude_state renamed to agent_state (AI-agnostic)
+   - lib.rs updated to export all 14 modules
+   - mcp.rs updated to 2231 lines (all 5 LMDBs wired)
+
+5. BUILD SUCCESSFUL:
+   - cargo build --release PASSED
+   - Binary: ~/SPFsmartGATE/target/release/spf-smart-gate
+
+================================================================================
+WHAT'S PENDING (POST-BUILD)
+================================================================================
+
+1. Add new tools to ~/.claude.json allowedTools:
+   - mcp__spf-smart-gate__spf_fs_exists
+   - mcp__spf-smart-gate__spf_fs_stat
+   - mcp__spf-smart-gate__spf_fs_ls
+   - mcp__spf-smart-gate__spf_fs_read
+   - mcp__spf-smart-gate__spf_fs_write
+   - mcp__spf-smart-gate__spf_fs_mkdir
+   - mcp__spf-smart-gate__spf_fs_rm
+   - mcp__spf-smart-gate__spf_fs_rename
+   - mcp__spf-smart-gate__spf_agent_prefs
+   - mcp__spf-smart-gate__spf_agent_memory_search
+   - mcp__spf-smart-gate__spf_agent_session
+   - mcp__spf-smart-gate__spf_agent_stats
+   - mcp__spf-smart-gate__spf_tools_list
+   - mcp__spf-smart-gate__spf_tools_get
+   - mcp__spf-smart-gate__spf_tools_stats
+   - mcp__spf-smart-gate__spf_sandbox_list
+   - mcp__spf-smart-gate__spf_sandbox_get
+   - mcp__spf-smart-gate__spf_sandbox_active
+   - mcp__spf-smart-gate__spf_sandbox_stats
+
+2. Path routing layer (FUTURE enhancement):
+   - Route ALL file operations through hierarchical LMDB structure
+   - Traversal containment at root level
+
+3. Config migration (FUTURE enhancement):
+   - config.rs still reads JSON
+   - Should read from config_db (LMDB 2)
+
+4. Cleanup:
+   - Delete duplicate main.rs in SPFsmartGATE root
+
+================================================================================
+SECURITY MODEL
+================================================================================
+
+SPF Smart Gate is an AI ENHANCEMENT & TRAINING FRAMEWORK:
+- Structure enables learning, not restriction
+- Human interference = teaching moments
+- Boundaries define the curriculum
+- Security protects the learning environment
+
+HIERARCHICAL ISOLATION:
+Agent operates within single virtual namespace backed by 5 LMDBs:
+
+/                  LMDB 1   READ-ONLY    System level
+/config/           LMDB 2   CONTROLLED   SPF manages configs
+/tools/            LMDB 3   GATED        Tools through SPF formula
+/sandbox/          LMDB 4   WRITE        Agent's workspace
+/home/claude/      LMDB 5   AGENT HOME   Personal space (~ expands here)
+
+Each LMDB is isolated. SPF routes requests based on path prefix.
+No direct cross-domain access. No escape from virtual root.
+
+================================================================================
+INTEGRATION CONFLICTS - HIERARCHICAL TRANSITION
+================================================================================
+
+CONFLICT 1: config.rs blocked_paths includes "/system"
+─────────────────────────────────────────────────────────────────────────────
+FILE: config.rs
+LINE: 94
+CURRENT:
+    blocked_paths: vec!["/tmp", "/etc", "/usr", "/system", ...]
+ISSUE:
+    In hierarchical design, /system/ is LMDB 1 (READ-ONLY virtual path),
+    not a REAL blocked path on the host filesystem.
+RESOLUTION:
+    - Add: virtual_blocked_paths for virtual FS rules
+    - Keep: blocked_paths for REAL fs backward compatibility
+    - Add: is_virtual_path_blocked() function
+
+CONFLICT 2: config.rs is_path_blocked() uses REAL filesystem
+─────────────────────────────────────────────────────────────────────────────
+FILE: config.rs
+LINE: 183-189
+CURRENT:
+    let canonical = std::fs::canonicalize(path)  // REAL filesystem
+ISSUE:
+    Uses REAL filesystem canonicalization. In hierarchical design,
+    should check VIRTUAL paths against virtual rules.
+RESOLUTION:
+    - Add: is_virtual_path_blocked(virtual_path) for virtual FS
+    - Keep: is_path_blocked() for REAL fs operations
+    - Route based on path prefix at call site
+
+CONFLICT 3: validate.rs checks REAL paths
+─────────────────────────────────────────────────────────────────────────────
+FILE: validate.rs
+LINE: 61-63, 86-88
+CURRENT:
+    if config.is_path_blocked(file_path) { ... }
+ISSUE:
+    Validates REAL path against REAL blocked paths list.
+    In hierarchical, should validate VIRTUAL path.
+RESOLUTION:
+    - Add: validate_virtual_edit(), validate_virtual_write()
+    - Keep: current functions for REAL fs backward compat
+    - Router determines which validation to use
+
+CONFLICT 4: validate.rs Path::exists() on REAL filesystem
+─────────────────────────────────────────────────────────────────────────────
+FILE: validate.rs
+LINE: 91
+CURRENT:
+    if std::path::Path::new(file_path).exists()
+ISSUE:
+    Checks REAL filesystem existence for Build Anchor.
+    In hierarchical, should check VIRTUAL fs existence.
+RESOLUTION:
+    - Add: fs.exists(virtual_path) check for virtual paths
+    - Keep: Path::exists() for REAL fs operations
+    - Router determines which check to use
+
+CONFLICT 5: session.rs stores REAL paths
+─────────────────────────────────────────────────────────────────────────────
+FILE: session.rs
+FIELDS: files_read, files_written (Vec<String>)
+CURRENT:
+    Stores REAL filesystem paths for Build Anchor tracking.
+ISSUE:
+    In hierarchical, Build Anchor should track VIRTUAL paths.
+RESOLUTION:
+    - Add: virtual_files_read, virtual_files_written fields
+    - Keep: files_read, files_written for backward compat
+    - Track both during transition
+
+CONFLICT 6: mcp.rs handlers use REAL filesystem
+─────────────────────────────────────────────────────────────────────────────
+FILE: mcp.rs
+HANDLERS: spf_read, spf_write, spf_edit, spf_glob, spf_grep
+CURRENT:
+    All handlers use std::fs operations on REAL filesystem.
+ISSUE:
+    In hierarchical, file ops should route through virtual FS.
+RESOLUTION:
+    - Add: path_router integration at handler entry
+    - Keep: current handlers as fallback for REAL paths
+    - Route: virtual paths → LMDB, real paths → std::fs
+
+CONFLICT 7: fs.rs creates wrong directories
+─────────────────────────────────────────────────────────────────────────────
+FILE: fs.rs
+LINES: 133-139
+CURRENT:
+    self.mkdir_internal("/home")?;
+    self.mkdir_internal("/home/user")?;
+    self.mkdir_internal("/home/user/.claude")?;
+    self.mkdir_internal("/home/user/sandbox")?;
+ISSUE:
+    Creates directories that belong to other LMDBs in hierarchical design:
+    - /home/claude/ should be LMDB 5 (agent_state)
+    - /sandbox/ should be LMDB 4 (sandbox_db)
+RESOLUTION:
+    - Remove: /home/* and /sandbox/* creation
+    - Keep: / and /system/* creation
+    - Add: mount point metadata for routing
+
+================================================================================
+RESOLUTION PLAN - ADDITIVE CHANGES
+================================================================================
+
+90% of current code PERSISTS unchanged. Changes are ADDITIVE.
+
+NEW MODULE: path_router.rs
+─────────────────────────────────────────────────────────────────────────────
+Purpose: Central path routing for hierarchical LMDB structure
+Functions:
+    - route_path(path) -> LmdbTarget (FS, Config, Tools, Sandbox, Agent)
+    - is_virtual_path(path) -> bool
+    - translate_virtual_to_real(virtual_path) -> Option<String>
+    - get_access_level(path) -> AccessLevel (ReadOnly, Controlled, Gated, Write, Home)
+
+UPDATES NEEDED:
+─────────────────────────────────────────────────────────────────────────────
+1. lib.rs
+   - Add: pub mod path_router;
+
+2. fs.rs (lines 133-139)
+   - Remove: /home/* and /sandbox/* directory creation
+   - Add: Mount point awareness for routing
+
+3. config.rs
+   - Add: virtual_blocked_paths: Vec<String>
+   - Add: is_virtual_path_blocked(path) -> bool
+   - Keep: existing functions unchanged
+
+4. validate.rs
+   - Add: validate_virtual_edit(), validate_virtual_write()
+   - Keep: existing functions unchanged
+
+5. session.rs
+   - Add: virtual_files_read: Vec<String>
+   - Add: virtual_files_written: Vec<String>
+   - Keep: existing fields unchanged
+
+6. mcp.rs
+   - Add: path_router integration at handler entry
+   - Keep: existing handlers unchanged
+
+FUNCTIONS THAT PERSIST UNCHANGED:
+─────────────────────────────────────────────────────────────────────────────
+config_db.rs    - ALL 20+ functions
+tools_db.rs     - ALL 15+ functions
+sandbox_db.rs   - ALL 20+ functions
+agent_state.rs  - ALL 25+ functions
+calculate.rs    - ALL complexity formula functions
+gate.rs         - ALL enforcement functions
+inspect.rs      - ALL content inspection functions
+web.rs          - ALL HTTP client functions
+storage.rs      - ALL session state functions
+main.rs         - ALL CLI functions
+
+CARGO.TOML: No changes needed - all dependencies present.
+
+================================================================================
+END OF BUILD DOCUMENTATION
+================================================================================
+
+
+################################################################################
+##                                                                            ##
+##                    LMDB 5 CLI INSTALLATION — FILE LIST                     ##
+##                    Full Containment: Claude CLI in LMDB 5                  ##
+##                                                                            ##
+################################################################################
+
+================================================================================
+FILES TO COPY INTO LMDB 5 (/home/agent/)
+================================================================================
+
+CURRENT FILEPATH                                          DESTINATION (LMDB 5)
+─────────────────────────────────────────────────────────────────────────────────
+
+CLAUDE CLI BINARY (69MB)
+─────────────────────────────────────────────────────────────────────────────────
+/data/data/com.termux/files/usr/lib/node_modules/@anthropic-ai/claude-code/
+                                                    →     /home/agent/bin/claude-code/
+
+SPF SMART GATE BINARY (~8MB)
+─────────────────────────────────────────────────────────────────────────────────
+~/SPFsmartGATE/target/release/spf-smart-gate        →     /home/agent/bin/spf-smart-gate
+
+MAIN CONFIG (20KB)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude.json                                      →     /home/agent/.claude.json
+
+CLAUDE CONFIG FILES (SMALL - DIRECT TO LMDB)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/settings.json                (16KB)       →     /home/agent/.claude/settings.json
+~/.claude/config.json                  (16KB)       →     /home/agent/.claude/config.json
+~/.claude/.credentials.json            (447B)       →     /home/agent/.claude/.credentials.json
+~/.claude/claude.md                    (20KB)       →     /home/agent/.claude/claude.md
+~/.claude/stats-cache.json             (3KB)        →     /home/agent/.claude/stats-cache.json
+~/.claude/settings.local.json          (113B)       →     /home/agent/.claude/settings.local.json
+
+CLAUDE DATA FILES (MEDIUM - LMDB OR BLOB)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/history.jsonl                (1.2MB)      →     /home/agent/.claude/history.jsonl
+
+CLAUDE DIRECTORIES (LARGE - BLOB STORAGE WITH SYMLINKS)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/projects/                    (119MB)      →     /home/agent/.claude/projects/
+~/.claude/file-history/                (25MB)       →     /home/agent/.claude/file-history/
+~/.claude/paste-cache/                 (~1MB)       →     /home/agent/.claude/paste-cache/
+~/.claude/session-env/                 (424KB)      →     /home/agent/.claude/session-env/
+~/.claude/todos/                       (316KB)      →     /home/agent/.claude/todos/
+~/.claude/plans/                       (20KB)       →     /home/agent/.claude/plans/
+~/.claude/tasks/                       (46KB)       →     /home/agent/.claude/tasks/
+~/.claude/shell-snapshots/             (44KB)       →     /home/agent/.claude/shell-snapshots/
+~/.claude/statsig/                     (40KB)       →     /home/agent/.claude/statsig/
+~/.claude/telemetry/                   (252KB)      →     /home/agent/.claude/telemetry/
+
+EXCLUDED (NOT COPIED)
+─────────────────────────────────────────────────────────────────────────────────
+~/.claude/debug/                       (441MB)      →     EXCLUDED (logs, not needed)
+~/.claude/spf-hooks-backup/            (123KB)      →     EXCLUDED (old backup)
+
+================================================================================
+STORAGE STRATEGY
+================================================================================
+
+< 1MB  → Store directly in LMDB 5
+> 1MB  → Blob storage on disk, metadata in LMDB 5, symlink for access
+
+BINARIES:
+  - claude-code/ (69MB) → blob storage
+  - spf-smart-gate (8MB) → blob storage
+
+LARGE DIRS:
+  - projects/ (119MB) → blob storage per file
+  - file-history/ (25MB) → blob storage per file
+
+================================================================================
+TOTAL SIZE ESTIMATE
+================================================================================
+
+Config files (direct LMDB):     ~60KB
+Medium files (LMDB/blob):       ~1.2MB
+Large directories (blob):       ~145MB
+Binaries (blob):                ~77MB
+─────────────────────────────────────────
+TOTAL:                          ~223MB (excluding debug/)
+
+================================================================================
+POST-COPY: UPDATE REFERENCES
+================================================================================
+
+1. mcpServers command path:
+   OLD: ~/SPFsmartGATE/target/release/spf-smart-gate
+   NEW: /home/agent/bin/spf-smart-gate (virtual) → blob path (real)
+
+2. Claude CLI invocation:
+   OLD: /usr/bin/claude → /usr/lib/node_modules/@anthropic-ai/claude-code/cli.js
+   NEW: /home/agent/bin/claude-code/cli.js (virtual) → blob path (real)
+
+3. Config file paths:
+   OLD: ~/.claude.json, ~/.claude/
+   NEW: /home/agent/.claude.json, /home/agent/.claude/
+
+================================================================================
+END OF LMDB 5 FILE LIST
+================================================================================
+
+
+################################################################################
+##                                                                            ##
+##                    LMDB 5 INSTALLATION SCRIPT                              ##
+##                    Surgical Transfer & Boot Injection                      ##
+##                                                                            ##
+################################################################################
+
+#!/bin/bash
+#===============================================================================
+# LMDB5 CLI INSTALLATION SCRIPT
+# Transfers Claude CLI and all configs into LMDB 5 virtual filesystem
+# Creates boot injection for seamless startup
+#
+# Usage: bash install-lmdb5.sh
+# Location: ~/SPFsmartGATE/scripts/install-lmdb5.sh
+#===============================================================================
+
+set -e  # Exit on error
+
+#-------------------------------------------------------------------------------
+# CONFIGURATION
+#-------------------------------------------------------------------------------
+
+SPF_HOME="$HOME/SPFsmartGATE"
+STORAGE="$SPF_HOME/storage"
+BLOBS="$STORAGE/blobs"
+LMDB5_DIR="$STORAGE/agent_state"
+MANIFEST="$STORAGE/lmdb5_manifest.json"
+BACKUP_DIR="$SPF_HOME/backup/pre-lmdb5-$(date +%Y%m%d-%H%M%S)"
+LOG="$SPF_HOME/state/lmdb5-install.log"
+
+# Source paths
+CLAUDE_CLI="/data/data/com.termux/files/usr/lib/node_modules/@anthropic-ai/claude-code"
+SPF_BINARY="$SPF_HOME/target/release/spf-smart-gate"
+CLAUDE_JSON="$HOME/.claude.json"
+CLAUDE_DIR="$HOME/.claude"
+
+# Virtual paths (LMDB 5)
+VHOME="/home/agent"
+
+#-------------------------------------------------------------------------------
+# HELPER FUNCTIONS
+#-------------------------------------------------------------------------------
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG"
+}
+
+error() {
+    echo "[ERROR] $1" | tee -a "$LOG"
+    exit 1
+}
+
+check_exists() {
+    if [ ! -e "$1" ]; then
+        error "Required file/dir not found: $1"
+    fi
+}
+
+sha256sum_file() {
+    sha256sum "$1" 2>/dev/null | cut -d' ' -f1
+}
+
+#-------------------------------------------------------------------------------
+# PRE-FLIGHT CHECKS
+#-------------------------------------------------------------------------------
+
+preflight() {
+    log "=== PRE-FLIGHT CHECKS ==="
+
+    # Check SPF build exists
+    check_exists "$SPF_BINARY"
+    log "✓ SPF binary found: $SPF_BINARY"
+
+    # Check Claude CLI exists
+    check_exists "$CLAUDE_CLI"
+    log "✓ Claude CLI found: $CLAUDE_CLI"
+
+    # Check Claude config exists
+    check_exists "$CLAUDE_JSON"
+    log "✓ Claude config found: $CLAUDE_JSON"
+
+    # Check Claude dir exists
+    check_exists "$CLAUDE_DIR"
+    log "✓ Claude dir found: $CLAUDE_DIR"
+
+    # Create directories
+    mkdir -p "$STORAGE" "$BLOBS" "$LMDB5_DIR" "$BACKUP_DIR"
+    mkdir -p "$SPF_HOME/state"
+    log "✓ Storage directories ready"
+
+    log "=== PRE-FLIGHT COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# BACKUP EXISTING
+#-------------------------------------------------------------------------------
+
+backup_existing() {
+    log "=== CREATING BACKUP ==="
+
+    # Backup current claude configs
+    if [ -f "$CLAUDE_JSON" ]; then
+        cp "$CLAUDE_JSON" "$BACKUP_DIR/claude.json"
+        log "✓ Backed up: .claude.json"
+    fi
+
+    # Backup claude dir (exclude debug/)
+    if [ -d "$CLAUDE_DIR" ]; then
+        rsync -a --exclude='debug/' "$CLAUDE_DIR/" "$BACKUP_DIR/claude/"
+        log "✓ Backed up: .claude/ (excluding debug/)"
+    fi
+
+    log "Backup location: $BACKUP_DIR"
+    log "=== BACKUP COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# COPY BINARIES TO BLOB STORAGE
+#-------------------------------------------------------------------------------
+
+copy_binaries() {
+    log "=== COPYING BINARIES ==="
+
+    # SPF Smart Gate binary
+    local spf_hash=$(sha256sum_file "$SPF_BINARY")
+    local spf_blob="$BLOBS/$spf_hash"
+    cp "$SPF_BINARY" "$spf_blob"
+    chmod +x "$spf_blob"
+    log "✓ SPF binary → blob: $spf_hash"
+    echo "$VHOME/bin/spf-smart-gate|$spf_blob|$(stat -c%s "$SPF_BINARY")|binary" >> "$MANIFEST.tmp"
+
+    # Claude CLI (entire directory)
+    local claude_blob_dir="$BLOBS/claude-code"
+    rm -rf "$claude_blob_dir"
+    cp -r "$CLAUDE_CLI" "$claude_blob_dir"
+    log "✓ Claude CLI → blob: claude-code/"
+    echo "$VHOME/bin/claude-code|$claude_blob_dir|directory|binary" >> "$MANIFEST.tmp"
+
+    log "=== BINARIES COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# COPY CONFIG FILES (SMALL - DIRECT)
+#-------------------------------------------------------------------------------
+
+copy_configs() {
+    log "=== COPYING CONFIG FILES ==="
+
+    local config_staging="$STORAGE/staging/configs"
+    mkdir -p "$config_staging"
+
+    # Main claude.json
+    cp "$CLAUDE_JSON" "$config_staging/claude.json"
+    echo "$VHOME/.claude.json|$config_staging/claude.json|$(stat -c%s "$CLAUDE_JSON")|config" >> "$MANIFEST.tmp"
+    log "✓ .claude.json"
+
+    # Small config files (< 1MB, store directly)
+    local small_files=(
+        "settings.json"
+        "config.json"
+        ".credentials.json"
+        "claude.md"
+        "stats-cache.json"
+        "settings.local.json"
+    )
+
+    for f in "${small_files[@]}"; do
+        if [ -f "$CLAUDE_DIR/$f" ]; then
+            cp "$CLAUDE_DIR/$f" "$config_staging/$f"
+            echo "$VHOME/.claude/$f|$config_staging/$f|$(stat -c%s "$CLAUDE_DIR/$f")|config" >> "$MANIFEST.tmp"
+            log "✓ .claude/$f"
+        fi
+    done
+
+    log "=== CONFIG FILES COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# COPY LARGE DIRECTORIES TO BLOB STORAGE
+#-------------------------------------------------------------------------------
+
+copy_large_dirs() {
+    log "=== COPYING LARGE DIRECTORIES ==="
+
+    local large_dirs=(
+        "projects"
+        "file-history"
+        "paste-cache"
+        "session-env"
+        "todos"
+        "plans"
+        "tasks"
+        "shell-snapshots"
+        "statsig"
+        "telemetry"
+    )
+
+    for dir in "${large_dirs[@]}"; do
+        if [ -d "$CLAUDE_DIR/$dir" ]; then
+            local blob_dir="$BLOBS/claude-$dir"
+            rm -rf "$blob_dir"
+            cp -r "$CLAUDE_DIR/$dir" "$blob_dir"
+            local size=$(du -sb "$CLAUDE_DIR/$dir" | cut -f1)
+            echo "$VHOME/.claude/$dir|$blob_dir|$size|directory" >> "$MANIFEST.tmp"
+            log "✓ .claude/$dir → blob"
+        fi
+    done
+
+    # history.jsonl (medium file)
+    if [ -f "$CLAUDE_DIR/history.jsonl" ]; then
+        local hist_hash=$(sha256sum_file "$CLAUDE_DIR/history.jsonl")
+        cp "$CLAUDE_DIR/history.jsonl" "$BLOBS/$hist_hash"
+        echo "$VHOME/.claude/history.jsonl|$BLOBS/$hist_hash|$(stat -c%s "$CLAUDE_DIR/history.jsonl")|file" >> "$MANIFEST.tmp"
+        log "✓ .claude/history.jsonl → blob"
+    fi
+
+    log "=== LARGE DIRECTORIES COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# CREATE LMDB5 MANIFEST (JSON)
+#-------------------------------------------------------------------------------
+
+create_manifest() {
+    log "=== CREATING MANIFEST ==="
+
+    # Convert tmp manifest to JSON
+    echo '{' > "$MANIFEST"
+    echo '  "version": "1.0",' >> "$MANIFEST"
+    echo '  "created": "'$(date -Iseconds)'",' >> "$MANIFEST"
+    echo '  "entries": [' >> "$MANIFEST"
+
+    local first=true
+    while IFS='|' read -r vpath rpath size ftype; do
+        if [ "$first" = true ]; then
+            first=false
+        else
+            echo ',' >> "$MANIFEST"
+        fi
+        echo -n '    {"virtual": "'$vpath'", "real": "'$rpath'", "size": "'$size'", "type": "'$ftype'"}' >> "$MANIFEST"
+    done < "$MANIFEST.tmp"
+
+    echo '' >> "$MANIFEST"
+    echo '  ]' >> "$MANIFEST"
+    echo '}' >> "$MANIFEST"
+
+    rm -f "$MANIFEST.tmp"
+    log "✓ Manifest created: $MANIFEST"
+    log "=== MANIFEST COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# CREATE BOOT INJECTION SCRIPT
+#-------------------------------------------------------------------------------
+
+create_boot_injection() {
+    log "=== CREATING BOOT INJECTION ==="
+
+    local boot_script="$SPF_HOME/scripts/boot-lmdb5.sh"
+    mkdir -p "$SPF_HOME/scripts"
+
+    cat > "$boot_script" << 'BOOTEOF'
+#!/bin/bash
+#===============================================================================
+# LMDB5 BOOT INJECTION
+# Loads manifest into LMDB 5 on startup
+# Called by: session-start.sh or systemd/init
+#===============================================================================
+
+SPF_HOME="$HOME/SPFsmartGATE"
+MANIFEST="$SPF_HOME/storage/lmdb5_manifest.json"
+SPF_BINARY="$SPF_HOME/storage/blobs/$(ls $SPF_HOME/storage/blobs/ | grep -v claude | head -1)"
+LOG="$SPF_HOME/state/boot.log"
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] BOOT: $1" >> "$LOG"
+}
+
+# Check manifest exists
+if [ ! -f "$MANIFEST" ]; then
+    log "ERROR: Manifest not found: $MANIFEST"
+    exit 1
+fi
+
+log "Loading LMDB5 manifest..."
+
+# The SPF binary will read the manifest and populate LMDB 5
+# This happens automatically when spf-smart-gate starts with 'serve'
+# The fs.rs init checks for manifest and imports entries
+
+log "LMDB5 boot injection complete"
+
+# Export virtual paths for Claude CLI
+export SPF_AGENT_HOME="/home/agent"
+export SPF_CLAUDE_CONFIG="/home/agent/.claude.json"
+export SPF_ACTIVE=1
+
+log "Environment exported: SPF_AGENT_HOME=$SPF_AGENT_HOME"
+BOOTEOF
+
+    chmod +x "$boot_script"
+    log "✓ Boot script: $boot_script"
+
+    # Update session-start.sh to call boot injection
+    local session_start="$SPF_HOME/hooks/session-start.sh"
+    if [ -f "$session_start" ]; then
+        if ! grep -q "boot-lmdb5.sh" "$session_start"; then
+            echo "" >> "$session_start"
+            echo "# LMDB5 Boot Injection" >> "$session_start"
+            echo "source $boot_script 2>/dev/null || true" >> "$session_start"
+            log "✓ Injected into session-start.sh"
+        else
+            log "✓ Boot injection already in session-start.sh"
+        fi
+    fi
+
+    log "=== BOOT INJECTION COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# CREATE SYMLINKS FOR BACKWARD COMPATIBILITY
+#-------------------------------------------------------------------------------
+
+create_symlinks() {
+    log "=== CREATING SYMLINKS ==="
+
+    # Create agent bin directory with symlinks to blob binaries
+    local agent_bin="$SPF_HOME/agent-bin"
+    mkdir -p "$agent_bin"
+
+    # SPF binary symlink
+    local spf_blob=$(ls "$BLOBS" | grep -v claude | head -1)
+    if [ -n "$spf_blob" ]; then
+        ln -sf "$BLOBS/$spf_blob" "$agent_bin/spf-smart-gate"
+        log "✓ Symlink: agent-bin/spf-smart-gate → blob"
+    fi
+
+    # Claude CLI symlink
+    if [ -d "$BLOBS/claude-code" ]; then
+        ln -sf "$BLOBS/claude-code" "$agent_bin/claude-code"
+        log "✓ Symlink: agent-bin/claude-code → blob"
+    fi
+
+    log "=== SYMLINKS COMPLETE ==="
+}
+
+#-------------------------------------------------------------------------------
+# VERIFICATION
+#-------------------------------------------------------------------------------
+
+verify_installation() {
+    log "=== VERIFICATION ==="
+
+    local errors=0
+
+    # Check manifest
+    if [ -f "$MANIFEST" ]; then
+        local count=$(grep -c '"virtual"' "$MANIFEST")
+        log "✓ Manifest entries: $count"
+    else
+        log "✗ Manifest missing"
+        ((errors++))
+    fi
+
+    # Check blobs
+    local blob_count=$(ls -1 "$BLOBS" 2>/dev/null | wc -l)
+    log "✓ Blob files: $blob_count"
+
+    # Check boot script
+    if [ -x "$SPF_HOME/scripts/boot-lmdb5.sh" ]; then
+        log "✓ Boot script executable"
+    else
+        log "✗ Boot script missing or not executable"
+        ((errors++))
+    fi
+
+    # Check SPF binary in blob
+    if [ -f "$SPF_HOME/agent-bin/spf-smart-gate" ]; then
+        log "✓ SPF binary accessible via agent-bin"
+    else
+        log "✗ SPF binary symlink missing"
+        ((errors++))
+    fi
+
+    if [ $errors -eq 0 ]; then
+        log "=== VERIFICATION PASSED ==="
+    else
+        log "=== VERIFICATION FAILED: $errors errors ==="
+        return 1
+    fi
+}
+
+#-------------------------------------------------------------------------------
+# UPDATE CLAUDE.JSON TO POINT TO NEW PATHS
+#-------------------------------------------------------------------------------
+
+update_claude_json() {
+    log "=== UPDATING CLAUDE.JSON REFERENCES ==="
+
+    # Update mcpServers command to use agent-bin path
+    local new_spf_path="$SPF_HOME/agent-bin/spf-smart-gate"
+
+    # Use jq if available, otherwise sed
+    if command -v jq &> /dev/null; then
+        jq '.mcpServers["spf-smart-gate"].command = "'$new_spf_path'"' \
+            "$CLAUDE_JSON" > "$CLAUDE_JSON.tmp" && mv "$CLAUDE_JSON.tmp" "$CLAUDE_JSON"
+        log "✓ Updated mcpServers path via jq"
+    else
+        sed -i 's|"command": ".*spf-smart-gate.*"|"command": "'$new_spf_path'"|' "$CLAUDE_JSON"
+        log "✓ Updated mcpServers path via sed"
+    fi
+
+    log "=== CLAUDE.JSON UPDATED ==="
+}
+
+#-------------------------------------------------------------------------------
+# PRINT SUMMARY
+#-------------------------------------------------------------------------------
+
+print_summary() {
+    echo ""
+    echo "==============================================================================="
+    echo "                    LMDB5 INSTALLATION COMPLETE"
+    echo "==============================================================================="
+    echo ""
+    echo "Backup:     $BACKUP_DIR"
+    echo "Manifest:   $MANIFEST"
+    echo "Blobs:      $BLOBS"
+    echo "Boot:       $SPF_HOME/scripts/boot-lmdb5.sh"
+    echo "Log:        $LOG"
+    echo ""
+    echo "Virtual filesystem layout:"
+    echo "  /home/agent/"
+    echo "  ├── .claude.json"
+    echo "  ├── .claude/"
+    echo "  │   ├── settings.json"
+    echo "  │   ├── config.json"
+    echo "  │   ├── projects/"
+    echo "  │   └── ..."
+    echo "  └── bin/"
+    echo "      ├── spf-smart-gate"
+    echo "      └── claude-code/"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Restart Claude CLI"
+    echo "  2. Test: spf_fs_ls /home/agent/"
+    echo "  3. Verify boot injection in session-start.sh"
+    echo ""
+    echo "==============================================================================="
+}
+
+#-------------------------------------------------------------------------------
+# MAIN
+#-------------------------------------------------------------------------------
+
+main() {
+    echo ""
+    echo "==============================================================================="
+    echo "              LMDB5 CLI INSTALLATION - FULL CONTAINMENT"
+    echo "==============================================================================="
+    echo ""
+
+    preflight
+    backup_existing
+
+    # Initialize manifest
+    > "$MANIFEST.tmp"
+
+    copy_binaries
+    copy_configs
+    copy_large_dirs
+    create_manifest
+    create_boot_injection
+    create_symlinks
+    update_claude_json
+    verify_installation
+    print_summary
+
+    log "=== INSTALLATION COMPLETE ==="
+}
+
+# Run main
+main "$@"
+
+#===============================================================================
+# END OF INSTALLATION SCRIPT
+#===============================================================================

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/1aff2d648c41bb62@v2

@@ -0,0 +1,127 @@
+# Plan: Wire spf_fs_* handlers to route directly to LMDB partitions
+
+## Context
+The virtual filesystem (LMDB 1 / SpfFs) has mount-point directories that map to the other 4 LMDBs:
+- `/system/config/` → LMDB 2 (SpfConfigDb)
+- `/system/tools/` → LMDB 3 (SpfToolsDb)
+- `/home/user/sandbox/` → LMDB 4 (SpfSandboxDb)
+- `/home/user/.claude/` → LMDB 5 (AgentStateDb)
+
+Currently these are empty directory stubs in LMDB 1. When you `spf_fs_ls /system/config/`, it queries SpfFs and returns nothing. The actual config data lives in config_db but is only accessible via separate `spf_config_*` tools. This is wrong — the filesystem should route directly to the correct LMDB partition.
+
+## Approach: Prefix-routing function in mcp.rs
+
+Add ONE routing function that sits at the top of each `spf_fs_*` handler. If the path matches a mount prefix, it routes to the correct LMDB and returns the result. If no match, falls through to SpfFs (LMDB 1) as before.
+
+**No new files. No new modules. No path_router.rs.** Just a routing function + 4 per-mount handlers, all inside mcp.rs.
+
+## File: `src/mcp.rs` (only file modified)
+
+### Change 1: Add routing function (~15 lines)
+Insert before `handle_tool_call()`:
+
+```rust
+fn route_to_lmdb(
+    path: &str, op: &str, args: &Value,
+    config_db: &Option<SpfConfigDb>,
+    tools_db: &Option<SpfToolsDb>,
+    sandbox_db: &Option<SpfSandboxDb>,
+    agent_db: &Option<AgentStateDb>,
+) -> Option<Value> {
+    if path.starts_with("/system/config") {
+        return Some(route_config(path, op, config_db));
+    }
+    if path.starts_with("/system/tools") {
+        return Some(route_tools(path, op, tools_db));
+    }
+    if path.starts_with("/home/user/sandbox") {
+        return Some(route_sandbox(path, op, sandbox_db));
+    }
+    if path.starts_with("/home/user/.claude") {
+        return Some(route_agent(path, op, agent_db));
+    }
+    None
+}
+```
+
+### Change 2: Add 4 per-mount route handlers (~200 lines total)
+
+Each handler supports: `ls`, `read`, `exists`, `stat`. Write/mkdir/rm/rename return "read-only mount".
+
+**route_config** (LMDB 2 — SpfConfigDb):
+- `ls /system/config/` → virtual files: `paths`, `patterns`, `tiers`, `formula`, `weights`, `mode`, `version`
+- `read /system/config/paths` → `db.list_path_rules()` formatted
+- `read /system/config/tiers` → `db.get_tiers()` as JSON
+- `read /system/config/formula` → `db.get_formula()` as JSON
+- `read /system/config/weights` → `db.get_weights()` as JSON
+- `read /system/config/patterns` → `db.list_dangerous_patterns()` formatted
+- `read /system/config/mode` → `db.get_enforce_mode()` as string
+- `read /system/config/version` → `db.get("spf", "version")`
+
+**route_tools** (LMDB 3 — SpfToolsDb):
+- `ls /system/tools/` → `db.list_tools()` → tool names as virtual files
+- `read /system/tools/{name}` → `db.get_tool(name)` → formatted entry
+- `exists /system/tools/{name}` → `db.get_tool(name).is_some()`
+
+**route_sandbox** (LMDB 4 — SpfSandboxDb):
+- `ls /home/user/sandbox/` → `db.list_projects()` → project names as virtual files
+- `read /home/user/sandbox/{name}` → project details formatted
+- `exists` → check project exists
+
+**route_agent** (LMDB 5 — AgentStateDb):
+- `ls /home/user/.claude/` → virtual dirs: `memory/`, `sessions/`, `state/`, plus `preferences` file, `context` file
+- `ls /home/user/.claude/memory/` → memory IDs
+- `ls /home/user/.claude/sessions/` → session IDs
+- `ls /home/user/.claude/state/` → state keys
+- `read /home/user/.claude/memory/{id}` → memory content
+- `read /home/user/.claude/sessions/{id}` → session details
+- `read /home/user/.claude/state/{key}` → state value
+- `read /home/user/.claude/preferences` → preferences JSON
+- `read /home/user/.claude/context` → `db.get_context_summary()`
+
+### Change 3: Wire routing into existing 8 handlers (~2 lines each)
+
+Each `spf_fs_*` handler gets a routing check at the top BEFORE the `fs_db` match:
+
+```rust
+"spf_fs_ls" => {
+    let path = args["path"].as_str().unwrap_or("/");
+    session.record_action("fs_ls", "list", Some(path));
+    let _ = storage.save_session(session);
+
+    // Route to LMDB partition if path matches mount point
+    if let Some(result) = route_to_lmdb(path, "ls", args, config_db, tools_db, sandbox_db, agent_db) {
+        return result;  // <-- ADD THIS
+    }
+
+    // Fall through to SpfFs (LMDB 1)
+    match fs_db { ... }  // existing code unchanged
+}
+```
+
+Same pattern for all 8 handlers: exists, stat, ls, read, write, mkdir, rm, rename.
+For write/mkdir/rm/rename, the routing function returns "read-only mount" for LMDB 2-5 paths.
+
+## What does NOT change
+- SpfFs (fs.rs) — untouched
+- config_db.rs, tools_db.rs, sandbox_db.rs, agent_state.rs — untouched
+- Tool definitions (the JSON schemas) — untouched
+- The existing `spf_config_*`, `spf_tools_*`, `spf_sandbox_*`, `spf_agent_*` handlers — untouched
+- handle_tool_call() signature — untouched (already has all 5 db params)
+
+## Verification
+After rebuild + deploy + reboot:
+1. `spf_fs_ls /` → `home`, `system` (from SpfFs — unchanged)
+2. `spf_fs_ls /system/config/` → `paths`, `patterns`, `tiers`, `formula`, `weights`, `mode`, `version`
+3. `spf_fs_read /system/config/tiers` → actual tier config JSON from LMDB 2
+4. `spf_fs_ls /system/tools/` → list of registered tool names from LMDB 3
+5. `spf_fs_ls /home/user/.claude/` → `memory/`, `sessions/`, `state/`, `preferences`, `context`
+6. `spf_fs_read /home/user/.claude/context` → context summary from LMDB 5
+7. `spf_fs_write /system/config/test` → "read-only mount" (blocked)
+8. Existing `spf_config_paths`, `spf_tools_list`, etc. still work independently
+
+## Summary
+- **1 file modified**: `src/mcp.rs`
+- **~220 lines added**: 1 routing function + 4 mount handlers + 8×2-line handler wiring
+- **0 files created or deleted**
+- **0 existing behavior changed** — pure additive, fallthrough to SpfFs preserved

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/3c246a0a460d44f6@v2

@@ -0,0 +1,90 @@
+# SPF Smart Gateway - MCP Command Gateway
+# Copyright 2026 Joseph Stone - All Rights Reserved
+#
+# All tool calls route through this gateway.
+# Enforces SPF complexity formula, validates rules,
+# gates all file/bash operations. Pure Rust, LMDB state,
+# MCP stdio JSON-RPC 2.0.
+
+[package]
+name = "spf-smart-gate"
+version = "2.0.0"
+edition = "2021"
+authors = ["Joseph Stone <joepcstone@gmail.com>"]
+description = "SPF Smart GATE - MCP command gateway with complexity enforcement"
+license-file = "LICENSE"
+repository = "https://github.com/stonecelljoseph-source/StoneCell-Processing-Formula-For-AI-Self-Governance"
+readme = "README.md"
+
+[[bin]]
+name = "spf-smart-gate"
+path = "src/main.rs"
+
+[lib]
+name = "spf_smart_gate"
+path = "src/lib.rs"
+
+[dependencies]
+# ============================================================================
+# STATE STORAGE - LMDB
+# ============================================================================
+heed = "0.20"
+
+# ============================================================================
+# SERIALIZATION
+# ============================================================================
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# ============================================================================
+# CLI
+# ============================================================================
+clap = { version = "4.5", features = ["derive"] }
+
+# ============================================================================
+# ERROR HANDLING
+# ============================================================================
+thiserror = "1.0"
+anyhow = "1.0"
+
+# ============================================================================
+# LOGGING
+# ============================================================================
+log = "0.4"
+env_logger = "0.11"
+
+# ============================================================================
+# TIME
+# ============================================================================
+chrono = { version = "0.4", features = ["serde"] }
+
+# ============================================================================
+# WEB BROWSER — AI-friendly HTTP client
+# ============================================================================
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "json"] }
+html2text = "0.6"
+
+# ============================================================================
+# FILESYSTEM — SHA256 checksums + hex encoding (NEW for fs.rs)
+# ============================================================================
+sha2 = "0.10"
+hex = "0.4"
+
+# ============================================================================
+# PROFILES
+# ============================================================================
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+panic = "abort"
+strip = true
+
+[profile.dev]
+opt-level = 1
+
+# ============================================================================
+# DEV DEPENDENCIES — for tests only
+# ============================================================================
+[dev-dependencies]
+tempfile = "3"

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/53a1fc82aaa6d2ce@v2

@@ -0,0 +1,115 @@
+# SPF Smart Gate v2.0.0 - Session Handoff
+**Date:** 2026-02-06
+**Status:** Security audit complete — backdoor removed, shell injection fixed, clean build
+
+## What Was Done This Session (Opus 4.6)
+
+### 1. BACKDOOR REMOVED — Approval System Fixed
+**Problem:** Opus 4.5 left `approved: true` as default in MCP tool schemas. Combined with `requires_approval: true` hardcoded for ALL tiers, the approval system was theater — everything auto-approved.
+
+**Fix (4 files):**
+- `config.rs` — Tier defaults: SIMPLE/LIGHT/MEDIUM `requires_approval: false`, CRITICAL `true`
+- `config.rs` — `get_tier()` reads actual config values instead of hardcoded `true`
+- `config_db.rs` — Same tier fix in LMDB `init_defaults()` and `get_tier_for_c()`
+- `mcp.rs` — ALL `approved` defaults changed from `true` to `false`
+
+**Result:** CRITICAL tier (C > 10000) is genuinely blocked without explicit `approved=true`. Lower tiers pass through, protected by Build Anchor + path blocking + content inspection.
+
+### 2. LMDB BOOT SYNC — `sync_tier_approval()`
+**Problem:** LMDB config database cached old `requires_approval: true` for all tiers. Code changes don't reach stored LMDB values.
+
+**Fix:** Added `sync_tier_approval()` in `config_db.rs`. Runs every boot. Compares LMDB-stored tier approval values against the policy array defined in code. Updates LMDB if they differ, logs changes. No version chains to track.
+
+**To change approval policy in future:** Edit the `policy` array in `sync_tier_approval()` → rebuild → reboot. Done.
+
+### 3. SHELL INJECTION FIXED — spf_glob + spf_grep
+**Problem:** User-provided `pattern`, `path`, `glob_filter` were interpolated into `format!()` strings and passed to `bash -c`. A crafted pattern could break out and execute arbitrary commands — in a security gateway.
+
+**Fix:** Replaced `Command::new("bash").arg("-c").arg(&cmd)` with:
+- `spf_glob`: `Command::new("find").arg(path).arg("-name").arg(pattern)` — no shell
+- `spf_grep`: `Command::new("rg").arg("--").arg(pattern).arg(path)` — `--` prevents flag injection
+- Output truncation done in Rust (`.lines().take(N)`) instead of piped `head`
+
+### 4. READ VALIDATION FIXED — validate_read
+**Problem:** `validate_read()` only checked `file_path.starts_with("/tmp")`. Reads to `/etc`, `/usr`, `/system` bypassed validation.
+
+**Fix:** Replaced with `config.is_path_blocked(file_path)` which checks all blocked paths with canonicalization (prevents `../` traversal).
+
+### 5. VERSION ALIGNED — 2.0.0
+- `Cargo.toml`: `1.0.0` → `2.0.0`
+- `mcp.rs`: `SERVER_VERSION` `1.0.0` → `2.0.0`
+- `config_db.rs`: LMDB stored version synced to `2.0.0`
+- `main.rs`: Already `2.0.0` (unchanged)
+
+### 6. DEAD CODE REMOVED
+- `src/gate-EDITED.rs` (172 LOC) — deleted, not in lib.rs
+- `src/mcp-EDITED.rs` (1420 LOC) — deleted, not in lib.rs
+- `src/claude_state.rs` (670 LOC) — deleted, superseded by agent_state.rs
+- **Total removed:** 2,262 lines
+
+## Files Modified
+```
+src/config.rs     - Tier defaults + get_tier() reads actual config
+src/config_db.rs  - Tier defaults + get_tier_for_c() + sync_tier_approval() + load_full_config() call
+src/mcp.rs        - approved defaults false, SERVER_VERSION 2.0.0, safe glob/grep
+src/validate.rs   - validate_read uses config.is_path_blocked()
+Cargo.toml        - version 2.0.0
+```
+
+## Files Deleted
+```
+src/gate-EDITED.rs
+src/mcp-EDITED.rs
+src/claude_state.rs
+```
+
+## Current State
+```
+Binary:  ~/SPFsmartGATE/target/release/spf-smart-gate (NEEDS REBUILD)
+Source:  16 files, ~6,610 lines, zero dead code
+Storage: ~/SPFsmartGATE/storage/
+  - spf_config/   → will self-heal tier approval on first boot via sync_tier_approval()
+  - spf_tools/
+  - spf_sandbox/
+  - agent_state/
+```
+
+## Build + Boot
+```bash
+cd ~/SPFsmartGATE
+cargo build --release
+# Restart Claude Code session — MCP server picks up new binary
+```
+
+## Post-Boot Verification
+```
+spf_status          → should show v2.0.0
+spf_calculate       → SIMPLE tier should show requires_approval: false
+spf_calculate       → CRITICAL tier should show requires_approval: true
+```
+
+## Architecture Reference
+```
+LMDB 1: SPF_STATE    - ~/SPFsmartGATE/storage/
+LMDB 2: SPF_CONFIG   - ~/SPFsmartGATE/storage/spf_config/
+LMDB 3: SPF_TOOLS    - ~/SPFsmartGATE/storage/spf_tools/
+LMDB 4: SPF_SANDBOX  - ~/SPFsmartGATE/storage/spf_sandbox/
+LMDB 5: AGENT_STATE  - ~/SPFsmartGATE/storage/agent_state/
+```
+
+## Config Loading Flow
+```
+main.rs
+  └─> SpfConfigDb::open(storage/spf_config)
+       └─> load_full_config()
+            └─> init_defaults() if empty
+            └─> sync_tier_approval()  ← NEW: enforces code-defined policy
+            └─> Assembles SpfConfig from LMDB
+  └─> mcp::run(config, session, storage)
+```
+
+## To Resume Work
+1. Read this file
+2. Run `spf_status` to confirm v2.0.0
+3. Run `spf_calculate` on a Write to confirm SIMPLE shows `requires_approval: false`
+4. Run `spf_calculate` on a high-complexity op to confirm CRITICAL shows `requires_approval: true`

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/6ca5b69f33e447bc@v2

@@ -0,0 +1,154 @@
+// SPF Smart Gateway - Rules Validator
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// Validates tool calls against SPF rules:
+// - Build Anchor Protocol (must read before edit/write)
+// - Blocked paths (/tmp, /etc, /usr, /system)
+// - Dangerous command detection
+// - File size limits
+// - Git force operation warnings
+
+use crate::config::{EnforceMode, SpfConfig};
+use crate::session::Session;
+use serde::{Deserialize, Serialize};
+
+/// Validation result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ValidationResult {
+    pub valid: bool,
+    pub warnings: Vec<String>,
+    pub errors: Vec<String>,
+}
+
+impl ValidationResult {
+    pub fn ok() -> Self {
+        Self { valid: true, warnings: Vec::new(), errors: Vec::new() }
+    }
+
+    pub fn warn(&mut self, msg: String) {
+        self.warnings.push(msg);
+    }
+
+    pub fn error(&mut self, msg: String) {
+        self.valid = false;
+        self.errors.push(msg);
+    }
+}
+
+/// Validate an Edit operation
+pub fn validate_edit(
+    file_path: &str,
+    config: &SpfConfig,
+    session: &Session,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Build Anchor Protocol — must read before edit
+    if config.require_read_before_edit && !session.files_read.contains(&file_path.to_string()) {
+        match config.enforce_mode {
+            EnforceMode::Hard => {
+                result.error(format!(
+                    "BUILD ANCHOR VIOLATION: Must read {} before editing", file_path
+                ));
+            }
+            EnforceMode::Soft => {
+                result.warn(format!("File not read before edit: {}", file_path));
+            }
+        }
+    }
+
+    // Blocked paths
+    if config.is_path_blocked(file_path) {
+        result.error(format!("PATH BLOCKED: {}", file_path));
+    }
+
+    result
+}
+
+/// Validate a Write operation
+pub fn validate_write(
+    file_path: &str,
+    content_len: usize,
+    config: &SpfConfig,
+    session: &Session,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // File size limit
+    if content_len > config.max_write_size {
+        result.warn(format!(
+            "Large write: {} bytes (max recommended: {})",
+            content_len, config.max_write_size
+        ));
+    }
+
+    // Blocked paths
+    if config.is_path_blocked(file_path) {
+        result.error(format!("PATH BLOCKED: {}", file_path));
+    }
+
+    // Build Anchor — must read existing file before overwriting
+    if std::path::Path::new(file_path).exists()
+        && !session.files_read.contains(&file_path.to_string())
+    {
+        match config.enforce_mode {
+            EnforceMode::Hard => {
+                result.error(format!(
+                    "BUILD ANCHOR VIOLATION: Must read existing file before overwrite: {}",
+                    file_path
+                ));
+            }
+            EnforceMode::Soft => {
+                result.warn(format!("Overwriting without read: {}", file_path));
+            }
+        }
+    }
+
+    result
+}
+
+/// Validate a Bash operation
+pub fn validate_bash(
+    command: &str,
+    config: &SpfConfig,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Dangerous command patterns
+    for pattern in &config.dangerous_commands {
+        if command.contains(pattern.as_str()) {
+            result.error(format!("DANGEROUS COMMAND: contains '{}'", pattern));
+        }
+    }
+
+    // Git force operations
+    if command.contains("git") {
+        for force in &config.git_force_patterns {
+            if command.contains(force.as_str()) {
+                result.warn(format!("Git force operation detected: {}", force));
+            }
+        }
+    }
+
+    // /tmp access
+    if command.contains("/tmp") {
+        result.error("NO /tmp ACCESS — Termux Android restriction".to_string());
+    }
+
+    result
+}
+
+/// Validate a Read operation — allowed unless path is blocked, tracks for Build Anchor
+pub fn validate_read(
+    file_path: &str,
+    config: &SpfConfig,
+) -> ValidationResult {
+    let mut result = ValidationResult::ok();
+
+    // Reads feed the Build Anchor but blocked paths still apply
+    if config.is_path_blocked(file_path) {
+        result.error(format!("BLOCKED PATH: {} is in blocked paths list", file_path));
+    }
+
+    result
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/7931b017237cdafd@v4

@@ -0,0 +1,490 @@
+// SPF Smart Gateway - Configuration LMDB
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// LMDB-backed configuration storage. Replaces config.json with persistent,
+// transactional storage. Supports hot-reload without restart.
+//
+// Database: SPF_CONFIG
+// Storage: ~/SPFsmartGATE/storage/spf_config/
+
+use anyhow::{anyhow, Result};
+use heed::types::*;
+use heed::{Database, Env, EnvOpenOptions};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// Import config types from canonical source (config.rs) - NO DUPLICATES
+use crate::config::{
+    EnforceMode, TierThreshold, TierConfig, FormulaConfig,
+    ToolWeight, ComplexityWeights, SpfConfig,
+};
+
+const MAX_DB_SIZE: usize = 10 * 1024 * 1024; // 10MB - config is small
+
+/// LMDB-backed SPF configuration storage
+pub struct SpfConfigDb {
+    env: Env,
+    /// Main config store: namespace:key → JSON value
+    config: Database<Str, Str>,
+    /// Path rules: "allowed:path" or "blocked:path" → bool
+    paths: Database<Str, SerdeBincode<bool>>,
+    /// Dangerous patterns: pattern → severity (1-10)
+    patterns: Database<Str, SerdeBincode<u8>>,
+}
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+impl SpfConfigDb {
+    /// Open or create config LMDB at given path
+    pub fn open(path: &Path) -> Result<Self> {
+        std::fs::create_dir_all(path)?;
+
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(MAX_DB_SIZE)
+                .max_dbs(8)
+                .open(path)?
+        };
+
+        let mut wtxn = env.write_txn()?;
+        let config = env.create_database(&mut wtxn, Some("config"))?;
+        let paths = env.create_database(&mut wtxn, Some("paths"))?;
+        let patterns = env.create_database(&mut wtxn, Some("patterns"))?;
+        wtxn.commit()?;
+
+        log::info!("SPF Config LMDB opened at {:?}", path);
+        Ok(Self { env, config, paths, patterns })
+    }
+
+    // ========================================================================
+    // CORE CONFIG OPERATIONS
+    // ========================================================================
+
+    /// Get a config value by namespace and key
+    pub fn get(&self, namespace: &str, key: &str) -> Result<Option<String>> {
+        let full_key = format!("{}:{}", namespace, key);
+        let rtxn = self.env.read_txn()?;
+        Ok(self.config.get(&rtxn, &full_key)?.map(|s| s.to_string()))
+    }
+
+    /// Set a config value
+    pub fn set(&self, namespace: &str, key: &str, value: &str) -> Result<()> {
+        let full_key = format!("{}:{}", namespace, key);
+        let mut wtxn = self.env.write_txn()?;
+        self.config.put(&mut wtxn, &full_key, value)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Get typed config value (deserialize from JSON)
+    pub fn get_typed<T: for<'de> Deserialize<'de>>(&self, namespace: &str, key: &str) -> Result<Option<T>> {
+        match self.get(namespace, key)? {
+            Some(json) => Ok(Some(serde_json::from_str(&json)?)),
+            None => Ok(None),
+        }
+    }
+
+    /// Set typed config value (serialize to JSON)
+    pub fn set_typed<T: Serialize>(&self, namespace: &str, key: &str, value: &T) -> Result<()> {
+        let json = serde_json::to_string(value)?;
+        self.set(namespace, key, &json)
+    }
+
+    // ========================================================================
+    // PATH RULES
+    // ========================================================================
+
+    /// Add an allowed path
+    pub fn allow_path(&self, path: &str) -> Result<()> {
+        let key = format!("allowed:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Add a blocked path
+    pub fn block_path(&self, path: &str) -> Result<()> {
+        let key = format!("blocked:{}", path);
+        let mut wtxn = self.env.write_txn()?;
+        self.paths.put(&mut wtxn, &key, &true)?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Remove a path rule
+    pub fn remove_path_rule(&self, rule_type: &str, path: &str) -> Result<bool> {
+        let key = format!("{}:{}", rule_type, path);
+        let mut wtxn = self.env.write_txn()?;
+        let deleted = self.paths.delete(&mut wtxn, &key)?;
+        wtxn.commit()?;
+        Ok(deleted)
+    }
+
+    /// Check if path is allowed (matches any allowed prefix)
+    pub fn is_path_allowed(&self, path: &str) -> Result<bool> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("allowed:") {
+                let allowed_path = &key[8..]; // Skip "allowed:"
+                if path.starts_with(allowed_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Check if path is blocked (matches any blocked prefix)
+    pub fn is_path_blocked(&self, path: &str) -> Result<bool> {
+        // Canonicalize to prevent traversal bypass
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        for result in iter {
+            let (key, _) = result?;
+            if key.starts_with("blocked:") {
+                let blocked_path = &key[8..]; // Skip "blocked:"
+                if canonical.starts_with(blocked_path) {
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// List all path rules
+    pub fn list_path_rules(&self) -> Result<Vec<(String, String)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.paths.iter(&rtxn)?;
+
+        let mut rules = Vec::new();
+        for result in iter {
+            let (key, _) = result?;
+            if let Some((rule_type, path)) = key.split_once(':') {
+                rules.push((rule_type.to_string(), path.to_string()));
+            }
+        }
+        Ok(rules)
+    }
+
+    // ========================================================================
+    // DANGEROUS PATTERNS
+    // ========================================================================
+
+    /// Add a dangerous pattern with severity (1-10)
+    pub fn add_dangerous_pattern(&self, pattern: &str, severity: u8) -> Result<()> {
+        let mut wtxn = self.env.write_txn()?;
+        self.patterns.put(&mut wtxn, pattern, &severity.min(10))?;
+        wtxn.commit()?;
+        Ok(())
+    }
+
+    /// Check if command matches any dangerous pattern, returns severity
+    pub fn check_dangerous(&self, command: &str) -> Result<Option<u8>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut max_severity: Option<u8> = None;
+        for result in iter {
+            let (pattern, severity) = result?;
+            if command.contains(pattern) {
+                max_severity = Some(max_severity.map_or(severity, |s| s.max(severity)));
+            }
+        }
+        Ok(max_severity)
+    }
+
+    /// List all dangerous patterns
+    pub fn list_dangerous_patterns(&self) -> Result<Vec<(String, u8)>> {
+        let rtxn = self.env.read_txn()?;
+        let iter = self.patterns.iter(&rtxn)?;
+
+        let mut patterns = Vec::new();
+        for result in iter {
+            let (pattern, severity) = result?;
+            patterns.push((pattern.to_string(), severity));
+        }
+        Ok(patterns)
+    }
+
+    // ========================================================================
+    // TIER CONFIG
+    // ========================================================================
+
+    /// Get tier config
+    pub fn get_tiers(&self) -> Result<TierConfig> {
+        self.get_typed::<TierConfig>("spf", "tiers")?
+            .ok_or_else(|| anyhow!("Tier config not found"))
+    }
+
+    /// Set tier config
+    pub fn set_tiers(&self, tiers: &TierConfig) -> Result<()> {
+        self.set_typed("spf", "tiers", tiers)
+    }
+
+    /// Get tier for complexity value
+    /// CRITICAL requires approval. Lower tiers protected by Build Anchor + path blocking + content inspection.
+    pub fn get_tier_for_c(&self, c: u64) -> Result<(&'static str, u8, u8, bool)> {
+        let tiers = self.get_tiers()?;
+
+        if c < tiers.simple.max_c {
+            Ok(("SIMPLE", tiers.simple.analyze_percent, tiers.simple.build_percent, tiers.simple.requires_approval))
+        } else if c < tiers.light.max_c {
+            Ok(("LIGHT", tiers.light.analyze_percent, tiers.light.build_percent, tiers.light.requires_approval))
+        } else if c < tiers.medium.max_c {
+            Ok(("MEDIUM", tiers.medium.analyze_percent, tiers.medium.build_percent, tiers.medium.requires_approval))
+        } else {
+            Ok(("CRITICAL", tiers.critical.analyze_percent, tiers.critical.build_percent, tiers.critical.requires_approval))
+        }
+    }
+
+    // ========================================================================
+    // FORMULA CONFIG
+    // ========================================================================
+
+    /// Get formula config
+    pub fn get_formula(&self) -> Result<FormulaConfig> {
+        self.get_typed::<FormulaConfig>("spf", "formula")?
+            .ok_or_else(|| anyhow!("Formula config not found"))
+    }
+
+    /// Set formula config
+    pub fn set_formula(&self, formula: &FormulaConfig) -> Result<()> {
+        self.set_typed("spf", "formula", formula)
+    }
+
+    // ========================================================================
+    // COMPLEXITY WEIGHTS
+    // ========================================================================
+
+    /// Get complexity weights
+    pub fn get_weights(&self) -> Result<ComplexityWeights> {
+        self.get_typed::<ComplexityWeights>("spf", "weights")?
+            .ok_or_else(|| anyhow!("Complexity weights not found"))
+    }
+
+    /// Set complexity weights
+    pub fn set_weights(&self, weights: &ComplexityWeights) -> Result<()> {
+        self.set_typed("spf", "weights", weights)
+    }
+
+    /// Get weight for a specific tool
+    pub fn get_tool_weight(&self, tool: &str) -> Result<ToolWeight> {
+        let weights = self.get_weights()?;
+        Ok(match tool.to_lowercase().as_str() {
+            "edit" => weights.edit,
+            "write" => weights.write,
+            "bash_dangerous" => weights.bash_dangerous,
+            "bash_git" => weights.bash_git,
+            "bash_piped" => weights.bash_piped,
+            "bash_simple" | "bash" => weights.bash_simple,
+            "read" => weights.read,
+            "search" | "glob" | "grep" => weights.search,
+            _ => weights.unknown,
+        })
+    }
+
+    // ========================================================================
+    // ENFORCE MODE
+    // ========================================================================
+
+    /// Get enforce mode
+    pub fn get_enforce_mode(&self) -> Result<EnforceMode> {
+        self.get_typed::<EnforceMode>("spf", "enforce_mode")?
+            .ok_or_else(|| anyhow!("Enforce mode not found"))
+    }
+
+    /// Set enforce mode
+    pub fn set_enforce_mode(&self, mode: &EnforceMode) -> Result<()> {
+        self.set_typed("spf", "enforce_mode", mode)
+    }
+
+    // ========================================================================
+    // MIGRATION
+    // ========================================================================
+
+    /// Initialize with defaults (call once on first run)
+    pub fn init_defaults(&self) -> Result<()> {
+        // Only init if not already initialized
+        if self.get("spf", "version")?.is_some() {
+            return Ok(());
+        }
+
+        self.set("spf", "version", "1.0.0")?;
+        self.set_enforce_mode(&EnforceMode::Hard)?;
+        self.set("spf", "require_read_before_edit", "true")?;
+        self.set("spf", "max_write_size", "100000")?;
+
+        // Default tiers — CRITICAL requires approval, lower tiers protected by other layers
+        self.set_tiers(&TierConfig {
+            simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: false },
+            light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: false },
+            medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: false },
+            critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+        })?;
+
+        // Default formula
+        self.set_formula(&FormulaConfig {
+            w_eff: 40000.0,
+            e: std::f64::consts::E,
+            basic_power: 1,
+            deps_power: 7,
+            complex_power: 10,
+            files_multiplier: 10,
+        })?;
+
+        // Default weights
+        self.set_weights(&ComplexityWeights {
+            edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+            write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+            bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+            bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+            bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+            read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+            search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+            unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+        })?;
+
+        // Default allowed paths
+        self.allow_path("/storage/emulated/0/Download/api-workspace/")?;
+        self.allow_path("/data/data/com.termux/files/home/")?;
+
+        // Default blocked paths
+        self.block_path("/tmp")?;
+        self.block_path("/etc")?;
+        self.block_path("/usr")?;
+        self.block_path("/system")?;
+        self.block_path("/data/data/com.termux/files/usr")?;
+
+        // Default dangerous patterns
+        self.add_dangerous_pattern("rm -rf /", 10)?;
+        self.add_dangerous_pattern("rm -rf ~", 10)?;
+        self.add_dangerous_pattern("dd if=", 9)?;
+        self.add_dangerous_pattern("> /dev/", 9)?;
+        self.add_dangerous_pattern("chmod 777", 7)?;
+        self.add_dangerous_pattern("curl | sh", 8)?;
+        self.add_dangerous_pattern("wget | sh", 8)?;
+        self.add_dangerous_pattern("curl|sh", 8)?;
+        self.add_dangerous_pattern("wget|sh", 8)?;
+
+        log::info!("SPF Config LMDB initialized with defaults");
+        Ok(())
+    }
+
+    /// Sync tier approval policy on every boot.
+    /// Source of truth is THIS code — LMDB stores runtime state, code defines policy.
+    /// Change the values here → next boot picks them up. No version tracking needed.
+    pub fn sync_tier_approval(&self) -> Result<()> {
+        let mut tiers = self.get_tiers()?;
+        let mut changed = false;
+
+        // === APPROVAL POLICY (edit here to change) ===
+        let policy: [(&str, bool); 4] = [
+            ("SIMPLE",   false),
+            ("LIGHT",    false),
+            ("MEDIUM",   false),
+            ("CRITICAL", true),
+        ];
+
+        let tier_refs = [
+            &mut tiers.simple,
+            &mut tiers.light,
+            &mut tiers.medium,
+            &mut tiers.critical,
+        ];
+
+        for (i, (name, required)) in policy.iter().enumerate() {
+            if tier_refs[i].requires_approval != *required {
+                log::info!("SPF sync: {} requires_approval {} → {}", name, tier_refs[i].requires_approval, required);
+                tier_refs[i].requires_approval = *required;
+                changed = true;
+            }
+        }
+
+        if changed {
+            self.set_tiers(&tiers)?;
+            log::info!("SPF tier approval policy synced");
+        }
+
+        // Keep version current
+        self.set("spf", "version", "2.0.0")?;
+
+        Ok(())
+    }
+
+    /// Get database stats
+    pub fn stats(&self) -> Result<(u64, u64, u64)> {
+        let rtxn = self.env.read_txn()?;
+        let config_stat = self.config.stat(&rtxn)?;
+        let paths_stat = self.paths.stat(&rtxn)?;
+        let patterns_stat = self.patterns.stat(&rtxn)?;
+        Ok((config_stat.entries as u64, paths_stat.entries as u64, patterns_stat.entries as u64))
+    }
+
+    // ========================================================================
+    // FULL CONFIG ASSEMBLY (for main.rs - single source of truth)
+    // ========================================================================
+
+    /// Load full SpfConfig from LMDB. Auto-initializes if empty.
+    /// This is the PRIMARY config loading method - replaces JSON file loading.
+    pub fn load_full_config(&self) -> Result<SpfConfig> {
+        // Ensure defaults exist, then sync approval policy from code
+        self.init_defaults()?;
+        self.sync_tier_approval()?;
+
+        // Collect path rules
+        let path_rules = self.list_path_rules()?;
+        let mut allowed_paths = Vec::new();
+        let mut blocked_paths = Vec::new();
+        for (rule_type, path) in path_rules {
+            match rule_type.as_str() {
+                "allowed" => allowed_paths.push(path),
+                "blocked" => blocked_paths.push(path),
+                _ => {}
+            }
+        }
+
+        // Collect dangerous commands
+        let dangerous_commands: Vec<String> = self.list_dangerous_patterns()?
+            .into_iter()
+            .map(|(pattern, _)| pattern)
+            .collect();
+
+        // Get scalar values
+        let version = self.get("spf", "version")?.unwrap_or_else(|| "1.0.0".to_string());
+        let require_read = self.get("spf", "require_read_before_edit")?
+            .map(|s| s == "true").unwrap_or(true);
+        let max_write = self.get("spf", "max_write_size")?
+            .and_then(|s| s.parse().ok()).unwrap_or(100_000);
+
+        // Assemble config (types are now identical - no conversion needed)
+        Ok(SpfConfig {
+            version,
+            enforce_mode: self.get_enforce_mode()?,
+            allowed_paths,
+            blocked_paths,
+            require_read_before_edit: require_read,
+            max_write_size: max_write,
+            tiers: self.get_tiers()?,
+            formula: self.get_formula()?,
+            complexity_weights: self.get_weights()?,
+            dangerous_commands,
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        })
+    }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/8b96b1c0ff21fa87@v2

@@ -0,0 +1,215 @@
+{
+  "numStartups": 5,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 4,
+    "plan-mode-for-complex-tasks": 1,
+    "terminal-setup": 1,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 1,
+    "install-slack-app": 1,
+    "drag-and-drop-images": 1,
+    "double-esc-code-restore": 1,
+    "continue": 1,
+    "shift-tab": 1,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1
+  },
+  "promptQueueUseCount": 223,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.20",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 1,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0.011288000000000001,
+      "lastAPIDuration": 2182,
+      "lastAPIDurationWithoutRetries": 2181,
+      "lastToolDuration": 0,
+      "lastDuration": 11335,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 3,
+      "lastTotalOutputTokens": 19,
+      "lastTotalCacheCreationInputTokens": 8952,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {
+        "claude-haiku-4-5-20251001": {
+          "inputTokens": 3,
+          "outputTokens": 19,
+          "cacheReadInputTokens": 0,
+          "cacheCreationInputTokens": 8952,
+          "webSearchRequests": 0,
+          "costUSD": 0.011288000000000001
+        }
+      },
+      "lastSessionId": "0fef5c9f-489e-4143-b5ce-7d4aee93e9be"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770353696393
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "displayName": "trumpmas",
+    "organizationRole": "admin",
+    "workspaceRole": null,
+    "organizationName": "trumpmas2@gmail.com's Organization"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": null,
+    "timestamp": 1770406999485
+  }
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v1

@@ -0,0 +1,153 @@
+{
+  "numStartups": 12,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 83389,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d24ca0fe-0ee2-4029-bad5-35330d7f27f7"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770426068024
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770429470515
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v2

@@ -0,0 +1,216 @@
+{
+  "numStartups": 12,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 83389,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d24ca0fe-0ee2-4029-bad5-35330d7f27f7"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770426068024
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770429470515
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v3

@@ -0,0 +1,216 @@
+{
+  "numStartups": 12,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 83389,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d24ca0fe-0ee2-4029-bad5-35330d7f27f7"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770426068024
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770429921639
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v4

@@ -0,0 +1,216 @@
+{
+  "numStartups": 12,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 83389,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d24ca0fe-0ee2-4029-bad5-35330d7f27f7"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770426068024
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770430101483
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v5

@@ -0,0 +1,216 @@
+{
+  "numStartups": 13,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 14896,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d20b66f9-3c45-48c7-be1e-06357c1039c2"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770431141682
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770430233461
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v6

@@ -0,0 +1,216 @@
+{
+  "numStartups": 13,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 14896,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d20b66f9-3c45-48c7-be1e-06357c1039c2"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770431141682
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770431195765
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v7

@@ -0,0 +1,216 @@
+{
+  "numStartups": 13,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 14896,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d20b66f9-3c45-48c7-be1e-06357c1039c2"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770431141682
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770431277304
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v8

@@ -0,0 +1,216 @@
+{
+  "numStartups": 13,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 14896,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d20b66f9-3c45-48c7-be1e-06357c1039c2"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770431141682
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770432079199
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/a22eabd3fe8c8cc0@v9

@@ -0,0 +1,216 @@
+{
+  "numStartups": 13,
+  "verbose": true,
+  "editorMode": "vim",
+  "autoCompactEnabled": false,
+  "customApiKeyResponses": {
+    "approved": [],
+    "rejected": [
+      "JHk1UJfEKyw-PgRyyQAA"
+    ]
+  },
+  "tipsHistory": {
+    "new-user-warmup": 7,
+    "plan-mode-for-complex-tasks": 12,
+    "terminal-setup": 11,
+    "memory-command": 1,
+    "theme-command": 1,
+    "status-line": 1,
+    "prompt-queue": 1,
+    "enter-to-steer-in-relatime": 1,
+    "todo-list": 1,
+    "install-github-app": 11,
+    "install-slack-app": 11,
+    "drag-and-drop-images": 11,
+    "double-esc-code-restore": 11,
+    "continue": 11,
+    "shift-tab": 12,
+    "image-paste": 1,
+    "desktop-app": 1,
+    "web-app": 1,
+    "mobile-app": 1,
+    "custom-agents": 6,
+    "agent-flag": 6,
+    "permissions": 11,
+    "rename-conversation": 11,
+    "custom-commands": 11
+  },
+  "promptQueueUseCount": 226,
+  "showExpandedTodos": true,
+  "firstStartTime": "2026-02-06T00:09:11.219Z",
+  "sonnet45MigrationComplete": true,
+  "opus45MigrationComplete": true,
+  "opusProMigrationComplete": true,
+  "thinkingMigrationComplete": true,
+  "cachedChromeExtensionInstalled": false,
+  "claudeCodeFirstTokenDate": "2025-12-27T11:46:20.360502Z",
+  "hasCompletedOnboarding": true,
+  "lastOnboardingVersion": "2.1.20",
+  "userID": "e876cd5db25257b276e86b85b7ba8c3abf0462fd3662cadee43f2d1f9f3359db",
+  "lastReleaseNotesSeen": "2.1.34",
+  "projects": {
+    "/data/data/com.termux/files/home": {
+      "allowedTools": [
+        "mcp__spf-smart-gate__spf_read",
+        "mcp__spf-smart-gate__spf_write",
+        "mcp__spf-smart-gate__spf_edit",
+        "mcp__spf-smart-gate__spf_bash",
+        "mcp__spf-smart-gate__spf_glob",
+        "mcp__spf-smart-gate__spf_grep",
+        "mcp__spf-smart-gate__spf_gate",
+        "mcp__spf-smart-gate__spf_calculate",
+        "mcp__spf-smart-gate__spf_status",
+        "mcp__spf-smart-gate__spf_session",
+        "mcp__spf-smart-gate__spf_web_search",
+        "mcp__spf-smart-gate__spf_web_fetch",
+        "mcp__spf-smart-gate__spf_web_download",
+        "mcp__spf-smart-gate__spf_web_api",
+        "mcp__spf-smart-gate__spf_notebook_edit",
+        "mcp__spf-smart-gate__spf_brain_search",
+        "mcp__spf-smart-gate__spf_brain_store",
+        "mcp__spf-smart-gate__spf_brain_context",
+        "mcp__spf-smart-gate__spf_brain_index",
+        "mcp__spf-smart-gate__spf_brain_list",
+        "mcp__spf-smart-gate__spf_brain_status",
+        "mcp__spf-smart-gate__spf_brain_recall",
+        "mcp__spf-smart-gate__spf_brain_list_docs",
+        "mcp__spf-smart-gate__spf_brain_get_doc",
+        "mcp__spf-smart-gate__spf_rag_collect_web",
+        "mcp__spf-smart-gate__spf_rag_collect_file",
+        "mcp__spf-smart-gate__spf_rag_collect_folder",
+        "mcp__spf-smart-gate__spf_rag_collect_drop",
+        "mcp__spf-smart-gate__spf_rag_index_gathered",
+        "mcp__spf-smart-gate__spf_rag_dedupe",
+        "mcp__spf-smart-gate__spf_rag_status",
+        "mcp__spf-smart-gate__spf_rag_list_gathered",
+        "mcp__spf-smart-gate__spf_rag_bandwidth_status",
+        "mcp__spf-smart-gate__spf_rag_fetch_url",
+        "mcp__spf-smart-gate__spf_rag_collect_rss",
+        "mcp__spf-smart-gate__spf_rag_list_feeds",
+        "mcp__spf-smart-gate__spf_rag_pending_searches",
+        "mcp__spf-smart-gate__spf_rag_fulfill_search",
+        "mcp__spf-smart-gate__spf_rag_smart_search",
+        "mcp__spf-smart-gate__spf_rag_auto_fetch_gaps",
+        "mcp__spf-smart-gate__spf_config_paths",
+        "mcp__spf-smart-gate__spf_config_stats",
+        "mcp__spf-smart-gate__spf_tools_list",
+        "mcp__spf-smart-gate__spf_tools_stats",
+        "mcp__spf-smart-gate__spf_tools_get",
+        "mcp__spf-smart-gate__spf_sandbox_list",
+        "mcp__spf-smart-gate__spf_sandbox_stats",
+        "mcp__spf-smart-gate__spf_sandbox_get",
+        "mcp__spf-smart-gate__spf_sandbox_active",
+        "mcp__spf-smart-gate__spf_agent_stats",
+        "mcp__spf-smart-gate__spf_agent_memory_search",
+        "mcp__spf-smart-gate__spf_agent_memory_by_tag",
+        "mcp__spf-smart-gate__spf_agent_session_info",
+        "mcp__spf-smart-gate__spf_agent_context",
+        "mcp__spf-smart-gate__spf_fs_exists",
+        "mcp__spf-smart-gate__spf_fs_stat",
+        "mcp__spf-smart-gate__spf_fs_ls",
+        "mcp__spf-smart-gate__spf_fs_read",
+        "mcp__spf-smart-gate__spf_fs_write",
+        "mcp__spf-smart-gate__spf_fs_mkdir",
+        "mcp__spf-smart-gate__spf_fs_rm",
+        "mcp__spf-smart-gate__spf_fs_rename"
+      ],
+      "mcpContextUris": [],
+      "mcpServers": {},
+      "enabledMcpjsonServers": [],
+      "disabledMcpjsonServers": [],
+      "hasTrustDialogAccepted": false,
+      "projectOnboardingSeenCount": 2,
+      "hasClaudeMdExternalIncludesApproved": false,
+      "hasClaudeMdExternalIncludesWarningShown": false,
+      "exampleFiles": [],
+      "reactVulnerabilityCache": {
+        "detected": false,
+        "package": null,
+        "packageName": null,
+        "version": null,
+        "packageManager": null
+      },
+      "lastCost": 0,
+      "lastAPIDuration": 0,
+      "lastAPIDurationWithoutRetries": 0,
+      "lastToolDuration": 0,
+      "lastDuration": 14896,
+      "lastLinesAdded": 0,
+      "lastLinesRemoved": 0,
+      "lastTotalInputTokens": 0,
+      "lastTotalOutputTokens": 0,
+      "lastTotalCacheCreationInputTokens": 0,
+      "lastTotalCacheReadInputTokens": 0,
+      "lastTotalWebSearchRequests": 0,
+      "lastModelUsage": {},
+      "lastSessionId": "d20b66f9-3c45-48c7-be1e-06357c1039c2"
+    }
+  },
+  "hasShownOpus45Notice": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": true,
+    "92793401-263e-4dfa-ba04-4b2840363205": true,
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "s1mAccessCache": {
+    "8ebbbe3d-9094-41ed-92bd-620bf216221b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770336589524
+    },
+    "92793401-263e-4dfa-ba04-4b2840363205": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770344127248
+    },
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": {
+      "hasAccess": false,
+      "hasAccessNotAsDefault": false,
+      "timestamp": 1770431141682
+    }
+  },
+  "groveConfigCache": {
+    "29d79e0f-2e30-408e-8edf-9874b67fcd8f": {
+      "grove_enabled": true,
+      "timestamp": 1770336589615
+    },
+    "68f5adee-e8b4-4fe4-88fa-f6bdc8e20bc7": {
+      "grove_enabled": true,
+      "timestamp": 1770344127325
+    },
+    "19e82393-1c4d-4953-a107-c1afa1b3c18b": {
+      "grove_enabled": true,
+      "timestamp": 1770353696705
+    }
+  },
+  "officialMarketplaceAutoInstallAttempted": true,
+  "officialMarketplaceAutoInstalled": true,
+  "mcpServers": {
+    "spf-smart-gate": {
+      "type": "stdio",
+      "command": "/data/data/com.termux/files/home/SPFsmartGATE/agent-bin/spf-smart-gate",
+      "args": [
+        "serve"
+      ],
+      "env": {}
+    }
+  },
+  "oauthAccount": {
+    "accountUuid": "19e82393-1c4d-4953-a107-c1afa1b3c18b",
+    "emailAddress": "trumpmas2@gmail.com",
+    "organizationUuid": "acf806a6-bf06-44ba-a456-bade1e01e08b",
+    "hasExtraUsageEnabled": true,
+    "billingType": "stripe_subscription",
+    "accountCreatedAt": "2025-12-21T00:39:54.325945Z",
+    "subscriptionCreatedAt": "2026-01-23T08:07:41.253153Z",
+    "displayName": "trumpmas"
+  },
+  "claudeInChromeDefaultEnabled": false,
+  "clientDataCache": {
+    "data": {},
+    "timestamp": 1770432258297
+  },
+  "hasShownOpus46Notice": {
+    "acf806a6-bf06-44ba-a456-bade1e01e08b": true
+  },
+  "showSpinnerTree": false
+}

SPFsmartGATE/LIVE/LMDB5/.claude/file-history/3ef62767-b555-4be8-86c4-8a5169f1a9a1/b33399737c174c57@v2

@@ -0,0 +1,196 @@
+// SPF Smart Gateway - Configuration
+// Copyright 2026 Joseph Stone - All Rights Reserved
+//
+// Loads SPF rules, tiers, formulas, blocked paths from config.json.
+
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+/// Master SPF configuration loaded from config.json
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SpfConfig {
+    pub version: String,
+    pub enforce_mode: EnforceMode,
+    pub allowed_paths: Vec<String>,
+    pub blocked_paths: Vec<String>,
+    pub require_read_before_edit: bool,
+    pub max_write_size: usize,
+    pub tiers: TierConfig,
+    pub formula: FormulaConfig,
+    pub complexity_weights: ComplexityWeights,
+    pub dangerous_commands: Vec<String>,
+    pub git_force_patterns: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum EnforceMode {
+    Soft,
+    Hard,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierConfig {
+    pub simple: TierThreshold,
+    pub light: TierThreshold,
+    pub medium: TierThreshold,
+    pub critical: TierThreshold,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TierThreshold {
+    pub max_c: u64,
+    pub analyze_percent: u8,
+    pub build_percent: u8,
+    pub requires_approval: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FormulaConfig {
+    /// W_eff: effective working memory in tokens
+    pub w_eff: f64,
+    /// Euler's number
+    pub e: f64,
+    /// C = (basic ^ basic_power) + (deps ^ deps_power) + (complex ^ complex_power) + (files * files_mult)
+    pub basic_power: u32,
+    pub deps_power: u32,
+    pub complex_power: u32,
+    pub files_multiplier: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComplexityWeights {
+    pub edit: ToolWeight,
+    pub write: ToolWeight,
+    pub bash_dangerous: ToolWeight,
+    pub bash_git: ToolWeight,
+    pub bash_piped: ToolWeight,
+    pub bash_simple: ToolWeight,
+    pub read: ToolWeight,
+    pub search: ToolWeight,
+    pub unknown: ToolWeight,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolWeight {
+    pub basic: u64,
+    pub dependencies: u64,
+    pub complex: u64,
+    pub files: u64,
+}
+
+impl Default for SpfConfig {
+    fn default() -> Self {
+        Self {
+            version: "1.0.0".to_string(),
+            enforce_mode: EnforceMode::Hard,
+            allowed_paths: vec![
+                "/storage/emulated/0/Download/api-workspace/".to_string(),
+                "/data/data/com.termux/files/home/".to_string(),
+            ],
+            blocked_paths: vec![
+                "/tmp".to_string(),
+                "/etc".to_string(),
+                "/usr".to_string(),
+                "/system".to_string(),
+                "/data/data/com.termux/files/usr".to_string(),
+            ],
+            require_read_before_edit: true,
+            max_write_size: 100_000,
+            tiers: TierConfig {
+                simple: TierThreshold { max_c: 500, analyze_percent: 40, build_percent: 60, requires_approval: false },
+                light: TierThreshold { max_c: 2000, analyze_percent: 60, build_percent: 40, requires_approval: false },
+                medium: TierThreshold { max_c: 10000, analyze_percent: 75, build_percent: 25, requires_approval: false },
+                critical: TierThreshold { max_c: u64::MAX, analyze_percent: 95, build_percent: 5, requires_approval: true },
+            },
+            formula: FormulaConfig {
+                w_eff: 40000.0,
+                e: std::f64::consts::E,
+                basic_power: 1,      // ^1 per SPF protocol
+                deps_power: 7,       // ^7 per SPF protocol
+                complex_power: 10,   // ^10 per SPF protocol
+                files_multiplier: 10, // ×10 per SPF protocol
+            },
+            // Weights scaled for formula: C = basic^1 + deps^7 + complex^10 + files×10
+            // deps^7: 2→128, 3→2187, 4→16384, 5→78125
+            // complex^10: 1→1, 2→1024
+            complexity_weights: ComplexityWeights {
+                edit: ToolWeight { basic: 10, dependencies: 2, complex: 1, files: 1 },
+                write: ToolWeight { basic: 20, dependencies: 2, complex: 1, files: 1 },
+                bash_dangerous: ToolWeight { basic: 50, dependencies: 5, complex: 2, files: 1 },
+                bash_git: ToolWeight { basic: 30, dependencies: 3, complex: 1, files: 1 },
+                bash_piped: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+                bash_simple: ToolWeight { basic: 10, dependencies: 1, complex: 0, files: 1 },
+                read: ToolWeight { basic: 5, dependencies: 1, complex: 0, files: 1 },
+                search: ToolWeight { basic: 8, dependencies: 2, complex: 0, files: 1 },
+                unknown: ToolWeight { basic: 20, dependencies: 3, complex: 1, files: 1 },
+            },
+            dangerous_commands: vec![
+                "rm -rf /".to_string(),
+                "rm -rf ~".to_string(),
+                "dd if=".to_string(),
+                "> /dev/".to_string(),
+                "chmod 777".to_string(),
+                "curl | sh".to_string(),
+                "wget | sh".to_string(),
+                "curl|sh".to_string(),
+                "wget|sh".to_string(),
+            ],
+            git_force_patterns: vec![
+                "--force".to_string(),
+                "--hard".to_string(),
+                "-f".to_string(),
+            ],
+        }
+    }
+}
+
+impl SpfConfig {
+    /// Load config from JSON file, falling back to defaults
+    pub fn load(path: &Path) -> anyhow::Result<Self> {
+        if path.exists() {
+            let content = std::fs::read_to_string(path)?;
+            let config: Self = serde_json::from_str(&content)?;
+            Ok(config)
+        } else {
+            log::warn!("Config not found at {:?}, using defaults", path);
+            Ok(Self::default())
+        }
+    }
+
+    /// Save config to JSON file
+    pub fn save(&self, path: &Path) -> anyhow::Result<()> {
+        let content = serde_json::to_string_pretty(self)?;
+        std::fs::write(path, content)?;
+        Ok(())
+    }
+
+    /// Get tier for a given complexity value
+    /// CRITICAL tier requires explicit user approval. Lower tiers protected by other layers.
+    pub fn get_tier(&self, c: u64) -> (&str, u8, u8, bool) {
+        if c < self.tiers.simple.max_c {
+            ("SIMPLE", self.tiers.simple.analyze_percent, self.tiers.simple.build_percent, self.tiers.simple.requires_approval)
+        } else if c < self.tiers.light.max_c {
+            ("LIGHT", self.tiers.light.analyze_percent, self.tiers.light.build_percent, self.tiers.light.requires_approval)
+        } else if c < self.tiers.medium.max_c {
+            ("MEDIUM", self.tiers.medium.analyze_percent, self.tiers.medium.build_percent, self.tiers.medium.requires_approval)
+        } else {
+            ("CRITICAL", self.tiers.critical.analyze_percent, self.tiers.critical.build_percent, self.tiers.critical.requires_approval)
+        }
+    }
+
+    /// Check if a path is blocked (with canonicalization to prevent traversal bypass)
+    pub fn is_path_blocked(&self, path: &str) -> bool {
+        // Canonicalize to resolve ../ traversal attempts
+        let canonical = std::fs::canonicalize(path)
+            .map(|p| p.to_string_lossy().to_string())
+            .unwrap_or_else(|_| path.to_string());
+        
+        self.blocked_paths.iter().any(|blocked| canonical.starts_with(blocked))
+    }
+
+    /// Check if a path is allowed
+    pub fn is_path_allowed(&self, path: &str) -> bool {
+        self.allowed_paths.iter().any(|allowed| path.starts_with(allowed))
+    }
+}