25 semantic tools grouped by category:

- Settings (1): `set_setting` (change a setting value via round-trip to frontend)

- `cmdr://settings`: All settings with current values, defaults, types, and constraints. Fetched via round-trip to the frontend (`mcp-get-all-settings` event).

Tools where the backend can't fully validate preconditions use `mcp_round_trip`: emit an event with a `requestId`, wait for the frontend to respond via `mcp-response` with `{ requestId, ok, error? }`, and return the actual outcome. Used by `nav_to_path` and `set_setting`. Resources that need frontend data use `resource_round_trip` (same pattern but returns `data` from the response). Used by `cmdr://settings`. Use these patterns for any new tool/resource where the backend would otherwise need to replicate frontend knowledge.

Frontend syncs state to these stores via Tauri commands (`update_left_pane_state`, `update_pane_tabs`, etc.). Settings are fetched on-demand via round-trip to the frontend rather than stored in a state store.

`PaneStateStore` is always synced (file pane changes frequently). `SoftDialogTracker` is updated by MCP tools themselves. Separating concerns keeps each store simple. Settings are fetched on-demand via `resource_round_trip` rather than stored, since they rarely change and can be queried from the frontend when needed.

The `cmdr://settings` resource and `set_setting` tool both use round-trips to the main window frontend. This means settings are always fetched fresh from the source of truth, rather than being synced to a Rust-side store. The tradeoff is a ~5s timeout if the frontend is unresponsive, but this avoids stale state issues.

&& let Some(tx) = tx.lock().unwrap().take()

{

let result = if resp.get("ok").and_then(|v| v.as_bool()).unwrap_or(false) {

Ok(())

} else {

let err = resp

.get("error")

.and_then(|v| v.as_str())

.unwrap_or("Unknown error")

.to_string();

Err(err)

};

let _ = tx.send(result);

}

// Settings commands

"set_setting" => execute_set_setting(app, params).await,

if let Some(store) = app.try_state::<PaneStateStore>() {

async fn execute_set_setting<R: Runtime>(app: &AppHandle<R>, params: &Value) -> ToolResult {

let id = params

.get("id")

.and_then(|v| v.as_str())

.ok_or_else(|| ToolError::invalid_params("Missing 'id' parameter"))?;

let value = params

.get("value")

.ok_or_else(|| ToolError::invalid_params("Missing 'value' parameter"))?;

mcp_round_trip(

app,

"mcp-set-setting",

json!({"settingId": id, "value": value}),

format!("OK: Set '{id}' to {value}"),

)

.await

use serde_json::{Value, json};

use tauri::{Emitter, Listener, Manager, Runtime, WebviewWindow};

Resource {

uri: "cmdr://settings".to_string(),

name: "Settings".to_string(),

description: "All settings with current values, defaults, types, and constraints".to_string(),

mime_type: "text/yaml".to_string(),

},

async fn resource_round_trip<R: Runtime>(

app: &tauri::AppHandle<R>,

event: &str,

mut payload: Value,

) -> Result<String, String> {

let request_id = uuid::Uuid::new_v4().to_string();

payload["requestId"] = json!(request_id);

let (tx, rx) = tokio::sync::oneshot::channel::<Result<String, String>>();

let expected_id = request_id.clone();

let tx = std::sync::Mutex::new(Some(tx));

let listener_id = app.listen("mcp-response", move |event| {

if let Ok(resp) = serde_json::from_str::<Value>(event.payload())

&& resp.get("requestId").and_then(|v| v.as_str()) == Some(&expected_id)

&& let Some(tx) = tx.lock().unwrap().take()

{

let result = if resp.get("ok").and_then(|v| v.as_bool()).unwrap_or(false) {

let data = resp.get("data").and_then(|v| v.as_str()).unwrap_or("").to_string();

Ok(data)

} else {

let err = resp

.get("error")

.and_then(|v| v.as_str())

.unwrap_or("Unknown error")

.to_string();

Err(err)

};

let _ = tx.send(result);

}

});

app.emit(event, payload).map_err(|e| e.to_string())?;

let result = tokio::time::timeout(std::time::Duration::from_secs(5), rx).await;

app.unlisten(listener_id);

match result {

Ok(Ok(data)) => data,

Ok(Err(_)) => Err("Frontend response channel dropped".to_string()),

Err(_) => Err("Frontend did not respond within 5 seconds".to_string()),

}

pub async fn read_resource<R: Runtime>(app: &tauri::AppHandle<R>, uri: &str) -> Result<ResourceContent, String> {

"cmdr://settings" => {

let text = resource_round_trip(app, "mcp-get-all-settings", json!({})).await?;

(text, "text/yaml")

}

assert_eq!(resources.len(), 4);

match read_resource(&state.app, uri).await {