diff --git a/‎memoria/crates/memoria-api/src/auth.rs‎
Lines changed: 15 additions & 3 deletions b/‎memoria/crates/memoria-api/src/auth.rs‎
Lines changed: 15 additions & 3 deletions
diff --git a/‎memoria/crates/memoria-api/src/routes/admin.rs‎
Lines changed: 21 additions & 8 deletions b/‎memoria/crates/memoria-api/src/routes/admin.rs‎
Lines changed: 21 additions & 8 deletions
diff --git a/‎memoria/crates/memoria-api/src/routes/mcp.rs‎
Lines changed: 138 additions & 13 deletions b/‎memoria/crates/memoria-api/src/routes/mcp.rs‎
Lines changed: 138 additions & 13 deletions
@@ -898,19 +898,25 @@ pub struct RpcMeta {
     pub success: bool,
     /// JSON-RPC error code (e.g. -32601) when success = false; None otherwise.
     pub error_code: Option<i32>,
+    pub tool_success: Option<bool>,
+    pub tool_error_kind: Option<&'static str>,
 }
 
 impl RpcMeta {
     pub fn ok() -> Self {
         Self {
             success: true,
             error_code: None,
+            tool_success: None,
+            tool_error_kind: None,
         }
     }
     pub fn err(code: i32) -> Self {
         Self {
             success: false,
             error_code: Some(code),
+            tool_success: None,
+            tool_error_kind: None,
         }
     }
 }
@@ -927,6 +933,8 @@ struct CallLogEntry {
     rpc_success: bool,
     /// JSON-RPC error code (e.g. -32601) when rpc_success = false; NULL otherwise.
     rpc_error_code: Option<i32>,
+    tool_success: Option<bool>,
+    tool_error_kind: Option<&'static str>,
 }
 
 /// Accumulates call log entries in memory and flushes them in batches to DB.
@@ -997,6 +1005,8 @@ impl CallLogBatcher {
                 latency_ms,
                 rpc_success: rpc.success,
                 rpc_error_code: rpc.error_code,
+                tool_success: rpc.tool_success,
+                tool_error_kind: rpc.tool_error_kind,
             });
         }
     }
