Exposes graph and memory APIs to zomes

Enables zomes to interact with the AIngle Cortex semantic
graph and Titans memory system.

Adds new host functions to query and store triples in the
graph, and to recall and remember memories via Cortex.

This allows zomes to leverage the knowledge layer for
enhanced reasoning and data management capabilities.

Author: ApiliumDevTeam

Cargo.lock

@@ -33,6 +33,7 @@ aingle_sqlite = { version = "0.0.1", path = "../aingle_sqlite" }
 aingle_middleware_bytes = "=0.0.3"
 aingle_state = { version = "0.0.1", path = "../aingle_state" }
 aingle_types = { version = "0.0.1", path = "../aingle_types" }
+aingle_cortex = { version = "0.2.0", path = "../aingle_cortex", default-features = false, features = ["rest"] }
 aingle_wasmer_host = "0.0.1"
 aingle_websocket = { version = "0.0.1", path = "../aingle_websocket" }
 wasmer = "=6.0.0"

crates/aingle/Cargo.toml

@@ -172,4 +172,12 @@ host_fn_api_impls! {
     // These are constant for the lifetime of a zome call.
     fn zome_info (()) -> zt::info::ZomeInfo;
 
+    // Semantic graph operations — query/store triples via Cortex.
+    fn graph_query (zt::graph::GraphQueryInput) -> zt::graph::GraphQueryOutput;
+    fn graph_store (zt::graph::GraphStoreInput) -> zt::graph::GraphStoreOutput;
+
+    // Titans memory operations — recall/remember via Cortex.
+    fn memory_recall (zt::graph::MemoryRecallInput) -> zt::graph::MemoryRecallOutput;
+    fn memory_remember (zt::graph::MemoryRememberInput) -> zt::graph::MemoryRememberOutput;
+
 }

crates/aingle/src/core/ribosome/host_fn.rs

@@ -0,0 +1,21 @@
+use crate::core::ribosome::CallContext;
+use crate::core::ribosome::RibosomeT;
+use aingle_cortex::client::{CortexClientConfig, CortexInternalClient};
+use aingle_types::prelude::*;
+use aingle_wasmer_host::prelude::WasmError;
+use aingle_zome_types::graph::{GraphQueryInput, GraphQueryOutput};
+use std::sync::Arc;
+
+/// Host function: query the Cortex semantic graph from within a zome.
+pub fn graph_query(
+    _ribosome: Arc<impl RibosomeT>,
+    _call_context: Arc<CallContext>,
+    input: GraphQueryInput,
+) -> Result<GraphQueryOutput, WasmError> {
+    let client = CortexInternalClient::new(CortexClientConfig::default());
+
+    tokio_helper::block_forever_on(async move {
+        client.graph_query(input).await
+    })
+    .map_err(|e| WasmError::Host(format!("graph_query failed: {}", e)))
+}

crates/aingle/src/core/ribosome/host_fn/graph_query.rs

@@ -0,0 +1,21 @@
+use crate::core::ribosome::CallContext;
+use crate::core::ribosome::RibosomeT;
+use aingle_cortex::client::{CortexClientConfig, CortexInternalClient};
+use aingle_types::prelude::*;
+use aingle_wasmer_host::prelude::WasmError;
+use aingle_zome_types::graph::{GraphStoreInput, GraphStoreOutput};
+use std::sync::Arc;
+
+/// Host function: store a triple in the Cortex semantic graph from within a zome.
+pub fn graph_store(
+    _ribosome: Arc<impl RibosomeT>,
+    _call_context: Arc<CallContext>,
+    input: GraphStoreInput,
+) -> Result<GraphStoreOutput, WasmError> {
+    let client = CortexInternalClient::new(CortexClientConfig::default());
+
+    tokio_helper::block_forever_on(async move {
+        client.graph_store(input).await
+    })
+    .map_err(|e| WasmError::Host(format!("graph_store failed: {}", e)))
+}

crates/aingle/src/core/ribosome/host_fn/graph_store.rs

