feat: implement SessionEnd hook, add multi-agent support, and update Antigravity MCP configuration logic

Author: fajarhide

README.md

@@ -154,7 +154,7 @@ By default, `omni init --claude` automatically hooks into **Claude Code**. Howev
 
 1. **VS Code & Continue.dev**: Use our MCP context provider (`integrations/continue-dev/`).
 2. **OpenCode & Codex CLI**: Built-in wrappers automatically pipe command output to OMNI.
-3. **Antigravity IDE**: OMNI natively supports IDEs like Antigravity via MCP over stdio. Just import the plugin manifest (`integrations/antigravity/antigravity.plugin.json`).
+3. **Antigravity IDE**: OMNI registers as a native MCP server in Antigravity's config (`~/.gemini/antigravity/mcp_config.json`). Run `omni init --antigravity` to set up automatically.
 
 **Multi-Agent Tuning (`~/.omni/config.toml`)**
 Different agents have different pain points. Keep VS Code chat clean, whilst letting OpenCode read more data. Tune them individually:

docs/HOW_TO_USE.md

@@ -1190,6 +1190,53 @@ You can use OMNI natively with OpenClaw by installing the official skill from Cl
 - **Install Command**: `clawhub install omni-signal-engine`
 - **Automatic Setup**: OpenClaw integration is completely automatic. Run `omni doctor --fix` to fetch and install the latest plugin directly from the OMNI public repository.
 
