Upload 2 files

memory upgrade. future upgrade. set paths to absolutes. to avoid security breach

src/gate.rs

@@ -217,6 +217,7 @@ pub fn process(
         // ── TIER D — Bounded inference ─────────────────────────────────────────
         "spf_transformer_infer" | "spf_transformer_chat" | "spf_transformer_train"
         | "spf_flint_train_evil" | "spf_flint_train_good"
+        | "spf_flint_store"
             => validate::validate_transformer_ops(params, config),
 
         // ── TIER E+ — Brain write (source-gated) ────────────────────────────
@@ -288,6 +289,10 @@ pub fn process(
             let content = params.content.as_deref().unwrap_or("");
             inspect::inspect_content(content, file_path, config)
         }
+        "spf_flint_store" => {
+            let content = params.text.as_deref().unwrap_or("");
+            inspect::inspect_content(content, "brain_store:text", config)
+        }
         _ => validate::ValidationResult::ok(),
     };
 

src/mcp.rs

@@ -393,6 +393,17 @@ pub fn tool_definitions() -> Vec<Value> {
             }),
             vec!["text"],
         ),
+        tool_def(
+            "spf_flint_store",
+            "Agent memory store through FLINT pipeline. Bypasses brain write gate. Stores in brain vectors + FLINT Working tier for memory lifecycle.",
+            json!({
+                "text": {"type": "string", "description": "Text to store"},
+                "title": {"type": "string", "description": "Document title", "default": "untitled"},
+                "collection": {"type": "string", "description": "Collection (default: default)", "default": "default"},
+                "tags": {"type": "string", "description": "Comma-separated tags", "default": ""}
+            }),
+            vec!["text"],
+        ),
 
         // ====== ADDITIONAL BRAIN TOOLS ======
         tool_def(
@@ -821,6 +832,7 @@ pub fn tool_alias_map(name: &str) -> &str {
         "bash" => "Bash", "glob" => "Glob", "grep" => "Grep",
         "calculate" => "spf_calculate", "status" => "spf_status", "session" => "spf_session",
         "brain_search" => "spf_brain_search", "brain_store" => "spf_brain_store",
+        "flint_store" => "spf_flint_store",
         "brain_context" => "spf_brain_context", "brain_index" => "spf_brain_index",
         "brain_list" => "spf_brain_list", "brain_status" => "spf_brain_status",
         "brain_recall" => "spf_brain_recall", "brain_list_docs" => "spf_brain_list_docs",
@@ -2330,6 +2342,48 @@ pub fn handle_tool_call(
             json!({"type": "text", "text": output})
         }
 
+        // ====== spf_flint_store ======
+        "spf_flint_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_str = args["tags"].as_str().unwrap_or("");
+
+            session.record_action("flint_store", "called", None);
+
+            // Strike 1: Brain store — vector storage for semantic search
+            let brain_result = crate::brain_local::brain_store(text, title, collection);
+
+            // Strike 2: Working memory — enables tiered promotion lifecycle
+            let working_result = if let Some(ref db) = agent_db {
+                let summary: String = text.chars().take(500).collect();
+                let tags: Vec<String> = if tags_str.is_empty() {
+                    vec![
+                        "tool:spf_flint_store".to_string(),
+                        "source:flint_store".to_string(),
+                        format!("collection:{}", collection),
+                    ]
+                } else {
+                    let mut t: Vec<String> = tags_str.split(',')
+                        .map(|s| s.trim().to_string())
+                        .filter(|s| !s.is_empty())
+                        .collect();
+                    t.push("tool:spf_flint_store".to_string());
+                    t.push("source:flint_store".to_string());
+                    t
+                };
+                match db.create_memory(&summary, crate::agent_state::MemoryType::Working, tags, "flint_store") {
+                    Ok(id) => format!("Working memory created: {}", id),
+                    Err(e) => format!("Working memory error: {}", e),
+                }
+            } else {
+                "Agent state DB not available — brain-only store".to_string()
+            };
+
+            let _ = storage.save_session(session);
+            json!({"type": "text", "text": format!("{}\n{}", brain_result, working_result)})
+        }
+
         // ====== spf_brain_context ======
         "spf_brain_context" => {
             let query = args["query"].as_str().unwrap_or("");