@@ -1065,12 +1075,12 @@ async fn flush_call_log_chunked(
     for chunk in entries.chunks(200) {
         let placeholders: String = chunk
             .iter()
-            .map(|_| "(?, ?, ?, ?, ?, ?, ?)")
+            .map(|_| "(?, ?, ?, ?, ?, ?, ?, ?, ?)")
             .collect::<Vec<_>>()
             .join(",");
         let sql = format!(
             "INSERT INTO {table} \
-                 (user_id, method, path, status_code, latency_ms, rpc_success, rpc_error_code) \
+                 (user_id, method, path, status_code, latency_ms, rpc_success, rpc_error_code, tool_success, tool_error_kind) \
                  VALUES {placeholders}"
         );
         let mut query = sqlx::query(&sql);
@@ -1082,7 +1092,9 @@ async fn flush_call_log_chunked(
                 .bind(e.status_code as i16)
                 .bind(e.latency_ms as i32)
                 .bind(e.rpc_success as i8)
-                .bind(e.rpc_error_code);
+                .bind(e.rpc_error_code)
+                .bind(e.tool_success.map(i8::from))
+                .bind(e.tool_error_kind);
         }
         query.execute(pool).await?;
     }
 
@@ -594,12 +594,12 @@ pub async fn user_call_stats(
     // Aggregate totals for the requested time window.
     // Error counting unifies HTTP errors (/v1/*) and JSON-RPC errors (/mcp/*):
     //   - /v1/* REST calls: HTTP status_code >= 400 signals an error
-    //   - /mcp/* JSON-RPC calls: HTTP is always 200; rpc_success = 0 signals an error
+    //   - /mcp/*: protocol and tool execution errors are independent dimensions
     let row = sqlx::query(&format!(
         "SELECT \
             CAST(COUNT(*) AS SIGNED) AS total, \
             CAST(COALESCE(AVG(latency_ms), 0) AS DOUBLE) AS avg_ms, \
-            CAST(SUM(CASE WHEN status_code >= 400 OR rpc_success = 0 THEN 1 ELSE 0 END) AS SIGNED) AS errors \
+            CAST(SUM(CASE WHEN status_code >= 400 OR rpc_success = 0 OR tool_success = 0 THEN 1 ELSE 0 END) AS SIGNED) AS errors \
          FROM {call_log} \
          WHERE user_id = ? AND called_at >= DATE_SUB(NOW(6), INTERVAL ? DAY)",
     ))
@@ -624,7 +624,11 @@ pub async fn user_call_stats(
             CAST(COALESCE(AVG(latency_ms), 0) AS DOUBLE) AS avg_ms, \
             CAST(COALESCE(MAX(latency_ms), 0) AS SIGNED) AS max_ms, \
             CAST(SUM(CASE WHEN status_code >= 400 THEN 1 ELSE 0 END) AS SIGNED) AS err_cnt, \
-            CAST(SUM(CASE WHEN rpc_success = 0 THEN 1 ELSE 0 END) AS SIGNED) AS rpc_err_cnt \
+            CAST(SUM(CASE WHEN rpc_success = 0 THEN 1 ELSE 0 END) AS SIGNED) AS rpc_err_cnt, \
+            CAST(SUM(CASE WHEN tool_success = 0 THEN 1 ELSE 0 END) AS SIGNED) AS tool_err_cnt, \
+            CAST(SUM(CASE WHEN tool_error_kind = 'input' THEN 1 ELSE 0 END) AS SIGNED) AS tool_input_cnt, \
+            CAST(SUM(CASE WHEN tool_error_kind = 'rejected' THEN 1 ELSE 0 END) AS SIGNED) AS tool_rejected_cnt, \
+            CAST(SUM(CASE WHEN tool_error_kind = 'backend' THEN 1 ELSE 0 END) AS SIGNED) AS tool_backend_cnt \
          FROM {call_log} \
          WHERE user_id = ? AND called_at >= DATE_SUB(NOW(6), INTERVAL ? DAY) \
          GROUP BY method, path \
@@ -647,8 +651,9 @@ pub async fn user_call_stats(
             let max_ms: i64 = r.try_get("max_ms").unwrap_or(0);
             let err_cnt: i64 = r.try_get("err_cnt").unwrap_or(0);
             let rpc_err_cnt: i64 = r.try_get("rpc_err_cnt").unwrap_or(0);
-            // Unified error count: HTTP errors for /v1/* + RPC errors for /mcp/*
-            let total_err = err_cnt + rpc_err_cnt;
+            // HTTP, protocol, and execution failures remain independently queryable.
+            let tool_err_cnt: i64 = r.try_get("tool_err_cnt").unwrap_or(0);
+            let total_err = err_cnt + rpc_err_cnt + tool_err_cnt;
             serde_json::json!({
                 "method": method,
                 "path": path,
@@ -657,6 +662,10 @@ pub async fn user_call_stats(
                 "max_ms": max_ms,
                 "error_count": total_err,
                 "rpc_error_count": rpc_err_cnt,
+                "tool_error_count": tool_err_cnt,
+                "tool_input_error_count": r.try_get::<i64, _>("tool_input_cnt").unwrap_or(0),
+                "tool_rejected_count": r.try_get::<i64, _>("tool_rejected_cnt").unwrap_or(0),
+                "tool_backend_error_count": r.try_get::<i64, _>("tool_backend_cnt").unwrap_or(0),
                 "error_rate": if cnt > 0 {
                     (total_err as f64 / cnt as f64 * 100.0).round() / 100.0
                 } else { 0.0 },
@@ -665,9 +674,9 @@ pub async fn user_call_stats(
         .collect();
 
     // Most recent 50 calls for the live "Recent Calls" feed.
-    // Include rpc_success so /mcp errors (HTTP 200 but RPC failure) show as "err".
+    // Include both protocol and tool outcomes for MCP responses with HTTP 200.
     let recent_rows = sqlx::query(&format!(
-        "SELECT method, path, status_code, latency_ms, called_at, rpc_success \
+        "SELECT method, path, status_code, latency_ms, called_at, rpc_success, tool_success, tool_error_kind \
          FROM {call_log} \
          WHERE user_id = ? \
          ORDER BY called_at DESC \
@@ -690,7 +699,9 @@ pub async fn user_call_stats(
                 .unwrap_or_else(|_| chrono::Utc::now());
             // rpc_success defaults to true (1) for /v1/* rows that predate the column.
             let rpc_success: i8 = r.try_get("rpc_success").unwrap_or(1);
-            let is_err = status_code >= 400 || rpc_success == 0;
+            let tool_success: Option<i8> = r.try_get("tool_success").unwrap_or(None);
+            let tool_error_kind: Option<String> = r.try_get("tool_error_kind").unwrap_or(None);
+            let is_err = status_code >= 400 || rpc_success == 0 || tool_success == Some(0);
             serde_json::json!({
                 "method": method,
                 "path": path,
@@ -699,6 +710,8 @@ pub async fn user_call_stats(
                 "called_at": called_at.to_rfc3339(),
                 // Unified status: HTTP error (/v1/*) OR JSON-RPC error (/mcp/*)
                 "status": if is_err { "err" } else { "ok" },
+                "tool_success": tool_success.map(|v| v != 0),
+                "tool_error_kind": tool_error_kind,
             })
         })
         .collect();
 
@@ -189,6 +189,26 @@ fn spawn_metrics_dirty_mark(
     });
 }
 
+fn result_outcome(method: &str, result: &serde_json::Value) -> RpcMeta {
+    let mut rpc = RpcMeta::ok();
+    if method == "tools/call" {
+        let kind = memoria_mcp::tool_result::error_kind(result);
+        rpc.tool_success = Some(kind.is_none());
+        rpc.tool_error_kind = kind.map(|kind| kind.as_str());
+    }
+    rpc
+}
+
+fn report_tool_outcome(tool: Option<&str>, rpc: &RpcMeta) {
+    if let Some(kind) = rpc.tool_error_kind {
+        if kind == "backend" {
+            tracing::warn!(tool, kind, "MCP tool backend failure");
+        } else {
+            tracing::debug!(tool, kind, "MCP tool input or operation rejected");
+        }
+    }
+}
+
 pub async fn mcp_handler(
     State(state): State<AppState>,
     auth: AuthUser,
@@ -317,6 +337,17 @@ pub async fn mcp_handler(
         }
     };
     // Use the exact dispatch name, never a sanitized/truncated metrics label.
+    if method == "tools/call" {
+        if let Err(error) = memoria_mcp::validate_tool_call(params.as_ref()) {
+            report_stats(&track_path, false);
+            if req.get("id").is_none() {
+                return StatusCode::NO_CONTENT.into_response();
+            }
+            return Json(json!({"jsonrpc": "2.0", "id": req["id"],
+                "error": {"code": error.code, "message": error.message}}))
+            .into_response();
+        }
+    }
     let authorization_error = if method == "tools/call" {
         let name = params
             .as_ref()
@@ -455,17 +486,24 @@ pub async fn mcp_handler(
         )
         .await;
         let rpc = match &dispatch_result {
-            Ok(_) => RpcMeta::ok(),
+            Ok(result) => result_outcome(&method, result),
             Err(e) => RpcMeta::err(e.code),
         };
-        if dispatch_result.is_ok() {
+        let tool_success = dispatch_result
+            .as_ref()
+            .is_ok_and(|result| !memoria_mcp::tool_result::is_error(result));
+        if tool_success {
             if let Some(mask) = tracked_tool.as_deref().and_then(mcp_tool_dirty_mask) {
                 spawn_metrics_dirty_mark(state.clone(), scope_id.clone(), mask);
             }
         }
-        // Report accurate ops metrics using the real RPC path and success flag
-        // (JSON-RPC errors still return HTTP 200, so is_success must come from rpc.success).
-        report_stats(&track_path, rpc.success);
+        // Service health excludes expected input/rejection errors; call logs
+        // retain both protocol and tool outcomes.
+        report_tool_outcome(tracked_tool.as_deref(), &rpc);
+        report_stats(
+            &track_path,
+            rpc.success && rpc.tool_error_kind != Some("backend"),
+        );
         record_call(204, rpc);
         return StatusCode::NO_CONTENT.into_response();
     }
@@ -495,9 +533,9 @@ pub async fn mcp_handler(
         return err_body.into_response();
     }
 
-    // JSON-RPC spec: the HTTP response is always 200 OK, even for RPC errors.
-    // Business-level error tracking uses rpc_success / rpc_error_code in the call log.
-    let (response, rpc) = match memoria_mcp::dispatch_http(
+    // This endpoint returns HTTP 200 for dispatched JSON-RPC responses. Protocol
+    // and tool execution outcomes must be tracked separately.
+    let (response, rpc, tool_success) = match memoria_mcp::dispatch_http(
         method.clone(),
         params,
         state.service.clone(),
@@ -507,10 +545,13 @@ pub async fn mcp_handler(
     .await
     {
         Ok(v) => {
+            let tool_success = !memoria_mcp::tool_result::is_error(&v);
+            let rpc = result_outcome(&method, &v);
             let result = if v.is_null() { json!({}) } else { v };
             (
                 Json(json!({"jsonrpc": "2.0", "id": id, "result": result})).into_response(),
-                RpcMeta::ok(),
+                rpc,
+                tool_success,
             )
         }
         Err(e) => (
@@ -521,18 +562,23 @@ pub async fn mcp_handler(
             }))
             .into_response(),
             RpcMeta::err(e.code),
+            false,
         ),
     };
 
-    if rpc.success {
+    if tool_success {
         if let Some(mask) = tracked_tool.as_deref().and_then(mcp_tool_dirty_mask) {
             spawn_metrics_dirty_mark(state.clone(), scope_id.clone(), mask);
         }
     }
 
-    // Report accurate ops metrics using the real RPC path and success flag
-    // (JSON-RPC errors still return HTTP 200, so is_success must come from rpc.success).
-    report_stats(&track_path, rpc.success);
+    // Service health excludes input/rejection errors; the per-tool call log
+    // retains every execution failure and its classification separately.
+    report_tool_outcome(tracked_tool.as_deref(), &rpc);
+    report_stats(
+        &track_path,
+        rpc.success && rpc.tool_error_kind != Some("backend"),
+    );
     record_call(200, rpc);
 
     response
@@ -544,6 +590,26 @@ mod tests {
     use crate::auth::{SCOPE_MEMORY_READ, SCOPE_MEMORY_WRITE};
     use serde_json::json;
 
+    #[test]
+    fn protocol_and_tool_outcomes_remain_separate() {
+        use memoria_mcp::tool_result::{classified_error, ErrorKind};
+        for kind in [ErrorKind::Input, ErrorKind::Rejected, ErrorKind::Backend] {
+            let rpc = super::result_outcome("tools/call", &classified_error(kind, "failure"));
+            assert!(rpc.success);
+            assert_eq!(rpc.error_code, None);
+            assert_eq!(rpc.tool_success, Some(false));
+            assert_eq!(rpc.tool_error_kind, Some(kind.as_str()));
+        }
+        assert_eq!(
+            super::result_outcome("tools/call", &json!({"content":[]})).tool_success,
+            Some(true)
+        );
+        assert_eq!(
+            super::result_outcome("tools/list", &json!({"tools":[]})).tool_success,
+            None
+        );
+    }
+
     fn test_state() -> crate::state::AppState {
         let pool = sqlx::mysql::MySqlPoolOptions::new()
             .connect_lazy("mysql://test:test@127.0.0.1/test")
@@ -664,6 +730,65 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn http_tool_errors_preserve_protocol_success_and_scope_denials() {
+        use axum::response::IntoResponse;
+        let state = test_state();
+        for (params, scopes, expected) in [
+            (
+                json!({"name":"memory_store","arguments":{"content":""}}),
+                vec![crate::auth::SCOPE_MEMORY_WRITE.into()],
+                None,
+            ),
+            (
+                json!({"name":"memory_future_tool"}),
+                vec![crate::auth::SCOPE_MEMORY_WRITE.into()],
+                Some(-32602),
+            ),
+            (
+                json!({"name":"memory_store","arguments":[]}),
+                vec![crate::auth::SCOPE_MEMORY_WRITE.into()],
+                Some(-32602),
+            ),
+            (
+                json!({"name":"memory_store","arguments":{"content":"denied"}}),
+                vec![],
+                Some(-32003),
+            ),
+        ] {
+            let response = super::mcp_handler(
+                axum::extract::State(state.clone()),
+                test_auth(scopes),
+                Default::default(),
+                json!({"jsonrpc":"2.0","id":"request","method":"tools/call","params":params})
+                    .to_string(),
+            )
+            .await
+            .into_response();
+            assert_eq!(response.status(), 200);
+            let body: serde_json::Value = serde_json::from_slice(
+                &axum::body::to_bytes(response.into_body(), 4096)
+                    .await
+                    .unwrap(),
+            )
+            .unwrap();
+            assert_eq!(body["id"], "request");
+            if let Some(code) = expected {
+                assert_eq!(body["error"]["code"], code, "{body}");
+                assert!(body.get("result").is_none());
+            } else {
+                assert_eq!(body["result"]["isError"], true, "{body}");
+                assert!(body.get("error").is_none());
+            }
+        }
+        // Rejected protocol envelopes and scope denials do not provision per-user
+        // storage. The execution error is logged as a successful RPC exchange.
+        assert_eq!(
+            state.call_log_batcher.pending_rpc_outcomes(),
+            vec![(true, None)]
+        );
+    }
+
     // ── tools/call — happy path ───────────────────────────────────────────────
 
     #[test]