@@ -0,0 +1,21 @@
+use crate::core::ribosome::CallContext;
+use crate::core::ribosome::RibosomeT;
+use aingle_cortex::client::{CortexClientConfig, CortexInternalClient};
+use aingle_types::prelude::*;
+use aingle_wasmer_host::prelude::WasmError;
+use aingle_zome_types::graph::{MemoryRecallInput, MemoryRecallOutput};
+use std::sync::Arc;
+
+/// Host function: recall memories from the Titans system via Cortex.
+pub fn memory_recall(
+    _ribosome: Arc<impl RibosomeT>,
+    _call_context: Arc<CallContext>,
+    input: MemoryRecallInput,
+) -> Result<MemoryRecallOutput, WasmError> {
+    let client = CortexInternalClient::new(CortexClientConfig::default());
+
+    tokio_helper::block_forever_on(async move {
+        client.memory_recall(input).await
+    })
+    .map_err(|e| WasmError::Host(format!("memory_recall failed: {}", e)))
+}

crates/aingle/src/core/ribosome/host_fn/memory_recall.rs

@@ -0,0 +1,21 @@
+use crate::core::ribosome::CallContext;
+use crate::core::ribosome::RibosomeT;
+use aingle_cortex::client::{CortexClientConfig, CortexInternalClient};
+use aingle_types::prelude::*;
+use aingle_wasmer_host::prelude::WasmError;
+use aingle_zome_types::graph::{MemoryRememberInput, MemoryRememberOutput};
+use std::sync::Arc;
+
+/// Host function: store a memory in the Titans system via Cortex.
+pub fn memory_remember(
+    _ribosome: Arc<impl RibosomeT>,
+    _call_context: Arc<CallContext>,
+    input: MemoryRememberInput,
+) -> Result<MemoryRememberOutput, WasmError> {
+    let client = CortexInternalClient::new(CortexClientConfig::default());
+
+    tokio_helper::block_forever_on(async move {
+        client.memory_remember(input).await
+    })
+    .map_err(|e| WasmError::Host(format!("memory_remember failed: {}", e)))
+}

crates/aingle/src/core/ribosome/host_fn/memory_remember.rs

@@ -67,6 +67,10 @@ use crate::core::ribosome::host_fn::x_25519_x_salsa20_poly1305_encrypt::x_25519_
 use crate::core::ribosome::host_fn::x_salsa20_poly1305_decrypt::x_salsa20_poly1305_decrypt;
 use crate::core::ribosome::host_fn::x_salsa20_poly1305_encrypt::x_salsa20_poly1305_encrypt;
 use crate::core::ribosome::host_fn::zome_info::zome_info;
+use crate::core::ribosome::host_fn::graph_query::graph_query;
+use crate::core::ribosome::host_fn::graph_store::graph_store;
+use crate::core::ribosome::host_fn::memory_recall::memory_recall;
+use crate::core::ribosome::host_fn::memory_remember::memory_remember;
 use crate::core::ribosome::CallContext;
 use crate::core::ribosome::Invocation;
 use crate::core::ribosome::RibosomeT;
@@ -568,6 +572,29 @@ impl RealRibosome {
             imports.define("env", "__schedule", host_fn!(store, func_env, unreachable));
         }
 
+        // Semantic graph and Titans memory host functions.
+        // These are always available (gated by Cortex connectivity, not permissions).
+        imports.define(
+            "env",
+            "__graph_query",
+            host_fn!(store, func_env, graph_query),
+        );
+        imports.define(
+            "env",
+            "__graph_store",
+            host_fn!(store, func_env, graph_store),
+        );
+        imports.define(
+            "env",
+            "__memory_recall",
+            host_fn!(store, func_env, memory_recall),
+        );
+        imports.define(
+            "env",
+            "__memory_remember",
+            host_fn!(store, func_env, memory_remember),
+        );
+
         (imports, func_env)
     }
 }

crates/aingle/src/core/ribosome/real_ribosome.rs

@@ -29,6 +29,7 @@ path = "src/main.rs"
 aingle_graph = { version = "0.2", path = "../aingle_graph" }
 aingle_logic = { version = "0.2", path = "../aingle_logic" }
 aingle_zk = { version = "0.2", path = "../aingle_zk" }
+titans_memory = { version = "0.2", path = "../titans_memory" }
 
 # Web framework (use 0.7 for async-graphql-axum compatibility)
 axum = { version = "0.7", features = ["ws", "macros"] }
@@ -75,6 +76,12 @@ validator = { version = "0.20", features = ["derive"] }
 # Regular expressions (for SPARQL FILTER)
 regex = "1.10"
 
+# HTTP client (for CortexInternalClient used by WASM host functions)
+reqwest = { version = "0.12", features = ["json"] }
+
+# Zome types (for WASM boundary types in client.rs)
+aingle_zome_types = { version = "^0.0.1", path = "../aingle_zome_types" }
+
 # Rate limiting
 dashmap = "6.0"