+### Antigravity IDE
+
+OMNI integrates with Antigravity IDE as a native MCP server, registered directly in Antigravity's MCP configuration file.
+
+**Automatic Setup:**
+```bash
+omni init --antigravity
+```
+
+This registers OMNI as an MCP server at:
+- **macOS/Linux**: `~/.gemini/antigravity/mcp_config.json`
+- **Windows**: `%USERPROFILE%\.gemini\antigravity\mcp_config.json`
+
+**Manual Setup:**
+
+If you prefer to configure manually, add the `omni` entry to your `mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "omni": {
+      "command": "/opt/homebrew/bin/omni",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+> [!NOTE]
+> Replace `/opt/homebrew/bin/omni` with the actual path to your OMNI binary. You can find it by running `which omni`.
+
+**Verification:**
+```bash
+omni doctor    # Check Antigravity integration status
+```
+
+The doctor output will show:
+```
+  Antigravity IDE:
+   Config:         ~/.gemini/antigravity/mcp_config.json [OK]
+```
+
+**Uninstall:**
+```bash
+omni reset --antigravity   # Remove OMNI from Antigravity MCP config
+```
+
 ---
 
 *This is a living document. OMNI is under active development — check the [CHANGELOG](https://github.com/fajarhide/omni/blob/main/CHANGELOG.md) for updates after each release.*

src/agents/antigravity.rs

@@ -6,6 +6,17 @@ use std::path::PathBuf;
 
 pub struct AntigravityIntegration;
 
+impl AntigravityIntegration {
+    /// Returns the path to the Antigravity MCP config file.
+    /// macOS/Linux: ~/.gemini/antigravity/mcp_config.json
+    /// Windows:     %USERPROFILE%\.gemini\antigravity\mcp_config.json
+    fn config_path() -> PathBuf {
+        dirs::home_dir()
+            .unwrap_or_else(|| PathBuf::from("."))
+            .join(".gemini/antigravity/mcp_config.json")
+    }
+}
+
 impl AgentIntegration for AntigravityIntegration {
     fn id(&self) -> &'static str {
         "antigravity"
@@ -16,86 +27,89 @@ impl AgentIntegration for AntigravityIntegration {
     }
 
     fn install(&self, exe_path: &str) -> anyhow::Result<()> {
-        let extensions_dir = dirs::home_dir()
-            .unwrap_or_else(|| PathBuf::from("."))
-            .join(".antigravity/extensions");
-        let plugin_dir = extensions_dir.join("omni-signal-engine");
-
-        fs::create_dir_all(&plugin_dir)?;
-
-        let manifest = json!({
-            "name": "omni-signal-engine",
-            "version": "0.1.0",
-            "description": "OMNI intelligent output distillation for Antigravity IDE",
-            "type": "mcp",
-            "mcp": {
-                "transport": "stdio",
-                "command": exe_path,
-                "args": ["--mcp"]
-            }
-        });
+        let config_path = Self::config_path();
+
+        if let Some(parent) = config_path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+
+        let mut val = if config_path.exists() {
+            let content = fs::read_to_string(&config_path)?;
+            serde_json::from_str(&content).unwrap_or_else(|_| json!({}))
+        } else {
+            json!({})
+        };
 
-        fs::write(
-            plugin_dir.join("package.json"),
-            serde_json::to_string_pretty(&manifest)?,
-        )?;
+        if let Some(obj) = val.as_object_mut() {
+            let mcp_servers = obj.entry("mcpServers").or_insert_with(|| json!({}));
+            if let Some(servers) = mcp_servers.as_object_mut() {
+                servers.insert(
+                    "omni".to_string(),
+                    json!({
+                        "command": exe_path,
+                        "args": ["serve"]
+                    }),
+                );
+            }
+        }
 
+        fs::write(&config_path, serde_json::to_string_pretty(&val)?)?;
         println!(
-            "  {} Installed MCP Plugin to ~/.antigravity/extensions/omni-signal-engine",
+            "  {} Configured MCP Server in ~/.gemini/antigravity/mcp_config.json",
             "✓".green()
         );
         Ok(())
     }
 
     fn uninstall(&self) -> anyhow::Result<()> {
-        let plugin_dir = dirs::home_dir()
-            .unwrap_or_else(|| PathBuf::from("."))
-            .join(".antigravity/extensions/omni-signal-engine");
+        let config_path = Self::config_path();
 
-        if plugin_dir.exists() {
-            fs::remove_dir_all(&plugin_dir).ok();
-            println!(
-                "  {} Removed MCP Plugin from ~/.antigravity/extensions/",
-                "✓".yellow()
-            );
+        if !config_path.exists() {
+            return Ok(());
         }
+
+        let content = fs::read_to_string(&config_path)?;
+        let Ok(mut val) = serde_json::from_str::<serde_json::Value>(&content) else {
+            return Ok(());
+        };
+
+        if let Some(obj) = val.as_object_mut()
+            && let Some(servers) = obj.get_mut("mcpServers").and_then(|v| v.as_object_mut())
+        {
+            servers.remove("omni");
+        }
+
+        fs::write(&config_path, serde_json::to_string_pretty(&val)?)?;
+        println!(
+            "  {} Removed MCP Server from ~/.gemini/antigravity/mcp_config.json",
+            "✓".yellow()
+        );
         Ok(())
     }
 
     fn doctor_check(&self, _fix_mode: bool, _warnings: &mut Vec<String>) -> bool {
-        let antigravity_dir = dirs::home_dir()
-            .unwrap_or_else(|| PathBuf::from("."))
-            .join(".antigravity/extensions");
+        let config_path = Self::config_path();
 
         println!("\n  {}", "Antigravity IDE:".cyan());
-        let mut ag_found = false;
-        if antigravity_dir.exists()
-            && let Ok(entries) = fs::read_dir(&antigravity_dir)
+        if config_path.exists()
+            && fs::read_to_string(&config_path)
+                .unwrap_or_default()
+                .contains("\"omni\":")
         {
-            for entry in entries.flatten() {
-                if entry
-                    .file_name()
-                    .to_string_lossy()
-                    .contains("omni-signal-engine")
-                {
-                    println!(
-                        "   {:<15} {} {}",
-                        "Config:".bright_black(),
-                        "plugin installed".bright_black(),
-                        "[OK]".green().bold()
-                    );
-                    ag_found = true;
-                    break;
-                }
-            }
-        }
-        if !ag_found {
+            println!(
+                "   {:<15} {} {}",
+                "Config:".bright_black(),
+                "~/.gemini/antigravity/mcp_config.json".bright_black(),
+                "[OK]".green().bold()
+            );
+            true
+        } else {
             println!(
                 "   {:<15} {}",
                 "Config:".bright_black(),
-                "not configured (check GUI)".bright_black()
+                "not configured".bright_black()
             );
+            false
         }
-        ag_found
     }
 }

src/agents/claude.rs

@@ -338,15 +338,37 @@ pub fn install_omni_hooks(val: &mut Value, exe_path: &str) {
         }));
     };
 
-    let script_path = format!("{} --pre-hook", exe_path);
+    let ensure_async_hook = |arr_val: &mut serde_json::Value, hook_cmd: &str| {
+        let arr = arr_val.as_array_mut().unwrap();
+        for v in arr.iter() {
+            if let Some(inner) = v.get("hooks").and_then(|h| h.as_array()) {
+                for h in inner {
+                    if h.get("command").and_then(|c| c.as_str()) == Some(hook_cmd) {
+                        return;
+                    }
+                }
+            }
+        }
+        arr.push(json!({
+            "hooks": [{
+                "type": "command",
+                "command": hook_cmd,
+                "async": true
+            }]
+        }));
+    };
+
+    let pre_cmd = format!("{} --pre-hook", exe_path);
     let post_cmd = format!("{} --post-hook", exe_path);
     let session_cmd = format!("{} --session-start", exe_path);
     let compact_cmd = format!("{} --pre-compact", exe_path);
+    let hook_cmd = format!("{} --hook", exe_path);
 
+    // Core hooks (blocking)
     ensure_hook(
         hooks.entry("PreToolUse").or_insert_with(|| json!([])),
         "Bash",
-        &script_path,
+        &pre_cmd,
     );
     ensure_hook(
         hooks.entry("PostToolUse").or_insert_with(|| json!([])),
@@ -363,6 +385,27 @@ pub fn install_omni_hooks(val: &mut Value, exe_path: &str) {
         "",
         &compact_cmd,
     );
+
+    // v0.5.7: New hooks (async — non-blocking, no output needed)
+    ensure_async_hook(
+        hooks.entry("SessionEnd").or_insert_with(|| json!([])),
+        &hook_cmd,
+    );
+    ensure_async_hook(
+        hooks
+            .entry("PostToolUseFailure")
+            .or_insert_with(|| json!([])),
+        &hook_cmd,
+    );
+    ensure_hook(
+        hooks.entry("SubagentStart").or_insert_with(|| json!([])),
+        "",
+        &session_cmd,
+    );
+    ensure_async_hook(
+        hooks.entry("FileChanged").or_insert_with(|| json!([])),
+        &hook_cmd,
+    );
 }
 
 pub fn install_mcp_server(exe_path: &str) -> anyhow::Result<()> {

src/agents/mod.rs

@@ -5,6 +5,7 @@ pub mod codex;
 pub mod copilot;
 pub mod cursor;
 pub mod gemini;
+pub mod multiagent;
 pub mod openclaw;
 pub mod opencode;
 pub mod roo_code;