diff --git a/Cargo.lock b/Cargo.lock
index 0a55630f..c54e03ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -380,6 +380,14 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "capability-demo"
+version = "0.1.0"
+dependencies = [
+ "ordo-core",
+ "serde_json",
+]
+
 [[package]]
 name = "cast"
 version = "0.3.0"
@@ -2380,6 +2388,7 @@ dependencies = [
  "clap",
  "dashmap",
  "futures",
+ "hashbrown 0.14.5",
  "hex",
  "hmac",
  "hostname",
diff --git a/Cargo.toml b/Cargo.toml
index 54b521c9..9adc4530 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,6 +8,7 @@ members = [
     "crates/ordo-server",
     "crates/ordo-platform",
     "crates/ordo-wasm",
+    "examples/capability-demo",
 ]
 
 [workspace.package]
diff --git a/crates/ordo-core/src/capability/mod.rs b/crates/ordo-core/src/capability/mod.rs
new file mode 100644
index 00000000..8898a762
--- /dev/null
+++ b/crates/ordo-core/src/capability/mod.rs
@@ -0,0 +1,72 @@
+mod provider;
+mod registry;
+
+pub use provider::{
+    CapabilityCategory, CapabilityConfig, CapabilityDescriptor, CapabilityInvoker,
+    CapabilityProvider, CapabilityRequest, CapabilityResponse, CircuitBreakerConfig, RetryPolicy,
+};
+pub use registry::CapabilityRegistry;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::prelude::{Action, ActionKind, Expr, RuleExecutor, RuleSet, Step, TerminalResult};
+    use crate::{context::Value, error::Result};
+    use std::sync::Arc;
+
+    struct EchoProvider;
+
+    impl CapabilityProvider for EchoProvider {
+        fn descriptor(&self) -> CapabilityDescriptor {
+            CapabilityDescriptor::new("demo.echo", CapabilityCategory::Compute)
+                .with_description("Echo payloads back to the caller")
+        }
+
+        fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+            Ok(CapabilityResponse::new(request.payload.clone()))
+        }
+    }
+
+    #[test]
+    fn executor_external_call_routes_through_capability_registry() {
+        let registry = Arc::new(CapabilityRegistry::new());
+        registry.register(Arc::new(EchoProvider));
+
+        let mut ruleset = RuleSet::new("capability_demo", "call_echo");
+        ruleset.add_step(Step::action(
+            "call_echo",
+            "Call echo",
+            vec![Action {
+                kind: ActionKind::ExternalCall {
+                    service: "demo.echo".to_string(),
+                    method: "echo".to_string(),
+                    params: vec![("amount".to_string(), Expr::field("amount"))],
+                    timeout_ms: 250,
+                    result_variable: Some("capability_result".to_string()),
+                },
+                description: String::new(),
+            }],
+            "done",
+        ));
+        ruleset.add_step(Step::terminal(
+            "done",
+            "Done",
+            TerminalResult::new("OK").with_output(
+                "echoed_amount",
+                Expr::field("$capability_result.payload.amount"),
+            ),
+        ));
+
+        let mut executor = RuleExecutor::new();
+        executor.set_capability_invoker(registry);
+
+        let input: Value = serde_json::from_str(r#"{"amount": 42}"#).unwrap();
+        let result = executor.execute(&ruleset, input).unwrap();
+
+        let amount = result
+            .output
+            .get_path("echoed_amount")
+            .expect("echoed amount missing");
+        assert_eq!(amount, &Value::int(42));
+    }
+}
diff --git a/crates/ordo-core/src/capability/provider.rs b/crates/ordo-core/src/capability/provider.rs
new file mode 100644
index 00000000..b8ac130a
--- /dev/null
+++ b/crates/ordo-core/src/capability/provider.rs
@@ -0,0 +1,231 @@
+use crate::context::Value;
+use crate::error::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// High-level execution tier for a capability.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CapabilityCategory {
+    Network,
+    Compute,
+    Action,
+}
+
+/// Retry policy for a capability.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RetryPolicy {
+    pub max_attempts: u32,
+    pub backoff_ms: u64,
+}
+
+impl RetryPolicy {
+    #[inline]
+    pub fn disabled() -> Self {
+        Self {
+            max_attempts: 1,
+            backoff_ms: 0,
+        }
+    }
+}
+
+impl Default for RetryPolicy {
+    fn default() -> Self {
+        Self::disabled()
+    }
+}
+
+/// Consecutive-failure breaker for a capability.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CircuitBreakerConfig {
+    pub failure_threshold: u32,
+    pub reset_timeout_ms: u64,
+}
+
+impl CircuitBreakerConfig {
+    #[inline]
+    pub fn disabled() -> Self {
+        Self {
+            failure_threshold: 0,
+            reset_timeout_ms: 0,
+        }
+    }
+
+    #[inline]
+    pub fn enabled(&self) -> bool {
+        self.failure_threshold > 0
+    }
+}
+
+impl Default for CircuitBreakerConfig {
+    fn default() -> Self {
+        Self::disabled()
+    }
+}
+
+/// Runtime policy for a registered capability.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CapabilityConfig {
+    pub category: CapabilityCategory,
+    pub timeout_ms: Option<u64>,
+    pub retry: RetryPolicy,
+    pub circuit_breaker: CircuitBreakerConfig,
+}
+
+impl CapabilityConfig {
+    #[inline]
+    pub fn new(category: CapabilityCategory) -> Self {
+        Self {
+            category,
+            timeout_ms: None,
+            retry: RetryPolicy::default(),
+            circuit_breaker: CircuitBreakerConfig::default(),
+        }
+    }
+
+    #[inline]
+    pub fn timeout(mut self, timeout_ms: u64) -> Self {
+        self.timeout_ms = Some(timeout_ms);
+        self
+    }
+
+    #[inline]
+    pub fn retry(mut self, retry: RetryPolicy) -> Self {
+        self.retry = retry;
+        self
+    }
+
+    #[inline]
+    pub fn circuit_breaker(mut self, circuit_breaker: CircuitBreakerConfig) -> Self {
+        self.circuit_breaker = circuit_breaker;
+        self
+    }
+}
+
+/// Metadata for a registered capability.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CapabilityDescriptor {
+    pub name: String,
+    pub description: String,
+    pub config: CapabilityConfig,
+}
+
+impl CapabilityDescriptor {
+    #[inline]
+    pub fn new(name: impl Into<String>, category: CapabilityCategory) -> Self {
+        Self {
+            name: name.into(),
+            description: String::new(),
+            config: CapabilityConfig::new(category),
+        }
+    }
+
+    #[inline]
+    pub fn with_description(mut self, description: impl Into<String>) -> Self {
+        self.description = description.into();
+        self
+    }
+
+    #[inline]
+    pub fn with_config(mut self, config: CapabilityConfig) -> Self {
+        self.config = config;
+        self
+    }
+}
+
+/// Normalized request shape passed to capability providers.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct CapabilityRequest {
+    pub capability: String,
+    pub operation: String,
+    #[serde(default)]
+    pub payload: Value,
+    #[serde(default)]
+    pub metadata: HashMap<String, String>,
+    #[serde(default)]
+    pub timeout_ms: Option<u64>,
+    #[serde(default)]
+    pub category: Option<CapabilityCategory>,
+}
+
+impl CapabilityRequest {
+    #[inline]
+    pub fn new(
+        capability: impl Into<String>,
+        operation: impl Into<String>,
+        payload: Value,
+    ) -> Self {
+        Self {
+            capability: capability.into(),
+            operation: operation.into(),
+            payload,
+            metadata: HashMap::new(),
+            timeout_ms: None,
+            category: None,
+        }
+    }
+
+    #[inline]
+    pub fn with_timeout(mut self, timeout_ms: u64) -> Self {
+        self.timeout_ms = Some(timeout_ms);
+        self
+    }
+
+    #[inline]
+    pub fn with_category(mut self, category: CapabilityCategory) -> Self {
+        self.category = Some(category);
+        self
+    }
+
+    #[inline]
+    pub fn with_metadata(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.metadata.insert(key.into(), value.into());
+        self
+    }
+}
+
+/// Normalized response shape returned by capability providers.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct CapabilityResponse {
+    #[serde(default)]
+    pub payload: Value,
+    #[serde(default)]
+    pub metadata: HashMap<String, String>,
+}
+
+impl CapabilityResponse {
+    #[inline]
+    pub fn new(payload: Value) -> Self {
+        Self {
+            payload,
+            metadata: HashMap::new(),
+        }
+    }
+
+    #[inline]
+    pub fn empty() -> Self {
+        Self::new(Value::Null)
+    }
+
+    #[inline]
+    pub fn with_metadata(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.metadata.insert(key.into(), value.into());
+        self
+    }
+}
+
+/// Provider implementation for a named capability.
+pub trait CapabilityProvider: Send + Sync {
+    fn descriptor(&self) -> CapabilityDescriptor;
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse>;
+}
+
+/// Trait used by the rule executor to call a capability registry.
+pub trait CapabilityInvoker: Send + Sync {
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse>;
+
+    fn describe(&self, capability: &str) -> Option<CapabilityDescriptor> {
+        let _ = capability;
+        None
+    }
+}
diff --git a/crates/ordo-core/src/capability/registry.rs b/crates/ordo-core/src/capability/registry.rs
new file mode 100644
index 00000000..4755140f
--- /dev/null
+++ b/crates/ordo-core/src/capability/registry.rs
@@ -0,0 +1,313 @@
+use super::provider::{
+    CapabilityDescriptor, CapabilityInvoker, CapabilityProvider, CapabilityRequest,
+    CapabilityResponse,
+};
+use crate::error::OrdoError;
+use crate::error::Result;
+use parking_lot::{Mutex, RwLock};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Default)]
+struct CircuitState {
+    consecutive_failures: u32,
+    opened_at: Option<Instant>,
+}
+
+struct RegisteredCapability {
+    descriptor: CapabilityDescriptor,
+    provider: Arc<dyn CapabilityProvider>,
+    state: Mutex<CircuitState>,
+}
+
+/// In-memory capability registry used by the executor and tests.
+#[derive(Default)]
+pub struct CapabilityRegistry {
+    providers: RwLock<HashMap<String, Arc<RegisteredCapability>>>,
+}
+
+impl CapabilityRegistry {
+    #[inline]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn register(
+        &self,
+        provider: Arc<dyn CapabilityProvider>,
+    ) -> Option<Arc<dyn CapabilityProvider>> {
+        let descriptor = provider.descriptor();
+        let name = descriptor.name.clone();
+        let registered = Arc::new(RegisteredCapability {
+            descriptor,
+            provider,
+            state: Mutex::new(CircuitState::default()),
+        });
+
+        self.providers
+            .write()
+            .insert(name, registered)
+            .map(|previous| previous.provider.clone())
+    }
+
+    #[inline]
+    pub fn contains(&self, capability: &str) -> bool {
+        self.providers.read().contains_key(capability)
+    }
+
+    pub fn list(&self) -> Vec<CapabilityDescriptor> {
+        self.providers
+            .read()
+            .values()
+            .map(|entry| entry.descriptor.clone())
+            .collect()
+    }
+
+    fn lookup(&self, capability: &str) -> Option<Arc<RegisteredCapability>> {
+        self.providers.read().get(capability).cloned()
+    }
+
+    fn ensure_circuit_closed(entry: &RegisteredCapability) -> Result<()> {
+        let config = &entry.descriptor.config.circuit_breaker;
+        if !config.enabled() {
+            return Ok(());
+        }
+
+        let mut state = entry.state.lock();
+        if let Some(opened_at) = state.opened_at {
+            let elapsed = opened_at.elapsed();
+            if elapsed >= Duration::from_millis(config.reset_timeout_ms) {
+                state.consecutive_failures = 0;
+                state.opened_at = None;
+                return Ok(());
+            }
+
+            let remaining = config
+                .reset_timeout_ms
+                .saturating_sub(elapsed.as_millis().min(u128::from(u64::MAX)) as u64);
+            return Err(OrdoError::CircuitOpen {
+                capability: entry.descriptor.name.clone(),
+                retry_after_ms: Some(remaining),
+            });
+        }
+
+        Ok(())
+    }
+
+    fn mark_success(entry: &RegisteredCapability) {
+        let mut state = entry.state.lock();
+        state.consecutive_failures = 0;
+        state.opened_at = None;
+    }
+
+    fn mark_failure(entry: &RegisteredCapability) {
+        let config = &entry.descriptor.config.circuit_breaker;
+        if !config.enabled() {
+            return;
+        }
+
+        let mut state = entry.state.lock();
+        state.consecutive_failures = state.consecutive_failures.saturating_add(1);
+        if state.consecutive_failures >= config.failure_threshold {
+            state.opened_at = Some(Instant::now());
+        }
+    }
+
+    fn is_retryable_error(error: &OrdoError) -> bool {
+        matches!(
+            error,
+            OrdoError::Timeout { .. } | OrdoError::CapabilityInvocation { .. }
+        )
+    }
+}
+
+impl CapabilityInvoker for CapabilityRegistry {
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+        let entry =
+            self.lookup(&request.capability)
+                .ok_or_else(|| OrdoError::CapabilityNotFound {
+                    capability: request.capability.clone(),
+                })?;
+
+        Self::ensure_circuit_closed(&entry)?;
+
+        let attempts = entry.descriptor.config.retry.max_attempts.max(1);
+        let timeout_ms = request.timeout_ms.or(entry.descriptor.config.timeout_ms);
+
+        for attempt in 0..attempts {
+            let start = Instant::now();
+            let response = entry.provider.invoke(request);
+            let response = match (timeout_ms, response) {
+                (Some(limit), Ok(_)) if start.elapsed().as_millis() as u64 > limit => {
+                    Err(OrdoError::Timeout { timeout_ms: limit })
+                }
+                (_, other) => other,
+            };
+
+            match response {
+                Ok(response) => {
+                    Self::mark_success(&entry);
+                    return Ok(response);
+                }
+                Err(error) => {
+                    Self::mark_failure(&entry);
+                    let should_retry = attempt + 1 < attempts && Self::is_retryable_error(&error);
+                    if should_retry {
+                        #[cfg(not(target_arch = "wasm32"))]
+                        if entry.descriptor.config.retry.backoff_ms > 0 {
+                            std::thread::sleep(Duration::from_millis(
+                                entry.descriptor.config.retry.backoff_ms,
+                            ));
+                        }
+                        continue;
+                    }
+                    return Err(error);
+                }
+            }
+        }
+
+        Err(OrdoError::internal_error_static(
+            "capability registry retry loop exited unexpectedly",
+        ))
+    }
+
+    fn describe(&self, capability: &str) -> Option<CapabilityDescriptor> {
+        self.lookup(capability)
+            .map(|entry| entry.descriptor.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::capability::{
+        CapabilityCategory, CapabilityConfig, CapabilityDescriptor, CircuitBreakerConfig,
+        RetryPolicy,
+    };
+    use crate::context::Value;
+    use std::collections::VecDeque;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    struct SequenceProvider {
+        descriptor: CapabilityDescriptor,
+        calls: AtomicUsize,
+        responses: Mutex<VecDeque<Result<CapabilityResponse>>>,
+    }
+
+    impl SequenceProvider {
+        fn new(
+            descriptor: CapabilityDescriptor,
+            responses: Vec<Result<CapabilityResponse>>,
+        ) -> Self {
+            Self {
+                descriptor,
+                calls: AtomicUsize::new(0),
+                responses: Mutex::new(responses.into()),
+            }
+        }
+    }
+
+    impl CapabilityProvider for SequenceProvider {
+        fn descriptor(&self) -> CapabilityDescriptor {
+            self.descriptor.clone()
+        }
+
+        fn invoke(&self, _request: &CapabilityRequest) -> Result<CapabilityResponse> {
+            self.calls.fetch_add(1, Ordering::Relaxed);
+            self.responses
+                .lock()
+                .pop_front()
+                .unwrap_or_else(|| Ok(CapabilityResponse::new(Value::string("default"))))
+        }
+    }
+
+    #[test]
+    fn registers_and_invokes_provider() {
+        let registry = CapabilityRegistry::new();
+        registry.register(Arc::new(SequenceProvider::new(
+            CapabilityDescriptor::new("demo.echo", CapabilityCategory::Compute),
+            vec![Ok(CapabilityResponse::new(Value::string("ok")))],
+        )));
+
+        let response = registry
+            .invoke(&CapabilityRequest::new(
+                "demo.echo",
+                "run",
+                Value::object(std::collections::HashMap::new()),
+            ))
+            .unwrap();
+
+        assert_eq!(response.payload, Value::string("ok"));
+        assert!(registry.contains("demo.echo"));
+        assert_eq!(registry.list().len(), 1);
+    }
+
+    #[test]
+    fn retries_transient_errors() {
+        let registry = CapabilityRegistry::new();
+        let descriptor = CapabilityDescriptor::new("demo.retry", CapabilityCategory::Network)
+            .with_config(
+                CapabilityConfig::new(CapabilityCategory::Network).retry(RetryPolicy {
+                    max_attempts: 2,
+                    backoff_ms: 0,
+                }),
+            );
+        let provider = Arc::new(SequenceProvider::new(
+            descriptor,
+            vec![
+                Err(OrdoError::CapabilityInvocation {
+                    capability: "demo.retry".to_string(),
+                    message: "temporary".into(),
+                }),
+                Ok(CapabilityResponse::new(Value::string("recovered"))),
+            ],
+        ));
+        let provider_ref = provider.clone();
+        registry.register(provider);
+
+        let response = registry
+            .invoke(&CapabilityRequest::new("demo.retry", "fetch", Value::Null))
+            .unwrap();
+
+        assert_eq!(response.payload, Value::string("recovered"));
+        assert_eq!(provider_ref.calls.load(Ordering::Relaxed), 2);
+    }
+
+    #[test]
+    fn opens_circuit_after_repeated_failures() {
+        let registry = CapabilityRegistry::new();
+        registry.register(Arc::new(SequenceProvider::new(
+            CapabilityDescriptor::new("demo.breaker", CapabilityCategory::Action).with_config(
+                CapabilityConfig::new(CapabilityCategory::Action).circuit_breaker(
+                    CircuitBreakerConfig {
+                        failure_threshold: 2,
+                        reset_timeout_ms: 1000,
+                    },
+                ),
+            ),
+            vec![
+                Err(OrdoError::CapabilityInvocation {
+                    capability: "demo.breaker".to_string(),
+                    message: "boom".into(),
+                }),
+                Err(OrdoError::CapabilityInvocation {
+                    capability: "demo.breaker".to_string(),
+                    message: "boom".into(),
+                }),
+            ],
+        )));
+
+        assert!(registry
+            .invoke(&CapabilityRequest::new("demo.breaker", "emit", Value::Null))
+            .is_err());
+        assert!(registry
+            .invoke(&CapabilityRequest::new("demo.breaker", "emit", Value::Null))
+            .is_err());
+
+        let error = registry
+            .invoke(&CapabilityRequest::new("demo.breaker", "emit", Value::Null))
+            .unwrap_err();
+        assert!(matches!(error, OrdoError::CircuitOpen { .. }));
+    }
+}
diff --git a/crates/ordo-core/src/context/store.rs b/crates/ordo-core/src/context/store.rs
index 0ff6ef04..1f8c5342 100644
--- a/crates/ordo-core/src/context/store.rs
+++ b/crates/ordo-core/src/context/store.rs
@@ -61,8 +61,12 @@ impl Context {
     /// - `_index`: get the current iteration index (if set)
     pub fn get(&self, path: &str) -> Option<&Value> {
         if let Some(var_name) = path.strip_prefix('$') {
-            // Variable reference
-            self.variables.get(var_name)
+            // Variable reference, with optional nested path access.
+            if let Some((name, nested)) = var_name.split_once('.') {
+                self.variables.get(name)?.get_path(nested)
+            } else {
+                self.variables.get(var_name)
+            }
         } else if let Some(item_path) = path.strip_prefix("item.") {
             // Current iteration item field
             self.current_item.as_ref()?.get_path(item_path)
@@ -178,6 +182,28 @@ mod tests {
         assert_eq!(ctx.get("$score"), None);
     }
 
+    #[test]
+    fn test_context_nested_variable_paths() {
+        let mut ctx = Context::new(Value::Null);
+        ctx.set_variable(
+            "result",
+            Value::object({
+                let mut m = std::collections::HashMap::new();
+                m.insert(
+                    "payload".to_string(),
+                    Value::object({
+                        let mut nested = std::collections::HashMap::new();
+                        nested.insert("score".to_string(), Value::int(7));
+                        nested
+                    }),
+                );
+                m
+            }),
+        );
+
+        assert_eq!(ctx.get("$result.payload.score"), Some(&Value::int(7)));
+    }
+
     #[test]
     fn test_context_item() {
         let mut ctx = Context::new(Value::Null);
diff --git a/crates/ordo-core/src/error.rs b/crates/ordo-core/src/error.rs
index 134aceac..8cd3de57 100644
--- a/crates/ordo-core/src/error.rs
+++ b/crates/ordo-core/src/error.rs
@@ -54,6 +54,24 @@ pub enum OrdoError {
     #[error("RuleSet not found: {name}")]
     RuleSetNotFound { name: String },
 
+    /// Capability not found
+    #[error("Capability not found: {capability}")]
+    CapabilityNotFound { capability: String },
+
+    /// Capability circuit breaker is open
+    #[error("Capability circuit open: {capability}")]
+    CircuitOpen {
+        capability: String,
+        retry_after_ms: Option<u64>,
+    },
+
+    /// Capability invocation failed
+    #[error("Capability invocation failed for {capability}: {message}")]
+    CapabilityInvocation {
+        capability: String,
+        message: Cow<'static, str>,
+    },
+
     /// Step not found
     #[error("Step not found: {step_id}")]
     StepNotFound { step_id: String },
@@ -171,6 +189,17 @@ impl OrdoError {
         }
     }
 
+    /// Create a capability invocation error
+    pub fn capability_invocation(
+        capability: impl Into<String>,
+        message: impl Into<Cow<'static, str>>,
+    ) -> Self {
+        Self::CapabilityInvocation {
+            capability: capability.into(),
+            message: message.into(),
+        }
+    }
+
     /// Create an internal error from a static string (no allocation)
     #[inline]
     pub fn internal_error_static(message: &'static str) -> Self {
diff --git a/crates/ordo-core/src/lib.rs b/crates/ordo-core/src/lib.rs
index 2c5a243e..ef59ae15 100644
--- a/crates/ordo-core/src/lib.rs
+++ b/crates/ordo-core/src/lib.rs
@@ -50,6 +50,7 @@
 #![allow(missing_docs)]
 #![warn(clippy::all)]
 
+pub mod capability;
 pub mod context;
 pub mod error;
 pub mod expr;
@@ -62,6 +63,11 @@ pub mod trace;
 
 /// Prelude module for convenient imports
 pub mod prelude {
+    pub use crate::capability::{
+        CapabilityCategory, CapabilityConfig, CapabilityDescriptor, CapabilityInvoker,
+        CapabilityProvider, CapabilityRegistry, CapabilityRequest, CapabilityResponse,
+        CircuitBreakerConfig, RetryPolicy,
+    };
     pub use crate::context::{Context, Value};
     pub use crate::error::{OrdoError, Result};
     pub use crate::expr::{
diff --git a/crates/ordo-core/src/rule/compiled_executor.rs b/crates/ordo-core/src/rule/compiled_executor.rs
index d823cdfc..e5afba22 100644
--- a/crates/ordo-core/src/rule/compiled_executor.rs
+++ b/crates/ordo-core/src/rule/compiled_executor.rs
@@ -5,6 +5,7 @@ use super::compiled::{
 };
 use super::metrics::{MetricSink, NoOpMetricSink};
 use super::{ExecutionResult, TerminalResult};
+use crate::capability::{CapabilityInvoker, CapabilityRequest};
 use crate::context::{Context, IString, Value};
 use crate::error::{OrdoError, Result};
 use crate::expr::BytecodeVM;
@@ -36,6 +37,7 @@ use wasm_time::Instant;
 pub struct CompiledRuleExecutor {
     vm: BytecodeVM,
     metric_sink: Arc<dyn MetricSink>,
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
 }
 
 impl Default for CompiledRuleExecutor {
@@ -49,6 +51,7 @@ impl CompiledRuleExecutor {
         Self {
             vm: BytecodeVM::new(),
             metric_sink: Arc::new(NoOpMetricSink),
+            capability_invoker: None,
         }
     }
 
@@ -56,9 +59,18 @@ impl CompiledRuleExecutor {
         Self {
             vm: BytecodeVM::new(),
             metric_sink,
+            capability_invoker: None,
         }
     }
 
+    pub fn set_capability_invoker(&mut self, capability_invoker: Arc<dyn CapabilityInvoker>) {
+        self.capability_invoker = Some(capability_invoker);
+    }
+
+    pub fn capability_invoker(&self) -> Option<Arc<dyn CapabilityInvoker>> {
+        self.capability_invoker.clone()
+    }
+
     pub fn execute(&self, ruleset: &CompiledRuleSet, input: Value) -> Result<ExecutionResult> {
         let start_time = Instant::now();
         let mut ctx = Context::new(input);
@@ -234,12 +246,38 @@ impl CompiledRuleExecutor {
                         ))
                     })
                     .collect::<Result<Vec<(String, String)>>>()?;
-                self.metric_sink.record_gauge(name, metric_value, &tags);
+                self.record_metric(name, metric_value, &tags)?;
             }
         }
         Ok(())
     }
 
+    fn record_metric(&self, name: &str, value: f64, tags: &[(String, String)]) -> Result<()> {
+        if let Some(capability_invoker) = &self.capability_invoker {
+            let mut tag_values = std::collections::HashMap::with_capacity(tags.len());
+            for (key, value) in tags {
+                tag_values.insert(key.clone(), Value::string(value));
+            }
+
+            let mut payload = std::collections::HashMap::with_capacity(3);
+            payload.insert("name".to_string(), Value::string(name));
+            payload.insert("value".to_string(), Value::float(value));
+            payload.insert("tags".to_string(), Value::object(tag_values));
+
+            let request =
+                CapabilityRequest::new("metrics.prometheus", "gauge", Value::object(payload));
+
+            match capability_invoker.invoke(&request) {
+                Ok(_) => return Ok(()),
+                Err(OrdoError::CapabilityNotFound { .. }) => {}
+                Err(error) => return Err(error),
+            }
+        }
+
+        self.metric_sink.record_gauge(name, value, tags);
+        Ok(())
+    }
+
     fn build_output(
         &self,
         ruleset: &CompiledRuleSet,
@@ -273,3 +311,82 @@ impl CompiledRuleExecutor {
         Ok(Value::object_optimized(output))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::capability::{
+        CapabilityCategory, CapabilityDescriptor, CapabilityProvider, CapabilityRegistry,
+        CapabilityResponse,
+    };
+    use crate::expr::Expr;
+    use crate::rule::metrics::MetricSink;
+    use crate::rule::{Action, ActionKind, RuleSet, RuleSetCompiler, Step, TerminalResult};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    struct TestMetricSink {
+        gauge_calls: AtomicUsize,
+    }
+
+    impl MetricSink for TestMetricSink {
+        fn record_gauge(&self, _name: &str, _value: f64, _tags: &[(String, String)]) {
+            self.gauge_calls.fetch_add(1, Ordering::SeqCst);
+        }
+
+        fn record_counter(&self, _name: &str, _value: f64, _tags: &[(String, String)]) {}
+    }
+
+    struct TestMetricCapability {
+        calls: AtomicUsize,
+    }
+
+    impl CapabilityProvider for TestMetricCapability {
+        fn descriptor(&self) -> CapabilityDescriptor {
+            CapabilityDescriptor::new("metrics.prometheus", CapabilityCategory::Action)
+        }
+
+        fn invoke(&self, _request: &CapabilityRequest) -> Result<CapabilityResponse> {
+            self.calls.fetch_add(1, Ordering::SeqCst);
+            Ok(CapabilityResponse::empty())
+        }
+    }
+
+    #[test]
+    fn compiled_executor_prefers_capability_metrics_when_available() {
+        let mut ruleset = RuleSet::new("compiled_metric_test", "record_metric");
+        ruleset.add_step(Step::action(
+            "record_metric",
+            "Record Metric",
+            vec![Action {
+                kind: ActionKind::Metric {
+                    name: "compiled_metric".to_string(),
+                    value: Expr::literal(9.0f64),
+                    tags: vec![("env".to_string(), "test".to_string())],
+                },
+                description: String::new(),
+            }],
+            "done",
+        ));
+        ruleset.add_step(Step::terminal("done", "Done", TerminalResult::new("OK")));
+        let compiled = RuleSetCompiler::compile(&ruleset).unwrap();
+
+        let sink = Arc::new(TestMetricSink {
+            gauge_calls: AtomicUsize::new(0),
+        });
+        let mut executor = CompiledRuleExecutor::with_metric_sink(sink.clone());
+        let registry = Arc::new(CapabilityRegistry::new());
+        let capability = Arc::new(TestMetricCapability {
+            calls: AtomicUsize::new(0),
+        });
+        let capability_ref = capability.clone();
+        registry.register(capability);
+        executor.set_capability_invoker(registry);
+
+        let input = serde_json::from_str(r#"{}"#).unwrap();
+        let result = executor.execute(&compiled, input).unwrap();
+
+        assert_eq!(result.code, "OK");
+        assert_eq!(capability_ref.calls.load(Ordering::SeqCst), 1);
+        assert_eq!(sink.gauge_calls.load(Ordering::SeqCst), 0);
+    }
+}
diff --git a/crates/ordo-core/src/rule/executor.rs b/crates/ordo-core/src/rule/executor.rs
index e7c3dde5..4815b9c4 100644
--- a/crates/ordo-core/src/rule/executor.rs
+++ b/crates/ordo-core/src/rule/executor.rs
@@ -5,6 +5,7 @@
 use super::metrics::{MetricSink, NoOpMetricSink};
 use super::model::{FieldMissingBehavior, RuleSet};
 use super::step::{ActionKind, Condition, LogLevel, Step, StepKind, TerminalResult};
+use crate::capability::{CapabilityInvoker, CapabilityRequest};
 use crate::context::{Context, Value};
 use crate::error::{OrdoError, Result};
 use crate::expr::{Evaluator, ExprParser};
@@ -90,6 +91,8 @@ pub struct RuleExecutor {
     metric_sink: Arc<dyn MetricSink>,
     /// Optional resolver for CallRuleSet actions
     resolver: Option<Arc<dyn super::RuleSetResolver>>,
+    /// Optional capability invoker for ExternalCall actions
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
     /// Maximum nesting depth for CallRuleSet (prevents unbounded recursion)
     max_call_depth: usize,
 }
@@ -101,6 +104,9 @@ impl Default for RuleExecutor {
 }
 
 impl RuleExecutor {
+    const METRIC_CAPABILITY: &'static str = "metrics.prometheus";
+    const METRIC_OPERATION_GAUGE: &'static str = "gauge";
+
     /// Create a new executor
     pub fn new() -> Self {
         Self {
@@ -108,6 +114,7 @@ impl RuleExecutor {
             trace_config: TraceConfig::default(),
             metric_sink: Arc::new(NoOpMetricSink),
             resolver: None,
+            capability_invoker: None,
             max_call_depth: 10,
         }
     }
@@ -119,6 +126,7 @@ impl RuleExecutor {
             trace_config,
             metric_sink: Arc::new(NoOpMetricSink),
             resolver: None,
+            capability_invoker: None,
             max_call_depth: 10,
         }
     }
@@ -130,6 +138,7 @@ impl RuleExecutor {
             trace_config: TraceConfig::default(),
             metric_sink,
             resolver: None,
+            capability_invoker: None,
             max_call_depth: 10,
         }
     }
@@ -144,6 +153,7 @@ impl RuleExecutor {
             trace_config,
             metric_sink,
             resolver: None,
+            capability_invoker: None,
             max_call_depth: 10,
         }
     }
@@ -153,6 +163,16 @@ impl RuleExecutor {
         self.resolver = Some(resolver);
     }
 
+    /// Set an invoker for ExternalCall actions
+    pub fn set_capability_invoker(&mut self, capability_invoker: Arc<dyn CapabilityInvoker>) {
+        self.capability_invoker = Some(capability_invoker);
+    }
+
+    /// Get the configured capability invoker
+    pub fn capability_invoker(&self) -> Option<Arc<dyn CapabilityInvoker>> {
+        self.capability_invoker.clone()
+    }
+
     /// Get the metric sink
     pub fn metric_sink(&self) -> &Arc<dyn MetricSink> {
         &self.metric_sink
@@ -544,8 +564,7 @@ impl RuleExecutor {
                         return Ok(());
                     }
                 };
-                // Record metric via sink
-                self.metric_sink.record_gauge(name, metric_value, tags);
+                self.record_metric(name, metric_value, tags)?;
                 tracing::debug!(metric = %name, value = %metric_value, tags = ?tags, "Metric recorded");
             }
 
@@ -599,11 +618,78 @@ impl RuleExecutor {
                 ctx.set_variable(result_variable, result_obj);
             }
 
-            ActionKind::ExternalCall { .. } => {
-                // TODO: Implement external calls
-                tracing::warn!("External calls not yet implemented");
+            ActionKind::ExternalCall {
+                service,
+                method,
+                params,
+                result_variable,
+                timeout_ms,
+            } => {
+                let capability_invoker = self.capability_invoker.as_ref().ok_or_else(|| {
+                    OrdoError::eval_error("ExternalCall requires a capability invoker")
+                })?;
+
+                let mut payload = std::collections::HashMap::with_capacity(params.len());
+                for (name, expr) in params {
+                    payload.insert(name.clone(), self.evaluator.eval(expr, ctx)?);
+                }
+
+                let mut request =
+                    CapabilityRequest::new(service.clone(), method.clone(), Value::object(payload));
+                if *timeout_ms > 0 {
+                    request = request.with_timeout(*timeout_ms);
+                }
+
+                let response = capability_invoker.invoke(&request)?;
+                if let Some(result_variable) = result_variable {
+                    let response_obj = Value::object({
+                        let mut m = std::collections::HashMap::new();
+                        m.insert("capability".to_string(), Value::string(service));
+                        m.insert("operation".to_string(), Value::string(method));
+                        m.insert("payload".to_string(), response.payload);
+                        let metadata = Value::object(
+                            response
+                                .metadata
+                                .into_iter()
+                                .map(|(key, value)| (key, Value::string(value)))
+                                .collect(),
+                        );
+                        m.insert("metadata".to_string(), metadata);
+                        m
+                    });
+                    ctx.set_variable(result_variable, response_obj);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn record_metric(&self, name: &str, value: f64, tags: &[(String, String)]) -> Result<()> {
+        if let Some(capability_invoker) = &self.capability_invoker {
+            let mut tag_values = std::collections::HashMap::with_capacity(tags.len());
+            for (key, value) in tags {
+                tag_values.insert(key.clone(), Value::string(value));
+            }
+
+            let mut payload = std::collections::HashMap::with_capacity(3);
+            payload.insert("name".to_string(), Value::string(name));
+            payload.insert("value".to_string(), Value::float(value));
+            payload.insert("tags".to_string(), Value::object(tag_values));
+
+            let request = CapabilityRequest::new(
+                Self::METRIC_CAPABILITY,
+                Self::METRIC_OPERATION_GAUGE,
+                Value::object(payload),
+            );
+
+            match capability_invoker.invoke(&request) {
+                Ok(_) => return Ok(()),
+                Err(OrdoError::CapabilityNotFound { .. }) => {}
+                Err(error) => return Err(error),
             }
         }
+
+        self.metric_sink.record_gauge(name, value, tags);
         Ok(())
     }
 
@@ -867,6 +953,79 @@ mod tests {
         assert_eq!(sink.gauge_calls.load(Ordering::SeqCst), 1);
     }
 
+    #[test]
+    fn test_execute_metric_via_capability_invoker() {
+        use crate::capability::{
+            CapabilityCategory, CapabilityDescriptor, CapabilityProvider, CapabilityRegistry,
+            CapabilityRequest, CapabilityResponse,
+        };
+        use crate::rule::metrics::MetricSink;
+        use crate::rule::step::{Action, ActionKind};
+        use std::sync::atomic::{AtomicUsize, Ordering};
+
+        struct TestMetricSink {
+            gauge_calls: AtomicUsize,
+        }
+
+        impl MetricSink for TestMetricSink {
+            fn record_gauge(&self, _name: &str, _value: f64, _tags: &[(String, String)]) {
+                self.gauge_calls.fetch_add(1, Ordering::SeqCst);
+            }
+
+            fn record_counter(&self, _name: &str, _value: f64, _tags: &[(String, String)]) {}
+        }
+
+        struct TestMetricCapability {
+            calls: AtomicUsize,
+        }
+
+        impl CapabilityProvider for TestMetricCapability {
+            fn descriptor(&self) -> CapabilityDescriptor {
+                CapabilityDescriptor::new("metrics.prometheus", CapabilityCategory::Action)
+            }
+
+            fn invoke(&self, _request: &CapabilityRequest) -> Result<CapabilityResponse> {
+                self.calls.fetch_add(1, Ordering::SeqCst);
+                Ok(CapabilityResponse::empty())
+            }
+        }
+
+        let sink = Arc::new(TestMetricSink {
+            gauge_calls: AtomicUsize::new(0),
+        });
+        let mut executor = RuleExecutor::with_metric_sink(sink.clone());
+        let registry = Arc::new(CapabilityRegistry::new());
+        let capability = Arc::new(TestMetricCapability {
+            calls: AtomicUsize::new(0),
+        });
+        let capability_ref = capability.clone();
+        registry.register(capability);
+        executor.set_capability_invoker(registry);
+
+        let mut ruleset = RuleSet::new("metric_capability_test", "record_metric");
+        ruleset.add_step(Step::action(
+            "record_metric",
+            "Record Metric",
+            vec![Action {
+                kind: ActionKind::Metric {
+                    name: "cap_metric".to_string(),
+                    value: Expr::literal(7.0f64),
+                    tags: vec![("env".to_string(), "test".to_string())],
+                },
+                description: String::new(),
+            }],
+            "done",
+        ));
+        ruleset.add_step(Step::terminal("done", "Done", TerminalResult::new("OK")));
+
+        let input = serde_json::from_str(r#"{}"#).unwrap();
+        let result = executor.execute(&ruleset, input).unwrap();
+
+        assert_eq!(result.code, "OK");
+        assert_eq!(capability_ref.calls.load(Ordering::SeqCst), 1);
+        assert_eq!(sink.gauge_calls.load(Ordering::SeqCst), 0);
+    }
+
     #[test]
     fn test_execute_batch_sequential() {
         let ruleset = create_test_ruleset();
diff --git a/crates/ordo-core/src/rule/step.rs b/crates/ordo-core/src/rule/step.rs
index 6b88b2b9..023a2502 100644
--- a/crates/ordo-core/src/rule/step.rs
+++ b/crates/ordo-core/src/rule/step.rs
@@ -332,11 +332,13 @@ pub enum ActionKind {
     },
 
     /// External call (future)
-    #[serde(skip)]
     ExternalCall {
         service: String,
         method: String,
         params: Vec<(String, Expr)>,
+        #[serde(default)]
+        result_variable: Option<String>,
+        #[serde(default)]
         timeout_ms: u64,
     },
 }
diff --git a/crates/ordo-server/Cargo.toml b/crates/ordo-server/Cargo.toml
index 5fd06dcf..ba75f99b 100644
--- a/crates/ordo-server/Cargo.toml
+++ b/crates/ordo-server/Cargo.toml
@@ -14,6 +14,7 @@ once_cell = "1.19"
 ordo-core = { version = "0.4.2", path = "../ordo-core" }
 ordo-proto = { version = "0.4.2", path = "../ordo-proto" }
 parking_lot.workspace = true
+hashbrown.workspace = true
 prost.workspace = true
 rand = "0.8"
 rayon.workspace = true
diff --git a/crates/ordo-server/src/api.rs b/crates/ordo-server/src/api.rs
index 8486b306..ac6f4d7c 100644
--- a/crates/ordo-server/src/api.rs
+++ b/crates/ordo-server/src/api.rs
@@ -14,6 +14,7 @@ use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Instant;
 
+use crate::capability_registry::emit_rule_execution_audit;
 use crate::error::ApiError;
 use crate::json::SimdJson;
 use crate::metrics;
@@ -486,9 +487,14 @@ pub async fn execute_ruleset(
             // Log audit event (with sampling)
             let source_ip = connect_info.map(|ci| ci.0.ip().to_string());
             let rule_id = format!("{}/{}", tenant.id, name);
-            state
-                .audit_logger
-                .log_execution(&rule_id, result.duration_us, &result.code, source_ip);
+            emit_rule_execution_audit(
+                state.executor.capability_invoker(),
+                &state.audit_logger,
+                &rule_id,
+                result.duration_us,
+                &result.code,
+                source_ip,
+            );
 
             result
         }
@@ -504,7 +510,9 @@ pub async fn execute_ruleset(
             // Log audit event for errors (with sampling)
             let source_ip = connect_info.map(|ci| ci.0.ip().to_string());
             let rule_id = format!("{}/{}", tenant.id, name);
-            state.audit_logger.log_execution(
+            emit_rule_execution_audit(
+                state.executor.capability_invoker(),
+                &state.audit_logger,
                 &rule_id,
                 start.elapsed().as_micros() as u64,
                 "error",
@@ -1437,6 +1445,9 @@ pub async fn execute_pipeline(
     let mut pipeline_executor =
         RuleExecutor::with_trace_and_metrics(TraceConfig::minimal(), state.metric_sink.clone());
     pipeline_executor.set_resolver(Arc::new(snapshot));
+    if let Some(capability_invoker) = state.executor.capability_invoker() {
+        pipeline_executor.set_capability_invoker(capability_invoker);
+    }
 
     let mut current_input = request.input;
     let mut stages = Vec::with_capacity(resolved.len());
diff --git a/crates/ordo-server/src/api_integration_tests.rs b/crates/ordo-server/src/api_integration_tests.rs
index d9b3ed36..00d34c6c 100644
--- a/crates/ordo-server/src/api_integration_tests.rs
+++ b/crates/ordo-server/src/api_integration_tests.rs
@@ -27,6 +27,7 @@ use tower_http::trace::TraceLayer;
 use crate::{
     api,
     audit::AuditLogger,
+    capability_registry::build_server_executor,
     debug::DebugSessionManager,
     metrics::PrometheusMetricSink,
     middleware,
@@ -36,14 +37,13 @@ use crate::{
     tenant::{TenantDefaults, TenantManager},
     AppState, ServerConfig,
 };
-use ordo_core::prelude::RuleExecutor;
 
 /// Build a full test app with all API routes and middleware (matching main.rs router).
 async fn build_full_test_app() -> Router {
     let store = Arc::new(RwLock::new(RuleStore::new()));
-    let executor = Arc::new(RuleExecutor::new());
     let metric_sink = Arc::new(PrometheusMetricSink::new());
     let audit_logger = Arc::new(AuditLogger::new(None, 10));
+    let executor = build_server_executor(metric_sink.clone(), Some(audit_logger.clone()));
     let debug_sessions = Arc::new(DebugSessionManager::new());
     let defaults = TenantDefaults {
         default_qps_limit: None,
diff --git a/crates/ordo-server/src/api_tests.rs b/crates/ordo-server/src/api_tests.rs
index 0b1bf4ac..7e9d6fc2 100644
--- a/crates/ordo-server/src/api_tests.rs
+++ b/crates/ordo-server/src/api_tests.rs
@@ -16,6 +16,7 @@ use tower_http::trace::TraceLayer;
 use crate::{
     api,
     audit::AuditLogger,
+    capability_registry::build_server_executor,
     debug::DebugSessionManager,
     metrics::PrometheusMetricSink,
     middleware,
@@ -25,13 +26,12 @@ use crate::{
     tenant::{TenantDefaults, TenantManager},
     AppState, ServerConfig,
 };
-use ordo_core::prelude::RuleExecutor;
 
 async fn build_test_app() -> Router {
     let store = Arc::new(RwLock::new(RuleStore::new()));
-    let executor = Arc::new(RuleExecutor::new());
     let metric_sink = Arc::new(PrometheusMetricSink::new());
     let audit_logger = Arc::new(AuditLogger::new(None, 0));
+    let executor = build_server_executor(metric_sink.clone(), Some(audit_logger.clone()));
     let debug_sessions = Arc::new(DebugSessionManager::new());
     let defaults = TenantDefaults {
         default_qps_limit: None,
@@ -372,9 +372,9 @@ async fn test_admin_reload_with_persistence() {
     let store = Arc::new(RwLock::new(RuleStore::new_with_persistence(
         dir.path().to_path_buf(),
     )));
-    let executor = Arc::new(RuleExecutor::new());
     let metric_sink = Arc::new(PrometheusMetricSink::new());
     let audit_logger = Arc::new(AuditLogger::new(None, 0));
+    let executor = build_server_executor(metric_sink.clone(), Some(audit_logger.clone()));
     let debug_sessions = Arc::new(DebugSessionManager::new());
     let defaults = TenantDefaults {
         default_qps_limit: None,
diff --git a/crates/ordo-server/src/capability_registry.rs b/crates/ordo-server/src/capability_registry.rs
new file mode 100644
index 00000000..a0dbb58c
--- /dev/null
+++ b/crates/ordo-server/src/capability_registry.rs
@@ -0,0 +1,576 @@
+use crate::audit::AuditLogger;
+use crate::metrics::PrometheusMetricSink;
+use ordo_core::context::Value;
+use ordo_core::prelude::{
+    CapabilityCategory, CapabilityConfig, CapabilityDescriptor, CapabilityInvoker,
+    CapabilityProvider, CapabilityRegistry, CapabilityRequest, CapabilityResponse, MetricSink,
+    OrdoError, Result, RuleExecutor, TraceConfig,
+};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+
+/// Server-side runtime registry wrapper that adds tracing around capability calls.
+#[derive(Default)]
+pub struct ServerCapabilityRegistry {
+    inner: CapabilityRegistry,
+}
+
+impl ServerCapabilityRegistry {
+    #[inline]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    #[inline]
+    pub fn register(
+        &self,
+        provider: Arc<dyn CapabilityProvider>,
+    ) -> Option<Arc<dyn CapabilityProvider>> {
+        self.inner.register(provider)
+    }
+
+    pub fn register_metric_sink(&self, sink: Arc<PrometheusMetricSink>) {
+        self.register(Arc::new(PrometheusMetricCapability { sink }));
+    }
+
+    pub fn register_audit_logger(&self, audit_logger: Arc<AuditLogger>) {
+        self.register(Arc::new(AuditCapability { audit_logger }));
+    }
+
+    pub fn register_http_client(&self) {
+        self.register(Arc::new(HttpCapability::new()));
+    }
+}
+
+impl CapabilityInvoker for ServerCapabilityRegistry {
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+        let span = tracing::info_span!(
+            "capability.invoke",
+            capability = %request.capability,
+            operation = %request.operation
+        );
+        let _guard = span.enter();
+        self.inner.invoke(request)
+    }
+
+    fn describe(&self, capability: &str) -> Option<CapabilityDescriptor> {
+        self.inner.describe(capability)
+    }
+}
+
+pub fn build_server_capability_invoker(
+    metric_sink: Arc<PrometheusMetricSink>,
+    audit_logger: Option<Arc<AuditLogger>>,
+) -> Arc<dyn CapabilityInvoker> {
+    let registry = Arc::new(ServerCapabilityRegistry::new());
+    registry.register_http_client();
+    registry.register_metric_sink(metric_sink);
+    if let Some(audit_logger) = audit_logger {
+        registry.register_audit_logger(audit_logger);
+    }
+    registry
+}
+
+pub fn build_rule_executor(
+    metric_sink: Arc<dyn MetricSink>,
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+) -> RuleExecutor {
+    let mut executor = RuleExecutor::with_trace_and_metrics(TraceConfig::minimal(), metric_sink);
+    if let Some(capability_invoker) = capability_invoker {
+        executor.set_capability_invoker(capability_invoker);
+    }
+    executor
+}
+
+#[cfg(test)]
+pub fn build_server_executor(
+    metric_sink: Arc<PrometheusMetricSink>,
+    audit_logger: Option<Arc<AuditLogger>>,
+) -> Arc<RuleExecutor> {
+    let capability_invoker = build_server_capability_invoker(metric_sink.clone(), audit_logger);
+    let metric_sink_trait: Arc<dyn MetricSink> = metric_sink;
+    Arc::new(build_rule_executor(
+        metric_sink_trait,
+        Some(capability_invoker),
+    ))
+}
+
+pub fn emit_rule_execution_audit(
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+    audit_logger: &AuditLogger,
+    rule_name: &str,
+    duration_us: u64,
+    result: &str,
+    source_ip: Option<String>,
+) {
+    if let Some(capability_invoker) = capability_invoker {
+        let payload = Value::object({
+            let mut m = std::collections::HashMap::new();
+            m.insert("rule_name".to_string(), Value::string(rule_name));
+            m.insert("duration_us".to_string(), Value::int(duration_us as i64));
+            m.insert("result".to_string(), Value::string(result));
+            if let Some(source_ip) = &source_ip {
+                m.insert("source_ip".to_string(), Value::string(source_ip));
+            }
+            m
+        });
+        let request = CapabilityRequest::new("audit.logger", "rule_executed", payload);
+        match capability_invoker.invoke(&request) {
+            Ok(_) => return,
+            Err(OrdoError::CapabilityNotFound { .. }) => {}
+            Err(error) => {
+                tracing::warn!(rule = %rule_name, error = %error, "Audit capability invocation failed, falling back to direct logger");
+            }
+        }
+    }
+
+    audit_logger.log_execution(rule_name, duration_us, result, source_ip);
+}
+
+pub fn invoke_http_json(
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+    method: &str,
+    url: &str,
+    headers: HashMap<String, String>,
+    json_body: &serde_json::Value,
+    timeout_ms: Option<u64>,
+) -> Result<Option<CapabilityResponse>> {
+    let Some(capability_invoker) = capability_invoker else {
+        return Ok(None);
+    };
+
+    let mut payload = std::collections::HashMap::new();
+    payload.insert("url".to_string(), Value::string(url));
+    payload.insert(
+        "headers".to_string(),
+        Value::object(
+            headers
+                .into_iter()
+                .map(|(key, value)| (key, Value::string(value)))
+                .collect(),
+        ),
+    );
+    let body = serde_json::from_value(json_body.clone()).map_err(|error| {
+        OrdoError::capability_invocation("network.http", format!("invalid json body: {}", error))
+    })?;
+    payload.insert("json_body".to_string(), body);
+
+    let mut request = CapabilityRequest::new(
+        "network.http",
+        method.to_ascii_lowercase(),
+        Value::object(payload),
+    );
+    if let Some(timeout_ms) = timeout_ms {
+        request = request.with_timeout(timeout_ms);
+    }
+
+    match capability_invoker.invoke(&request) {
+        Ok(response) => Ok(Some(response)),
+        Err(OrdoError::CapabilityNotFound { .. }) => Ok(None),
+        Err(error) => Err(error),
+    }
+}
+
+pub fn http_response_status(response: &CapabilityResponse) -> Option<u16> {
+    match response.payload.get_path("status") {
+        Some(Value::Int(status)) => (*status).try_into().ok(),
+        _ => None,
+    }
+}
+
+struct PrometheusMetricCapability {
+    sink: Arc<PrometheusMetricSink>,
+}
+
+impl CapabilityProvider for PrometheusMetricCapability {
+    fn descriptor(&self) -> CapabilityDescriptor {
+        CapabilityDescriptor::new("metrics.prometheus", CapabilityCategory::Action)
+            .with_description("Bridge capability calls into the Prometheus rule metric sink")
+            .with_config(CapabilityConfig::new(CapabilityCategory::Action))
+    }
+
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+        let payload = expect_object(&request.payload, "metrics.prometheus")?;
+        let name = required_string(payload, "name", "metrics.prometheus")?;
+        let value = required_number(payload, "value", "metrics.prometheus")?;
+        let tags = optional_tags(payload, "tags", "metrics.prometheus")?;
+
+        match request.operation.as_str() {
+            "counter" => self.sink.record_counter(name, value, &tags),
+            "gauge" => self.sink.record_gauge(name, value, &tags),
+            other => {
+                return Err(OrdoError::capability_invocation(
+                    "metrics.prometheus",
+                    format!("unsupported operation '{}'", other),
+                ));
+            }
+        }
+
+        Ok(CapabilityResponse::empty()
+            .with_metadata("metric", name.to_string())
+            .with_metadata("operation", request.operation.clone()))
+    }
+}
+
+struct AuditCapability {
+    audit_logger: Arc<AuditLogger>,
+}
+
+impl CapabilityProvider for AuditCapability {
+    fn descriptor(&self) -> CapabilityDescriptor {
+        CapabilityDescriptor::new("audit.logger", CapabilityCategory::Action)
+            .with_description("Bridge capability calls into the structured audit logger")
+            .with_config(CapabilityConfig::new(CapabilityCategory::Action))
+    }
+
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+        let payload = expect_object(&request.payload, "audit.logger")?;
+        match request.operation.as_str() {
+            "rule_executed" => {
+                let rule_name = required_string(payload, "rule_name", "audit.logger")?;
+                let duration_us = required_i64(payload, "duration_us", "audit.logger")?;
+                let result = required_string(payload, "result", "audit.logger")?;
+                let source_ip = optional_string(payload, "source_ip");
+                self.audit_logger.log_execution(
+                    rule_name,
+                    duration_us.max(0) as u64,
+                    result,
+                    source_ip,
+                );
+                Ok(CapabilityResponse::empty()
+                    .with_metadata("event", "rule_executed")
+                    .with_metadata("rule_name", rule_name.to_string()))
+            }
+            other => Err(OrdoError::capability_invocation(
+                "audit.logger",
+                format!("unsupported operation '{}'", other),
+            )),
+        }
+    }
+}
+
+struct HttpCapability {
+    client: reqwest::Client,
+}
+
+impl HttpCapability {
+    fn new() -> Self {
+        let client = reqwest::Client::builder()
+            .timeout(Duration::from_secs(10))
+            .connect_timeout(Duration::from_secs(5))
+            .build()
+            .unwrap_or_else(|_| reqwest::Client::new());
+        Self { client }
+    }
+}
+
+impl CapabilityProvider for HttpCapability {
+    fn descriptor(&self) -> CapabilityDescriptor {
+        CapabilityDescriptor::new("network.http", CapabilityCategory::Network)
+            .with_description("Issue outbound HTTP requests through a capability provider")
+            .with_config(CapabilityConfig::new(CapabilityCategory::Network).timeout(10_000))
+    }
+
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+        let payload = expect_object(&request.payload, "network.http")?;
+        let url = required_string(payload, "url", "network.http")?;
+        let method = request
+            .operation
+            .parse::<reqwest::Method>()
+            .map_err(|error| {
+                OrdoError::capability_invocation(
+                    "network.http",
+                    format!("invalid method '{}': {}", request.operation, error),
+                )
+            })?;
+        let headers = optional_tags(payload, "headers", "network.http")?;
+
+        let json_body = payload
+            .get("json_body")
+            .map(|body| {
+                serde_json::to_value(body).map_err(|error| {
+                    OrdoError::capability_invocation(
+                        "network.http",
+                        format!("failed to serialize request body: {}", error),
+                    )
+                })
+            })
+            .transpose()?;
+        let (status, body_text) = execute_http_request(
+            self.client.clone(),
+            method,
+            url.to_string(),
+            headers,
+            json_body,
+            request.timeout_ms,
+        )?;
+
+        let mut payload = std::collections::HashMap::new();
+        payload.insert("status".to_string(), Value::int(status as i64));
+        payload.insert("body".to_string(), Value::string(&body_text));
+        if let Ok(json_body) = serde_json::from_str::<serde_json::Value>(&body_text) {
+            let json_body = serde_json::from_value(json_body).map_err(|error| {
+                OrdoError::capability_invocation(
+                    "network.http",
+                    format!("failed to convert response body: {}", error),
+                )
+            })?;
+            payload.insert("json_body".to_string(), json_body);
+        }
+
+        Ok(CapabilityResponse::new(Value::object(payload))
+            .with_metadata("status", status.to_string()))
+    }
+}
+
+fn execute_http_request(
+    client: reqwest::Client,
+    method: reqwest::Method,
+    url: String,
+    headers: Vec<(String, String)>,
+    json_body: Option<serde_json::Value>,
+    timeout_ms: Option<u64>,
+) -> Result<(u16, String)> {
+    async fn send(
+        client: reqwest::Client,
+        method: reqwest::Method,
+        url: String,
+        headers: Vec<(String, String)>,
+        json_body: Option<serde_json::Value>,
+        timeout_ms: Option<u64>,
+    ) -> std::result::Result<(u16, String), reqwest::Error> {
+        let mut builder = client.request(method, url);
+        if let Some(timeout_ms) = timeout_ms {
+            builder = builder.timeout(Duration::from_millis(timeout_ms));
+        }
+        for (name, value) in headers {
+            builder = builder.header(name, value);
+        }
+        if let Some(json_body) = json_body {
+            builder = builder.json(&json_body);
+        }
+        let response = builder.send().await?;
+        let status = response.status().as_u16();
+        let body = response.text().await.unwrap_or_default();
+        Ok((status, body))
+    }
+
+    let current = tokio::runtime::Handle::try_current();
+    match current {
+        Ok(handle) => match handle.runtime_flavor() {
+            tokio::runtime::RuntimeFlavor::MultiThread => tokio::task::block_in_place(|| {
+                handle.block_on(send(client, method, url, headers, json_body, timeout_ms))
+            })
+            .map_err(|error| OrdoError::capability_invocation("network.http", error.to_string())),
+            tokio::runtime::RuntimeFlavor::CurrentThread | _ => std::thread::spawn(move || {
+                let runtime = tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()
+                    .map_err(|error| {
+                        OrdoError::capability_invocation(
+                            "network.http",
+                            format!("failed to build runtime: {}", error),
+                        )
+                    })?;
+                runtime
+                    .block_on(send(client, method, url, headers, json_body, timeout_ms))
+                    .map_err(|error| {
+                        OrdoError::capability_invocation("network.http", error.to_string())
+                    })
+            })
+            .join()
+            .map_err(|_| {
+                OrdoError::capability_invocation("network.http", "http worker thread panicked")
+            })?,
+        },
+        Err(_) => {
+            let runtime = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .map_err(|error| {
+                    OrdoError::capability_invocation(
+                        "network.http",
+                        format!("failed to build runtime: {}", error),
+                    )
+                })?;
+            runtime
+                .block_on(send(client, method, url, headers, json_body, timeout_ms))
+                .map_err(|error| {
+                    OrdoError::capability_invocation("network.http", error.to_string())
+                })
+        }
+    }
+}
+
+fn expect_object<'a>(
+    value: &'a Value,
+    capability: &str,
+) -> Result<&'a hashbrown::HashMap<ordo_core::context::IString, Value>> {
+    value.as_object().ok_or_else(|| {
+        OrdoError::capability_invocation(capability, "expected object payload for capability")
+    })
+}
+
+fn required_string<'a>(
+    object: &'a hashbrown::HashMap<ordo_core::context::IString, Value>,
+    field: &str,
+    capability: &str,
+) -> Result<&'a str> {
+    object
+        .get(field)
+        .and_then(Value::as_str)
+        .ok_or_else(|| OrdoError::capability_invocation(capability, format!("missing '{}'", field)))
+}
+
+fn optional_string(
+    object: &hashbrown::HashMap<ordo_core::context::IString, Value>,
+    field: &str,
+) -> Option<String> {
+    object
+        .get(field)
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+fn required_number(
+    object: &hashbrown::HashMap<ordo_core::context::IString, Value>,
+    field: &str,
+    capability: &str,
+) -> Result<f64> {
+    match object.get(field) {
+        Some(Value::Int(value)) => Ok(*value as f64),
+        Some(Value::Float(value)) => Ok(*value),
+        Some(Value::Bool(value)) => Ok(if *value { 1.0 } else { 0.0 }),
+        _ => Err(OrdoError::capability_invocation(
+            capability,
+            format!("field '{}' must be numeric", field),
+        )),
+    }
+}
+
+fn required_i64(
+    object: &hashbrown::HashMap<ordo_core::context::IString, Value>,
+    field: &str,
+    capability: &str,
+) -> Result<i64> {
+    match object.get(field) {
+        Some(Value::Int(value)) => Ok(*value),
+        _ => Err(OrdoError::capability_invocation(
+            capability,
+            format!("field '{}' must be an integer", field),
+        )),
+    }
+}
+
+fn optional_tags(
+    object: &hashbrown::HashMap<ordo_core::context::IString, Value>,
+    field: &str,
+    capability: &str,
+) -> Result<Vec<(String, String)>> {
+    let Some(Value::Object(tags)) = object.get(field) else {
+        return Ok(Vec::new());
+    };
+
+    let mut result = Vec::with_capacity(tags.len());
+    for (key, value) in tags {
+        let value = value.as_str().ok_or_else(|| {
+            OrdoError::capability_invocation(capability, format!("tag '{}' must be a string", key))
+        })?;
+        result.push((key.to_string(), value.to_string()));
+    }
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::{body::Bytes, http::Method, routing::any, Json, Router};
+    use serde_json::json;
+    use tokio::{net::TcpListener, sync::mpsc, time::Duration};
+
+    #[test]
+    fn metric_capability_accepts_gauge_requests() {
+        let registry = ServerCapabilityRegistry::new();
+        registry.register_metric_sink(Arc::new(PrometheusMetricSink::new()));
+
+        let payload = Value::object({
+            let mut m = std::collections::HashMap::new();
+            m.insert("name".to_string(), Value::string("score"));
+            m.insert("value".to_string(), Value::int(3));
+            m
+        });
+
+        let response = registry
+            .invoke(&CapabilityRequest::new(
+                "metrics.prometheus",
+                "gauge",
+                payload,
+            ))
+            .unwrap();
+
+        assert_eq!(response.metadata.get("metric"), Some(&"score".to_string()));
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn http_capability_posts_json() {
+        let listener = match TcpListener::bind("127.0.0.1:0").await {
+            Ok(listener) => listener,
+            Err(error) if error.kind() == std::io::ErrorKind::PermissionDenied => return,
+            Err(error) => panic!("failed to bind test listener: {}", error),
+        };
+        let addr = listener.local_addr().unwrap();
+        let (tx, mut rx) = mpsc::unbounded_channel();
+        let app = Router::new().route(
+            "/hook",
+            any(move |method: Method, body: Bytes| {
+                let tx = tx.clone();
+                async move {
+                    let json_body = serde_json::from_slice::<serde_json::Value>(&body)
+                        .unwrap_or(serde_json::Value::Null);
+                    let _ = tx.send((method.clone(), json_body.clone()));
+
+                    Json(json!({
+                        "method": method.as_str(),
+                        "received": json_body,
+                        "ok": true
+                    }))
+                }
+            }),
+        );
+        let server = tokio::spawn(async move {
+            axum::serve(listener, app).await.unwrap();
+        });
+
+        let capability_invoker =
+            build_server_capability_invoker(Arc::new(PrometheusMetricSink::new()), None);
+        let response = invoke_http_json(
+            Some(capability_invoker),
+            "post",
+            &format!("http://{}/hook", addr),
+            HashMap::new(),
+            &json!({"hello": "world"}),
+            Some(1_000),
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(http_response_status(&response), Some(200));
+        let (method, received_body) = tokio::time::timeout(Duration::from_secs(1), rx.recv())
+            .await
+            .expect("timed out waiting for test server request")
+            .expect("test server did not receive request");
+        assert_eq!(method, Method::POST);
+        assert_eq!(received_body.get("hello"), Some(&json!("world")));
+        assert_eq!(
+            response.payload.get_path("json_body.received.hello"),
+            Some(&Value::string("world"))
+        );
+        assert_eq!(
+            response.payload.get_path("json_body.method"),
+            Some(&Value::string("POST"))
+        );
+
+        server.abort();
+    }
+}
diff --git a/crates/ordo-server/src/grpc.rs b/crates/ordo-server/src/grpc.rs
index 4a3c16e6..3dfc7d30 100644
--- a/crates/ordo-server/src/grpc.rs
+++ b/crates/ordo-server/src/grpc.rs
@@ -582,12 +582,17 @@ impl OrdoService for OrdoGrpcService {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::audit::AuditLogger;
+    use crate::capability_registry::build_server_executor;
+    use crate::metrics::PrometheusMetricSink;
     use crate::rate_limiter::RateLimiter;
     use crate::tenant::{TenantDefaults, TenantManager};
 
     async fn create_test_service() -> OrdoGrpcService {
         let store = Arc::new(RwLock::new(RuleStore::new()));
-        let executor = Arc::new(RuleExecutor::new());
+        let metric_sink = Arc::new(PrometheusMetricSink::new());
+        let audit_logger = Arc::new(AuditLogger::new(None, 0));
+        let executor = build_server_executor(metric_sink, Some(audit_logger));
         let defaults = TenantDefaults {
             default_qps_limit: Some(1000),
             default_burst_limit: Some(100),
diff --git a/crates/ordo-server/src/main.rs b/crates/ordo-server/src/main.rs
index c1ecd3ac..78a9c440 100644
--- a/crates/ordo-server/src/main.rs
+++ b/crates/ordo-server/src/main.rs
@@ -49,6 +49,7 @@ use tracing::{info, warn};
 
 mod api;
 mod audit;
+mod capability_registry;
 mod config;
 pub mod debug;
 mod error;
@@ -67,10 +68,11 @@ pub mod wal;
 pub mod webhook;
 
 use audit::AuditLogger;
+use capability_registry::{build_rule_executor, build_server_capability_invoker, invoke_http_json};
 use config::ServerConfig;
 use grpc::OrdoGrpcService;
 use metrics::PrometheusMetricSink;
-use ordo_core::prelude::{RuleExecutor, TraceConfig};
+use ordo_core::prelude::RuleExecutor;
 use ordo_core::signature::ed25519::decode_public_key;
 use ordo_core::signature::RuleVerifier;
 use rate_limiter::RateLimiter;
@@ -225,13 +227,29 @@ async fn main() -> anyhow::Result<()> {
     let metric_sink = Arc::new(PrometheusMetricSink::new());
     info!("Initialized Prometheus metric sink for custom rule metrics");
 
-    // Initialize shared executor (moved out of RuleStore for lock-free execution)
-    let executor = Arc::new(RuleExecutor::with_trace_and_metrics(
-        TraceConfig::minimal(),
-        metric_sink.clone(),
+    let signature_verifier = build_signature_verifier(&config)?;
+
+    // Initialize audit logger
+    let audit_logger = Arc::new(AuditLogger::new(
+        config.audit_dir.clone(),
+        config.audit_sample_rate,
     ));
 
-    let signature_verifier = build_signature_verifier(&config)?;
+    // Log audit configuration
+    if config.audit_dir.is_some() {
+        info!(
+            "Audit logging enabled: dir={:?}, sample_rate={}%",
+            config.audit_dir, config.audit_sample_rate
+        );
+    } else {
+        info!(
+            "Audit logging to stdout only, sample_rate={}%",
+            config.audit_sample_rate
+        );
+    }
+
+    let capability_invoker =
+        build_server_capability_invoker(metric_sink.clone(), Some(audit_logger.clone()));
 
     // Initialize shared store (with or without persistence)
     let store = if let Some(ref rules_dir) = config.rules_dir {
@@ -244,10 +262,11 @@ async fn main() -> anyhow::Result<()> {
             "Initializing store with persistence at {:?} (max {} versions)",
             store_dir, config.max_versions
         );
-        let mut store = RuleStore::new_with_persistence_and_metrics(
+        let mut store = RuleStore::new_with_persistence_and_metrics_and_capabilities(
             store_dir,
             config.max_versions,
             metric_sink.clone(),
+            Some(capability_invoker.clone()),
         );
         if let Some(verifier) = signature_verifier.clone() {
             store.set_signature_verifier(verifier, config.signature_allow_unsigned_local);
@@ -335,7 +354,10 @@ async fn main() -> anyhow::Result<()> {
         Arc::new(RwLock::new(store))
     } else {
         info!("Initializing in-memory store (no persistence)");
-        let mut store = RuleStore::new_with_metrics(metric_sink.clone());
+        let mut store = RuleStore::new_with_metrics_and_capabilities(
+            metric_sink.clone(),
+            Some(capability_invoker.clone()),
+        );
         if let Some(verifier) = signature_verifier.clone() {
             store.set_signature_verifier(verifier, config.signature_allow_unsigned_local);
         }
@@ -357,25 +379,13 @@ async fn main() -> anyhow::Result<()> {
         );
     }
 
-    // Initialize audit logger
-    let audit_logger = Arc::new(AuditLogger::new(
-        config.audit_dir.clone(),
-        config.audit_sample_rate,
+    // Initialize shared executor (moved out of RuleStore for lock-free execution)
+    let metric_sink_trait: Arc<dyn ordo_core::prelude::MetricSink> = metric_sink.clone();
+    let executor = Arc::new(build_rule_executor(
+        metric_sink_trait,
+        Some(capability_invoker.clone()),
     ));
 
-    // Log audit configuration
-    if config.audit_dir.is_some() {
-        info!(
-            "Audit logging enabled: dir={:?}, sample_rate={}%",
-            config.audit_dir, config.audit_sample_rate
-        );
-    } else {
-        info!(
-            "Audit logging to stdout only, sample_rate={}%",
-            config.audit_sample_rate
-        );
-    }
-
     // Initialize debug session manager
     let debug_sessions = Arc::new(debug::DebugSessionManager::new());
     // Initialize tenant manager
@@ -408,7 +418,10 @@ async fn main() -> anyhow::Result<()> {
     // Shutdown broadcast channel — signal handlers and servers share this.
     let (shutdown_tx, shutdown_rx) = watch::channel(false);
 
-    let webhook_manager = webhook::WebhookManager::new(shutdown_rx.clone());
+    let webhook_manager = webhook::WebhookManager::new_with_capabilities(
+        shutdown_rx.clone(),
+        Some(capability_invoker.clone()),
+    );
 
     // Log server started event
     {
@@ -632,6 +645,7 @@ async fn main() -> anyhow::Result<()> {
             let http_version = version.clone();
             let http_token = token.clone();
             let http_reg_secret = reg_secret.clone();
+            let http_capability_invoker = capability_invoker.clone();
             let log_url = platform_url.clone();
             let log_name = http_server_name.clone();
 
@@ -652,25 +666,49 @@ async fn main() -> anyhow::Result<()> {
                 });
                 let hb_payload = serde_json::json!({ "server_id": http_server_id });
 
-                let hb_req_builder = || {
-                    let mut r = client.post(&hb_url).json(&hb_payload);
-                    if let Some(ref secret) = http_reg_secret {
-                        r = r.header("x-registration-secret", secret.as_str());
-                    }
-                    r
-                };
-
                 let mut interval = tokio::time::interval(Duration::from_secs(30));
                 interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
 
                 loop {
-                    let mut r = client.post(&reg_url).json(&payload);
+                    let mut headers = std::collections::HashMap::new();
                     if let Some(ref secret) = http_reg_secret {
-                        r = r.header("x-registration-secret", secret.as_str());
+                        headers.insert("x-registration-secret".to_string(), secret.to_string());
+                    }
+                    match invoke_http_json(
+                        Some(http_capability_invoker.clone()),
+                        "post",
+                        &reg_url,
+                        headers.clone(),
+                        &payload,
+                        Some(5_000),
+                    ) {
+                        Ok(Some(_)) => {}
+                        Ok(None) | Err(_) => {
+                            let mut r = client.post(&reg_url).json(&payload);
+                            if let Some(ref secret) = http_reg_secret {
+                                r = r.header("x-registration-secret", secret.as_str());
+                            }
+                            let _ = r.send().await;
+                        }
                     }
-                    let _ = r.send().await;
                     interval.tick().await;
-                    let _ = hb_req_builder().send().await;
+                    match invoke_http_json(
+                        Some(http_capability_invoker.clone()),
+                        "post",
+                        &hb_url,
+                        headers.clone(),
+                        &hb_payload,
+                        Some(5_000),
+                    ) {
+                        Ok(Some(_)) => {}
+                        Ok(None) | Err(_) => {
+                            let mut r = client.post(&hb_url).json(&hb_payload);
+                            if let Some(ref secret) = http_reg_secret {
+                                r = r.header("x-registration-secret", secret.as_str());
+                            }
+                            let _ = r.send().await;
+                        }
+                    }
                 }
             });
 
diff --git a/crates/ordo-server/src/store.rs b/crates/ordo-server/src/store.rs
index 4afe5ebb..f892ee25 100644
--- a/crates/ordo-server/src/store.rs
+++ b/crates/ordo-server/src/store.rs
@@ -9,7 +9,7 @@ use crate::sync::event::SyncEvent;
 use crate::sync::file_watcher::RecentWrites;
 use crate::wal::{WalManager, WalOpKind};
 use once_cell::sync::Lazy;
-use ordo_core::prelude::{MetricSink, RuleExecutor, RuleSet, TraceConfig};
+use ordo_core::prelude::{CapabilityInvoker, MetricSink, RuleExecutor, RuleSet, TraceConfig};
 use ordo_core::signature::{strip_signature, RuleVerifier};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
@@ -114,11 +114,27 @@ pub struct VersionListResponse {
 }
 
 impl RuleStore {
+    fn build_executor(
+        metric_sink: Option<Arc<dyn MetricSink>>,
+        capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+    ) -> RuleExecutor {
+        let mut executor = match metric_sink {
+            Some(metric_sink) => {
+                RuleExecutor::with_trace_and_metrics(TraceConfig::minimal(), metric_sink)
+            }
+            None => RuleExecutor::with_trace(TraceConfig::minimal()),
+        };
+        if let Some(capability_invoker) = capability_invoker {
+            executor.set_capability_invoker(capability_invoker);
+        }
+        executor
+    }
+
     /// Create a new in-memory store (no persistence)
     pub fn new() -> Self {
         Self {
             rulesets: HashMap::new(),
-            executor: RuleExecutor::with_trace(TraceConfig::minimal()),
+            executor: Self::build_executor(None, None),
             rules_dir: None,
             multi_tenancy_enabled: false,
             default_tenant: "default".to_string(),
@@ -137,9 +153,16 @@ impl RuleStore {
 
     /// Create a new in-memory store with a custom metric sink
     pub fn new_with_metrics(metric_sink: Arc<dyn MetricSink>) -> Self {
+        Self::new_with_metrics_and_capabilities(metric_sink, None)
+    }
+
+    pub fn new_with_metrics_and_capabilities(
+        metric_sink: Arc<dyn MetricSink>,
+        capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+    ) -> Self {
         Self {
             rulesets: HashMap::new(),
-            executor: RuleExecutor::with_trace_and_metrics(TraceConfig::minimal(), metric_sink),
+            executor: Self::build_executor(Some(metric_sink), capability_invoker),
             rules_dir: None,
             multi_tenancy_enabled: false,
             default_tenant: "default".to_string(),
@@ -166,7 +189,7 @@ impl RuleStore {
     pub fn new_with_persistence_and_versions(rules_dir: PathBuf, max_versions: usize) -> Self {
         Self {
             rulesets: HashMap::new(),
-            executor: RuleExecutor::with_trace(TraceConfig::minimal()),
+            executor: Self::build_executor(None, None),
             rules_dir: Some(rules_dir),
             multi_tenancy_enabled: false,
             default_tenant: "default".to_string(),
@@ -188,10 +211,24 @@ impl RuleStore {
         rules_dir: PathBuf,
         max_versions: usize,
         metric_sink: Arc<dyn MetricSink>,
+    ) -> Self {
+        Self::new_with_persistence_and_metrics_and_capabilities(
+            rules_dir,
+            max_versions,
+            metric_sink,
+            None,
+        )
+    }
+
+    pub fn new_with_persistence_and_metrics_and_capabilities(
+        rules_dir: PathBuf,
+        max_versions: usize,
+        metric_sink: Arc<dyn MetricSink>,
+        capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
     ) -> Self {
         Self {
             rulesets: HashMap::new(),
-            executor: RuleExecutor::with_trace_and_metrics(TraceConfig::minimal(), metric_sink),
+            executor: Self::build_executor(Some(metric_sink), capability_invoker),
             rules_dir: Some(rules_dir),
             multi_tenancy_enabled: false,
             default_tenant: "default".to_string(),
diff --git a/crates/ordo-server/src/uds.rs b/crates/ordo-server/src/uds.rs
index 253d0ef2..925e5adf 100644
--- a/crates/ordo-server/src/uds.rs
+++ b/crates/ordo-server/src/uds.rs
@@ -84,6 +84,9 @@ pub fn cleanup_uds(uds_path: &Path) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::audit::AuditLogger;
+    use crate::capability_registry::build_server_executor;
+    use crate::metrics::PrometheusMetricSink;
     use crate::tenant::{TenantDefaults, TenantManager};
     use std::time::Duration;
     use tempfile::tempdir;
@@ -94,7 +97,9 @@ mod tests {
         let socket_path = temp_dir.path().join("test.sock");
 
         let store = Arc::new(tokio::sync::RwLock::new(RuleStore::new()));
-        let executor = Arc::new(RuleExecutor::new());
+        let metric_sink = Arc::new(PrometheusMetricSink::new());
+        let audit_logger = Arc::new(AuditLogger::new(None, 0));
+        let executor = build_server_executor(metric_sink, Some(audit_logger));
         let defaults = TenantDefaults {
             default_qps_limit: Some(1000),
             default_burst_limit: Some(100),
@@ -126,11 +131,30 @@ mod tests {
             .await
         });
 
-        // Give server time to start
-        tokio::time::sleep(Duration::from_millis(100)).await;
+        // Wait for the socket file to appear rather than assuming a fixed startup latency.
+        let mut started = false;
+        for _ in 0..20 {
+            if socket_path.exists() {
+                started = true;
+                break;
+            }
+            if server_handle.is_finished() {
+                let result = server_handle.await.expect("UDS task join failed");
+                match result {
+                    Err(error)
+                        if error
+                            .downcast_ref::<std::io::Error>()
+                            .is_some_and(|e| e.kind() == std::io::ErrorKind::PermissionDenied) =>
+                    {
+                        return;
+                    }
+                    other => panic!("UDS server exited before socket creation: {:?}", other),
+                }
+            }
+            tokio::time::sleep(Duration::from_millis(50)).await;
+        }
 
-        // Verify socket file exists
-        assert!(socket_path.exists());
+        assert!(started, "UDS socket was not created in time");
 
         // Abort server
         server_handle.abort();
diff --git a/crates/ordo-server/src/webhook.rs b/crates/ordo-server/src/webhook.rs
index 3ae3c13d..7ec006e6 100644
--- a/crates/ordo-server/src/webhook.rs
+++ b/crates/ordo-server/src/webhook.rs
@@ -5,6 +5,7 @@
 //! to avoid blocking the main request path.
 
 use chrono::{DateTime, Utc};
+use ordo_core::prelude::CapabilityInvoker;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -12,6 +13,8 @@ use std::time::Duration;
 use tokio::sync::{mpsc, RwLock};
 use tracing::{debug, error, info, warn};
 
+use crate::capability_registry::{http_response_status, invoke_http_json};
+
 /// Events that can trigger webhooks.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -99,6 +102,13 @@ pub struct WebhookManager {
 impl WebhookManager {
     /// Create a new WebhookManager and spawn the background delivery task.
     pub fn new(shutdown_rx: tokio::sync::watch::Receiver<bool>) -> Arc<Self> {
+        Self::new_with_capabilities(shutdown_rx, None)
+    }
+
+    pub fn new_with_capabilities(
+        shutdown_rx: tokio::sync::watch::Receiver<bool>,
+        capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+    ) -> Arc<Self> {
         let (tx, rx) = mpsc::channel::<DeliveryJob>(1024);
         let client = reqwest::Client::builder()
             .timeout(Duration::from_secs(10))
@@ -113,7 +123,7 @@ impl WebhookManager {
         });
 
         // Spawn background delivery task
-        tokio::spawn(delivery_loop(rx, client, shutdown_rx));
+        tokio::spawn(delivery_loop(rx, client, capability_invoker, shutdown_rx));
 
         manager
     }
@@ -198,13 +208,14 @@ impl WebhookManager {
 async fn delivery_loop(
     mut rx: mpsc::Receiver<DeliveryJob>,
     client: reqwest::Client,
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
     mut shutdown_rx: tokio::sync::watch::Receiver<bool>,
 ) {
     loop {
         tokio::select! {
             job = rx.recv() => {
                 match job {
-                    Some(job) => deliver_with_retry(&client, job).await,
+                    Some(job) => deliver_with_retry(&client, capability_invoker.clone(), job).await,
                     None => break, // Channel closed
                 }
             }
@@ -212,7 +223,7 @@ async fn delivery_loop(
                 info!("Webhook delivery task shutting down");
                 // Drain remaining jobs
                 while let Ok(job) = rx.try_recv() {
-                    deliver_with_retry(&client, job).await;
+                    deliver_with_retry(&client, capability_invoker.clone(), job).await;
                 }
                 break;
             }
@@ -222,55 +233,117 @@ async fn delivery_loop(
 }
 
 /// Deliver a single webhook with exponential backoff retry.
-async fn deliver_with_retry(client: &reqwest::Client, job: DeliveryJob) {
+async fn deliver_with_retry(
+    client: &reqwest::Client,
+    capability_invoker: Option<Arc<dyn CapabilityInvoker>>,
+    job: DeliveryJob,
+) {
     let webhook_id = &job.webhook.id;
     let max_retries = job.webhook.max_retries as u32;
+    let body_json = serde_json::to_value(&job.payload).unwrap_or(serde_json::Value::Null);
+    let mut headers = HashMap::new();
+    headers.insert("Content-Type".to_string(), "application/json".to_string());
+    headers.insert(
+        "User-Agent".to_string(),
+        format!("ordo-webhook/{}", ordo_core::VERSION),
+    );
+    headers.insert(
+        "X-Ordo-Event".to_string(),
+        format!("{:?}", job.payload.event).to_lowercase(),
+    );
+    headers.insert("X-Ordo-Webhook-ID".to_string(), webhook_id.clone());
 
     for attempt in 0..=max_retries {
-        let mut request = client
-            .post(&job.webhook.url)
-            .header("Content-Type", "application/json")
-            .header("User-Agent", format!("ordo-webhook/{}", ordo_core::VERSION))
-            .header(
-                "X-Ordo-Event",
-                format!("{:?}", job.payload.event).to_lowercase(),
-            )
-            .header("X-Ordo-Webhook-ID", webhook_id.as_str())
-            .header("X-Ordo-Delivery-Attempt", (attempt + 1).to_string());
+        let mut attempt_headers = headers.clone();
+        attempt_headers.insert(
+            "X-Ordo-Delivery-Attempt".to_string(),
+            (attempt + 1).to_string(),
+        );
 
         // HMAC signature if secret is set
         if let Some(ref secret) = job.webhook.secret {
             if let Ok(body_bytes) = serde_json::to_vec(&job.payload) {
                 let signature = hmac_sha256(secret.as_bytes(), &body_bytes);
-                request = request.header("X-Ordo-Signature", format!("sha256={}", signature));
+                attempt_headers.insert(
+                    "X-Ordo-Signature".to_string(),
+                    format!("sha256={}", signature),
+                );
             }
         }
 
-        match request.json(&job.payload).send().await {
-            Ok(resp) if resp.status().is_success() => {
-                debug!(
-                    webhook_id = %webhook_id,
-                    status = %resp.status(),
-                    attempt = attempt + 1,
-                    "Webhook delivered"
-                );
-                return;
+        let capability_result = invoke_http_json(
+            capability_invoker.clone(),
+            "post",
+            &job.webhook.url,
+            attempt_headers.clone(),
+            &body_json,
+            Some(10_000),
+        );
+
+        let mut delivered = false;
+        match capability_result {
+            Ok(Some(response)) => {
+                if let Some(status) = http_response_status(&response) {
+                    if (200..300).contains(&status) {
+                        debug!(
+                            webhook_id = %webhook_id,
+                            status = status,
+                            attempt = attempt + 1,
+                            "Webhook delivered"
+                        );
+                        return;
+                    }
+                    warn!(
+                        webhook_id = %webhook_id,
+                        status = status,
+                        attempt = attempt + 1,
+                        "Webhook delivery failed"
+                    );
+                    delivered = true;
+                }
             }
-            Ok(resp) => {
+            Ok(None) => {}
+            Err(error) => {
                 warn!(
                     webhook_id = %webhook_id,
-                    status = %resp.status(),
+                    error = %error,
                     attempt = attempt + 1,
-                    "Webhook delivery failed"
+                    "Webhook capability delivery error"
                 );
             }
-            Err(e) => {
-                warn!(
-                    webhook_id = %webhook_id,
-                    error = %e,
-                    attempt = attempt + 1,
-                    "Webhook delivery error"
-                );
+        }
+
+        if !delivered {
+            let mut request = client.post(&job.webhook.url);
+            for (name, value) in &attempt_headers {
+                request = request.header(name, value);
+            }
+            match request.json(&job.payload).send().await {
+                Ok(resp) if resp.status().is_success() => {
+                    debug!(
+                        webhook_id = %webhook_id,
+                        status = %resp.status(),
+                        attempt = attempt + 1,
+                        "Webhook delivered"
+                    );
+                    return;
+                }
+                Ok(resp) => {
+                    warn!(
+                        webhook_id = %webhook_id,
+                        status = %resp.status(),
+                        attempt = attempt + 1,
+                        "Webhook delivery failed"
+                    );
+                }
+                Err(e) => {
+                    warn!(
+                        webhook_id = %webhook_id,
+                        error = %e,
+                        attempt = attempt + 1,
+                        "Webhook delivery error"
+                    );
+                }
             }
         }
 
@@ -310,6 +383,8 @@ fn generate_id() -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::capability_registry::build_server_capability_invoker;
+    use crate::metrics::PrometheusMetricSink;
 
     #[test]
     fn test_generate_id() {
@@ -353,7 +428,13 @@ mod tests {
     #[tokio::test]
     async fn test_webhook_manager_crud() {
         let (_tx, rx) = tokio::sync::watch::channel(false);
-        let manager = WebhookManager::new(rx);
+        let manager = WebhookManager::new_with_capabilities(
+            rx,
+            Some(build_server_capability_invoker(
+                Arc::new(PrometheusMetricSink::new()),
+                None,
+            )),
+        );
 
         // Register
         let id = manager
@@ -408,7 +489,13 @@ mod tests {
     #[tokio::test]
     async fn test_fire_filters_inactive_and_events() {
         let (_tx, rx) = tokio::sync::watch::channel(false);
-        let manager = WebhookManager::new(rx);
+        let manager = WebhookManager::new_with_capabilities(
+            rx,
+            Some(build_server_capability_invoker(
+                Arc::new(PrometheusMetricSink::new()),
+                None,
+            )),
+        );
 
         // Register inactive hook
         manager
diff --git a/examples/capability-demo/Cargo.toml b/examples/capability-demo/Cargo.toml
new file mode 100644
index 00000000..01c9c8e3
--- /dev/null
+++ b/examples/capability-demo/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "capability-demo"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ordo-core = { path = "../../crates/ordo-core", default-features = false }
+serde_json = "1"
diff --git a/examples/capability-demo/src/main.rs b/examples/capability-demo/src/main.rs
new file mode 100644
index 00000000..6ad80771
--- /dev/null
+++ b/examples/capability-demo/src/main.rs
@@ -0,0 +1,51 @@
+use ordo_core::prelude::*;
+use std::sync::Arc;
+
+struct EchoProvider;
+
+impl CapabilityProvider for EchoProvider {
+    fn descriptor(&self) -> CapabilityDescriptor {
+        CapabilityDescriptor::new("demo.echo", CapabilityCategory::Compute)
+            .with_description("Echo payloads back to the caller")
+    }
+
+    fn invoke(&self, request: &CapabilityRequest) -> Result<CapabilityResponse> {
+        Ok(CapabilityResponse::new(request.payload.clone()))
+    }
+}
+
+fn main() {
+    let registry = Arc::new(CapabilityRegistry::new());
+    registry.register(Arc::new(EchoProvider));
+
+    let mut ruleset = RuleSet::new("capability_demo", "call_echo");
+    ruleset.add_step(Step::action(
+        "call_echo",
+        "Call capability",
+        vec![Action {
+            kind: ActionKind::ExternalCall {
+                service: "demo.echo".to_string(),
+                method: "echo".to_string(),
+                params: vec![("amount".to_string(), Expr::field("amount"))],
+                result_variable: Some("result".to_string()),
+                timeout_ms: 250,
+            },
+            description: "Capability call demo".to_string(),
+        }],
+        "done",
+    ));
+    ruleset.add_step(Step::terminal(
+        "done",
+        "Done",
+        TerminalResult::new("OK")
+            .with_output("echoed_amount", Expr::field("$result.payload.amount")),
+    ));
+
+    let mut executor = RuleExecutor::new();
+    executor.set_capability_invoker(registry);
+
+    let input: Value = serde_json::from_str(r#"{"amount": 42}"#).unwrap();
+    let result = executor.execute(&ruleset, input).unwrap();
+
+    println!("{:?}", result.output);
+}
diff --git a/ordo-editor/apps/docs/.vitepress/config.mts b/ordo-editor/apps/docs/.vitepress/config.mts
index dd535f24..2c821ca4 100644
--- a/ordo-editor/apps/docs/.vitepress/config.mts
+++ b/ordo-editor/apps/docs/.vitepress/config.mts
@@ -85,6 +85,7 @@ export default withMermaid(defineConfig({
                 { text: 'Rule Persistence', link: '/en/guide/persistence' },
                 { text: 'Version Management', link: '/en/guide/versioning' },
                 { text: 'Audit Logging', link: '/en/guide/audit-logging' },
+                { text: 'Capabilities & External Calls', link: '/en/guide/capabilities' },
                 { text: 'Rule Signing', link: '/en/guide/rule-signing' },
                 { text: 'Decision Table', link: '/en/guide/decision-table' },
                 { text: 'Editor Store & Undo/Redo', link: '/en/guide/editor-store' },
@@ -179,6 +180,7 @@ export default withMermaid(defineConfig({
                 { text: '版本管理', link: '/zh/guide/versioning' },
                 { text: '规则签名', link: '/zh/guide/rule-signing' },
                 { text: '审计日志', link: '/zh/guide/audit-logging' },
+                { text: '能力与外部调用', link: '/zh/guide/capabilities' },
                 { text: '决策表', link: '/zh/guide/decision-table' },
                 { text: '编辑器状态管理', link: '/zh/guide/editor-store' },
                 { text: '分布式部署', link: '/zh/guide/distributed-deployment' },
diff --git a/ordo-editor/apps/docs/en/guide/capabilities.md b/ordo-editor/apps/docs/en/guide/capabilities.md
new file mode 100644
index 00000000..0670ee31
--- /dev/null
+++ b/ordo-editor/apps/docs/en/guide/capabilities.md
@@ -0,0 +1,161 @@
+# Capabilities and External Calls
+
+Ordo uses a capability boundary for outbound side effects and runtime integrations. This keeps rule execution deterministic inside the engine while still allowing rules and server components to call metrics, audit sinks, HTTP endpoints, and other providers through a stable interface.
+
+## What a capability is
+
+A capability provider exposes a named runtime service plus one or more operations.
+
+- The provider name is the capability name, such as `metrics.prometheus`, `audit.logger`, or `network.http`.
+- The operation is the method invoked on that capability, such as `gauge`, `rule_executed`, or `post`.
+- The payload is a typed object that the provider receives and returns.
+
+At runtime, `ExternalCall` actions are translated into a capability request:
+
+```json
+{
+  "action": "external_call",
+  "service": "demo.echo",
+  "method": "echo",
+  "params": [["amount", { "Field": "amount" }]],
+  "result_variable": "echo_result",
+  "timeout_ms": 250
+}
+```
+
+If `result_variable` is set, Ordo stores the capability response under that variable:
+
+- `$echo_result.capability`
+- `$echo_result.operation`
+- `$echo_result.payload`
+- `$echo_result.metadata`
+
+## Built-in server capabilities
+
+The server currently registers these capability providers by default:
+
+| Capability           | Category  | Typical operations                                         | Purpose                                         |
+| -------------------- | --------- | ---------------------------------------------------------- | ----------------------------------------------- |
+| `metrics.prometheus` | `action`  | `gauge`, `counter`                                         | Record rule metrics through the Prometheus sink |
+| `audit.logger`       | `action`  | `rule_executed`                                            | Emit structured execution audit events          |
+| `network.http`       | `network` | `get`, `post`, `put`, `patch`, `delete`, `head`, `options` | Send outbound HTTP requests                     |
+
+## Studio `externalCalls` mapping
+
+Studio action steps can define `externalCalls`. The editor adapter now converts them into engine `external_call` actions using these rules.
+
+### HTTP calls
+
+Use `type: "http"` when the target is an outbound HTTP endpoint.
+
+```ts
+{
+  type: 'http',
+  target: 'PATCH https://api.example.com/score',
+  params: {
+    applicantId: Expr.variable('$.applicant.id'),
+    score: Expr.number(720),
+  },
+  resultVariable: 'http_result',
+  timeout: 1500,
+}
+```
+
+This becomes:
+
+```json
+{
+  "action": "external_call",
+  "service": "network.http",
+  "method": "patch",
+  "params": [
+    ["url", { "Literal": "https://api.example.com/score" }],
+    [
+      "json_body",
+      {
+        "Object": [
+          ["applicantId", { "Field": "applicant.id" }],
+          ["score", { "Literal": 720 }]
+        ]
+      }
+    ]
+  ],
+  "result_variable": "http_result",
+  "timeout_ms": 1500
+}
+```
+
+Rules:
+
+- If `target` starts with `METHOD <space> URL`, that HTTP method is used.
+- If no method prefix is provided, Ordo defaults to `POST`.
+- `params` are sent as `json_body`.
+- `target` becomes the `url` payload field for `network.http`.
+
+### Function and gRPC calls
+
+For `type: "function"` and `type: "grpc"`, the editor treats `target` as a capability reference.
+
+Supported target forms:
+
+- `demo.echo`
+- `demo.echo#echo`
+- `demo.echo::echo`
+
+Rules:
+
+- `service` is the capability name.
+- `method` is parsed from `#` or `::` when present.
+- If no method is supplied, Ordo defaults to `invoke` for `function` and `call` for `grpc`.
+- `params` are passed through as the capability payload object.
+
+Example:
+
+```ts
+{
+  type: 'function',
+  target: 'demo.echo#echo',
+  params: {
+    payload: Expr.object({
+      amount: Expr.variable('$.amount'),
+      approved: Expr.boolean(true),
+    }),
+  },
+  resultVariable: 'echo_result',
+}
+```
+
+## Expression support in capability payloads
+
+Capability payload values can use the same expression model as normal rule actions. The editor adapter now serializes:
+
+- literals
+- field references
+- arrays
+- objects
+- binary and unary expressions
+- conditional expressions
+- function calls
+- simple member paths like `$.user.profile.id`
+
+## Current limitations
+
+Studio already models some fields that the engine does not execute yet:
+
+- `retry`
+- `onError`
+- `fallbackValue`
+
+These fields remain editor-level metadata today. They are preserved in the Studio model, but they are not translated into runtime behavior by the engine adapter yet.
+
+That means:
+
+- retries are not applied automatically by `ExternalCall`
+- fallback values are not injected automatically on failure
+- error handling modes are not yet mapped to engine semantics
+
+If you need those behaviors today, implement them inside the capability provider itself or keep the rule logic explicit in separate steps.
+
+## Example provider
+
+The repository includes a minimal provider example in [`examples/capability-demo`](https://github.com/Pama-Lee/Ordo/tree/main/examples/capability-demo). It registers a `demo.echo` provider, invokes it from an `ExternalCall`, and reads the result through `$result.payload`.
diff --git a/ordo-editor/apps/docs/en/guide/what-is-ordo.md b/ordo-editor/apps/docs/en/guide/what-is-ordo.md
index 60584c72..4c577948 100644
--- a/ordo-editor/apps/docs/en/guide/what-is-ordo.md
+++ b/ordo-editor/apps/docs/en/guide/what-is-ordo.md
@@ -14,13 +14,13 @@ Most teams start with a rule engine. Then they realize the hard part isn't execu
 
 Ordo addresses the full lifecycle:
 
-| Stage | What Ordo provides |
-|-------|--------------------|
-| **Author** | Studio flow editor, decision tables, template library |
-| **Test** | Per-ruleset test cases, run in CI, export to YAML |
-| **Govern** | Fact catalog, typed contracts, version history, audit log |
-| **Execute** | Fast engine, hot reload, multi-tenancy |
-| **Observe** | Execution traces, Prometheus metrics, structured logs |
+| Stage       | What Ordo provides                                        |
+| ----------- | --------------------------------------------------------- |
+| **Author**  | Studio flow editor, decision tables, template library     |
+| **Test**    | Per-ruleset test cases, run in CI, export to YAML         |
+| **Govern**  | Fact catalog, typed contracts, version history, audit log |
+| **Execute** | Fast engine, hot reload, multi-tenancy                    |
+| **Observe** | Execution traces, Prometheus metrics, structured logs     |
 
 ## Architecture
 
diff --git a/ordo-editor/apps/docs/en/index.md b/ordo-editor/apps/docs/en/index.md
index ed9c1c14..a8446214 100644
--- a/ordo-editor/apps/docs/en/index.md
+++ b/ordo-editor/apps/docs/en/index.md
@@ -70,4 +70,3 @@ features:
   }
 }
 ```
-
diff --git a/ordo-editor/apps/docs/en/roadmap.md b/ordo-editor/apps/docs/en/roadmap.md
index fcbc961a..9d2a6d91 100644
--- a/ordo-editor/apps/docs/en/roadmap.md
+++ b/ordo-editor/apps/docs/en/roadmap.md
@@ -11,18 +11,18 @@ outline: [2, 3]
 
 Ordo already ships a production-grade core:
 
-| Module | Capabilities |
-|--------|-------------|
-| **Engine** | Sub-microsecond rule execution, bytecode VM + Cranelift JIT, expression optimizer |
-| **Transports** | HTTP REST, gRPC (with TLS/mTLS), Unix Domain Socket |
-| **Visual Editor** | Three editing modes (Form / Flow Graph / JSON), decision tables, execution & performance panels |
-| **CLI** | `ordo eval`, `ordo exec`, `ordo test` |
-| **WASM** | Run the engine in browsers |
-| **SDKs** | Go, Java, Python |
-| **Studio** | Org/project/member management, fact catalog, concept registry, decision contracts, version history |
-| **Multi-tenancy** | Per-tenant QPS limits, burst control, timeouts |
-| **Observability** | Prometheus metrics, OTLP tracing, JSON Lines audit log, WAL crash-safe persistence |
-| **i18n** | English, Simplified Chinese, Traditional Chinese |
+| Module            | Capabilities                                                                                       |
+| ----------------- | -------------------------------------------------------------------------------------------------- |
+| **Engine**        | Sub-microsecond rule execution, bytecode VM + Cranelift JIT, expression optimizer                  |
+| **Transports**    | HTTP REST, gRPC (with TLS/mTLS), Unix Domain Socket                                                |
+| **Visual Editor** | Three editing modes (Form / Flow Graph / JSON), decision tables, execution & performance panels    |
+| **CLI**           | `ordo eval`, `ordo exec`, `ordo test`                                                              |
+| **WASM**          | Run the engine in browsers                                                                         |
+| **SDKs**          | Go, Java, Python                                                                                   |
+| **Studio**        | Org/project/member management, fact catalog, concept registry, decision contracts, version history |
+| **Multi-tenancy** | Per-tenant QPS limits, burst control, timeouts                                                     |
+| **Observability** | Prometheus metrics, OTLP tracing, JSON Lines audit log, WAL crash-safe persistence                 |
+| **i18n**          | English, Simplified Chinese, Traditional Chinese                                                   |
 
 ---
 
@@ -34,12 +34,12 @@ Ordo already ships a production-grade core:
 
 Pre-built industry templates — each includes a complete RuleSet, pre-defined Facts & Concepts, sample input data, and a side-by-side "from if/else to Ordo" migration guide.
 
-| Template | Scenario | Showcases |
-|----------|----------|-----------|
-| E-commerce Pricing | Discount tiers + VIP levels + time windows | Decision tables, hit policies |
-| Loan Approval | Multi-condition branches + scorecard | Decision graph, multi-step flow |
-| API Routing | Weighted routing + region + fallback | Action nodes, score aggregation |
-| Permission Check | RBAC + attribute conditions | Policy layer, DENY_OVERRIDES |
+| Template           | Scenario                                   | Showcases                       |
+| ------------------ | ------------------------------------------ | ------------------------------- |
+| E-commerce Pricing | Discount tiers + VIP levels + time windows | Decision tables, hit policies   |
+| Loan Approval      | Multi-condition branches + scorecard       | Decision graph, multi-step flow |
+| API Routing        | Weighted routing + region + fallback       | Action nodes, score aggregation |
+| Permission Check   | RBAC + attribute conditions                | Policy layer, DENY_OVERRIDES    |
 
 ### Guided Onboarding
 
@@ -124,12 +124,12 @@ Search, filter, and visualize execution traces:
 
 Configurable alerts with webhook notification:
 
-| Condition | Example |
-|-----------|---------|
-| Error rate spike | Expression evaluation failures > 1% |
-| Latency anomaly | P99 > threshold for 5 minutes |
-| Traffic drop | QPS suddenly falls (upstream issue?) |
-| Result shift | Reject rate jumps from 10% to 40% |
+| Condition        | Example                              |
+| ---------------- | ------------------------------------ |
+| Error rate spike | Expression evaluation failures > 1%  |
+| Latency anomaly  | P99 > threshold for 5 minutes        |
+| Traffic drop     | QPS suddenly falls (upstream issue?) |
+| Result shift     | Reject rate jumps from 10% to 40%    |
 
 ---
 
@@ -204,17 +204,17 @@ Interactive organization-wide graph:
 
 ### What Cloud Adds
 
-| Capability | Self-hosted (OSS) | Ordo Cloud |
-|-----------|-------------------|------------|
-| Rule editing & publishing | :white_check_mark: | :white_check_mark: |
-| Self-managed Engine | :white_check_mark: | :white_check_mark: |
-| **Hosted Engine** (shared or dedicated) | — | :white_check_mark: |
-| **Bring your own Engine** (register to Cloud) | — | :white_check_mark: |
-| **Real-time collaborative editing** | — | :white_check_mark: |
-| **SSO / SAML** | — | :white_check_mark: |
-| **Long-term metrics & custom dashboards** | — | :white_check_mark: |
-| **Compliance report export** | — | :white_check_mark: |
-| **SLA guarantee + priority support** | — | :white_check_mark: |
+| Capability                                    | Self-hosted (OSS)  | Ordo Cloud         |
+| --------------------------------------------- | ------------------ | ------------------ |
+| Rule editing & publishing                     | :white_check_mark: | :white_check_mark: |
+| Self-managed Engine                           | :white_check_mark: | :white_check_mark: |
+| **Hosted Engine** (shared or dedicated)       | —                  | :white_check_mark: |
+| **Bring your own Engine** (register to Cloud) | —                  | :white_check_mark: |
+| **Real-time collaborative editing**           | —                  | :white_check_mark: |
+| **SSO / SAML**                                | —                  | :white_check_mark: |
+| **Long-term metrics & custom dashboards**     | —                  | :white_check_mark: |
+| **Compliance report export**                  | —                  | :white_check_mark: |
+| **SLA guarantee + priority support**          | —                  | :white_check_mark: |
 
 ---
 
diff --git a/ordo-editor/apps/docs/zh/guide/capabilities.md b/ordo-editor/apps/docs/zh/guide/capabilities.md
new file mode 100644
index 00000000..0aa682d0
--- /dev/null
+++ b/ordo-editor/apps/docs/zh/guide/capabilities.md
@@ -0,0 +1,161 @@
+# 能力与外部调用
+
+Ordo 用 capability 边界来承接外部副作用和运行时集成。这样规则引擎内部仍然保持确定性执行，而指标、审计、HTTP 外调等运行时行为则通过统一接口接入。
+
+## 什么是 capability
+
+一个 capability provider 暴露一个具名运行时服务，以及该服务上的一个或多个操作。
+
+- provider 名称就是 capability 名，例如 `metrics.prometheus`、`audit.logger`、`network.http`
+- operation 是 capability 上调用的方法，例如 `gauge`、`rule_executed`、`post`
+- payload 是传给 provider 的对象数据，同时也是返回结果的主要承载体
+
+运行时里，`ExternalCall` action 会被翻译成 capability 请求：
+
+```json
+{
+  "action": "external_call",
+  "service": "demo.echo",
+  "method": "echo",
+  "params": [["amount", { "Field": "amount" }]],
+  "result_variable": "echo_result",
+  "timeout_ms": 250
+}
+```
+
+如果设置了 `result_variable`，Ordo 会把响应存到这个变量下面：
+
+- `$echo_result.capability`
+- `$echo_result.operation`
+- `$echo_result.payload`
+- `$echo_result.metadata`
+
+## Server 内置 capability
+
+当前 server 默认会注册这些 provider：
+
+| Capability           | 分类      | 常见 operation                                             | 用途                              |
+| -------------------- | --------- | ---------------------------------------------------------- | --------------------------------- |
+| `metrics.prometheus` | `action`  | `gauge`、`counter`                                         | 通过 Prometheus sink 记录规则指标 |
+| `audit.logger`       | `action`  | `rule_executed`                                            | 发出结构化执行审计事件            |
+| `network.http`       | `network` | `get`、`post`、`put`、`patch`、`delete`、`head`、`options` | 发送出站 HTTP 请求                |
+
+## Studio `externalCalls` 如何映射
+
+Studio 的 action step 可以定义 `externalCalls`。现在 editor adapter 会按下面这套规则把它转成 engine 的 `external_call`。
+
+### HTTP 调用
+
+当目标是 HTTP 端点时，使用 `type: "http"`。
+
+```ts
+{
+  type: 'http',
+  target: 'PATCH https://api.example.com/score',
+  params: {
+    applicantId: Expr.variable('$.applicant.id'),
+    score: Expr.number(720),
+  },
+  resultVariable: 'http_result',
+  timeout: 1500,
+}
+```
+
+会被转成：
+
+```json
+{
+  "action": "external_call",
+  "service": "network.http",
+  "method": "patch",
+  "params": [
+    ["url", { "Literal": "https://api.example.com/score" }],
+    [
+      "json_body",
+      {
+        "Object": [
+          ["applicantId", { "Field": "applicant.id" }],
+          ["score", { "Literal": 720 }]
+        ]
+      }
+    ]
+  ],
+  "result_variable": "http_result",
+  "timeout_ms": 1500
+}
+```
+
+规则如下：
+
+- 如果 `target` 以 `METHOD + 空格 + URL` 开头，就使用这个 HTTP method
+- 如果没有 method 前缀，默认使用 `POST`
+- `params` 会被打包成 `json_body`
+- `target` 会变成 `network.http` payload 里的 `url`
+
+### Function 与 gRPC 调用
+
+对于 `type: "function"` 和 `type: "grpc"`，editor 会把 `target` 当成 capability 引用。
+
+支持的 target 形式：
+
+- `demo.echo`
+- `demo.echo#echo`
+- `demo.echo::echo`
+
+规则如下：
+
+- `service` 是 capability 名称
+- 如果 target 里带了 `#` 或 `::`，就把后半段解析成 `method`
+- 如果没有显式 method，`function` 默认用 `invoke`，`grpc` 默认用 `call`
+- `params` 会原样变成 capability payload
+
+示例：
+
+```ts
+{
+  type: 'function',
+  target: 'demo.echo#echo',
+  params: {
+    payload: Expr.object({
+      amount: Expr.variable('$.amount'),
+      approved: Expr.boolean(true),
+    }),
+  },
+  resultVariable: 'echo_result',
+}
+```
+
+## capability payload 里支持的表达式
+
+现在 editor adapter 可以把下列表达式序列化进 capability payload：
+
+- 字面量
+- 字段引用
+- 数组
+- 对象
+- 二元与一元表达式
+- 条件表达式
+- 函数调用
+- 类似 `$.user.profile.id` 这样的简单 member path
+
+## 当前限制
+
+Studio 模型里已经有一些字段，但引擎暂时还没有执行语义：
+
+- `retry`
+- `onError`
+- `fallbackValue`
+
+这些字段目前仍然只停留在 editor 模型层，还不会被 adapter 翻译成真正的 runtime 行为。
+
+这意味着：
+
+- `ExternalCall` 不会自动重试
+- capability 调用失败时不会自动写入 fallback 值
+- `onError` 还没有映射成引擎语义
+
+如果你现在就需要这些行为，应该把它们实现在 capability provider 内部，或者在规则里拆成显式步骤处理。
+
+## 示例 provider
+
+仓库里有一个最小示例 [`examples/capability-demo`](https://github.com/Pama-Lee/Ordo/tree/main/examples/capability-demo)。它注册了 `demo.echo` provider，通过 `ExternalCall` 调用它，并用 `$result.payload` 读取返回值。
diff --git a/ordo-editor/apps/docs/zh/guide/what-is-ordo.md b/ordo-editor/apps/docs/zh/guide/what-is-ordo.md
index 8a4cbc74..d3fc0599 100644
--- a/ordo-editor/apps/docs/zh/guide/what-is-ordo.md
+++ b/ordo-editor/apps/docs/zh/guide/what-is-ordo.md
@@ -14,13 +14,13 @@
 
 Ordo 覆盖规则的完整生命周期：
 
-| 阶段 | Ordo 提供的能力 |
-|------|----------------|
-| **编写** | Studio 流程编辑器、决策表、模板库 |
-| **测试** | 规则集级别测试用例、CI 集成、导出 YAML |
+| 阶段     | Ordo 提供的能力                            |
+| -------- | ------------------------------------------ |
+| **编写** | Studio 流程编辑器、决策表、模板库          |
+| **测试** | 规则集级别测试用例、CI 集成、导出 YAML     |
 | **治理** | 事实目录、带类型的契约、版本历史、审计日志 |
-| **执行** | 高性能引擎、热重载、多租户 |
-| **观测** | 执行追踪、Prometheus 指标、结构化日志 |
+| **执行** | 高性能引擎、热重载、多租户                 |
+| **观测** | 执行追踪、Prometheus 指标、结构化日志      |
 
 ## 架构
 
diff --git a/ordo-editor/apps/docs/zh/index.md b/ordo-editor/apps/docs/zh/index.md
index d853ba53..cc5f3fc7 100644
--- a/ordo-editor/apps/docs/zh/index.md
+++ b/ordo-editor/apps/docs/zh/index.md
@@ -70,4 +70,3 @@ features:
   }
 }
 ```
-
diff --git a/ordo-editor/apps/docs/zh/roadmap.md b/ordo-editor/apps/docs/zh/roadmap.md
index 1e01476e..d26fb7b7 100644
--- a/ordo-editor/apps/docs/zh/roadmap.md
+++ b/ordo-editor/apps/docs/zh/roadmap.md
@@ -11,18 +11,18 @@ outline: [2, 3]
 
 Ordo 已具备生产级的核心能力：
 
-| 模块 | 能力 |
-|------|------|
-| **执行引擎** | 亚微秒级规则执行、字节码 VM + Cranelift JIT、表达式优化器 |
-| **传输协议** | HTTP REST、gRPC（支持 TLS/mTLS）、Unix Domain Socket |
-| **可视化编辑器** | 三种编辑模式（表单 / 流程图 / JSON）、决策表、执行与性能面板 |
-| **CLI** | `ordo eval`、`ordo exec`、`ordo test` |
-| **WASM** | 在浏览器中运行引擎 |
-| **SDK** | Go、Java、Python |
-| **Studio** | 组织/项目/成员管理、事实目录、概念注册、决策契约、版本历史 |
-| **多租户** | 租户级 QPS 限流、突发控制、超时管理 |
-| **可观测性** | Prometheus 指标、OTLP 链路追踪、JSON Lines 审计日志、WAL 崩溃安全持久化 |
-| **国际化** | 英文、简体中文、繁体中文 |
+| 模块             | 能力                                                                    |
+| ---------------- | ----------------------------------------------------------------------- |
+| **执行引擎**     | 亚微秒级规则执行、字节码 VM + Cranelift JIT、表达式优化器               |
+| **传输协议**     | HTTP REST、gRPC（支持 TLS/mTLS）、Unix Domain Socket                    |
+| **可视化编辑器** | 三种编辑模式（表单 / 流程图 / JSON）、决策表、执行与性能面板            |
+| **CLI**          | `ordo eval`、`ordo exec`、`ordo test`                                   |
+| **WASM**         | 在浏览器中运行引擎                                                      |
+| **SDK**          | Go、Java、Python                                                        |
+| **Studio**       | 组织/项目/成员管理、事实目录、概念注册、决策契约、版本历史              |
+| **多租户**       | 租户级 QPS 限流、突发控制、超时管理                                     |
+| **可观测性**     | Prometheus 指标、OTLP 链路追踪、JSON Lines 审计日志、WAL 崩溃安全持久化 |
+| **国际化**       | 英文、简体中文、繁体中文                                                |
 
 ---
 
@@ -34,12 +34,12 @@ Ordo 已具备生产级的核心能力：
 
 预置行业模板——每个模板包含完整的 RuleSet、预定义的 Facts 和 Concepts、示例输入数据，以及"从 if/else 到 Ordo"的迁移对比说明。
 
-| 模板 | 场景 | 展示能力 |
-|------|------|----------|
-| 电商优惠券发放 | 满减 + VIP 等级 + 时间窗口 | 决策表、命中策略 |
-| 贷款审批 | 多条件分支 + 评分卡 | 决策图、多步骤流程 |
-| API 路由选择 | 权重路由 + 地域 + 降级 | Action 节点、评分聚合 |
-| 权限判定 | RBAC + 属性条件 | 策略层、DENY_OVERRIDES |
+| 模板           | 场景                       | 展示能力               |
+| -------------- | -------------------------- | ---------------------- |
+| 电商优惠券发放 | 满减 + VIP 等级 + 时间窗口 | 决策表、命中策略       |
+| 贷款审批       | 多条件分支 + 评分卡        | 决策图、多步骤流程     |
+| API 路由选择   | 权重路由 + 地域 + 降级     | Action 节点、评分聚合  |
+| 权限判定       | RBAC + 属性条件            | 策略层、DENY_OVERRIDES |
 
 ### 引导式 Onboarding
 
@@ -124,12 +124,12 @@ Ordo 已具备生产级的核心能力：
 
 可配置的告警 + Webhook 通知：
 
-| 条件 | 示例 |
-|------|------|
-| 错误率飙升 | 表达式执行失败率 > 1% |
-| 延迟异常 | P99 连续 5 分钟超过阈值 |
-| 流量骤降 | QPS 突然下降（可能上游出问题） |
-| 结果偏移 | 拒绝率从 10% 跳到 40% |
+| 条件       | 示例                           |
+| ---------- | ------------------------------ |
+| 错误率飙升 | 表达式执行失败率 > 1%          |
+| 延迟异常   | P99 连续 5 分钟超过阈值        |
+| 流量骤降   | QPS 突然下降（可能上游出问题） |
+| 结果偏移   | 拒绝率从 10% 跳到 40%          |
 
 ---
 
@@ -204,17 +204,17 @@ Ordo 已具备生产级的核心能力：
 
 ### Cloud 增值功能
 
-| 能力 | 自部署（开源） | Ordo Cloud |
-|------|--------------|------------|
-| 规则编辑与发布 | :white_check_mark: | :white_check_mark: |
-| 自管理 Engine | :white_check_mark: | :white_check_mark: |
-| **托管 Engine**（共享或独占） | — | :white_check_mark: |
-| **接入自有 Engine**（注册到 Cloud） | — | :white_check_mark: |
-| **实时协同编辑** | — | :white_check_mark: |
-| **SSO / SAML** | — | :white_check_mark: |
-| **长期指标存储 + 自定义 Dashboard** | — | :white_check_mark: |
-| **合规报告导出** | — | :white_check_mark: |
-| **SLA 保证 + 优先支持** | — | :white_check_mark: |
+| 能力                                | 自部署（开源）     | Ordo Cloud         |
+| ----------------------------------- | ------------------ | ------------------ |
+| 规则编辑与发布                      | :white_check_mark: | :white_check_mark: |
+| 自管理 Engine                       | :white_check_mark: | :white_check_mark: |
+| **托管 Engine**（共享或独占）       | —                  | :white_check_mark: |
+| **接入自有 Engine**（注册到 Cloud） | —                  | :white_check_mark: |
+| **实时协同编辑**                    | —                  | :white_check_mark: |
+| **SSO / SAML**                      | —                  | :white_check_mark: |
+| **长期指标存储 + 自定义 Dashboard** | —                  | :white_check_mark: |
+| **合规报告导出**                    | —                  | :white_check_mark: |
+| **SLA 保证 + 优先支持**             | —                  | :white_check_mark: |
 
 ---
 
diff --git a/ordo-editor/apps/studio/src/App.vue b/ordo-editor/apps/studio/src/App.vue
index 6651274c..d89970a1 100644
--- a/ordo-editor/apps/studio/src/App.vue
+++ b/ordo-editor/apps/studio/src/App.vue
@@ -1,30 +1,32 @@
 <script setup lang="ts">
-import { onMounted, computed, provide } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { LOCALE_KEY, type Lang } from '@ordo-engine/editor-vue'
-import CommandPalette from '@/components/CommandPalette.vue'
+import { onMounted, computed, provide } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { LOCALE_KEY, type Lang } from '@ordo-engine/editor-vue';
+import CommandPalette from '@/components/CommandPalette.vue';
 
-const auth = useAuthStore()
-const { locale } = useI18n()
+const auth = useAuthStore();
+const { locale } = useI18n();
 
 // Bridge Studio's vue-i18n locale to the editor component's LOCALE_KEY.
 const editorLocale = computed<Lang>({
   get: () => {
-    const v = locale.value
-    if (v === 'en' || v === 'zh-CN' || v === 'zh-TW') return v
-    return 'en'
+    const v = locale.value;
+    if (v === 'en' || v === 'zh-CN' || v === 'zh-TW') return v;
+    return 'en';
   },
-  set: (v) => { locale.value = v },
-})
-provide(LOCALE_KEY, editorLocale)
+  set: (v) => {
+    locale.value = v;
+  },
+});
+provide(LOCALE_KEY, editorLocale);
 
 onMounted(async () => {
   // Restore user info if a token exists
   if (auth.token && !auth.user) {
-    await auth.fetchMe()
+    await auth.fetchMe();
   }
-})
+});
 </script>
 
 <template>
diff --git a/ordo-editor/apps/studio/src/api/catalog-client.ts b/ordo-editor/apps/studio/src/api/catalog-client.ts
index 6bc98108..cbb414a6 100644
--- a/ordo-editor/apps/studio/src/api/catalog-client.ts
+++ b/ordo-editor/apps/studio/src/api/catalog-client.ts
@@ -3,19 +3,12 @@
  * All endpoints are project-scoped: /api/v1/projects/:pid/...
  */
 
-import type {
-  ConceptDefinition,
-  DecisionContract,
-  FactDefinition,
-} from './types'
+import type { ConceptDefinition, DecisionContract, FactDefinition } from './types';
 
-const BASE = '/api/v1'
+const BASE = '/api/v1';
 
-async function request<T>(
-  path: string,
-  options: RequestInit & { token: string },
-): Promise<T> {
-  const { token, ...init } = options
+async function request<T>(path: string, options: RequestInit & { token: string }): Promise<T> {
+  const { token, ...init } = options;
   const resp = await fetch(`${BASE}/${path}`, {
     ...init,
     headers: {
@@ -23,89 +16,97 @@ async function request<T>(
       Authorization: `Bearer ${token}`,
       ...(init.headers as Record<string, string>),
     },
-  })
+  });
   if (!resp.ok) {
-    let errMsg = `HTTP ${resp.status}`
+    let errMsg = `HTTP ${resp.status}`;
     try {
-      const body = await resp.json()
-      errMsg = body.error || errMsg
+      const body = await resp.json();
+      errMsg = body.error || errMsg;
     } catch {
       // ignore
     }
-    const err = new Error(errMsg) as Error & { status: number }
-    err.status = resp.status
-    throw err
+    const err = new Error(errMsg) as Error & { status: number };
+    err.status = resp.status;
+    throw err;
   }
-  if (resp.status === 204) return undefined as T
-  return resp.json()
+  if (resp.status === 204) return undefined as T;
+  return resp.json();
 }
 
 export const catalogApi = {
   // ── Fact Catalog ─────────────────────────────────────────────────────────────
 
   listFacts(token: string, projectId: string): Promise<FactDefinition[]> {
-    return request(`projects/${projectId}/facts`, { method: 'GET', token })
+    return request(`projects/${projectId}/facts`, { method: 'GET', token });
   },
 
-  upsertFact(token: string, projectId: string, fact: Omit<FactDefinition, 'created_at' | 'updated_at'>): Promise<FactDefinition> {
+  upsertFact(
+    token: string,
+    projectId: string,
+    fact: Omit<FactDefinition, 'created_at' | 'updated_at'>
+  ): Promise<FactDefinition> {
     return request(`projects/${projectId}/facts`, {
       method: 'POST',
       token,
       body: JSON.stringify(fact),
-    })
+    });
   },
 
   deleteFact(token: string, projectId: string, name: string): Promise<void> {
     return request(`projects/${projectId}/facts/${encodeURIComponent(name)}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
 
   // ── Concept Registry ─────────────────────────────────────────────────────────
 
   listConcepts(token: string, projectId: string): Promise<ConceptDefinition[]> {
-    return request(`projects/${projectId}/concepts`, { method: 'GET', token })
+    return request(`projects/${projectId}/concepts`, { method: 'GET', token });
   },
 
-  upsertConcept(token: string, projectId: string, concept: Omit<ConceptDefinition, 'created_at' | 'updated_at'>): Promise<ConceptDefinition> {
+  upsertConcept(
+    token: string,
+    projectId: string,
+    concept: Omit<ConceptDefinition, 'created_at' | 'updated_at'>
+  ): Promise<ConceptDefinition> {
     return request(`projects/${projectId}/concepts`, {
       method: 'POST',
       token,
       body: JSON.stringify(concept),
-    })
+    });
   },
 
   deleteConcept(token: string, projectId: string, name: string): Promise<void> {
     return request(`projects/${projectId}/concepts/${encodeURIComponent(name)}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
 
   // ── Decision Contracts ───────────────────────────────────────────────────────
 
   listContracts(token: string, projectId: string): Promise<DecisionContract[]> {
-    return request(`projects/${projectId}/contracts`, { method: 'GET', token })
+    return request(`projects/${projectId}/contracts`, { method: 'GET', token });
   },
 
   upsertContract(
     token: string,
     projectId: string,
     rulesetName: string,
-    contract: Omit<DecisionContract, 'ruleset_name' | 'updated_at'>,
+    contract: Omit<DecisionContract, 'ruleset_name' | 'updated_at'>
   ): Promise<DecisionContract> {
     return request(`projects/${projectId}/contracts/${encodeURIComponent(rulesetName)}`, {
       method: 'PUT',
       token,
       body: JSON.stringify(contract),
-    })
+    });
   },
 
   deleteContract(token: string, projectId: string, rulesetName: string): Promise<void> {
     return request(`projects/${projectId}/contracts/${encodeURIComponent(rulesetName)}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
-}
+};
diff --git a/ordo-editor/apps/studio/src/api/platform-client.ts b/ordo-editor/apps/studio/src/api/platform-client.ts
index 19d80e24..a462ba57 100644
--- a/ordo-editor/apps/studio/src/api/platform-client.ts
+++ b/ordo-editor/apps/studio/src/api/platform-client.ts
@@ -3,7 +3,7 @@
  * Handles auth, organizations, projects, and members.
  */
 
-import { i18n } from '@/i18n'
+import { i18n } from '@/i18n';
 import type {
   AppendRulesetHistoryEntry,
   SystemConfig,
@@ -57,23 +57,23 @@ import type {
   UpdateRoleRequest,
   UserInfo,
   UserRoleAssignment,
-} from './types'
+} from './types';
 
-const BASE = '/api/v1'
+const BASE = '/api/v1';
 
 export const systemApi = {
   getConfig(): Promise<SystemConfig> {
-    return request('/system/config')
+    return request('/system/config');
   },
-}
+};
 
-type PlatformApiError = Error & { status: number; code?: string }
+type PlatformApiError = Error & { status: number; code?: string };
 
 function currentLocale(): string {
   try {
-    return (i18n.global.locale as any).value || 'en'
+    return (i18n.global.locale as any).value || 'en';
   } catch {
-    return 'en'
+    return 'en';
   }
 }
 
@@ -81,68 +81,68 @@ function currentLocale(): string {
 
 async function request<T>(
   path: string,
-  options: RequestInit & { token?: string } = {},
+  options: RequestInit & { token?: string } = {}
 ): Promise<T> {
-  const { token, ...init } = options
+  const { token, ...init } = options;
   const headers: Record<string, string> = {
     'Content-Type': 'application/json',
     'Accept-Language': currentLocale(),
     ...(init.headers as Record<string, string>),
-  }
+  };
   if (token) {
-    headers['Authorization'] = `Bearer ${token}`
+    headers['Authorization'] = `Bearer ${token}`;
   }
 
-  const resp = await fetch(`${BASE}${path}`, { ...init, headers })
+  const resp = await fetch(`${BASE}${path}`, { ...init, headers });
   if (!resp.ok) {
-    let errMsg = `HTTP ${resp.status}`
-    let errCode: string | undefined
+    let errMsg = `HTTP ${resp.status}`;
+    let errCode: string | undefined;
     try {
-      const body = await resp.json()
-      errMsg = body.error || errMsg
-      errCode = body.code
+      const body = await resp.json();
+      errMsg = body.error || errMsg;
+      errCode = body.code;
     } catch {
       // ignore parse errors
     }
-    const err = new Error(errMsg) as PlatformApiError
-    err.status = resp.status
-    err.code = errCode
-    throw err
+    const err = new Error(errMsg) as PlatformApiError;
+    err.status = resp.status;
+    err.code = errCode;
+    throw err;
   }
-  if (resp.status === 204) return undefined as T
-  return resp.json()
+  if (resp.status === 204) return undefined as T;
+  return resp.json();
 }
 
 async function requestText(
   path: string,
-  options: RequestInit & { token?: string } = {},
+  options: RequestInit & { token?: string } = {}
 ): Promise<string> {
-  const { token, ...init } = options
+  const { token, ...init } = options;
   const headers: Record<string, string> = {
     'Accept-Language': currentLocale(),
     ...(init.headers as Record<string, string>),
-  }
+  };
   if (token) {
-    headers['Authorization'] = `Bearer ${token}`
+    headers['Authorization'] = `Bearer ${token}`;
   }
 
-  const resp = await fetch(`${BASE}${path}`, { ...init, headers })
+  const resp = await fetch(`${BASE}${path}`, { ...init, headers });
   if (!resp.ok) {
-    let errMsg = `HTTP ${resp.status}`
-    let errCode: string | undefined
+    let errMsg = `HTTP ${resp.status}`;
+    let errCode: string | undefined;
     try {
-      const body = await resp.json()
-      errMsg = body.error || errMsg
-      errCode = body.code
+      const body = await resp.json();
+      errMsg = body.error || errMsg;
+      errCode = body.code;
     } catch {
       // ignore parse errors
     }
-    const err = new Error(errMsg) as PlatformApiError
-    err.status = resp.status
-    err.code = errCode
-    throw err
+    const err = new Error(errMsg) as PlatformApiError;
+    err.status = resp.status;
+    err.code = errCode;
+    throw err;
   }
-  return resp.text()
+  return resp.text();
 }
 
 // ── Auth ──────────────────────────────────────────────────────────────────────
@@ -152,26 +152,26 @@ export const authApi = {
     return request('/auth/register', {
       method: 'POST',
       body: JSON.stringify({ email, password, display_name }),
-    })
+    });
   },
 
   login(email: string, password: string): Promise<AuthResponse> {
     return request('/auth/login', {
       method: 'POST',
       body: JSON.stringify({ email, password }),
-    })
+    });
   },
 
   me(token: string): Promise<UserInfo> {
-    return request('/auth/me', { token })
+    return request('/auth/me', { token });
   },
 
   refresh(token: string): Promise<AuthResponse> {
-    return request('/auth/refresh', { method: 'POST', token })
+    return request('/auth/refresh', { method: 'POST', token });
   },
 
   updateProfile(token: string, patch: { display_name?: string }): Promise<UserInfo> {
-    return request('/auth/me', { method: 'PUT', token, body: JSON.stringify(patch) })
+    return request('/auth/me', { method: 'PUT', token, body: JSON.stringify(patch) });
   },
 
   changePassword(token: string, current_password: string, new_password: string): Promise<void> {
@@ -179,51 +179,60 @@ export const authApi = {
       method: 'POST',
       token,
       body: JSON.stringify({ current_password, new_password }),
-    })
+    });
   },
-}
+};
 
 // ── Organizations ─────────────────────────────────────────────────────────────
 
 export const orgApi = {
   list(token: string): Promise<OrgResponse[]> {
-    return request('/orgs', { token })
+    return request('/orgs', { token });
   },
 
   get(token: string, orgId: string): Promise<Organization> {
-    return request(`/orgs/${orgId}`, { token })
+    return request(`/orgs/${orgId}`, { token });
   },
 
-  create(token: string, name: string, description?: string, parent_org_id?: string): Promise<OrgResponse> {
+  create(
+    token: string,
+    name: string,
+    description?: string,
+    parent_org_id?: string
+  ): Promise<OrgResponse> {
     return request('/orgs', {
       method: 'POST',
       token,
       body: JSON.stringify({ name, description, parent_org_id }),
-    })
+    });
   },
 
   listSubOrgs(token: string, orgId: string): Promise<OrgResponse[]> {
-    return request(`/orgs/${orgId}/sub-orgs`, { token })
+    return request(`/orgs/${orgId}/sub-orgs`, { token });
   },
 
-  update(token: string, orgId: string, patch: { name?: string; description?: string }): Promise<OrgResponse> {
+  update(
+    token: string,
+    orgId: string,
+    patch: { name?: string; description?: string }
+  ): Promise<OrgResponse> {
     return request(`/orgs/${orgId}`, {
       method: 'PUT',
       token,
       body: JSON.stringify(patch),
-    })
+    });
   },
 
   delete(token: string, orgId: string): Promise<void> {
-    return request(`/orgs/${orgId}`, { method: 'DELETE', token })
+    return request(`/orgs/${orgId}`, { method: 'DELETE', token });
   },
-}
+};
 
 // ── Members ───────────────────────────────────────────────────────────────────
 
 export const memberApi = {
   list(token: string, orgId: string): Promise<Member[]> {
-    return request(`/orgs/${orgId}/members`, { token })
+    return request(`/orgs/${orgId}/members`, { token });
   },
 
   invite(token: string, orgId: string, email: string, role: Role): Promise<Member> {
@@ -231,7 +240,7 @@ export const memberApi = {
       method: 'POST',
       token,
       body: JSON.stringify({ email, role }),
-    })
+    });
   },
 
   updateRole(token: string, orgId: string, userId: string, role: Role): Promise<void> {
@@ -239,51 +248,51 @@ export const memberApi = {
       method: 'PUT',
       token,
       body: JSON.stringify({ role }),
-    })
+    });
   },
 
   remove(token: string, orgId: string, userId: string): Promise<void> {
-    return request(`/orgs/${orgId}/members/${userId}`, { method: 'DELETE', token })
+    return request(`/orgs/${orgId}/members/${userId}`, { method: 'DELETE', token });
   },
-}
+};
 
 // ── Sub-org member management (parent org context) ────────────────────────────
 
 export const subOrgMemberApi = {
   list(token: string, parentOrgId: string, subOrgId: string): Promise<Member[]> {
-    return request(`/orgs/${parentOrgId}/sub-orgs/${subOrgId}/members`, { token })
+    return request(`/orgs/${parentOrgId}/sub-orgs/${subOrgId}/members`, { token });
   },
 
   add(
     token: string,
     parentOrgId: string,
     subOrgId: string,
-    body: { user_id: string; role: Role },
+    body: { user_id: string; role: Role }
   ): Promise<Member> {
     return request(`/orgs/${parentOrgId}/sub-orgs/${subOrgId}/members`, {
       method: 'POST',
       token,
       body: JSON.stringify(body),
-    })
+    });
   },
 
   remove(token: string, parentOrgId: string, subOrgId: string, userId: string): Promise<void> {
     return request(`/orgs/${parentOrgId}/sub-orgs/${subOrgId}/members/${userId}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
-}
+};
 
 // ── Projects ──────────────────────────────────────────────────────────────────
 
 export const projectApi = {
   list(token: string, orgId: string): Promise<Project[]> {
-    return request(`/orgs/${orgId}/projects`, { token })
+    return request(`/orgs/${orgId}/projects`, { token });
   },
 
   get(token: string, orgId: string, projectId: string): Promise<Project> {
-    return request(`/orgs/${orgId}/projects/${projectId}`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}`, { token });
   },
 
   create(token: string, orgId: string, name: string, description?: string): Promise<Project> {
@@ -291,63 +300,63 @@ export const projectApi = {
       method: 'POST',
       token,
       body: JSON.stringify({ name, description }),
-    })
+    });
   },
 
   update(
     token: string,
     orgId: string,
     projectId: string,
-    patch: { name?: string; description?: string },
+    patch: { name?: string; description?: string }
   ): Promise<Project> {
     return request(`/orgs/${orgId}/projects/${projectId}`, {
       method: 'PUT',
       token,
       body: JSON.stringify(patch),
-    })
+    });
   },
 
   delete(token: string, orgId: string, projectId: string): Promise<void> {
-    return request(`/orgs/${orgId}/projects/${projectId}`, { method: 'DELETE', token })
+    return request(`/orgs/${orgId}/projects/${projectId}`, { method: 'DELETE', token });
   },
 
   bindServer(
     token: string,
     orgId: string,
     projectId: string,
-    payload: BindServerRequest,
+    payload: BindServerRequest
   ): Promise<void> {
     return request(`/orgs/${orgId}/projects/${projectId}/server`, {
       method: 'PUT',
       token,
       body: JSON.stringify(payload),
-    })
+    });
   },
-}
+};
 
 // ── Templates ────────────────────────────────────────────────────────────────
 
 export const templateApi = {
   list(token: string): Promise<TemplateMetadata[]> {
-    return request('/templates', { token })
+    return request('/templates', { token });
   },
 
   get(token: string, id: string): Promise<TemplateDetail> {
-    return request(`/templates/${id}`, { token })
+    return request(`/templates/${id}`, { token });
   },
 
   createProject(
     token: string,
     orgId: string,
-    payload: CreateFromTemplatePayload,
+    payload: CreateFromTemplatePayload
   ): Promise<Project> {
     return request(`/orgs/${orgId}/projects/from-template`, {
       method: 'POST',
       token,
       body: JSON.stringify(payload),
-    })
+    });
   },
-}
+};
 
 // ── Test Cases ───────────────────────────────────────────────────────────────
 
@@ -355,15 +364,20 @@ export const testApi = {
   list(token: string, projectId: string, rulesetName: string): Promise<TestCase[]> {
     return request(`/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests`, {
       token,
-    })
+    });
   },
 
-  create(token: string, projectId: string, rulesetName: string, tc: TestCaseInput): Promise<TestCase> {
+  create(
+    token: string,
+    projectId: string,
+    rulesetName: string,
+    tc: TestCaseInput
+  ): Promise<TestCase> {
     return request(`/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests`, {
       method: 'POST',
       token,
       body: JSON.stringify(tc),
-    })
+    });
   },
 
   update(
@@ -371,31 +385,32 @@ export const testApi = {
     projectId: string,
     rulesetName: string,
     id: string,
-    tc: TestCaseInput,
+    tc: TestCaseInput
   ): Promise<TestCase> {
     return request(
       `/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests/${id}`,
-      { method: 'PUT', token, body: JSON.stringify(tc) },
-    )
+      { method: 'PUT', token, body: JSON.stringify(tc) }
+    );
   },
 
   delete(token: string, projectId: string, rulesetName: string, id: string): Promise<void> {
     return request(
       `/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests/${id}`,
-      { method: 'DELETE', token },
-    )
+      { method: 'DELETE', token }
+    );
   },
 
   runAll(
     token: string,
     projectId: string,
     rulesetName: string,
-    req: TestRunRequest = {},
+    req: TestRunRequest = {}
   ): Promise<TestRunResult[]> {
-    return request(
-      `/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests/run`,
-      { method: 'POST', token, body: JSON.stringify(req) },
-    )
+    return request(`/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests/run`, {
+      method: 'POST',
+      token,
+      body: JSON.stringify(req),
+    });
   },
 
   runOne(
@@ -403,31 +418,33 @@ export const testApi = {
     projectId: string,
     rulesetName: string,
     testId: string,
-    req: TestRunRequest = {},
+    req: TestRunRequest = {}
   ): Promise<TestRunResult> {
     return request(
       `/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests/${testId}/run`,
-      { method: 'POST', token, body: JSON.stringify(req) },
-    )
+      { method: 'POST', token, body: JSON.stringify(req) }
+    );
   },
 
   runProject(
     token: string,
     projectId: string,
-    req: ProjectTestRunRequest = {},
+    req: ProjectTestRunRequest = {}
   ): Promise<ProjectTestRunResult> {
     return request(`/projects/${projectId}/tests/run`, {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   /** Returns a download URL (use window.open or anchor href). */
   exportUrl(projectId: string, rulesetName: string, format: 'yaml' | 'json' = 'yaml'): string {
-    return `${BASE}/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/tests/export?format=${format}`
+    return `${BASE}/projects/${projectId}/rulesets/${encodeURIComponent(
+      rulesetName
+    )}/tests/export?format=${format}`;
   },
-}
+};
 
 // ── Ruleset History ──────────────────────────────────────────────────────────
 
@@ -436,114 +453,117 @@ export const rulesetHistoryApi = {
     return request(`/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/history`, {
       method: 'GET',
       token,
-    })
+    });
   },
 
   append(
     token: string,
     projectId: string,
     rulesetName: string,
-    entries: AppendRulesetHistoryEntry[],
+    entries: AppendRulesetHistoryEntry[]
   ): Promise<RulesetHistoryResponse> {
     return request(`/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/history`, {
       method: 'POST',
       token,
       body: JSON.stringify({ entries }),
-    })
+    });
   },
-}
+};
 
 // ── GitHub OAuth ──────────────────────────────────────────────────────────────
 
 export const githubApi = {
   getConnectUrl(token: string): Promise<GitHubConnectUrlResponse> {
-    return request('/github/connect', { token })
+    return request('/github/connect', { token });
   },
 
   getStatus(token: string): Promise<GitHubStatus> {
-    return request('/github/status', { token })
+    return request('/github/status', { token });
   },
 
   disconnect(token: string): Promise<void> {
-    return request('/github/disconnect', { method: 'DELETE', token })
+    return request('/github/disconnect', { method: 'DELETE', token });
   },
-}
+};
 
 // ── GitHub Marketplace ────────────────────────────────────────────────────────
 
 export const marketplaceApi = {
   search(
     token: string,
-    params: { q?: string; sort?: 'stars' | 'updated'; page?: number; per_page?: number },
+    params: { q?: string; sort?: 'stars' | 'updated'; page?: number; per_page?: number }
   ): Promise<MarketplaceSearchResponse> {
-    const qs = new URLSearchParams()
-    if (params.q) qs.set('q', params.q)
-    if (params.sort) qs.set('sort', params.sort)
-    if (params.page) qs.set('page', String(params.page))
-    if (params.per_page) qs.set('per_page', String(params.per_page))
-    return request(`/marketplace/search?${qs}`, { token })
+    const qs = new URLSearchParams();
+    if (params.q) qs.set('q', params.q);
+    if (params.sort) qs.set('sort', params.sort);
+    if (params.page) qs.set('page', String(params.page));
+    if (params.per_page) qs.set('per_page', String(params.per_page));
+    return request(`/marketplace/search?${qs}`, { token });
   },
 
   getItem(token: string, owner: string, repo: string): Promise<MarketplaceDetail> {
-    return request(`/marketplace/repos/${owner}/${repo}`, { token })
+    return request(`/marketplace/repos/${owner}/${repo}`, { token });
   },
 
   install(
     token: string,
     owner: string,
     repo: string,
-    payload: InstallMarketplacePayload,
+    payload: InstallMarketplacePayload
   ): Promise<Project> {
     return request(`/marketplace/install/${owner}/${repo}`, {
       method: 'POST',
       token,
       body: JSON.stringify(payload),
-    })
+    });
   },
-}
+};
 
 // ── Servers ───────────────────────────────────────────────────────────────────
 
 export const serverApi = {
   list(token: string): Promise<ServerInfo[]> {
-    return request('/servers', { token })
+    return request('/servers', { token });
   },
 
   get(token: string, id: string): Promise<ServerInfo> {
-    return request(`/servers/${id}`, { token })
+    return request(`/servers/${id}`, { token });
   },
 
-  getHealth(token: string, id: string): Promise<{ online: boolean; response?: string; error?: string; url: string }> {
-    return request(`/servers/${id}/health`, { token })
+  getHealth(
+    token: string,
+    id: string
+  ): Promise<{ online: boolean; response?: string; error?: string; url: string }> {
+    return request(`/servers/${id}/health`, { token });
   },
 
   getMetrics(token: string, id: string): Promise<string> {
-    return requestText(`/servers/${id}/metrics`, { token })
+    return requestText(`/servers/${id}/metrics`, { token });
   },
 
   delete(token: string, id: string): Promise<void> {
-    return request(`/servers/${id}`, { method: 'DELETE', token })
+    return request(`/servers/${id}`, { method: 'DELETE', token });
   },
-}
+};
 
 // ── Environments ──────────────────────────────────────────────────────────────
 
 export const environmentApi = {
   list(token: string, orgId: string, projectId: string): Promise<ProjectEnvironment[]> {
-    return request(`/orgs/${orgId}/projects/${projectId}/environments`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/environments`, { token });
   },
 
   create(
     token: string,
     orgId: string,
     projectId: string,
-    req: CreateEnvironmentRequest,
+    req: CreateEnvironmentRequest
   ): Promise<ProjectEnvironment> {
     return request(`/orgs/${orgId}/projects/${projectId}/environments`, {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   update(
@@ -551,20 +571,20 @@ export const environmentApi = {
     orgId: string,
     projectId: string,
     envId: string,
-    req: UpdateEnvironmentRequest,
+    req: UpdateEnvironmentRequest
   ): Promise<ProjectEnvironment> {
     return request(`/orgs/${orgId}/projects/${projectId}/environments/${envId}`, {
       method: 'PUT',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   delete(token: string, orgId: string, projectId: string, envId: string): Promise<void> {
     return request(`/orgs/${orgId}/projects/${projectId}/environments/${envId}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
 
   setCanary(
@@ -572,25 +592,27 @@ export const environmentApi = {
     orgId: string,
     projectId: string,
     envId: string,
-    req: SetCanaryRequest,
+    req: SetCanaryRequest
   ): Promise<ProjectEnvironment> {
     return request(`/orgs/${orgId}/projects/${projectId}/environments/${envId}/canary`, {
       method: 'PUT',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
-}
+};
 
 // ── Draft Rulesets ────────────────────────────────────────────────────────────
 
 export const rulesetDraftApi = {
   list(token: string, orgId: string, projectId: string): Promise<ProjectRulesetMeta[]> {
-    return request(`/orgs/${orgId}/projects/${projectId}/rulesets`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/rulesets`, { token });
   },
 
   get(token: string, orgId: string, projectId: string, name: string): Promise<ProjectRuleset> {
-    return request(`/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}`, {
+      token,
+    });
   },
 
   /** Returns the saved draft on success, or a DraftConflictResponse (status 409) on conflict. */
@@ -599,41 +621,44 @@ export const rulesetDraftApi = {
     orgId: string,
     projectId: string,
     name: string,
-    req: SaveDraftRequest,
+    req: SaveDraftRequest
   ): Promise<ProjectRuleset | DraftConflictResponse> {
-    const resp = await fetch(`${BASE}/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}`, {
-      method: 'PUT',
-      headers: {
-        'Content-Type': 'application/json',
-        'Accept-Language': currentLocale(),
-        Authorization: `Bearer ${token}`,
-      },
-      body: JSON.stringify(req),
-    })
+    const resp = await fetch(
+      `${BASE}/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}`,
+      {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept-Language': currentLocale(),
+          Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify(req),
+      }
+    );
     if (resp.status === 409) {
-      return resp.json() as Promise<DraftConflictResponse>
+      return resp.json() as Promise<DraftConflictResponse>;
     }
     if (!resp.ok) {
-      let errMsg = `HTTP ${resp.status}`
-      let errCode: string | undefined
+      let errMsg = `HTTP ${resp.status}`;
+      let errCode: string | undefined;
       try {
-        const body = await resp.json()
-        errMsg = body.error || errMsg
-        errCode = body.code
+        const body = await resp.json();
+        errMsg = body.error || errMsg;
+        errCode = body.code;
       } catch {}
-      const err = new Error(errMsg) as PlatformApiError
-      err.status = resp.status
-      err.code = errCode
-      throw err
+      const err = new Error(errMsg) as PlatformApiError;
+      err.status = resp.status;
+      err.code = errCode;
+      throw err;
     }
-    return resp.json()
+    return resp.json();
   },
 
   delete(token: string, orgId: string, projectId: string, name: string): Promise<void> {
     return request(`/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
 
   publish(
@@ -641,12 +666,12 @@ export const rulesetDraftApi = {
     orgId: string,
     projectId: string,
     name: string,
-    req: PublishRequest,
+    req: PublishRequest
   ): Promise<RulesetDeployment> {
     return request(
       `/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}/publish`,
-      { method: 'POST', token, body: JSON.stringify(req) },
-    )
+      { method: 'POST', token, body: JSON.stringify(req) }
+    );
   },
 
   listDeployments(
@@ -654,23 +679,23 @@ export const rulesetDraftApi = {
     orgId: string,
     projectId: string,
     name: string,
-    limit?: number,
+    limit?: number
   ): Promise<RulesetDeployment[]> {
-    const qs = limit ? `?limit=${limit}` : ''
+    const qs = limit ? `?limit=${limit}` : '';
     return request(
       `/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}/deployments${qs}`,
-      { token },
-    )
+      { token }
+    );
   },
 
   listProjectDeployments(
     token: string,
     orgId: string,
     projectId: string,
-    limit?: number,
+    limit?: number
   ): Promise<RulesetDeployment[]> {
-    const qs = limit ? `?limit=${limit}` : ''
-    return request(`/orgs/${orgId}/projects/${projectId}/deployments${qs}`, { token })
+    const qs = limit ? `?limit=${limit}` : '';
+    return request(`/orgs/${orgId}/projects/${projectId}/deployments${qs}`, { token });
   },
 
   redeploy(
@@ -679,38 +704,44 @@ export const rulesetDraftApi = {
     projectId: string,
     name: string,
     deploymentId: string,
-    req: RedeployRequest,
+    req: RedeployRequest
   ): Promise<RulesetDeployment> {
     return request(
-      `/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(name)}/deployments/${deploymentId}/redeploy`,
-      { method: 'POST', token, body: JSON.stringify(req) },
-    )
+      `/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(
+        name
+      )}/deployments/${deploymentId}/redeploy`,
+      { method: 'POST', token, body: JSON.stringify(req) }
+    );
   },
-}
+};
 
 // ── RBAC ──────────────────────────────────────────────────────────────────────
 
 export const roleApi = {
   list(token: string, orgId: string): Promise<OrgRole[]> {
-    return request(`/orgs/${orgId}/roles`, { token })
+    return request(`/orgs/${orgId}/roles`, { token });
   },
 
   create(token: string, orgId: string, req: CreateRoleRequest): Promise<OrgRole> {
-    return request(`/orgs/${orgId}/roles`, { method: 'POST', token, body: JSON.stringify(req) })
+    return request(`/orgs/${orgId}/roles`, { method: 'POST', token, body: JSON.stringify(req) });
   },
 
   update(token: string, orgId: string, roleId: string, req: UpdateRoleRequest): Promise<OrgRole> {
-    return request(`/orgs/${orgId}/roles/${roleId}`, { method: 'PUT', token, body: JSON.stringify(req) })
+    return request(`/orgs/${orgId}/roles/${roleId}`, {
+      method: 'PUT',
+      token,
+      body: JSON.stringify(req),
+    });
   },
 
   delete(token: string, orgId: string, roleId: string): Promise<void> {
-    return request(`/orgs/${orgId}/roles/${roleId}`, { method: 'DELETE', token })
+    return request(`/orgs/${orgId}/roles/${roleId}`, { method: 'DELETE', token });
   },
-}
+};
 
 export const memberRoleApi = {
   list(token: string, orgId: string, userId: string): Promise<UserRoleAssignment[]> {
-    return request(`/orgs/${orgId}/members/${userId}/roles`, { token })
+    return request(`/orgs/${orgId}/members/${userId}/roles`, { token });
   },
 
   assign(token: string, orgId: string, userId: string, req: AssignRoleRequest): Promise<void> {
@@ -718,19 +749,19 @@ export const memberRoleApi = {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   revoke(token: string, orgId: string, userId: string, roleId: string): Promise<void> {
-    return request(`/orgs/${orgId}/members/${userId}/roles/${roleId}`, { method: 'DELETE', token })
+    return request(`/orgs/${orgId}/members/${userId}/roles/${roleId}`, { method: 'DELETE', token });
   },
-}
+};
 
 // ── Release Center ───────────────────────────────────────────────────────────
 
 export const releaseApi = {
   listPolicies(token: string, orgId: string, projectId: string): Promise<ReleasePolicy[]> {
-    return request(`/orgs/${orgId}/projects/${projectId}/release-policies`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/release-policies`, { token });
   },
 
   createPolicy(
@@ -738,23 +769,23 @@ export const releaseApi = {
     orgId: string,
     projectId: string,
     req: {
-      name: string
-      scope: 'org' | 'project'
-      target_type: 'project' | 'environment'
-      target_id: string
-      description?: string
-      min_approvals: number
-      allow_self_approval: boolean
-      approver_ids: string[]
-      rollout_strategy: RolloutStrategy
-      rollback_policy: RollbackPolicy
-    },
+      name: string;
+      scope: 'org' | 'project';
+      target_type: 'project' | 'environment';
+      target_id: string;
+      description?: string;
+      min_approvals: number;
+      allow_self_approval: boolean;
+      approver_ids: string[];
+      rollout_strategy: RolloutStrategy;
+      rollback_policy: RollbackPolicy;
+    }
   ): Promise<ReleasePolicy> {
     return request(`/orgs/${orgId}/projects/${projectId}/release-policies`, {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   updatePolicy(
@@ -763,41 +794,43 @@ export const releaseApi = {
     projectId: string,
     policyId: string,
     req: {
-      name?: string
-      description?: string
-      min_approvals?: number
-      allow_self_approval?: boolean
-      approver_ids?: string[]
-      rollout_strategy?: RolloutStrategy
-      rollback_policy?: RollbackPolicy
-    },
+      name?: string;
+      description?: string;
+      min_approvals?: number;
+      allow_self_approval?: boolean;
+      approver_ids?: string[];
+      rollout_strategy?: RolloutStrategy;
+      rollback_policy?: RollbackPolicy;
+    }
   ): Promise<ReleasePolicy> {
     return request(`/orgs/${orgId}/projects/${projectId}/release-policies/${policyId}`, {
       method: 'PUT',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   deletePolicy(token: string, orgId: string, projectId: string, policyId: string): Promise<void> {
     return request(`/orgs/${orgId}/projects/${projectId}/release-policies/${policyId}`, {
       method: 'DELETE',
       token,
-    })
+    });
   },
 
   listRequests(token: string, orgId: string, projectId: string): Promise<ReleaseRequest[]> {
-    return request(`/orgs/${orgId}/projects/${projectId}/releases`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/releases`, { token });
   },
 
   previewTarget(
     token: string,
     orgId: string,
     projectId: string,
-    environmentId: string,
+    environmentId: string
   ): Promise<ReleaseTargetPreview> {
-    const qs = new URLSearchParams({ environment_id: environmentId })
-    return request(`/orgs/${orgId}/projects/${projectId}/releases/preview?${qs.toString()}`, { token })
+    const qs = new URLSearchParams({ environment_id: environmentId });
+    return request(`/orgs/${orgId}/projects/${projectId}/releases/preview?${qs.toString()}`, {
+      token,
+    });
   },
 
   createRequest(
@@ -805,91 +838,98 @@ export const releaseApi = {
     orgId: string,
     projectId: string,
     req: {
-      ruleset_name: string
-      version: string
-      environment_id: string
-      policy_id?: string
-      title: string
-      change_summary: string
-      release_note?: string
-      rollback_version?: string
-      affected_instance_count?: number
-    },
+      ruleset_name: string;
+      version: string;
+      environment_id: string;
+      policy_id?: string;
+      title: string;
+      change_summary: string;
+      release_note?: string;
+      rollback_version?: string;
+      affected_instance_count?: number;
+    }
   ): Promise<ReleaseRequest> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases`, {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
-  getRequest(token: string, orgId: string, projectId: string, releaseId: string): Promise<ReleaseRequest> {
-    return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}`, { token })
+  getRequest(
+    token: string,
+    orgId: string,
+    projectId: string,
+    releaseId: string
+  ): Promise<ReleaseRequest> {
+    return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}`, { token });
   },
 
   executeRequest(
     token: string,
     orgId: string,
     projectId: string,
-    releaseId: string,
+    releaseId: string
   ): Promise<ReleaseExecution> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/execute`, {
       method: 'POST',
       token,
-    })
+    });
   },
 
   pauseExecution(
     token: string,
     orgId: string,
     projectId: string,
-    releaseId: string,
+    releaseId: string
   ): Promise<ReleaseExecution> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/pause`, {
       method: 'POST',
       token,
-    })
+    });
   },
 
   resumeExecution(
     token: string,
     orgId: string,
     projectId: string,
-    releaseId: string,
+    releaseId: string
   ): Promise<ReleaseExecution> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/resume`, {
       method: 'POST',
       token,
-    })
+    });
   },
 
   rollbackExecution(
     token: string,
     orgId: string,
     projectId: string,
-    releaseId: string,
+    releaseId: string
   ): Promise<ReleaseExecution> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/rollback`, {
       method: 'POST',
       token,
-    })
+    });
   },
 
   getRequestExecution(
     token: string,
     orgId: string,
     projectId: string,
-    releaseId: string,
+    releaseId: string
   ): Promise<ReleaseExecution | null> {
-    return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/execution`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/execution`, {
+      token,
+    });
   },
 
   getCurrentExecution(
     token: string,
     orgId: string,
-    projectId: string,
+    projectId: string
   ): Promise<ReleaseExecution | null> {
-    return request(`/orgs/${orgId}/projects/${projectId}/release-executions/current`, { token })
+    return request(`/orgs/${orgId}/projects/${projectId}/release-executions/current`, { token });
   },
 
   approveRequest(
@@ -897,13 +937,13 @@ export const releaseApi = {
     orgId: string,
     projectId: string,
     releaseId: string,
-    req: ReviewReleaseRequest,
+    req: ReviewReleaseRequest
   ): Promise<ReleaseRequest> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/approve`, {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   rejectRequest(
@@ -911,13 +951,13 @@ export const releaseApi = {
     orgId: string,
     projectId: string,
     releaseId: string,
-    req: ReviewReleaseRequest,
+    req: ReviewReleaseRequest
   ): Promise<ReleaseRequest> {
     return request(`/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/reject`, {
       method: 'POST',
       token,
       body: JSON.stringify(req),
-    })
+    });
   },
 
   getExecutionEvents(
@@ -925,18 +965,18 @@ export const releaseApi = {
     orgId: string,
     projectId: string,
     releaseId: string,
-    executionId: string,
+    executionId: string
   ): Promise<ReleaseExecutionEvent[]> {
     return request(
       `/orgs/${orgId}/projects/${projectId}/releases/${releaseId}/executions/${executionId}/events`,
-      { token },
-    )
+      { token }
+    );
   },
 
   listPendingForMe(token: string, orgId: string): Promise<ReleaseRequest[]> {
-    return request(`/orgs/${orgId}/releases/pending-for-me`, { token })
+    return request(`/orgs/${orgId}/releases/pending-for-me`, { token });
   },
-}
+};
 
 export const engineApi = {
   executeWithTrace(
@@ -945,16 +985,16 @@ export const engineApi = {
     projectId: string,
     rulesetName: string,
     input: Record<string, unknown>,
-    ruleset: Record<string, unknown>,
+    ruleset: Record<string, unknown>
   ): Promise<{
-    code: string
-    message: string
-    output: Record<string, unknown>
-    duration_us: number
+    code: string;
+    message: string;
+    output: Record<string, unknown>;
+    duration_us: number;
     trace?: {
-      path: string
-      steps: Array<{ id: string; name: string; duration_us: number }>
-    }
+      path: string;
+      steps: Array<{ id: string; name: string; duration_us: number }>;
+    };
   }> {
     return request(
       `/orgs/${orgId}/projects/${projectId}/rulesets/${encodeURIComponent(rulesetName)}/trace`,
@@ -962,34 +1002,34 @@ export const engineApi = {
         method: 'POST',
         token,
         body: JSON.stringify({ ruleset, input }),
-      },
-    )
+      }
+    );
   },
-}
+};
 
 export const notificationApi = {
   list(
     token: string,
     orgId: string,
-    opts: { unread_only?: boolean; limit?: number; offset?: number } = {},
+    opts: { unread_only?: boolean; limit?: number; offset?: number } = {}
   ): Promise<PlatformNotification[]> {
-    const params = new URLSearchParams()
-    if (opts.unread_only) params.set('unread_only', 'true')
-    if (opts.limit) params.set('limit', String(opts.limit))
-    if (opts.offset) params.set('offset', String(opts.offset))
-    const qs = params.toString()
-    return request(`/orgs/${orgId}/notifications${qs ? `?${qs}` : ''}`, { token })
+    const params = new URLSearchParams();
+    if (opts.unread_only) params.set('unread_only', 'true');
+    if (opts.limit) params.set('limit', String(opts.limit));
+    if (opts.offset) params.set('offset', String(opts.offset));
+    const qs = params.toString();
+    return request(`/orgs/${orgId}/notifications${qs ? `?${qs}` : ''}`, { token });
   },
 
   count(token: string, orgId: string): Promise<NotificationCount> {
-    return request(`/orgs/${orgId}/notifications/count`, { token })
+    return request(`/orgs/${orgId}/notifications/count`, { token });
   },
 
   markRead(token: string, orgId: string, notifId: string): Promise<void> {
-    return request(`/orgs/${orgId}/notifications/${notifId}/read`, { method: 'POST', token })
+    return request(`/orgs/${orgId}/notifications/${notifId}/read`, { method: 'POST', token });
   },
 
   markAllRead(token: string, orgId: string): Promise<void> {
-    return request(`/orgs/${orgId}/notifications/read-all`, { method: 'POST', token })
+    return request(`/orgs/${orgId}/notifications/read-all`, { method: 'POST', token });
   },
-}
+};
diff --git a/ordo-editor/apps/studio/src/api/types.ts b/ordo-editor/apps/studio/src/api/types.ts
index d72991c5..9fe8b423 100644
--- a/ordo-editor/apps/studio/src/api/types.ts
+++ b/ordo-editor/apps/studio/src/api/types.ts
@@ -2,486 +2,486 @@
  * Shared TypeScript types mirroring ordo-platform and ordo-server responses
  */
 
-import type { RuleSet } from '@ordo-engine/editor-core'
+import type { RuleSet } from '@ordo-engine/editor-core';
 
 // ── System ────────────────────────────────────────────────────────────────────
 
 export interface SystemConfig {
-  allow_registration: boolean
-  allow_org_creation: boolean
+  allow_registration: boolean;
+  allow_org_creation: boolean;
 }
 
 // ── Auth ──────────────────────────────────────────────────────────────────────
 
-export type Role = 'owner' | 'admin' | 'editor' | 'viewer'
+export type Role = 'owner' | 'admin' | 'editor' | 'viewer';
 
 export interface UserInfo {
-  id: string
-  email: string
-  display_name: string
-  created_at: string
-  last_login: string | null
+  id: string;
+  email: string;
+  display_name: string;
+  created_at: string;
+  last_login: string | null;
 }
 
 export interface AuthResponse {
-  token: string
-  user: UserInfo
+  token: string;
+  user: UserInfo;
 }
 
 // ── Organization ──────────────────────────────────────────────────────────────
 
 export interface OrgResponse {
-  id: string
-  name: string
-  description: string | null
-  created_at: string
-  created_by: string
-  member_count: number
-  parent_org_id: string | null
-  depth: number
-  child_count: number
-  project_count: number
+  id: string;
+  name: string;
+  description: string | null;
+  created_at: string;
+  created_by: string;
+  member_count: number;
+  parent_org_id: string | null;
+  depth: number;
+  child_count: number;
+  project_count: number;
 }
 
 export interface Organization {
-  id: string
-  name: string
-  description: string | null
-  created_at: string
-  created_by: string
-  members: Member[]
-  parent_org_id: string | null
-  depth: number
+  id: string;
+  name: string;
+  description: string | null;
+  created_at: string;
+  created_by: string;
+  members: Member[];
+  parent_org_id: string | null;
+  depth: number;
 }
 
 export interface CreateOrgRequest {
-  name: string
-  description?: string
-  parent_org_id?: string
+  name: string;
+  description?: string;
+  parent_org_id?: string;
 }
 
 export interface Member {
-  user_id: string
-  email: string
-  display_name: string
-  role: Role
-  invited_at: string
+  user_id: string;
+  email: string;
+  display_name: string;
+  role: Role;
+  invited_at: string;
 }
 
 // ── Project ───────────────────────────────────────────────────────────────────
 
 export interface Project {
   /** Same as ordo-server tenant_id */
-  id: string
-  name: string
-  description: string | null
-  org_id: string
-  created_at: string
-  created_by: string
-  server_id: string | null
+  id: string;
+  name: string;
+  description: string | null;
+  org_id: string;
+  created_at: string;
+  created_by: string;
+  server_id: string | null;
 }
 
 // ── Server Registry ───────────────────────────────────────────────────────────
 
-export type ServerStatus = 'online' | 'offline' | 'degraded'
+export type ServerStatus = 'online' | 'offline' | 'degraded';
 
 export interface ServerInfo {
-  id: string
-  name: string
-  url: string
-  org_id: string | null
-  labels: Record<string, string>
-  version: string | null
-  status: ServerStatus
-  last_seen: string | null
-  registered_at: string
+  id: string;
+  name: string;
+  url: string;
+  org_id: string | null;
+  labels: Record<string, string>;
+  version: string | null;
+  status: ServerStatus;
+  last_seen: string | null;
+  registered_at: string;
 }
 
 export interface BindServerRequest {
-  server_id: string | null
+  server_id: string | null;
 }
 
 // ── Ruleset Change History (ordo-platform) ──────────────────────────────────
 
-export type RulesetHistorySource = 'sync' | 'edit' | 'save' | 'restore' | 'create' | 'publish'
+export type RulesetHistorySource = 'sync' | 'edit' | 'save' | 'restore' | 'create' | 'publish';
 
 export interface RulesetHistoryEntry {
-  id: string
-  ruleset_name: string
-  action: string
-  source: RulesetHistorySource
-  created_at: string
-  author_id: string
-  author_email: string
-  author_display_name: string
-  snapshot: RuleSet
+  id: string;
+  ruleset_name: string;
+  action: string;
+  source: RulesetHistorySource;
+  created_at: string;
+  author_id: string;
+  author_email: string;
+  author_display_name: string;
+  snapshot: RuleSet;
 }
 
 export interface RulesetHistoryResponse {
-  ruleset_name: string
-  entries: RulesetHistoryEntry[]
+  ruleset_name: string;
+  entries: RulesetHistoryEntry[];
 }
 
 export interface AppendRulesetHistoryEntry {
-  id: string
-  action: string
-  source: RulesetHistorySource
-  created_at?: string
-  snapshot: RuleSet
+  id: string;
+  action: string;
+  source: RulesetHistorySource;
+  created_at?: string;
+  snapshot: RuleSet;
 }
 
 // ── Engine (ordo-server) ──────────────────────────────────────────────────────
 
 export interface RuleSetInfo {
-  name: string
-  version: string
-  published_version?: string | null
-  description: string
+  name: string;
+  version: string;
+  published_version?: string | null;
+  description: string;
 }
 
 export interface VersionInfo {
-  seq: number
-  version: string
-  created_at: string
+  seq: number;
+  version: string;
+  created_at: string;
 }
 
 export interface VersionListResponse {
-  name: string
-  current_version: string
-  versions: VersionInfo[]
+  name: string;
+  current_version: string;
+  versions: VersionInfo[];
 }
 
 export interface ExecuteRequest {
-  input: Record<string, unknown>
+  input: Record<string, unknown>;
   options?: {
-    include_trace?: boolean
-    timeout_ms?: number
-  }
+    include_trace?: boolean;
+    timeout_ms?: number;
+  };
 }
 
 export interface ExecuteResponse {
   result: {
-    code: string
-    message: string
-    output: Record<string, unknown>
-  }
-  duration_us: number
-  trace?: unknown
+    code: string;
+    message: string;
+    output: Record<string, unknown>;
+  };
+  duration_us: number;
+  trace?: unknown;
 }
 
 // ── Fact Catalog (ordo-book Ch7) ──────────────────────────────────────────────
 
-export type FactDataType = 'string' | 'number' | 'boolean' | 'date' | 'object'
-export type NullPolicy = 'error' | 'default' | 'skip'
+export type FactDataType = 'string' | 'number' | 'boolean' | 'date' | 'object';
+export type NullPolicy = 'error' | 'default' | 'skip';
 
 export interface FactDefinition {
-  name: string
-  data_type: FactDataType
-  source: string
-  latency_ms?: number
-  null_policy: NullPolicy
-  description?: string
-  owner?: string
-  created_at: string
-  updated_at: string
+  name: string;
+  data_type: FactDataType;
+  source: string;
+  latency_ms?: number;
+  null_policy: NullPolicy;
+  description?: string;
+  owner?: string;
+  created_at: string;
+  updated_at: string;
 }
 
 // ── Concept Registry (ordo-book Ch7) ─────────────────────────────────────────
 
 export interface ConceptDefinition {
-  name: string
-  data_type: FactDataType
-  expression: string
-  dependencies: string[]
-  description?: string
-  created_at: string
-  updated_at: string
+  name: string;
+  data_type: FactDataType;
+  expression: string;
+  dependencies: string[];
+  description?: string;
+  created_at: string;
+  updated_at: string;
 }
 
 // ── Decision Contract (ordo-book Ch13) ───────────────────────────────────────
 
 export interface ContractField {
-  name: string
-  data_type: FactDataType
-  required: boolean
-  description?: string
+  name: string;
+  data_type: FactDataType;
+  required: boolean;
+  description?: string;
 }
 
 export interface DecisionContract {
-  ruleset_name: string
-  version_pattern: string
-  owner: string
-  sla_p99_ms?: number
-  input_fields: ContractField[]
-  output_fields: ContractField[]
-  notes?: string
-  updated_at: string
+  ruleset_name: string;
+  version_pattern: string;
+  owner: string;
+  sla_p99_ms?: number;
+  input_fields: ContractField[];
+  output_fields: ContractField[];
+  notes?: string;
+  updated_at: string;
 }
 
 // ── Rule Templates (M1.1) ────────────────────────────────────────────────────
 
-export type TemplateDifficulty = 'beginner' | 'intermediate' | 'advanced'
+export type TemplateDifficulty = 'beginner' | 'intermediate' | 'advanced';
 
 export interface TemplateMetadata {
-  id: string
-  name: string
-  description: string
-  tags: string[]
-  icon?: string
-  difficulty: TemplateDifficulty
-  features: string[]
+  id: string;
+  name: string;
+  description: string;
+  tags: string[];
+  icon?: string;
+  difficulty: TemplateDifficulty;
+  features: string[];
 }
 
 export interface TemplateSample {
-  label: string
-  input: Record<string, unknown>
-  expected_result?: string
+  label: string;
+  input: Record<string, unknown>;
+  expected_result?: string;
 }
 
 export interface TemplateDetail extends TemplateMetadata {
-  facts: FactDefinition[]
-  concepts: ConceptDefinition[]
-  ruleset: RuleSet
-  samples: TemplateSample[]
-  contract?: DecisionContract
-  tests: TestCase[]
+  facts: FactDefinition[];
+  concepts: ConceptDefinition[];
+  ruleset: RuleSet;
+  samples: TemplateSample[];
+  contract?: DecisionContract;
+  tests: TestCase[];
 }
 
 export interface CreateFromTemplatePayload {
-  template_id: string
-  project_name: string
-  project_description?: string
+  template_id: string;
+  project_name: string;
+  project_description?: string;
 }
 
 // ── Test Cases (M1.2) ────────────────────────────────────────────────────────
 
 export interface TestExpectation {
-  code?: string
-  message?: string
-  output?: Record<string, unknown>
+  code?: string;
+  message?: string;
+  output?: Record<string, unknown>;
 }
 
 export interface TestCase {
-  id: string
-  name: string
-  description?: string
-  input: Record<string, unknown>
-  expect: TestExpectation
-  tags: string[]
-  created_at: string
-  updated_at: string
-  created_by: string
+  id: string;
+  name: string;
+  description?: string;
+  input: Record<string, unknown>;
+  expect: TestExpectation;
+  tags: string[];
+  created_at: string;
+  updated_at: string;
+  created_by: string;
 }
 
 export interface TestCaseInput {
-  name: string
-  description?: string
-  input: Record<string, unknown>
-  expect: TestExpectation
-  tags?: string[]
+  name: string;
+  description?: string;
+  input: Record<string, unknown>;
+  expect: TestExpectation;
+  tags?: string[];
 }
 
 export interface TestRunResult {
-  test_id: string
-  test_name: string
-  passed: boolean
-  failures: string[]
-  duration_us: number
-  actual_code?: string
-  actual_message?: string
-  actual_output?: Record<string, unknown>
-  trace?: TestExecutionTrace
+  test_id: string;
+  test_name: string;
+  passed: boolean;
+  failures: string[];
+  duration_us: number;
+  actual_code?: string;
+  actual_message?: string;
+  actual_output?: Record<string, unknown>;
+  trace?: TestExecutionTrace;
 }
 
 export interface TestExecutionTraceStep {
-  id: string
-  name: string
-  duration_us: number
-  next_step?: string | null
-  is_terminal?: boolean
-  input_snapshot?: Record<string, unknown> | null
-  variables_snapshot?: Record<string, unknown> | null
+  id: string;
+  name: string;
+  duration_us: number;
+  next_step?: string | null;
+  is_terminal?: boolean;
+  input_snapshot?: Record<string, unknown> | null;
+  variables_snapshot?: Record<string, unknown> | null;
 }
 
 export interface TestExecutionTrace {
-  trace_id: string
-  path: string[]
-  path_string: string
-  result_code: string
-  total_duration_us: number
-  error?: string | null
-  steps: TestExecutionTraceStep[]
+  trace_id: string;
+  path: string[];
+  path_string: string;
+  result_code: string;
+  total_duration_us: number;
+  error?: string | null;
+  steps: TestExecutionTraceStep[];
 }
 
 export interface TestRunRequest {
-  ruleset?: Record<string, unknown>
-  include_trace?: boolean
+  ruleset?: Record<string, unknown>;
+  include_trace?: boolean;
 }
 
 export interface ProjectTestRunRequest {
-  rulesets?: Record<string, Record<string, unknown>>
-  include_trace?: boolean
+  rulesets?: Record<string, Record<string, unknown>>;
+  include_trace?: boolean;
 }
 
 export interface RulesetTestSummary {
-  ruleset_name: string
-  total: number
-  passed: number
-  failed: number
-  results: TestRunResult[]
+  ruleset_name: string;
+  total: number;
+  passed: number;
+  failed: number;
+  results: TestRunResult[];
 }
 
 export interface ProjectTestRunResult {
-  total: number
-  passed: number
-  failed: number
-  rulesets: RulesetTestSummary[]
+  total: number;
+  passed: number;
+  failed: number;
+  rulesets: RulesetTestSummary[];
 }
 
 // ── GitHub Integration ────────────────────────────────────────────────────────
 
 export interface GitHubConnectUrlResponse {
-  url: string
+  url: string;
 }
 
 export interface GitHubStatus {
-  connected: boolean
-  login?: string
-  name?: string
-  avatar_url?: string
-  connected_at?: string
+  connected: boolean;
+  login?: string;
+  name?: string;
+  avatar_url?: string;
+  connected_at?: string;
 }
 
 // ── GitHub Marketplace ────────────────────────────────────────────────────────
 
 export interface MarketplaceItem {
-  id: string
-  name: string
-  full_name: string
-  description: string | null
-  html_url: string
-  stars: number
-  topics: string[]
-  updated_at: string
-  owner_login: string
-  owner_avatar: string
-  icon?: string
-  difficulty?: TemplateDifficulty
-  tags: string[]
-  features: string[]
+  id: string;
+  name: string;
+  full_name: string;
+  description: string | null;
+  html_url: string;
+  stars: number;
+  topics: string[];
+  updated_at: string;
+  owner_login: string;
+  owner_avatar: string;
+  icon?: string;
+  difficulty?: TemplateDifficulty;
+  tags: string[];
+  features: string[];
 }
 
 export interface MarketplaceSearchResponse {
-  items: MarketplaceItem[]
-  total_count: number
-  page: number
-  per_page: number
+  items: MarketplaceItem[];
+  total_count: number;
+  page: number;
+  per_page: number;
 }
 
 /** Full detail: MarketplaceItem fields + TemplateDetail fields + GitHub enrichments */
 export interface MarketplaceDetail extends TemplateDetail {
-  github_url?: string
-  stars?: number
-  owner_login?: string
-  owner_avatar?: string
-  full_name?: string
-  updated_at?: string
-  topics?: string[]
+  github_url?: string;
+  stars?: number;
+  owner_login?: string;
+  owner_avatar?: string;
+  full_name?: string;
+  updated_at?: string;
+  topics?: string[];
 }
 
 export interface InstallMarketplacePayload {
-  org_id: string
-  project_name: string
-  project_description?: string
+  org_id: string;
+  project_name: string;
+  project_description?: string;
 }
 
 // ── Environments ─────────────────────────────────────────────────────────────
 
 export interface ProjectEnvironment {
-  id: string
-  project_id: string
-  name: string
-  server_ids: string[]
-  nats_subject_prefix: string | null
-  is_default: boolean
-  canary_target_env_id: string | null
-  canary_percentage: number
-  created_at: string
+  id: string;
+  project_id: string;
+  name: string;
+  server_ids: string[];
+  nats_subject_prefix: string | null;
+  is_default: boolean;
+  canary_target_env_id: string | null;
+  canary_percentage: number;
+  created_at: string;
 }
 
 export interface CreateEnvironmentRequest {
-  name: string
-  server_ids: string[]
-  nats_subject_prefix?: string | null
+  name: string;
+  server_ids: string[];
+  nats_subject_prefix?: string | null;
 }
 
 export interface UpdateEnvironmentRequest {
-  name?: string
-  server_ids?: string[]
-  nats_subject_prefix?: string | null
+  name?: string;
+  server_ids?: string[];
+  nats_subject_prefix?: string | null;
 }
 
 export interface SetCanaryRequest {
-  canary_target_env_id: string | null
-  canary_percentage: number
+  canary_target_env_id: string | null;
+  canary_percentage: number;
 }
 
 // ── Draft Rulesets ────────────────────────────────────────────────────────────
 
 export interface ProjectRulesetMeta {
-  id: string
-  project_id: string
-  name: string
-  draft_seq: number
-  draft_updated_at: string
-  draft_updated_by: string | null
-  draft_version: string | null
-  published_version: string | null
-  published_at: string | null
-  created_at: string
+  id: string;
+  project_id: string;
+  name: string;
+  draft_seq: number;
+  draft_updated_at: string;
+  draft_updated_by: string | null;
+  draft_version: string | null;
+  published_version: string | null;
+  published_at: string | null;
+  created_at: string;
 }
 
 export interface ProjectRuleset extends ProjectRulesetMeta {
-  draft: RuleSet
+  draft: RuleSet;
 }
 
 export interface SaveDraftRequest {
-  ruleset: RuleSet
-  expected_seq: number
+  ruleset: RuleSet;
+  expected_seq: number;
 }
 
 export interface DraftConflictResponse {
-  conflict: true
-  server_draft: RuleSet
-  server_seq: number
+  conflict: true;
+  server_draft: RuleSet;
+  server_seq: number;
 }
 
 // ── Deployments ───────────────────────────────────────────────────────────────
 
-export type DeploymentStatus = 'queued' | 'success' | 'failed'
+export type DeploymentStatus = 'queued' | 'success' | 'failed';
 
 export interface RulesetDeployment {
-  id: string
-  project_id: string
-  environment_id: string
-  environment_name: string | null
-  ruleset_name: string
-  version: string
-  release_note: string | null
-  snapshot: RuleSet
-  deployed_at: string
-  deployed_by: string | null
-  status: DeploymentStatus
+  id: string;
+  project_id: string;
+  environment_id: string;
+  environment_name: string | null;
+  ruleset_name: string;
+  version: string;
+  release_note: string | null;
+  snapshot: RuleSet;
+  deployed_at: string;
+  deployed_by: string | null;
+  status: DeploymentStatus;
 }
 
 export interface PublishRequest {
-  environment_id: string
-  release_note?: string
+  environment_id: string;
+  release_note?: string;
 }
 
 export interface RedeployRequest {
-  environment_id: string
-  release_note?: string
+  environment_id: string;
+  release_note?: string;
 }
 
 // ── Release Center ────────────────────────────────────────────────────────────
@@ -495,156 +495,156 @@ export type ReleaseRequestStatus =
   | 'executing'
   | 'completed'
   | 'failed'
-  | 'rolled_back'
+  | 'rolled_back';
 
-export type ReleaseApprovalDecision = 'pending' | 'approved' | 'rejected'
+export type ReleaseApprovalDecision = 'pending' | 'approved' | 'rejected';
 
 export type RolloutStrategyKind =
   | 'all_at_once'
   | 'fixed_batch'
   | 'percentage_batch'
-  | 'time_interval_batch'
+  | 'time_interval_batch';
 
 export interface RolloutStrategy {
-  kind: RolloutStrategyKind
-  batch_size?: number
-  batch_percentage?: number
-  batch_interval_seconds?: number
-  auto_rollback_on_failure?: boolean
-  pause_on_error_rate?: number
-  pause_on_metric_breach?: boolean
+  kind: RolloutStrategyKind;
+  batch_size?: number;
+  batch_percentage?: number;
+  batch_interval_seconds?: number;
+  auto_rollback_on_failure?: boolean;
+  pause_on_error_rate?: number;
+  pause_on_metric_breach?: boolean;
 }
 
 export interface RollbackPolicy {
-  auto_rollback: boolean
-  max_failed_instances: number
-  metric_guard?: string
+  auto_rollback: boolean;
+  max_failed_instances: number;
+  metric_guard?: string;
 }
 
 export interface ReleaseApprovalRecord {
-  id: string
-  stage: number
-  reviewer_id: string
-  reviewer_name: string
-  reviewer_email?: string | null
-  decision: ReleaseApprovalDecision
-  comment?: string
-  decided_at?: string
+  id: string;
+  stage: number;
+  reviewer_id: string;
+  reviewer_name: string;
+  reviewer_email?: string | null;
+  decision: ReleaseApprovalDecision;
+  comment?: string;
+  decided_at?: string;
 }
 
 export interface ReleaseVersionDiff {
-  from_version?: string | null
-  to_version: string
-  rollback_version?: string | null
-  changed: boolean
+  from_version?: string | null;
+  to_version: string;
+  rollback_version?: string | null;
+  changed: boolean;
 }
 
 export interface ReleaseStepDiffItem {
-  id: string
-  name: string
-  step_type?: string | null
+  id: string;
+  name: string;
+  step_type?: string | null;
 }
 
 export interface ReleaseContentDiffSummary {
-  baseline_version?: string | null
-  step_count_before: number
-  step_count_after: number
-  group_count_before: number
-  group_count_after: number
-  added_steps: ReleaseStepDiffItem[]
-  removed_steps: ReleaseStepDiffItem[]
-  modified_steps: ReleaseStepDiffItem[]
-  added_groups: string[]
-  removed_groups: string[]
-  modified_groups: string[]
-  input_schema_changed: boolean
-  output_schema_changed: boolean
-  tags_changed: boolean
-  description_changed: boolean
+  baseline_version?: string | null;
+  step_count_before: number;
+  step_count_after: number;
+  group_count_before: number;
+  group_count_after: number;
+  added_steps: ReleaseStepDiffItem[];
+  removed_steps: ReleaseStepDiffItem[];
+  modified_steps: ReleaseStepDiffItem[];
+  added_groups: string[];
+  removed_groups: string[];
+  modified_groups: string[];
+  input_schema_changed: boolean;
+  output_schema_changed: boolean;
+  tags_changed: boolean;
+  description_changed: boolean;
 }
 
 export interface ReleaseRequestSnapshot {
-  requester_id: string
-  requester_name?: string | null
-  requester_email?: string | null
-  policy_name?: string | null
-  policy_scope?: 'org' | 'project' | null
-  target_type?: 'environment' | 'project' | null
-  target_id?: string | null
-  environment_name?: string | null
-  approver_ids: string[]
-  approver_names: string[]
-  approver_emails: string[]
-  min_approvals?: number | null
-  allow_self_approval?: boolean | null
-  rollout_strategy: RolloutStrategy
-  rollback_policy: RollbackPolicy
-  affected_instance_count: number
+  requester_id: string;
+  requester_name?: string | null;
+  requester_email?: string | null;
+  policy_name?: string | null;
+  policy_scope?: 'org' | 'project' | null;
+  target_type?: 'environment' | 'project' | null;
+  target_id?: string | null;
+  environment_name?: string | null;
+  approver_ids: string[];
+  approver_names: string[];
+  approver_emails: string[];
+  min_approvals?: number | null;
+  allow_self_approval?: boolean | null;
+  rollout_strategy: RolloutStrategy;
+  rollback_policy: RollbackPolicy;
+  affected_instance_count: number;
 }
 
 export interface ReleaseRequest {
-  id: string
-  org_id?: string
-  project_id?: string
-  title: string
-  ruleset_name: string
-  version: string
-  environment_id: string
-  environment_name: string | null
-  change_summary: string
-  release_note?: string | null
-  status: ReleaseRequestStatus
-  created_by: string
-  created_by_name?: string | null
-  created_by_email?: string | null
-  created_at: string
-  updated_at?: string
-  approvals: ReleaseApprovalRecord[]
-  affected_instance_count: number
-  policy_id?: string | null
-  rollout_strategy: RolloutStrategy
-  rollback_version?: string | null
-  version_diff: ReleaseVersionDiff
-  content_diff: ReleaseContentDiffSummary
-  request_snapshot: ReleaseRequestSnapshot
+  id: string;
+  org_id?: string;
+  project_id?: string;
+  title: string;
+  ruleset_name: string;
+  version: string;
+  environment_id: string;
+  environment_name: string | null;
+  change_summary: string;
+  release_note?: string | null;
+  status: ReleaseRequestStatus;
+  created_by: string;
+  created_by_name?: string | null;
+  created_by_email?: string | null;
+  created_at: string;
+  updated_at?: string;
+  approvals: ReleaseApprovalRecord[];
+  affected_instance_count: number;
+  policy_id?: string | null;
+  rollout_strategy: RolloutStrategy;
+  rollback_version?: string | null;
+  version_diff: ReleaseVersionDiff;
+  content_diff: ReleaseContentDiffSummary;
+  request_snapshot: ReleaseRequestSnapshot;
 }
 
 export interface ReleaseTargetServerPreview {
-  id: string
-  name: string
-  url: string
-  status: 'online' | 'offline' | 'degraded'
-  version?: string | null
+  id: string;
+  name: string;
+  url: string;
+  status: 'online' | 'offline' | 'degraded';
+  version?: string | null;
 }
 
 export interface ReleaseTargetPreview {
-  environment_id: string
-  environment_name: string
-  affected_instance_count: number
-  bound_servers: ReleaseTargetServerPreview[]
-  message?: string | null
+  environment_id: string;
+  environment_name: string;
+  affected_instance_count: number;
+  bound_servers: ReleaseTargetServerPreview[];
+  message?: string | null;
 }
 
 export interface ReleasePolicy {
-  id: string
-  org_id?: string
-  project_id?: string | null
-  name: string
-  scope: 'org' | 'project'
-  target_type: 'environment' | 'project'
-  target_id: string
-  description?: string
-  min_approvals: number
-  allow_self_approval: boolean
-  approver_ids: string[]
-  rollout_strategy: RolloutStrategy
-  rollback_policy: RollbackPolicy
-  created_at?: string
-  updated_at: string
+  id: string;
+  org_id?: string;
+  project_id?: string | null;
+  name: string;
+  scope: 'org' | 'project';
+  target_type: 'environment' | 'project';
+  target_id: string;
+  description?: string;
+  min_approvals: number;
+  allow_self_approval: boolean;
+  approver_ids: string[];
+  rollout_strategy: RolloutStrategy;
+  rollback_policy: RollbackPolicy;
+  created_at?: string;
+  updated_at: string;
 }
 
 export interface ReviewReleaseRequest {
-  comment?: string
+  comment?: string;
 }
 
 export type ReleaseExecutionStatus =
@@ -655,7 +655,7 @@ export type ReleaseExecutionStatus =
   | 'verifying'
   | 'rollback_in_progress'
   | 'completed'
-  | 'failed'
+  | 'failed';
 
 export type ReleaseInstanceStatus =
   | 'pending'
@@ -665,124 +665,136 @@ export type ReleaseInstanceStatus =
   | 'success'
   | 'failed'
   | 'rolled_back'
-  | 'skipped'
+  | 'skipped';
 
 export interface ReleaseExecutionInstance {
-  id: string
-  instance_name: string
-  zone?: string
-  current_version: string
-  target_version: string
-  status: ReleaseInstanceStatus
-  updated_at?: string
-  message?: string
+  id: string;
+  instance_name: string;
+  zone?: string;
+  current_version: string;
+  target_version: string;
+  status: ReleaseInstanceStatus;
+  updated_at?: string;
+  message?: string;
   metric_summary?: {
-    batch_index?: number
-    total_batches?: number
-    duration_ms?: number
-    applied_at?: string
-    event?: string
-    [key: string]: unknown
-  }
+    batch_index?: number;
+    total_batches?: number;
+    duration_ms?: number;
+    applied_at?: string;
+    event?: string;
+    [key: string]: unknown;
+  };
 }
 
 export interface ReleaseExecutionEvent {
-  id: string
-  release_execution_id: string
-  instance_id?: string
-  event_type: string
-  payload: Record<string, unknown>
-  created_at: string
+  id: string;
+  release_execution_id: string;
+  instance_id?: string;
+  event_type: string;
+  payload: Record<string, unknown>;
+  created_at: string;
 }
 
 export interface PlatformNotification {
-  id: string
-  org_id: string
-  user_id: string
-  type: 'release_review_requested' | 'release_approved' | 'release_rejected' | string
-  ref_id?: string
-  ref_type?: string
+  id: string;
+  org_id: string;
+  user_id: string;
+  type: 'release_review_requested' | 'release_approved' | 'release_rejected' | string;
+  ref_id?: string;
+  ref_type?: string;
   payload: {
-    title?: string
-    project_id?: string
-    requester_id?: string
-    reviewer_id?: string
-    [key: string]: unknown
-  }
-  read_at?: string
-  created_at: string
+    title?: string;
+    project_id?: string;
+    requester_id?: string;
+    reviewer_id?: string;
+    [key: string]: unknown;
+  };
+  read_at?: string;
+  created_at: string;
 }
 
 export interface NotificationCount {
-  unread: number
+  unread: number;
 }
 
 export interface ReleaseExecution {
-  id: string
-  request_id: string
-  status: ReleaseExecutionStatus
-  started_at: string
-  current_batch: number
-  total_batches: number
-  strategy: RolloutStrategy
+  id: string;
+  request_id: string;
+  status: ReleaseExecutionStatus;
+  started_at: string;
+  current_batch: number;
+  total_batches: number;
+  strategy: RolloutStrategy;
   summary: {
-    total_instances: number
-    succeeded_instances: number
-    failed_instances: number
-    pending_instances: number
-  }
-  instances: ReleaseExecutionInstance[]
+    total_instances: number;
+    succeeded_instances: number;
+    failed_instances: number;
+    pending_instances: number;
+  };
+  instances: ReleaseExecutionInstance[];
 }
 
 // ── RBAC ──────────────────────────────────────────────────────────────────────
 
 export interface OrgRole {
-  id: string
-  org_id: string
-  name: string
-  description: string | null
-  permissions: string[]
-  is_system: boolean
-  created_at: string
+  id: string;
+  org_id: string;
+  name: string;
+  description: string | null;
+  permissions: string[];
+  is_system: boolean;
+  created_at: string;
 }
 
 export interface CreateRoleRequest {
-  name: string
-  description?: string
-  permissions: string[]
+  name: string;
+  description?: string;
+  permissions: string[];
 }
 
 export interface UpdateRoleRequest {
-  name?: string
-  description?: string
-  permissions?: string[]
+  name?: string;
+  description?: string;
+  permissions?: string[];
 }
 
 export interface UserRoleAssignment {
-  user_id: string
-  org_id: string
-  role_id: string
-  role_name: string
-  assigned_at: string
-  assigned_by: string | null
+  user_id: string;
+  org_id: string;
+  role_id: string;
+  role_name: string;
+  assigned_at: string;
+  assigned_by: string | null;
 }
 
 export interface AssignRoleRequest {
-  role_id: string
+  role_id: string;
 }
 
 // ── All permission constants ───────────────────────────────────────────────────
 
 export const PERMISSIONS = [
-  'org:view', 'org:manage',
-  'member:view', 'member:invite', 'member:remove',
-  'role:view', 'role:manage',
-  'project:view', 'project:create', 'project:manage', 'project:delete',
-  'ruleset:view', 'ruleset:edit', 'ruleset:publish',
-  'environment:view', 'environment:manage',
-  'server:view', 'server:manage',
+  'org:view',
+  'org:manage',
+  'member:view',
+  'member:invite',
+  'member:remove',
+  'role:view',
+  'role:manage',
+  'project:view',
+  'project:create',
+  'project:manage',
+  'project:delete',
+  'ruleset:view',
+  'ruleset:edit',
+  'ruleset:publish',
+  'environment:view',
+  'environment:manage',
+  'server:view',
+  'server:manage',
   'test:run',
-  'deployment:view', 'deployment:redeploy',
+  'deployment:view',
+  'deployment:redeploy',
   'canary:manage',
   'release:policy.manage',
   'release:request.create',
@@ -794,13 +806,13 @@ export const PERMISSIONS = [
   'release:resume',
   'release:rollback',
   'release:instance.view',
-] as const
+] as const;
 
-export type Permission = typeof PERMISSIONS[number]
+export type Permission = (typeof PERMISSIONS)[number];
 
 // ── Error ─────────────────────────────────────────────────────────────────────
 
 export interface ApiError {
-  error: string
-  status: number
+  error: string;
+  status: number;
 }
diff --git a/ordo-editor/apps/studio/src/assets.d.ts b/ordo-editor/apps/studio/src/assets.d.ts
index cca58c80..00cce807 100644
--- a/ordo-editor/apps/studio/src/assets.d.ts
+++ b/ordo-editor/apps/studio/src/assets.d.ts
@@ -1,24 +1,24 @@
 declare module '*.png' {
-  const src: string
-  export default src
+  const src: string;
+  export default src;
 }
 
 declare module '*.jpg' {
-  const src: string
-  export default src
+  const src: string;
+  export default src;
 }
 
 declare module '*.jpeg' {
-  const src: string
-  export default src
+  const src: string;
+  export default src;
 }
 
 declare module '*.webp' {
-  const src: string
-  export default src
+  const src: string;
+  export default src;
 }
 
 declare module '*.svg' {
-  const src: string
-  export default src
+  const src: string;
+  export default src;
 }
diff --git a/ordo-editor/apps/studio/src/components/ChangeHistoryPanel.vue b/ordo-editor/apps/studio/src/components/ChangeHistoryPanel.vue
index 0cc9fdc6..8a78044e 100644
--- a/ordo-editor/apps/studio/src/components/ChangeHistoryPanel.vue
+++ b/ordo-editor/apps/studio/src/components/ChangeHistoryPanel.vue
@@ -1,28 +1,28 @@
 <script setup lang="ts">
-import { computed } from 'vue'
-import { useI18n } from 'vue-i18n'
-import type { RulesetHistoryEntry } from '@/api/types'
+import { computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import type { RulesetHistoryEntry } from '@/api/types';
 
 const props = defineProps<{
-  entries: RulesetHistoryEntry[]
-  currentIndex: number
-  collapsed: boolean
-  loading?: boolean
-  syncing?: boolean
-  canUndo: boolean
-  canRedo: boolean
-}>()
+  entries: RulesetHistoryEntry[];
+  currentIndex: number;
+  collapsed: boolean;
+  loading?: boolean;
+  syncing?: boolean;
+  canUndo: boolean;
+  canRedo: boolean;
+}>();
 
 const emit = defineEmits<{
-  toggle: []
-  undo: []
-  redo: []
-  restore: [index: number]
-}>()
+  toggle: [];
+  undo: [];
+  redo: [];
+  restore: [index: number];
+}>();
 
-const { t, locale } = useI18n()
+const { t, locale } = useI18n();
 
-const currentEntry = computed(() => props.entries[props.currentIndex] ?? null)
+const currentEntry = computed(() => props.entries[props.currentIndex] ?? null);
 
 function formatTime(value: string) {
   return new Date(value).toLocaleTimeString(
@@ -31,36 +31,36 @@ function formatTime(value: string) {
       hour: '2-digit',
       minute: '2-digit',
       second: '2-digit',
-    },
-  )
+    }
+  );
 }
 
 function sourceLabel(source: RulesetHistoryEntry['source']) {
   switch (source) {
     case 'save':
-      return t('historyPanel.sourceSave')
+      return t('historyPanel.sourceSave');
     case 'restore':
-      return t('historyPanel.sourceRestore')
+      return t('historyPanel.sourceRestore');
     case 'create':
-      return t('historyPanel.sourceCreate')
+      return t('historyPanel.sourceCreate');
     case 'sync':
-      return t('historyPanel.sourceSync')
+      return t('historyPanel.sourceSync');
     case 'edit':
     default:
-      return t('historyPanel.sourceEdit')
+      return t('historyPanel.sourceEdit');
   }
 }
 
 function sourceBadgeLabel(source: RulesetHistoryEntry['source']) {
   switch (source) {
     case 'save':
-      return t('historyPanel.badgeCheckpoint')
+      return t('historyPanel.badgeCheckpoint');
     case 'restore':
-      return t('historyPanel.badgeRestore')
+      return t('historyPanel.badgeRestore');
     case 'create':
-      return t('historyPanel.badgeCreate')
+      return t('historyPanel.badgeCreate');
     default:
-      return ''
+      return '';
   }
 }
 </script>
diff --git a/ordo-editor/apps/studio/src/components/CommandPalette.vue b/ordo-editor/apps/studio/src/components/CommandPalette.vue
index fe7feb49..39e86c69 100644
--- a/ordo-editor/apps/studio/src/components/CommandPalette.vue
+++ b/ordo-editor/apps/studio/src/components/CommandPalette.vue
@@ -1,33 +1,33 @@
 <script setup lang="ts">
-import { ref, computed, onMounted, onUnmounted, watch, nextTick } from 'vue'
-import { useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useProjectStore } from '@/stores/project'
-import { useCatalogStore } from '@/stores/catalog'
-import { useOrgStore } from '@/stores/org'
-
-const { t } = useI18n()
-const router = useRouter()
-const projectStore = useProjectStore()
-const catalogStore = useCatalogStore()
-const orgStore = useOrgStore()
-
-const visible = ref(false)
-const query = ref('')
-const selectedIdx = ref(0)
-const inputRef = ref<HTMLInputElement | null>(null)
+import { ref, computed, onMounted, onUnmounted, watch, nextTick } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useProjectStore } from '@/stores/project';
+import { useCatalogStore } from '@/stores/catalog';
+import { useOrgStore } from '@/stores/org';
+
+const { t } = useI18n();
+const router = useRouter();
+const projectStore = useProjectStore();
+const catalogStore = useCatalogStore();
+const orgStore = useOrgStore();
+
+const visible = ref(false);
+const query = ref('');
+const selectedIdx = ref(0);
+const inputRef = ref<HTMLInputElement | null>(null);
 
 interface ResultItem {
-  id: string
-  label: string
-  desc?: string
-  group: string
-  action: () => void
+  id: string;
+  label: string;
+  desc?: string;
+  group: string;
+  action: () => void;
 }
 
 const results = computed<ResultItem[]>(() => {
-  const q = query.value.toLowerCase().trim()
-  const items: ResultItem[] = []
+  const q = query.value.toLowerCase().trim();
+  const items: ResultItem[] = [];
 
   // Projects
   for (const p of projectStore.projects) {
@@ -37,22 +37,28 @@ const results = computed<ResultItem[]>(() => {
         label: p.name,
         desc: p.description ?? undefined,
         group: t('search.groupProjects'),
-        action: () => { const oid = orgStore.currentOrg?.id; if (oid) router.push(`/orgs/${oid}/projects/${p.id}/editor`) },
-      })
+        action: () => {
+          const oid = orgStore.currentOrg?.id;
+          if (oid) router.push(`/orgs/${oid}/projects/${p.id}/editor`);
+        },
+      });
     }
   }
 
   // Rulesets
   for (const r of projectStore.rulesets) {
     if (!q || r.name.toLowerCase().includes(q)) {
-      const pid = projectStore.currentProject?.id
+      const pid = projectStore.currentProject?.id;
       items.push({
         id: `ruleset-${r.name}`,
         label: r.name,
         desc: projectStore.currentProject?.name,
         group: t('search.groupRulesets'),
-        action: () => { const oid = orgStore.currentOrg?.id; if (oid && pid) router.push(`/orgs/${oid}/projects/${pid}/editor/${r.name}`) },
-      })
+        action: () => {
+          const oid = orgStore.currentOrg?.id;
+          if (oid && pid) router.push(`/orgs/${oid}/projects/${pid}/editor/${r.name}`);
+        },
+      });
     }
   }
 
@@ -65,11 +71,11 @@ const results = computed<ResultItem[]>(() => {
         desc: f.description ?? undefined,
         group: t('search.groupFacts'),
         action: () => {
-          const pid = projectStore.currentProject?.id
-          const oid = orgStore.currentOrg?.id
-          if (oid && pid) router.push(`/orgs/${oid}/projects/${pid}/facts`)
+          const pid = projectStore.currentProject?.id;
+          const oid = orgStore.currentOrg?.id;
+          if (oid && pid) router.push(`/orgs/${oid}/projects/${pid}/facts`);
         },
-      })
+      });
     }
   }
 
@@ -82,70 +88,72 @@ const results = computed<ResultItem[]>(() => {
         desc: c.description ?? undefined,
         group: t('search.groupConcepts'),
         action: () => {
-          const pid = projectStore.currentProject?.id
-          const oid = orgStore.currentOrg?.id
-          if (oid && pid) router.push(`/orgs/${oid}/projects/${pid}/concepts`)
+          const pid = projectStore.currentProject?.id;
+          const oid = orgStore.currentOrg?.id;
+          if (oid && pid) router.push(`/orgs/${oid}/projects/${pid}/concepts`);
         },
-      })
+      });
     }
   }
 
-  return items.slice(0, 20)
-})
+  return items.slice(0, 20);
+});
 
 // Group results for display
 const groups = computed(() => {
-  const map = new Map<string, ResultItem[]>()
+  const map = new Map<string, ResultItem[]>();
   for (const item of results.value) {
-    if (!map.has(item.group)) map.set(item.group, [])
-    map.get(item.group)!.push(item)
+    if (!map.has(item.group)) map.set(item.group, []);
+    map.get(item.group)!.push(item);
   }
-  return map
-})
+  return map;
+});
 
 // Flat list for keyboard nav
-const flatItems = computed(() => results.value)
+const flatItems = computed(() => results.value);
 
 function open() {
-  visible.value = true
-  query.value = ''
-  selectedIdx.value = 0
-  nextTick(() => inputRef.value?.focus())
+  visible.value = true;
+  query.value = '';
+  selectedIdx.value = 0;
+  nextTick(() => inputRef.value?.focus());
 }
 
 function close() {
-  visible.value = false
+  visible.value = false;
 }
 
 function onKeydown(e: KeyboardEvent) {
   if ((e.ctrlKey || e.metaKey) && e.key === 'k') {
-    e.preventDefault()
-    visible.value ? close() : open()
+    e.preventDefault();
+    visible.value ? close() : open();
   }
 }
 
 function onPaletteKey(e: KeyboardEvent) {
   if (e.key === 'Escape') {
-    close()
+    close();
   } else if (e.key === 'ArrowDown') {
-    e.preventDefault()
-    selectedIdx.value = Math.min(selectedIdx.value + 1, flatItems.value.length - 1)
+    e.preventDefault();
+    selectedIdx.value = Math.min(selectedIdx.value + 1, flatItems.value.length - 1);
   } else if (e.key === 'ArrowUp') {
-    e.preventDefault()
-    selectedIdx.value = Math.max(selectedIdx.value - 1, 0)
+    e.preventDefault();
+    selectedIdx.value = Math.max(selectedIdx.value - 1, 0);
   } else if (e.key === 'Enter') {
-    const item = flatItems.value[selectedIdx.value]
+    const item = flatItems.value[selectedIdx.value];
     if (item) {
-      item.action()
-      close()
+      item.action();
+      close();
     }
   }
 }
 
-watch(query, () => { selectedIdx.value = 0 })
+watch(query, () => {
+  selectedIdx.value = 0;
+});
 
-onMounted(() => window.addEventListener('keydown', onKeydown))
-onUnmounted(() => window.removeEventListener('keydown', onKeydown))
+onMounted(() => window.addEventListener('keydown', onKeydown));
+onUnmounted(() => window.removeEventListener('keydown', onKeydown));
 </script>
 
 <template>
@@ -176,7 +184,10 @@ onUnmounted(() => window.removeEventListener('keydown', onKeydown))
                 :key="item.id"
                 class="palette-item"
                 :class="{ 'is-selected': flatItems.indexOf(item) === selectedIdx }"
-                @click="item.action(); close()"
+                @click="
+                  item.action();
+                  close();
+                "
                 @mouseenter="selectedIdx = flatItems.indexOf(item)"
               >
                 <span class="palette-item__label">{{ item.label }}</span>
diff --git a/ordo-editor/apps/studio/src/components/layout/AppLayout.vue b/ordo-editor/apps/studio/src/components/layout/AppLayout.vue
index d1c4eaf9..9398f9df 100644
--- a/ordo-editor/apps/studio/src/components/layout/AppLayout.vue
+++ b/ordo-editor/apps/studio/src/components/layout/AppLayout.vue
@@ -1,80 +1,81 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import platformLogo from '@/assets/platform-logo.png'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { useProjectStore } from '@/stores/project'
-import { useServerStore } from '@/stores/server'
-import { useNotificationStore } from '@/stores/notification'
-import { usePersistentNotificationStore } from '@/stores/persistentNotifications'
-import { i18n, LOCALE_OPTIONS, setLocale, type Locale } from '@/i18n'
-
-const router = useRouter()
-const route = useRoute()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const projectStore = useProjectStore()
-const serverStore = useServerStore()
-const notifStore = useNotificationStore()
-const persistentNotifStore = usePersistentNotificationStore()
-const { t } = useI18n()
-
-const currentLocale = computed(() => (i18n.global.locale as any).value as Locale)
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import platformLogo from '@/assets/platform-logo.png';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { useProjectStore } from '@/stores/project';
+import { useServerStore } from '@/stores/server';
+import { useNotificationStore } from '@/stores/notification';
+import { usePersistentNotificationStore } from '@/stores/persistentNotifications';
+import { i18n, LOCALE_OPTIONS, setLocale, type Locale } from '@/i18n';
+
+const router = useRouter();
+const route = useRoute();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const projectStore = useProjectStore();
+const serverStore = useServerStore();
+const notifStore = useNotificationStore();
+const persistentNotifStore = usePersistentNotificationStore();
+const { t } = useI18n();
+
+const currentLocale = computed(() => (i18n.global.locale as any).value as Locale);
 const currentLocaleLabel = computed(
-  () => LOCALE_OPTIONS.find((option) => option.value === currentLocale.value)?.label ?? 'EN',
-)
+  () => LOCALE_OPTIONS.find((option) => option.value === currentLocale.value)?.label ?? 'EN'
+);
 
-const currentOrgId = computed(() => orgStore.currentOrg?.id ?? '')
+const currentOrgId = computed(() => orgStore.currentOrg?.id ?? '');
 const currentProjectId = computed(() =>
-  typeof route.params.projectId === 'string' ? route.params.projectId : null,
-)
+  typeof route.params.projectId === 'string' ? route.params.projectId : null
+);
 
 const currentProject = computed(() =>
   currentProjectId.value
     ? projectStore.projects.find((project) => project.id === currentProjectId.value) ?? null
-    : projectStore.currentProject,
-)
+    : projectStore.currentProject
+);
 
 // ── Topbar dropdown state ────────────────────────────────────────────────────
 
-const projectPickerOpen = ref(false)
-const orgSwitcherOpen = ref(false)
-const healthOpen = ref(false)
-const notifOpen = ref(false)
-const orgSwitcherRef = ref<HTMLElement | null>(null)
-const projectPickerRef = ref<HTMLElement | null>(null)
-const healthRef = ref<HTMLElement | null>(null)
-const notifRef = ref<HTMLElement | null>(null)
-const showCreateOrg = ref(false)
-const creatingOrg = ref(false)
-const newOrgName = ref('')
-const newOrgDesc = ref('')
+const projectPickerOpen = ref(false);
+const orgSwitcherOpen = ref(false);
+const healthOpen = ref(false);
+const notifOpen = ref(false);
+const orgSwitcherRef = ref<HTMLElement | null>(null);
+const projectPickerRef = ref<HTMLElement | null>(null);
+const healthRef = ref<HTMLElement | null>(null);
+const notifRef = ref<HTMLElement | null>(null);
+const showCreateOrg = ref(false);
+const creatingOrg = ref(false);
+const newOrgName = ref('');
+const newOrgDesc = ref('');
 
 function onDocumentClick(e: MouseEvent) {
-  const target = e.target as Node
-  if (orgSwitcherRef.value && !orgSwitcherRef.value.contains(target)) orgSwitcherOpen.value = false
-  if (projectPickerRef.value && !projectPickerRef.value.contains(target)) projectPickerOpen.value = false
-  if (healthRef.value && !healthRef.value.contains(target)) healthOpen.value = false
-  if (notifRef.value && !notifRef.value.contains(target)) notifOpen.value = false
+  const target = e.target as Node;
+  if (orgSwitcherRef.value && !orgSwitcherRef.value.contains(target)) orgSwitcherOpen.value = false;
+  if (projectPickerRef.value && !projectPickerRef.value.contains(target))
+    projectPickerOpen.value = false;
+  if (healthRef.value && !healthRef.value.contains(target)) healthOpen.value = false;
+  if (notifRef.value && !notifRef.value.contains(target)) notifOpen.value = false;
 }
 
 // ── Server health ────────────────────────────────────────────────────────────
 
 const boundServer = computed(() => {
-  if (!currentProject.value?.server_id) return null
-  return serverStore.getById(currentProject.value.server_id) ?? null
-})
+  if (!currentProject.value?.server_id) return null;
+  return serverStore.getById(currentProject.value.server_id) ?? null;
+});
 
-const boundServerStatus = computed(() => boundServer.value?.status ?? 'default')
+const boundServerStatus = computed(() => boundServer.value?.status ?? 'default');
 
 function statusTheme(status: string) {
-  if (status === 'online') return 'success'
-  if (status === 'degraded') return 'warning'
-  if (status === 'default') return 'default'
-  return 'danger'
+  if (status === 'online') return 'success';
+  if (status === 'degraded') return 'warning';
+  if (status === 'default') return 'default';
+  return 'danger';
 }
 
 // ── Project picker ───────────────────────────────────────────────────────────
@@ -84,178 +85,262 @@ const projectOptions = computed(() =>
     id: p.id,
     name: p.name,
     active: p.id === currentProject.value?.id,
-  })),
-)
+  }))
+);
 
 function switchProject(projectId: string) {
-  projectPickerOpen.value = false
-  navigate(`/orgs/${currentOrgId.value}/projects/${projectId}/editor`)
+  projectPickerOpen.value = false;
+  navigate(`/orgs/${currentOrgId.value}/projects/${projectId}/editor`);
 }
 
 // ── Notifications ────────────────────────────────────────────────────────────
 
 function formatNotifTime(date: Date) {
-  const diff = Date.now() - date.getTime()
-  if (diff < 60_000) return t('shell.justNow')
-  if (diff < 3_600_000) return t('shell.minutesAgo', { n: Math.floor(diff / 60_000) })
-  if (diff < 86_400_000) return t('shell.hoursAgo', { n: Math.floor(diff / 3_600_000) })
-  return date.toLocaleDateString()
+  const diff = Date.now() - date.getTime();
+  if (diff < 60_000) return t('shell.justNow');
+  if (diff < 3_600_000) return t('shell.minutesAgo', { n: Math.floor(diff / 60_000) });
+  if (diff < 86_400_000) return t('shell.hoursAgo', { n: Math.floor(diff / 3_600_000) });
+  return date.toLocaleDateString();
 }
 
 function notifIcon(type: string) {
-  if (type === 'success') return 'check-circle'
-  if (type === 'error') return 'close-circle'
-  if (type === 'warning') return 'error-circle'
-  return 'info-circle'
+  if (type === 'success') return 'check-circle';
+  if (type === 'error') return 'close-circle';
+  if (type === 'warning') return 'error-circle';
+  return 'info-circle';
 }
 
 // ── Page info ────────────────────────────────────────────────────────────────
 
 const pageInfo = computed(() => {
-  const name = route.name?.toString()
+  const name = route.name?.toString();
   switch (name) {
-    case 'dashboard':      return { title: t('nav.dashboard'), subtitle: t('shell.dashboardSubtitle', { projects: projectStore.projects.length, members: orgStore.members.length, servers: serverStore.servers.filter(s => s.status === 'online').length }) }
-    case 'projects':       return { title: t('nav.projects'), subtitle: t('shell.projectsSubtitle') }
-    case 'org-members':    return { title: t('nav.members'), subtitle: t('shell.membersSubtitle') }
+    case 'dashboard':
+      return {
+        title: t('nav.dashboard'),
+        subtitle: t('shell.dashboardSubtitle', {
+          projects: projectStore.projects.length,
+          members: orgStore.members.length,
+          servers: serverStore.servers.filter((s) => s.status === 'online').length,
+        }),
+      };
+    case 'projects':
+      return { title: t('nav.projects'), subtitle: t('shell.projectsSubtitle') };
+    case 'org-members':
+      return { title: t('nav.members'), subtitle: t('shell.membersSubtitle') };
     case 'org-roles':
     case 'org-role-create':
-    case 'org-role-edit':  return { title: t('nav.roles'), subtitle: t('shell.rolesSubtitle') }
-    case 'org-settings':   return { title: t('nav.orgSettings'), subtitle: t('shell.orgSettingsSubtitle') }
-    case 'settings':       return { title: t('nav.settings'), subtitle: t('shell.settingsSubtitle') }
-    case 'servers':        return { title: t('settings.serverRegistry.title'), subtitle: t('shell.serversSubtitle') }
-    case 'org-servers':    return { title: t('settings.serverRegistry.title'), subtitle: t('shell.serversSubtitle') }
+    case 'org-role-edit':
+      return { title: t('nav.roles'), subtitle: t('shell.rolesSubtitle') };
+    case 'org-settings':
+      return { title: t('nav.orgSettings'), subtitle: t('shell.orgSettingsSubtitle') };
+    case 'settings':
+      return { title: t('nav.settings'), subtitle: t('shell.settingsSubtitle') };
+    case 'servers':
+      return { title: t('settings.serverRegistry.title'), subtitle: t('shell.serversSubtitle') };
+    case 'org-servers':
+      return { title: t('settings.serverRegistry.title'), subtitle: t('shell.serversSubtitle') };
     case 'editor':
-    case 'editor-ruleset': return { title: currentProject.value?.name ?? t('projectNav.rules'), subtitle: t('shell.editorSubtitle') }
-    case 'facts':          return { title: t('projectNav.facts'), subtitle: t('facts.desc') }
-    case 'concepts':       return { title: t('projectNav.concepts'), subtitle: t('concepts.desc') }
-    case 'contracts':      return { title: t('projectNav.contracts'), subtitle: t('contracts.desc') }
-    case 'tests':          return { title: t('projectNav.tests'), subtitle: t('shell.testsSubtitle') }
-    case 'versions':       return { title: t('projectNav.versions'), subtitle: t('shell.versionsSubtitle') }
+    case 'editor-ruleset':
+      return {
+        title: currentProject.value?.name ?? t('projectNav.rules'),
+        subtitle: t('shell.editorSubtitle'),
+      };
+    case 'facts':
+      return { title: t('projectNav.facts'), subtitle: t('facts.desc') };
+    case 'concepts':
+      return { title: t('projectNav.concepts'), subtitle: t('concepts.desc') };
+    case 'contracts':
+      return { title: t('projectNav.contracts'), subtitle: t('contracts.desc') };
+    case 'tests':
+      return { title: t('projectNav.tests'), subtitle: t('shell.testsSubtitle') };
+    case 'versions':
+      return { title: t('projectNav.versions'), subtitle: t('shell.versionsSubtitle') };
     case 'project-releases':
     case 'project-release-requests':
     case 'project-release-request-detail':
     case 'project-release-policies':
     case 'project-release-history':
-      return { title: t('projectNav.releases'), subtitle: t('releaseCenter.subtitle') }
-    case 'project-instances': return { title: t('projectNav.instances'), subtitle: t('projectInstances.bindingDesc') }
-    case 'project-settings':    return { title: t('projectNav.settings'), subtitle: t('projectSettings.serverBindingDesc') }
-    case 'marketplace':         return { title: t('marketplace.title'), subtitle: t('marketplace.subtitle') }
-    case 'marketplace-detail':  return { title: t('marketplace.detail'), subtitle: t('marketplace.subtitle') }
-    default:               return { title: t('nav.dashboard'), subtitle: t('shell.dashboardSubtitle', { projects: projectStore.projects.length, members: orgStore.members.length, servers: serverStore.servers.filter(s => s.status === 'online').length }) }
+      return { title: t('projectNav.releases'), subtitle: t('releaseCenter.subtitle') };
+    case 'project-instances':
+      return { title: t('projectNav.instances'), subtitle: t('projectInstances.bindingDesc') };
+    case 'project-settings':
+      return { title: t('projectNav.settings'), subtitle: t('projectSettings.serverBindingDesc') };
+    case 'marketplace':
+      return { title: t('marketplace.title'), subtitle: t('marketplace.subtitle') };
+    case 'marketplace-detail':
+      return { title: t('marketplace.detail'), subtitle: t('marketplace.subtitle') };
+    default:
+      return {
+        title: t('nav.dashboard'),
+        subtitle: t('shell.dashboardSubtitle', {
+          projects: projectStore.projects.length,
+          members: orgStore.members.length,
+          servers: serverStore.servers.filter((s) => s.status === 'online').length,
+        }),
+      };
   }
-})
+});
 
 // ── Nav items ────────────────────────────────────────────────────────────────
 
 const workspaceItems = computed(() => {
-  const projectTarget = currentOrgId.value ? `/orgs/${currentOrgId.value}/projects` : '/orgs'
+  const projectTarget = currentOrgId.value ? `/orgs/${currentOrgId.value}/projects` : '/orgs';
   return [
-    { value: 'dashboard', label: t('nav.dashboard'), icon: 'dashboard-1', active: route.path.startsWith('/dashboard'), action: () => navigate('/dashboard') },
-    { value: 'projects',  label: t('nav.projects'), icon: 'layers', active: route.path.includes('/projects') && route.query.openTemplate !== '1', action: () => navigate(projectTarget) },
-    { value: 'templates', label: t('template.fromTemplate'), icon: 'gesture-applause', active: route.path.includes('/projects') && route.query.openTemplate === '1', action: () => navigate(projectTarget, { openTemplate: '1' }) },
-  ]
-})
+    {
+      value: 'dashboard',
+      label: t('nav.dashboard'),
+      icon: 'dashboard-1',
+      active: route.path.startsWith('/dashboard'),
+      action: () => navigate('/dashboard'),
+    },
+    {
+      value: 'projects',
+      label: t('nav.projects'),
+      icon: 'layers',
+      active: route.path.includes('/projects') && route.query.openTemplate !== '1',
+      action: () => navigate(projectTarget),
+    },
+    {
+      value: 'templates',
+      label: t('template.fromTemplate'),
+      icon: 'gesture-applause',
+      active: route.path.includes('/projects') && route.query.openTemplate === '1',
+      action: () => navigate(projectTarget, { openTemplate: '1' }),
+    },
+  ];
+});
 
 const orgItems = computed(() => {
-  if (!currentOrgId.value) return []
+  if (!currentOrgId.value) return [];
   return [
-    { value: 'members',    label: t('nav.members'), icon: 'usergroup', active: route.path.includes('/members'), action: () => navigate(`/orgs/${currentOrgId.value}/members`) },
-    { value: 'roles',      label: t('nav.roles'), icon: 'secured', active: route.path.includes('/roles'), action: () => navigate(`/orgs/${currentOrgId.value}/roles`) },
-    { value: 'servers',    label: t('settings.serverRegistry.title'), icon: 'internet', active: route.path.includes(`/orgs/${currentOrgId.value}/servers`), action: () => navigate(`/orgs/${currentOrgId.value}/servers`) },
-    { value: 'orgSettings', label: t('nav.orgSettings'), icon: 'setting-1', active: route.path.includes(`/orgs/${currentOrgId.value}/settings`), action: () => navigate(`/orgs/${currentOrgId.value}/settings`) },
-  ]
-})
+    {
+      value: 'members',
+      label: t('nav.members'),
+      icon: 'usergroup',
+      active: route.path.includes('/members'),
+      action: () => navigate(`/orgs/${currentOrgId.value}/members`),
+    },
+    {
+      value: 'roles',
+      label: t('nav.roles'),
+      icon: 'secured',
+      active: route.path.includes('/roles'),
+      action: () => navigate(`/orgs/${currentOrgId.value}/roles`),
+    },
+    {
+      value: 'servers',
+      label: t('settings.serverRegistry.title'),
+      icon: 'internet',
+      active: route.path.includes(`/orgs/${currentOrgId.value}/servers`),
+      action: () => navigate(`/orgs/${currentOrgId.value}/servers`),
+    },
+    {
+      value: 'orgSettings',
+      label: t('nav.orgSettings'),
+      icon: 'setting-1',
+      active: route.path.includes(`/orgs/${currentOrgId.value}/settings`),
+      action: () => navigate(`/orgs/${currentOrgId.value}/settings`),
+    },
+  ];
+});
 
 const systemItems = computed(() => [
-  { value: 'settings', label: t('nav.settings'), icon: 'setting', active: route.path.startsWith('/settings'), action: () => navigate('/settings') },
-])
+  {
+    value: 'settings',
+    label: t('nav.settings'),
+    icon: 'setting',
+    active: route.path.startsWith('/settings'),
+    action: () => navigate('/settings'),
+  },
+]);
 
 // Org switcher list: root orgs first, then their sub-orgs indented below each parent
 const orgOptions = computed(() => {
-  const roots = orgStore.orgs.filter((o) => o.depth === 0)
-  const result: { label: string; value: string; depth: number }[] = []
+  const roots = orgStore.orgs.filter((o) => o.depth === 0);
+  const result: { label: string; value: string; depth: number }[] = [];
   for (const root of roots) {
-    result.push({ label: root.name, value: root.id, depth: 0 })
-    const subs = orgStore.orgs.filter((o) => o.parent_org_id === root.id)
+    result.push({ label: root.name, value: root.id, depth: 0 });
+    const subs = orgStore.orgs.filter((o) => o.parent_org_id === root.id);
     for (const sub of subs) {
-      result.push({ label: sub.name, value: sub.id, depth: 1 })
+      result.push({ label: sub.name, value: sub.id, depth: 1 });
     }
   }
-  return result
-})
+  return result;
+});
 
 // ── Lifecycle ────────────────────────────────────────────────────────────────
 
 onMounted(async () => {
-  await orgStore.fetchOrgs()
+  await orgStore.fetchOrgs();
   if (orgStore.currentOrg) {
-    await projectStore.fetchProjects(orgStore.currentOrg.id)
-    persistentNotifStore.startPolling(orgStore.currentOrg.id)
+    await projectStore.fetchProjects(orgStore.currentOrg.id);
+    persistentNotifStore.startPolling(orgStore.currentOrg.id);
   }
-  await serverStore.fetchServers()
-  document.addEventListener('click', onDocumentClick, true)
-})
+  await serverStore.fetchServers();
+  document.addEventListener('click', onDocumentClick, true);
+});
 
 onUnmounted(() => {
-  persistentNotifStore.stopPolling()
-  document.removeEventListener('click', onDocumentClick, true)
-})
+  persistentNotifStore.stopPolling();
+  document.removeEventListener('click', onDocumentClick, true);
+});
 
 watch(currentOrgId, async (id) => {
   if (id) {
-    await serverStore.fetchServers()
-    persistentNotifStore.stopPolling()
-    persistentNotifStore.startPolling(id)
+    await serverStore.fetchServers();
+    persistentNotifStore.stopPolling();
+    persistentNotifStore.startPolling(id);
   }
-})
+});
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
 function navigate(to: string, query?: Record<string, string>) {
-  router.push(query ? { path: to, query } : to)
+  router.push(query ? { path: to, query } : to);
 }
 
 async function onOrgChange(value: string) {
-  await orgStore.selectOrg(value)
-  await projectStore.fetchProjects(value)
-  orgSwitcherOpen.value = false
-  navigate(`/orgs/${value}/projects`)
+  await orgStore.selectOrg(value);
+  await projectStore.fetchProjects(value);
+  orgSwitcherOpen.value = false;
+  navigate(`/orgs/${value}/projects`);
 }
 
 function cycleLocale() {
-  const locales = LOCALE_OPTIONS.map((option) => option.value)
-  const index = locales.indexOf(currentLocale.value)
-  setLocale(locales[(index + 1) % locales.length])
+  const locales = LOCALE_OPTIONS.map((option) => option.value);
+  const index = locales.indexOf(currentLocale.value);
+  setLocale(locales[(index + 1) % locales.length]);
 }
 
 function triggerGlobalCommandPalette() {
-  window.dispatchEvent(new KeyboardEvent('keydown', { key: 'k', ctrlKey: true, bubbles: true }))
+  window.dispatchEvent(new KeyboardEvent('keydown', { key: 'k', ctrlKey: true, bubbles: true }));
 }
 
 function handleLogout() {
-  auth.logout()
-  router.push('/login')
+  auth.logout();
+  router.push('/login');
 }
 
 async function handleCreateOrg() {
   if (!newOrgName.value.trim()) {
-    MessagePlugin.warning(t('org.nameRequired'))
-    return
+    MessagePlugin.warning(t('org.nameRequired'));
+    return;
   }
-  creatingOrg.value = true
+  creatingOrg.value = true;
   try {
-    const org = await orgStore.createOrg(newOrgName.value.trim(), newOrgDesc.value || undefined)
-    newOrgName.value = ''
-    newOrgDesc.value = ''
-    showCreateOrg.value = false
-    orgSwitcherOpen.value = false
-    await projectStore.fetchProjects(org.id)
-    MessagePlugin.success(t('org.createSuccess'))
-    navigate(`/orgs/${org.id}/projects`)
+    const org = await orgStore.createOrg(newOrgName.value.trim(), newOrgDesc.value || undefined);
+    newOrgName.value = '';
+    newOrgDesc.value = '';
+    showCreateOrg.value = false;
+    orgSwitcherOpen.value = false;
+    await projectStore.fetchProjects(org.id);
+    MessagePlugin.success(t('org.createSuccess'));
+    navigate(`/orgs/${org.id}/projects`);
   } catch (error: any) {
-    MessagePlugin.error(error.message)
+    MessagePlugin.error(error.message);
   } finally {
-    creatingOrg.value = false
+    creatingOrg.value = false;
   }
 }
 </script>
@@ -280,7 +365,13 @@ async function handleCreateOrg() {
 
       <section class="sidebar__section">
         <div class="sidebar__section-label">{{ t('shell.workspace') }}</div>
-        <button v-for="item in workspaceItems" :key="item.value" class="sidebar-link" :class="{ 'is-active': item.active }" @click="item.action">
+        <button
+          v-for="item in workspaceItems"
+          :key="item.value"
+          class="sidebar-link"
+          :class="{ 'is-active': item.active }"
+          @click="item.action"
+        >
           <t-icon :name="item.icon" />
           <span>{{ item.label }}</span>
         </button>
@@ -288,7 +379,13 @@ async function handleCreateOrg() {
 
       <section v-if="orgItems.length" class="sidebar__section">
         <div class="sidebar__section-label">{{ t('shell.orgContext') }}</div>
-        <button v-for="item in orgItems" :key="item.value" class="sidebar-link" :class="{ 'is-active': item.active }" @click="item.action">
+        <button
+          v-for="item in orgItems"
+          :key="item.value"
+          class="sidebar-link"
+          :class="{ 'is-active': item.active }"
+          @click="item.action"
+        >
           <t-icon :name="item.icon" />
           <span>{{ item.label }}</span>
         </button>
@@ -296,7 +393,13 @@ async function handleCreateOrg() {
 
       <section class="sidebar__section sidebar__section--grow">
         <div class="sidebar__section-label">{{ t('shell.system') }}</div>
-        <button v-for="item in systemItems" :key="item.value" class="sidebar-link" :class="{ 'is-active': item.active }" @click="item.action">
+        <button
+          v-for="item in systemItems"
+          :key="item.value"
+          class="sidebar-link"
+          :class="{ 'is-active': item.active }"
+          @click="item.action"
+        >
           <t-icon :name="item.icon" />
           <span>{{ item.label }}</span>
         </button>
@@ -350,8 +453,15 @@ async function handleCreateOrg() {
               @click="orgSwitcherOpen = !orgSwitcherOpen"
             >
               <t-icon name="institution" size="13px" />
-              <span class="topbar-pill__text">{{ orgStore.currentOrg?.name ?? t('shell.noOrg') }}</span>
-              <t-icon name="chevron-down" size="12px" class="topbar-pill__arrow" :class="{ 'is-flipped': orgSwitcherOpen }" />
+              <span class="topbar-pill__text">{{
+                orgStore.currentOrg?.name ?? t('shell.noOrg')
+              }}</span>
+              <t-icon
+                name="chevron-down"
+                size="12px"
+                class="topbar-pill__arrow"
+                :class="{ 'is-flipped': orgSwitcherOpen }"
+              />
             </button>
 
             <div v-show="orgSwitcherOpen" class="topbar-dropdown topbar-dropdown--orgs">
@@ -363,10 +473,19 @@ async function handleCreateOrg() {
                 :class="{ 'is-active': org.value === currentOrgId, 'is-suborg': org.depth > 0 }"
                 @click="onOrgChange(org.value)"
               >
-                <span v-if="org.depth > 0" class="suborg-indent-connector" aria-hidden="true"></span>
+                <span
+                  v-if="org.depth > 0"
+                  class="suborg-indent-connector"
+                  aria-hidden="true"
+                ></span>
                 <t-icon :name="org.depth > 0 ? 'root-list' : 'institution'" size="13px" />
                 <span>{{ org.label }}</span>
-                <t-icon v-if="org.value === currentOrgId" name="check" size="13px" class="topbar-dropdown__check" />
+                <t-icon
+                  v-if="org.value === currentOrgId"
+                  name="check"
+                  size="13px"
+                  class="topbar-dropdown__check"
+                />
               </button>
               <div class="topbar-dropdown__footer">
                 <button class="topbar-dropdown__action" @click="showCreateOrg = true">
@@ -389,8 +508,15 @@ async function handleCreateOrg() {
               @click="projectPickerOpen = !projectPickerOpen"
             >
               <t-icon name="layers" size="13px" />
-              <span class="topbar-pill__text">{{ currentProject?.name ?? t('shell.noProject') }}</span>
-              <t-icon name="chevron-down" size="12px" class="topbar-pill__arrow" :class="{ 'is-flipped': projectPickerOpen }" />
+              <span class="topbar-pill__text">{{
+                currentProject?.name ?? t('shell.noProject')
+              }}</span>
+              <t-icon
+                name="chevron-down"
+                size="12px"
+                class="topbar-pill__arrow"
+                :class="{ 'is-flipped': projectPickerOpen }"
+              />
             </button>
 
             <div v-show="projectPickerOpen" class="topbar-dropdown topbar-dropdown--wide">
@@ -404,7 +530,12 @@ async function handleCreateOrg() {
               >
                 <t-icon name="layers" size="13px" />
                 <span>{{ proj.name }}</span>
-                <t-icon v-if="proj.active" name="check" size="13px" class="topbar-dropdown__check" />
+                <t-icon
+                  v-if="proj.active"
+                  name="check"
+                  size="13px"
+                  class="topbar-dropdown__check"
+                />
               </button>
             </div>
           </div>
@@ -441,9 +572,19 @@ async function handleCreateOrg() {
                 </div>
                 <div class="health-row">
                   <span>{{ t('shell.healthLastSeen') }}</span>
-                  <strong>{{ boundServer.last_seen ? new Date(boundServer.last_seen).toLocaleString() : t('shell.never') }}</strong>
+                  <strong>{{
+                    boundServer.last_seen
+                      ? new Date(boundServer.last_seen).toLocaleString()
+                      : t('shell.never')
+                  }}</strong>
                 </div>
-                <button class="health-detail-link" @click="healthOpen = false; navigate(`/orgs/${currentOrgId}/servers`)">
+                <button
+                  class="health-detail-link"
+                  @click="
+                    healthOpen = false;
+                    navigate(`/orgs/${currentOrgId}/servers`);
+                  "
+                >
                   {{ t('shell.openRegistry') }} →
                 </button>
               </template>
@@ -455,12 +596,22 @@ async function handleCreateOrg() {
           <div ref="notifRef" class="topbar-pill-wrap">
             <button
               class="topbar-pill topbar-pill--icon"
-              :class="{ 'is-open': notifOpen, 'has-unread': persistentNotifStore.unreadCount > 0 || notifStore.unreadCount > 0 }"
+              :class="{
+                'is-open': notifOpen,
+                'has-unread': persistentNotifStore.unreadCount > 0 || notifStore.unreadCount > 0,
+              }"
               @click="notifOpen = !notifOpen"
             >
               <t-icon name="notification" size="16px" />
-              <span v-if="persistentNotifStore.unreadCount > 0 || notifStore.unreadCount > 0" class="notif-badge">
-                {{ (persistentNotifStore.unreadCount + notifStore.unreadCount) > 99 ? '99+' : persistentNotifStore.unreadCount + notifStore.unreadCount }}
+              <span
+                v-if="persistentNotifStore.unreadCount > 0 || notifStore.unreadCount > 0"
+                class="notif-badge"
+              >
+                {{
+                  persistentNotifStore.unreadCount + notifStore.unreadCount > 99
+                    ? '99+'
+                    : persistentNotifStore.unreadCount + notifStore.unreadCount
+                }}
               </span>
             </button>
 
@@ -477,7 +628,7 @@ async function handleCreateOrg() {
               </div>
 
               <div v-if="notifStore.notifications.length === 0" class="notif-empty">
-                <t-icon name="notification" size="24px" style="opacity:0.25" />
+                <t-icon name="notification" size="24px" style="opacity: 0.25" />
                 <span>{{ t('shell.noNotifications') }}</span>
               </div>
 
@@ -500,7 +651,13 @@ async function handleCreateOrg() {
               </div>
 
               <div v-if="currentOrgId" class="topbar-dropdown__footer">
-                <button class="topbar-dropdown__action" @click="notifOpen = false; navigate(`/orgs/${currentOrgId}/notifications`)">
+                <button
+                  class="topbar-dropdown__action"
+                  @click="
+                    notifOpen = false;
+                    navigate(`/orgs/${currentOrgId}/notifications`);
+                  "
+                >
                   <t-icon name="inbox" size="13px" />
                   <span>{{ t('notifications.viewInbox') }}</span>
                 </button>
@@ -652,7 +809,9 @@ async function handleCreateOrg() {
   cursor: pointer;
   color: var(--ordo-text-secondary);
   background: transparent;
-  transition: background 0.12s ease, color 0.12s ease;
+  transition:
+    background 0.12s ease,
+    color 0.12s ease;
 }
 
 .sidebar-link:hover {
@@ -857,7 +1016,10 @@ async function handleCreateOrg() {
   color: var(--ordo-text-primary);
   background: var(--ordo-bg-panel);
   cursor: pointer;
-  transition: border-color 0.12s, background 0.12s, color 0.12s;
+  transition:
+    border-color 0.12s,
+    background 0.12s,
+    color 0.12s;
   white-space: nowrap;
 }
 
@@ -911,7 +1073,9 @@ async function handleCreateOrg() {
   border: 1px solid var(--ordo-border-color);
   border-radius: 12px;
   background: var(--ordo-bg-panel);
-  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.10), 0 2px 6px rgba(0, 0, 0, 0.06);
+  box-shadow:
+    0 8px 24px rgba(0, 0, 0, 0.1),
+    0 2px 6px rgba(0, 0, 0, 0.06);
   overflow: hidden;
 }
 
@@ -1022,7 +1186,9 @@ async function handleCreateOrg() {
   gap: 8px;
   color: var(--ordo-text-primary);
   cursor: pointer;
-  transition: background 0.1s, border-color 0.1s;
+  transition:
+    background 0.1s,
+    border-color 0.1s;
 }
 
 .topbar-dropdown__action:hover {
@@ -1039,10 +1205,21 @@ async function handleCreateOrg() {
   flex-shrink: 0;
 }
 
-.health-dot--online   { background: #34c759; box-shadow: 0 0 0 2px rgba(52, 199, 89, 0.2); }
-.health-dot--degraded { background: #ff9500; box-shadow: 0 0 0 2px rgba(255, 149, 0, 0.2); }
-.health-dot--offline  { background: #ff3b30; box-shadow: 0 0 0 2px rgba(255, 59, 48, 0.2); }
-.health-dot--default  { background: #aeaaa2; }
+.health-dot--online {
+  background: #34c759;
+  box-shadow: 0 0 0 2px rgba(52, 199, 89, 0.2);
+}
+.health-dot--degraded {
+  background: #ff9500;
+  box-shadow: 0 0 0 2px rgba(255, 149, 0, 0.2);
+}
+.health-dot--offline {
+  background: #ff3b30;
+  box-shadow: 0 0 0 2px rgba(255, 59, 48, 0.2);
+}
+.health-dot--default {
+  background: #aeaaa2;
+}
 
 .health-row {
   display: flex;
@@ -1173,10 +1350,22 @@ async function handleCreateOrg() {
   justify-content: center;
 }
 
-.notif-icon--success { background: #e8f8ef; color: #00a854; }
-.notif-icon--error   { background: #fff1f0; color: #f53f3f; }
-.notif-icon--warning { background: #fff8e8; color: #e8a805; }
-.notif-icon--info    { background: #edf4ff; color: #3065a4; }
+.notif-icon--success {
+  background: #e8f8ef;
+  color: #00a854;
+}
+.notif-icon--error {
+  background: #fff1f0;
+  color: #f53f3f;
+}
+.notif-icon--warning {
+  background: #fff8e8;
+  color: #e8a805;
+}
+.notif-icon--info {
+  background: #edf4ff;
+  color: #3065a4;
+}
 
 .notif-content {
   min-width: 0;
diff --git a/ordo-editor/apps/studio/src/components/layout/ProjectLayout.vue b/ordo-editor/apps/studio/src/components/layout/ProjectLayout.vue
index 074a1ab8..c4f1b591 100644
--- a/ordo-editor/apps/studio/src/components/layout/ProjectLayout.vue
+++ b/ordo-editor/apps/studio/src/components/layout/ProjectLayout.vue
@@ -1,20 +1,20 @@
 <script setup lang="ts">
-import { computed, onMounted, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useProjectStore } from '@/stores/project'
-import { useCatalogStore } from '@/stores/catalog'
+import { computed, onMounted, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useProjectStore } from '@/stores/project';
+import { useCatalogStore } from '@/stores/catalog';
 
-const route = useRoute()
-const router = useRouter()
-const projectStore = useProjectStore()
-const catalogStore = useCatalogStore()
-const { t } = useI18n()
+const route = useRoute();
+const router = useRouter();
+const projectStore = useProjectStore();
+const catalogStore = useCatalogStore();
+const { t } = useI18n();
 
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
 
-const base = computed(() => `/orgs/${orgId.value}/projects/${projectId.value}`)
+const base = computed(() => `/orgs/${orgId.value}/projects/${projectId.value}`);
 
 const tabs = computed(() => [
   {
@@ -87,21 +87,23 @@ const tabs = computed(() => [
     to: `${base.value}/settings`,
     active: route.path.endsWith('/settings'),
   },
-])
+]);
 
 // Load catalog when project changes
 async function loadProject(pid: string) {
-  if (!pid) return
+  if (!pid) return;
   // Ensure project is selected in store
-  const existing = projectStore.projects.find((p) => p.id === pid)
+  const existing = projectStore.projects.find((p) => p.id === pid);
   if (existing && (!projectStore.currentProject || projectStore.currentProject.id !== pid)) {
-    await projectStore.selectProject(existing)
+    await projectStore.selectProject(existing);
   }
-  await catalogStore.fetchAll(pid)
+  await catalogStore.fetchAll(pid);
 }
 
-onMounted(() => loadProject(projectId.value))
-watch(projectId, (pid) => { if (pid) loadProject(pid) })
+onMounted(() => loadProject(projectId.value));
+watch(projectId, (pid) => {
+  if (pid) loadProject(pid);
+});
 </script>
 
 <template>
@@ -121,7 +123,7 @@ watch(projectId, (pid) => { if (pid) loadProject(pid) })
         </RouterLink>
       </div>
       <div class="project-nav__project-name">
-        <t-icon name="layers" size="12px" style="opacity:0.5" />
+        <t-icon name="layers" size="12px" style="opacity: 0.5" />
         {{ projectStore.currentProject?.name ?? '...' }}
       </div>
     </nav>
@@ -171,7 +173,9 @@ watch(projectId, (pid) => { if (pid) loadProject(pid) })
   color: var(--ordo-text-secondary);
   text-decoration: none;
   border-bottom: 2px solid transparent;
-  transition: color 0.1s, border-color 0.1s;
+  transition:
+    color 0.1s,
+    border-color 0.1s;
   white-space: nowrap;
 }
 
diff --git a/ordo-editor/apps/studio/src/components/project/CreateFromTemplateDialog.vue b/ordo-editor/apps/studio/src/components/project/CreateFromTemplateDialog.vue
index 70988afe..1215c57b 100644
--- a/ordo-editor/apps/studio/src/components/project/CreateFromTemplateDialog.vue
+++ b/ordo-editor/apps/studio/src/components/project/CreateFromTemplateDialog.vue
@@ -1,239 +1,248 @@
 <script setup lang="ts">
-import { ref, watch, computed, onBeforeUnmount } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useTemplateStore } from '@/stores/template'
-import { useGithubStore } from '@/stores/github'
-import { useAuthStore } from '@/stores/auth'
-import { marketplaceApi } from '@/api/platform-client'
-import type { MarketplaceDetail, MarketplaceItem, Project, TemplateDetail, TemplateMetadata } from '@/api/types'
+import { ref, watch, computed, onBeforeUnmount } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useTemplateStore } from '@/stores/template';
+import { useGithubStore } from '@/stores/github';
+import { useAuthStore } from '@/stores/auth';
+import { marketplaceApi } from '@/api/platform-client';
+import type {
+  MarketplaceDetail,
+  MarketplaceItem,
+  Project,
+  TemplateDetail,
+  TemplateMetadata,
+} from '@/api/types';
 
 const props = defineProps<{
-  visible: boolean
-  orgId: string
-}>()
+  visible: boolean;
+  orgId: string;
+}>();
 
 const emit = defineEmits<{
-  (e: 'update:visible', v: boolean): void
-  (e: 'created', p: Project): void
-}>()
-
-type TemplateSource = 'builtin' | 'github'
-
-const { t } = useI18n()
-const store = useTemplateStore()
-const githubStore = useGithubStore()
-const authStore = useAuthStore()
-
-const source = ref<TemplateSource>('builtin')
-const selectedId = ref<string | null>(null)
-const selectedRepo = ref<string | null>(null)
-const projectName = ref('')
-const projectDesc = ref('')
-const githubQuery = ref('')
-
-const marketplaceItems = ref<MarketplaceItem[]>([])
-const marketplaceDetail = ref<MarketplaceDetail | null>(null)
-const marketplaceLoading = ref(false)
-const marketplaceDetailLoading = ref(false)
-const marketplaceInstalling = ref(false)
-let searchDebounceTimer: ReturnType<typeof setTimeout> | null = null
-
-const selectedTemplate = computed<TemplateMetadata | null>(() =>
-  store.templates.find((tpl) => tpl.id === selectedId.value) ?? null,
-)
-
-const selectedMarketplaceItem = computed<MarketplaceItem | null>(() =>
-  marketplaceItems.value.find((item) => item.full_name === selectedRepo.value) ?? null,
-)
+  (e: 'update:visible', v: boolean): void;
+  (e: 'created', p: Project): void;
+}>();
+
+type TemplateSource = 'builtin' | 'github';
+
+const { t } = useI18n();
+const store = useTemplateStore();
+const githubStore = useGithubStore();
+const authStore = useAuthStore();
+
+const source = ref<TemplateSource>('builtin');
+const selectedId = ref<string | null>(null);
+const selectedRepo = ref<string | null>(null);
+const projectName = ref('');
+const projectDesc = ref('');
+const githubQuery = ref('');
+
+const marketplaceItems = ref<MarketplaceItem[]>([]);
+const marketplaceDetail = ref<MarketplaceDetail | null>(null);
+const marketplaceLoading = ref(false);
+const marketplaceDetailLoading = ref(false);
+const marketplaceInstalling = ref(false);
+let searchDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+const selectedTemplate = computed<TemplateMetadata | null>(
+  () => store.templates.find((tpl) => tpl.id === selectedId.value) ?? null
+);
+
+const selectedMarketplaceItem = computed<MarketplaceItem | null>(
+  () => marketplaceItems.value.find((item) => item.full_name === selectedRepo.value) ?? null
+);
 
 const activeDetail = computed<TemplateDetail | MarketplaceDetail | null>(() =>
-  source.value === 'github' ? marketplaceDetail.value : store.currentDetail,
-)
+  source.value === 'github' ? marketplaceDetail.value : store.currentDetail
+);
 
 const activeCreating = computed(() =>
-  source.value === 'github' ? marketplaceInstalling.value : store.creating,
-)
+  source.value === 'github' ? marketplaceInstalling.value : store.creating
+);
 
-const activeFacts = computed(() => activeDetail.value?.facts ?? [])
-const activeConcepts = computed(() => activeDetail.value?.concepts ?? [])
-const activeSamples = computed(() => activeDetail.value?.samples ?? [])
-const activeFeatures = computed(() => activeDetail.value?.features ?? [])
+const activeFacts = computed(() => activeDetail.value?.facts ?? []);
+const activeConcepts = computed(() => activeDetail.value?.concepts ?? []);
+const activeSamples = computed(() => activeDetail.value?.samples ?? []);
+const activeFeatures = computed(() => activeDetail.value?.features ?? []);
 
 async function onOpen() {
-  source.value = 'builtin'
-  selectedId.value = null
-  selectedRepo.value = null
-  projectName.value = ''
-  projectDesc.value = ''
-  githubQuery.value = ''
-  marketplaceItems.value = []
-  marketplaceDetail.value = null
-  store.clearDetail()
-
-  await Promise.all([store.fetchTemplates(), githubStore.fetchStatus()])
+  source.value = 'builtin';
+  selectedId.value = null;
+  selectedRepo.value = null;
+  projectName.value = '';
+  projectDesc.value = '';
+  githubQuery.value = '';
+  marketplaceItems.value = [];
+  marketplaceDetail.value = null;
+  store.clearDetail();
+
+  await Promise.all([store.fetchTemplates(), githubStore.fetchStatus()]);
 
   if (store.templates.length > 0) {
-    await selectBuiltinTemplate(store.templates[0].id)
+    await selectBuiltinTemplate(store.templates[0].id);
   }
 }
 
 watch(
   () => props.visible,
   async (open) => {
-    if (!open) return
-    await onOpen()
-  },
-)
+    if (!open) return;
+    await onOpen();
+  }
+);
 
 watch(source, async (mode) => {
-  projectName.value = ''
-  projectDesc.value = ''
+  projectName.value = '';
+  projectDesc.value = '';
 
   if (mode === 'builtin') {
     if (!selectedId.value && store.templates.length > 0) {
-      await selectBuiltinTemplate(store.templates[0].id)
-      return
+      await selectBuiltinTemplate(store.templates[0].id);
+      return;
     }
-    const tpl = selectedTemplate.value
+    const tpl = selectedTemplate.value;
     if (tpl) {
-      projectName.value = `${tpl.name} - ${t('template.copySuffix')}`
+      projectName.value = `${tpl.name} - ${t('template.copySuffix')}`;
     }
-    return
+    return;
   }
 
-  await githubStore.fetchStatus()
+  await githubStore.fetchStatus();
   if (!marketplaceItems.value.length) {
-    await fetchMarketplaceItems()
+    await fetchMarketplaceItems();
   }
   if (!selectedRepo.value && marketplaceItems.value.length > 0) {
-    await selectMarketplaceItem(marketplaceItems.value[0])
-    return
+    await selectMarketplaceItem(marketplaceItems.value[0]);
+    return;
   }
-  const detail = marketplaceDetail.value
+  const detail = marketplaceDetail.value;
   if (detail) {
-    projectName.value = detail.name || detail.full_name || ''
+    projectName.value = detail.name || detail.full_name || '';
   }
-})
+});
 
 watch(githubQuery, () => {
-  if (source.value !== 'github') return
-  if (searchDebounceTimer) clearTimeout(searchDebounceTimer)
+  if (source.value !== 'github') return;
+  if (searchDebounceTimer) clearTimeout(searchDebounceTimer);
   searchDebounceTimer = setTimeout(() => {
-    void fetchMarketplaceItems()
-  }, 350)
-})
+    void fetchMarketplaceItems();
+  }, 350);
+});
 
 onBeforeUnmount(() => {
   if (searchDebounceTimer) {
-    clearTimeout(searchDebounceTimer)
+    clearTimeout(searchDebounceTimer);
   }
-})
+});
 
 async function selectBuiltinTemplate(id: string) {
-  selectedId.value = id
-  await store.fetchDetail(id)
-  const tpl = store.templates.find((x) => x.id === id)
+  selectedId.value = id;
+  await store.fetchDetail(id);
+  const tpl = store.templates.find((x) => x.id === id);
   if (tpl) {
-    projectName.value = `${tpl.name} - ${t('template.copySuffix')}`
+    projectName.value = `${tpl.name} - ${t('template.copySuffix')}`;
   }
 }
 
 async function fetchMarketplaceItems() {
-  if (!authStore.token) return
-  marketplaceLoading.value = true
+  if (!authStore.token) return;
+  marketplaceLoading.value = true;
   try {
     const resp = await marketplaceApi.search(authStore.token, {
       q: githubQuery.value.trim() || undefined,
       sort: 'stars',
       page: 1,
       per_page: 24,
-    })
-    marketplaceItems.value = resp.items
-    if (selectedRepo.value && !marketplaceItems.value.some((item) => item.full_name === selectedRepo.value)) {
-      selectedRepo.value = null
-      marketplaceDetail.value = null
+    });
+    marketplaceItems.value = resp.items;
+    if (
+      selectedRepo.value &&
+      !marketplaceItems.value.some((item) => item.full_name === selectedRepo.value)
+    ) {
+      selectedRepo.value = null;
+      marketplaceDetail.value = null;
     }
     if (!selectedRepo.value && marketplaceItems.value.length > 0) {
-      await selectMarketplaceItem(marketplaceItems.value[0])
+      await selectMarketplaceItem(marketplaceItems.value[0]);
     }
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('marketplace.loadError'))
+    MessagePlugin.error(e?.message ?? t('marketplace.loadError'));
   } finally {
-    marketplaceLoading.value = false
+    marketplaceLoading.value = false;
   }
 }
 
 async function selectMarketplaceItem(item: MarketplaceItem) {
-  if (!authStore.token) return
-  const [owner, repo] = item.full_name.split('/')
-  if (!owner || !repo) return
-  selectedRepo.value = item.full_name
-  marketplaceDetailLoading.value = true
+  if (!authStore.token) return;
+  const [owner, repo] = item.full_name.split('/');
+  if (!owner || !repo) return;
+  selectedRepo.value = item.full_name;
+  marketplaceDetailLoading.value = true;
   try {
-    marketplaceDetail.value = await marketplaceApi.getItem(authStore.token, owner, repo)
-    projectName.value = marketplaceDetail.value.name || marketplaceDetail.value.full_name || repo
+    marketplaceDetail.value = await marketplaceApi.getItem(authStore.token, owner, repo);
+    projectName.value = marketplaceDetail.value.name || marketplaceDetail.value.full_name || repo;
   } catch (e: any) {
-    marketplaceDetail.value = null
-    MessagePlugin.error(e?.message ?? t('marketplace.loadError'))
+    marketplaceDetail.value = null;
+    MessagePlugin.error(e?.message ?? t('marketplace.loadError'));
   } finally {
-    marketplaceDetailLoading.value = false
+    marketplaceDetailLoading.value = false;
   }
 }
 
 async function connectGithub() {
   try {
-    await githubStore.connect()
-    await fetchMarketplaceItems()
+    await githubStore.connect();
+    await fetchMarketplaceItems();
     if (marketplaceItems.value.length > 0) {
-      await selectMarketplaceItem(marketplaceItems.value[0])
+      await selectMarketplaceItem(marketplaceItems.value[0]);
     }
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('marketplace.connectError'))
+    MessagePlugin.error(e?.message ?? t('marketplace.connectError'));
   }
 }
 
 function close() {
-  emit('update:visible', false)
+  emit('update:visible', false);
 }
 
 async function handleCreate() {
   if (!projectName.value.trim()) {
-    MessagePlugin.warning(t('template.projectNameRequired'))
-    return
+    MessagePlugin.warning(t('template.projectNameRequired'));
+    return;
   }
 
   if (source.value === 'github') {
     if (!selectedRepo.value || !authStore.token) {
-      MessagePlugin.warning(t('template.selectRequired'))
-      return
+      MessagePlugin.warning(t('template.selectRequired'));
+      return;
     }
-    const [owner, repo] = selectedRepo.value.split('/')
+    const [owner, repo] = selectedRepo.value.split('/');
     if (!owner || !repo) {
-      MessagePlugin.warning(t('template.selectRequired'))
-      return
+      MessagePlugin.warning(t('template.selectRequired'));
+      return;
     }
-    marketplaceInstalling.value = true
+    marketplaceInstalling.value = true;
     try {
       const project = await marketplaceApi.install(authStore.token, owner, repo, {
         org_id: props.orgId,
         project_name: projectName.value.trim(),
         project_description: projectDesc.value.trim() || undefined,
-      })
-      MessagePlugin.success(t('template.createSuccess'))
-      emit('created', project)
-      close()
+      });
+      MessagePlugin.success(t('template.createSuccess'));
+      emit('created', project);
+      close();
     } catch (e: any) {
-      MessagePlugin.error(e?.message ?? t('template.createFailed'))
+      MessagePlugin.error(e?.message ?? t('template.createFailed'));
     } finally {
-      marketplaceInstalling.value = false
+      marketplaceInstalling.value = false;
     }
-    return
+    return;
   }
 
   if (!selectedId.value) {
-    MessagePlugin.warning(t('template.selectRequired'))
-    return
+    MessagePlugin.warning(t('template.selectRequired'));
+    return;
   }
 
   try {
@@ -241,24 +250,24 @@ async function handleCreate() {
       template_id: selectedId.value,
       project_name: projectName.value.trim(),
       project_description: projectDesc.value.trim() || undefined,
-    })
-    MessagePlugin.success(t('template.createSuccess'))
-    emit('created', project)
-    close()
+    });
+    MessagePlugin.success(t('template.createSuccess'));
+    emit('created', project);
+    close();
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('template.createFailed'))
+    MessagePlugin.error(e?.message ?? t('template.createFailed'));
   }
 }
 
 function difficultyTheme(d: string): 'primary' | 'warning' | 'danger' {
-  if (d === 'advanced') return 'danger'
-  if (d === 'intermediate') return 'warning'
-  return 'primary'
+  if (d === 'advanced') return 'danger';
+  if (d === 'intermediate') return 'warning';
+  return 'primary';
 }
 
 function stepCount(detail: TemplateDetail | MarketplaceDetail | null): number {
-  if (!detail?.ruleset?.steps) return 0
-  return Object.keys(detail.ruleset.steps).length
+  if (!detail?.ruleset?.steps) return 0;
+  return Object.keys(detail.ruleset.steps).length;
 }
 </script>
 
@@ -333,7 +342,12 @@ function stepCount(detail: TemplateDetail | MarketplaceDetail | null): number {
               >
                 {{ t(`template.difficulty.${item.difficulty}`) }}
               </t-tag>
-              <t-tag v-for="tag in (item.tags ?? []).slice(0, 3)" :key="tag" size="small" variant="outline">
+              <t-tag
+                v-for="tag in (item.tags ?? []).slice(0, 3)"
+                :key="tag"
+                size="small"
+                variant="outline"
+              >
                 {{ tag }}
               </t-tag>
             </div>
@@ -366,14 +380,22 @@ function stepCount(detail: TemplateDetail | MarketplaceDetail | null): number {
               <t-tag size="small" :theme="difficultyTheme(tpl.difficulty)" variant="light">
                 {{ t(`template.difficulty.${tpl.difficulty}`) }}
               </t-tag>
-              <t-tag v-for="tag in tpl.tags" :key="tag" size="small" variant="outline">{{ tag }}</t-tag>
+              <t-tag v-for="tag in tpl.tags" :key="tag" size="small" variant="outline">{{
+                tag
+              }}</t-tag>
             </div>
           </div>
         </template>
       </div>
 
       <div class="tpl-detail">
-        <div v-if="(source === 'github' && marketplaceDetailLoading) || (source === 'builtin' && store.detailLoading)" class="tpl-loading tpl-loading--detail">
+        <div
+          v-if="
+            (source === 'github' && marketplaceDetailLoading) ||
+            (source === 'builtin' && store.detailLoading)
+          "
+          class="tpl-loading tpl-loading--detail"
+        >
           <t-skeleton theme="article" animation="gradient" :row-col="[1, 1, 1, 1, 1, 1]" />
         </div>
         <template v-else-if="activeDetail">
@@ -491,7 +513,9 @@ function stepCount(detail: TemplateDetail | MarketplaceDetail | null): number {
   border-radius: var(--ordo-radius-md);
   padding: 12px 14px;
   cursor: pointer;
-  transition: border-color 0.15s, background 0.15s;
+  transition:
+    border-color 0.15s,
+    background 0.15s;
   display: flex;
   flex-direction: column;
   gap: 6px;
diff --git a/ordo-editor/apps/studio/src/components/project/DraftConflictDialog.vue b/ordo-editor/apps/studio/src/components/project/DraftConflictDialog.vue
index bfceb0d4..0b459e07 100644
--- a/ordo-editor/apps/studio/src/components/project/DraftConflictDialog.vue
+++ b/ordo-editor/apps/studio/src/components/project/DraftConflictDialog.vue
@@ -33,22 +33,22 @@
 </template>
 
 <script setup lang="ts">
-import { computed } from 'vue'
-import type { RuleSet } from '@ordo-engine/editor-core'
-import { StudioDialogActions } from '@/components/ui'
+import { computed } from 'vue';
+import type { RuleSet } from '@ordo-engine/editor-core';
+import { StudioDialogActions } from '@/components/ui';
 
 const props = defineProps<{
-  localDraft: RuleSet
-  serverDraft: RuleSet
-}>()
+  localDraft: RuleSet;
+  serverDraft: RuleSet;
+}>();
 
 defineEmits<{
-  (e: 'useLocal'): void
-  (e: 'useServer'): void
-}>()
+  (e: 'useLocal'): void;
+  (e: 'useServer'): void;
+}>();
 
-const localJson = computed(() => JSON.stringify(props.localDraft, null, 2))
-const serverJson = computed(() => JSON.stringify(props.serverDraft, null, 2))
+const localJson = computed(() => JSON.stringify(props.localDraft, null, 2));
+const serverJson = computed(() => JSON.stringify(props.serverDraft, null, 2));
 </script>
 
 <style scoped>
diff --git a/ordo-editor/apps/studio/src/components/project/PublishDialog.vue b/ordo-editor/apps/studio/src/components/project/PublishDialog.vue
index 8a38588e..b6fd5af9 100644
--- a/ordo-editor/apps/studio/src/components/project/PublishDialog.vue
+++ b/ordo-editor/apps/studio/src/components/project/PublishDialog.vue
@@ -6,11 +6,19 @@
     :footer="false"
     destroy-on-close
     @close="$emit('close')"
-    @update:visible="(value: boolean) => { if (!value) $emit('close') }"
+    @update:visible="
+      (value: boolean) => {
+        if (!value) $emit('close');
+      }
+    "
   >
     <t-form label-align="top" :colon="false" class="publish-form">
       <t-form-item :label="$t('publish.environment')" required>
-        <t-select v-model="selectedEnvId" :placeholder="$t('publish.noEnvs')" :disabled="publishing">
+        <t-select
+          v-model="selectedEnvId"
+          :placeholder="$t('publish.noEnvs')"
+          :disabled="publishing"
+        >
           <t-option
             v-for="env in environments"
             :key="env.id"
@@ -47,50 +55,50 @@
 </template>
 
 <script setup lang="ts">
-import { ref } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { rulesetDraftApi } from '@/api/platform-client'
-import type { ProjectEnvironment, RulesetDeployment } from '@/api/types'
-import { useAuthStore } from '@/stores/auth'
-import { StudioDialogActions } from '@/components/ui'
+import { ref } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { rulesetDraftApi } from '@/api/platform-client';
+import type { ProjectEnvironment, RulesetDeployment } from '@/api/types';
+import { useAuthStore } from '@/stores/auth';
+import { StudioDialogActions } from '@/components/ui';
 
 const props = defineProps<{
-  orgId: string
-  projectId: string
-  rulesetName: string
-  environments: ProjectEnvironment[]
-}>()
+  orgId: string;
+  projectId: string;
+  rulesetName: string;
+  environments: ProjectEnvironment[];
+}>();
 
 const emit = defineEmits<{
-  (e: 'close'): void
-  (e: 'published', deployment: RulesetDeployment): void
-}>()
+  (e: 'close'): void;
+  (e: 'published', deployment: RulesetDeployment): void;
+}>();
 
-const { t } = useI18n()
-const auth = useAuthStore()
+const { t } = useI18n();
+const auth = useAuthStore();
 
-const selectedEnvId = ref(props.environments.find((e) => e.is_default)?.id ?? '')
-const releaseNote = ref('')
-const publishing = ref(false)
-const error = ref<string | null>(null)
+const selectedEnvId = ref(props.environments.find((e) => e.is_default)?.id ?? '');
+const releaseNote = ref('');
+const publishing = ref(false);
+const error = ref<string | null>(null);
 
 async function handlePublish() {
-  if (!selectedEnvId.value || !auth.token) return
-  publishing.value = true
-  error.value = null
+  if (!selectedEnvId.value || !auth.token) return;
+  publishing.value = true;
+  error.value = null;
   try {
     const deployment = await rulesetDraftApi.publish(
       auth.token,
       props.orgId,
       props.projectId,
       props.rulesetName,
-      { environment_id: selectedEnvId.value, release_note: releaseNote.value || undefined },
-    )
-    emit('published', deployment)
+      { environment_id: selectedEnvId.value, release_note: releaseNote.value || undefined }
+    );
+    emit('published', deployment);
   } catch (e: any) {
-    error.value = e.message || t('publish.failed')
+    error.value = e.message || t('publish.failed');
   } finally {
-    publishing.value = false
+    publishing.value = false;
   }
 }
 </script>
@@ -103,5 +111,4 @@ async function handlePublish() {
 .publish-alert {
   margin-top: 8px;
 }
-
 </style>
diff --git a/ordo-editor/apps/studio/src/components/project/ReleaseNav.vue b/ordo-editor/apps/studio/src/components/project/ReleaseNav.vue
index e6e43b56..53cc6e50 100644
--- a/ordo-editor/apps/studio/src/components/project/ReleaseNav.vue
+++ b/ordo-editor/apps/studio/src/components/project/ReleaseNav.vue
@@ -1,21 +1,41 @@
 <script setup lang="ts">
-import { computed } from 'vue'
-import { useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
+import { computed } from 'vue';
+import { useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
 
-const route = useRoute()
-const { t } = useI18n()
+const route = useRoute();
+const { t } = useI18n();
 
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
-const base = computed(() => `/orgs/${orgId.value}/projects/${projectId.value}/releases`)
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
+const base = computed(() => `/orgs/${orgId.value}/projects/${projectId.value}/releases`);
 
 const tabs = computed(() => [
-  { key: 'overview', label: t('releaseCenter.navOverview'), to: `${base.value}`, active: route.path === `${base.value}` },
-  { key: 'requests', label: t('releaseCenter.navRequests'), to: `${base.value}/requests`, active: route.path.includes('/releases/requests') },
-  { key: 'policies', label: t('releaseCenter.navPolicies'), to: `${base.value}/policies`, active: route.path.endsWith('/releases/policies') },
-  { key: 'history', label: t('releaseCenter.navHistory'), to: `${base.value}/history` , active: route.path.endsWith('/releases/history') || route.path.endsWith('/deployments') },
-])
+  {
+    key: 'overview',
+    label: t('releaseCenter.navOverview'),
+    to: `${base.value}`,
+    active: route.path === `${base.value}`,
+  },
+  {
+    key: 'requests',
+    label: t('releaseCenter.navRequests'),
+    to: `${base.value}/requests`,
+    active: route.path.includes('/releases/requests'),
+  },
+  {
+    key: 'policies',
+    label: t('releaseCenter.navPolicies'),
+    to: `${base.value}/policies`,
+    active: route.path.endsWith('/releases/policies'),
+  },
+  {
+    key: 'history',
+    label: t('releaseCenter.navHistory'),
+    to: `${base.value}/history`,
+    active: route.path.endsWith('/releases/history') || route.path.endsWith('/deployments'),
+  },
+]);
 </script>
 
 <template>
@@ -48,7 +68,9 @@ const tabs = computed(() => [
   font-size: 13px;
   color: var(--ordo-text-secondary);
   text-decoration: none;
-  transition: background 0.2s ease, color 0.2s ease;
+  transition:
+    background 0.2s ease,
+    color 0.2s ease;
 }
 
 .release-nav__link:hover {
diff --git a/ordo-editor/apps/studio/src/components/trace/RuleTraceRunner.vue b/ordo-editor/apps/studio/src/components/trace/RuleTraceRunner.vue
index 8e06b0f9..1e4fd8c2 100644
--- a/ordo-editor/apps/studio/src/components/trace/RuleTraceRunner.vue
+++ b/ordo-editor/apps/studio/src/components/trace/RuleTraceRunner.vue
@@ -1,204 +1,215 @@
 <script setup lang="ts">
-import { computed, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { convertToEngineFormat } from '@ordo-engine/editor-core'
-import { engineApi, rulesetDraftApi, testApi } from '@/api/platform-client'
-import { useAuthStore } from '@/stores/auth'
-import { isEngineRuleset, normalizeRuleset } from '@/utils/ruleset'
-import type { ProjectRulesetMeta, TestCase } from '@/api/types'
+import { computed, ref, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { convertToEngineFormat } from '@ordo-engine/editor-core';
+import { engineApi, rulesetDraftApi, testApi } from '@/api/platform-client';
+import { useAuthStore } from '@/stores/auth';
+import { isEngineRuleset, normalizeRuleset } from '@/utils/ruleset';
+import type { ProjectRulesetMeta, TestCase } from '@/api/types';
 
 const props = defineProps<{
-  orgId: string
-  projectId: string
-  rulesets: ProjectRulesetMeta[]
-}>()
+  orgId: string;
+  projectId: string;
+  rulesets: ProjectRulesetMeta[];
+}>();
 
-const { t } = useI18n()
-const auth = useAuthStore()
+const { t } = useI18n();
+const auth = useAuthStore();
 
 // ── State ─────────────────────────────────────────────────────────────────────
 
-const selectedRuleset = ref('')
-const inputJson = ref('{\n  \n}')
-const running = ref(false)
+const selectedRuleset = ref('');
+const inputJson = ref('{\n  \n}');
+const running = ref(false);
 
 type TraceResult = {
-  code: string
-  message: string
-  output: Record<string, unknown>
-  duration_us: number
+  code: string;
+  message: string;
+  output: Record<string, unknown>;
+  duration_us: number;
   trace?: {
-    path: string
-    steps: Array<{ id: string; name: string; duration_us: number }>
-  }
-}
+    path: string;
+    steps: Array<{ id: string; name: string; duration_us: number }>;
+  };
+};
 
-const result = ref<TraceResult | null>(null)
-const error = ref('')
+const result = ref<TraceResult | null>(null);
+const error = ref('');
 
 // ── Test cases ────────────────────────────────────────────────────────────────
 
-const testCases = ref<TestCase[]>([])
-const testCasesLoading = ref(false)
-const testCasesExpanded = ref(true)
-const activeTestCase = ref<TestCase | null>(null)
+const testCases = ref<TestCase[]>([]);
+const testCasesLoading = ref(false);
+const testCasesExpanded = ref(true);
+const activeTestCase = ref<TestCase | null>(null);
 
 watch(selectedRuleset, async (name) => {
-  testCases.value = []
-  activeTestCase.value = null
-  result.value = null
-  error.value = ''
-  if (!name || !auth.token) return
-  testCasesLoading.value = true
+  testCases.value = [];
+  activeTestCase.value = null;
+  result.value = null;
+  error.value = '';
+  if (!name || !auth.token) return;
+  testCasesLoading.value = true;
   try {
-    testCases.value = await testApi.list(auth.token, props.projectId, name)
+    testCases.value = await testApi.list(auth.token, props.projectId, name);
   } catch {
     // ignore — test cases are optional
   } finally {
-    testCasesLoading.value = false
+    testCasesLoading.value = false;
   }
-})
+});
 
 function loadTestCase(tc: TestCase) {
-  activeTestCase.value = tc
-  inputJson.value = JSON.stringify(tc.input, null, 2)
+  activeTestCase.value = tc;
+  inputJson.value = JSON.stringify(tc.input, null, 2);
 }
 
 // ── Execution history ──────────────────────────────────────────────────────────
 
 type HistoryEntry = {
-  rulesetName: string
-  input: string
-  result: TraceResult | null
-  error: string
-  timestamp: Date
-}
+  rulesetName: string;
+  input: string;
+  result: TraceResult | null;
+  error: string;
+  timestamp: Date;
+};
 
-const history = ref<HistoryEntry[]>([])
-const rightTab = ref<'result' | 'history'>('result')
+const history = ref<HistoryEntry[]>([]);
+const rightTab = ref<'result' | 'history'>('result');
 
 function addHistory(entry: Omit<HistoryEntry, 'timestamp'>) {
-  history.value.unshift({ ...entry, timestamp: new Date() })
-  if (history.value.length > 10) history.value.length = 10
+  history.value.unshift({ ...entry, timestamp: new Date() });
+  if (history.value.length > 10) history.value.length = 10;
 }
 
 function restoreHistory(entry: HistoryEntry) {
-  selectedRuleset.value = entry.rulesetName
-  inputJson.value = entry.input
-  result.value = entry.result
-  error.value = entry.error
-  activeTestCase.value = null
-  rightTab.value = 'result'
+  selectedRuleset.value = entry.rulesetName;
+  inputJson.value = entry.input;
+  result.value = entry.result;
+  error.value = entry.error;
+  activeTestCase.value = null;
+  rightTab.value = 'result';
 }
 
 function formatHistoryTime(ts: Date) {
-  return ts.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' })
+  return ts.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
 }
 
 // ── Save as test case ─────────────────────────────────────────────────────────
 
-const saveDialogVisible = ref(false)
-const saveName = ref('')
-const saving = ref(false)
+const saveDialogVisible = ref(false);
+const saveName = ref('');
+const saving = ref(false);
 
 function openSaveDialog() {
-  saveName.value = ''
-  saveDialogVisible.value = true
+  saveName.value = '';
+  saveDialogVisible.value = true;
 }
 
 async function saveAsTestCase() {
-  if (!saveName.value.trim() || !result.value || !auth.token) return
-  saving.value = true
+  if (!saveName.value.trim() || !result.value || !auth.token) return;
+  saving.value = true;
   try {
-    let parsed: Record<string, unknown> = {}
-    try { parsed = JSON.parse(inputJson.value) } catch { /**/ }
+    let parsed: Record<string, unknown> = {};
+    try {
+      parsed = JSON.parse(inputJson.value);
+    } catch {
+      /**/
+    }
     await testApi.create(auth.token, props.projectId, selectedRuleset.value, {
       name: saveName.value.trim(),
       input: parsed,
       expect: { code: result.value.code, output: result.value.output },
       tags: [],
-    })
+    });
     // Refresh test cases
-    testCases.value = await testApi.list(auth.token, props.projectId, selectedRuleset.value)
-    MessagePlugin.success(t('trace.saveAsTestSuccess'))
-    saveDialogVisible.value = false
+    testCases.value = await testApi.list(auth.token, props.projectId, selectedRuleset.value);
+    MessagePlugin.success(t('trace.saveAsTestSuccess'));
+    saveDialogVisible.value = false;
   } catch (e: any) {
-    MessagePlugin.error(e.message ?? String(e))
+    MessagePlugin.error(e.message ?? String(e));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 // ── Execution ─────────────────────────────────────────────────────────────────
 
-const expandedSteps = ref<Set<string>>(new Set())
+const expandedSteps = ref<Set<string>>(new Set());
 
 const rulesetOptions = computed(() =>
-  props.rulesets.map((r) => ({ label: r.name, value: r.name })),
-)
+  props.rulesets.map((r) => ({ label: r.name, value: r.name }))
+);
 
 function toggleStep(id: string) {
   if (expandedSteps.value.has(id)) {
-    expandedSteps.value.delete(id)
+    expandedSteps.value.delete(id);
   } else {
-    expandedSteps.value.add(id)
+    expandedSteps.value.add(id);
   }
 }
 
 function stepIconName(idx: number, steps: unknown[]) {
-  return idx === steps.length - 1 ? 'check-circle' : 'arrow-right-circle'
+  return idx === steps.length - 1 ? 'check-circle' : 'arrow-right-circle';
 }
 
 function formatDuration(us: number) {
-  if (us < 1000) return `${us}µs`
-  return `${(us / 1000).toFixed(1)}ms`
+  if (us < 1000) return `${us}µs`;
+  return `${(us / 1000).toFixed(1)}ms`;
 }
 
 // Compare active test case expectation vs result
 const expectationMatch = computed(() => {
-  if (!activeTestCase.value || !result.value) return null
-  const tc = activeTestCase.value
-  const r = result.value
-  const codeMatch = !tc.expect.code || tc.expect.code === r.code
-  const outputDiffs: Array<{ key: string; expected: unknown; actual: unknown }> = []
+  if (!activeTestCase.value || !result.value) return null;
+  const tc = activeTestCase.value;
+  const r = result.value;
+  const codeMatch = !tc.expect.code || tc.expect.code === r.code;
+  const outputDiffs: Array<{ key: string; expected: unknown; actual: unknown }> = [];
   if (tc.expect.output) {
     for (const [k, v] of Object.entries(tc.expect.output)) {
-      const actual = r.output?.[k]
+      const actual = r.output?.[k];
       if (JSON.stringify(actual) !== JSON.stringify(v)) {
-        outputDiffs.push({ key: k, expected: v, actual })
+        outputDiffs.push({ key: k, expected: v, actual });
       }
     }
   }
-  return { codeMatch, outputDiffs, pass: codeMatch && outputDiffs.length === 0 }
-})
+  return { codeMatch, outputDiffs, pass: codeMatch && outputDiffs.length === 0 };
+});
 
 async function runTrace() {
   if (!selectedRuleset.value) {
-    MessagePlugin.warning(t('trace.selectRuleset'))
-    return
+    MessagePlugin.warning(t('trace.selectRuleset'));
+    return;
   }
-  if (!auth.token) return
+  if (!auth.token) return;
 
-  let parsed: Record<string, unknown>
+  let parsed: Record<string, unknown>;
   try {
-    parsed = JSON.parse(inputJson.value)
+    parsed = JSON.parse(inputJson.value);
   } catch {
-    MessagePlugin.error(t('trace.invalidJson'))
-    return
+    MessagePlugin.error(t('trace.invalidJson'));
+    return;
   }
 
-  running.value = true
-  error.value = ''
-  result.value = null
-  rightTab.value = 'result'
+  running.value = true;
+  error.value = '';
+  result.value = null;
+  rightTab.value = 'result';
 
   try {
     // Fetch draft and convert from editor format to engine format using the adapter.
-    const draft = await rulesetDraftApi.get(auth.token, props.orgId, props.projectId, selectedRuleset.value)
+    const draft = await rulesetDraftApi.get(
+      auth.token,
+      props.orgId,
+      props.projectId,
+      selectedRuleset.value
+    );
     const engineRuleset = isEngineRuleset(draft.draft)
-      ? draft.draft as unknown as Record<string, unknown>
-      : convertToEngineFormat(normalizeRuleset(draft.draft, selectedRuleset.value)) as unknown as Record<string, unknown>
+      ? (draft.draft as unknown as Record<string, unknown>)
+      : (convertToEngineFormat(
+          normalizeRuleset(draft.draft, selectedRuleset.value)
+        ) as unknown as Record<string, unknown>);
 
     result.value = await engineApi.executeWithTrace(
       auth.token,
@@ -206,15 +217,25 @@ async function runTrace() {
       props.projectId,
       selectedRuleset.value,
       parsed,
-      engineRuleset,
-    )
-    addHistory({ rulesetName: selectedRuleset.value, input: inputJson.value, result: result.value, error: '' })
+      engineRuleset
+    );
+    addHistory({
+      rulesetName: selectedRuleset.value,
+      input: inputJson.value,
+      result: result.value,
+      error: '',
+    });
   } catch (e: any) {
-    error.value = e.message ?? String(e)
-    MessagePlugin.error(error.value)
-    addHistory({ rulesetName: selectedRuleset.value, input: inputJson.value, result: null, error: error.value })
+    error.value = e.message ?? String(e);
+    MessagePlugin.error(error.value);
+    addHistory({
+      rulesetName: selectedRuleset.value,
+      input: inputJson.value,
+      result: null,
+      error: error.value,
+    });
   } finally {
-    running.value = false
+    running.value = false;
   }
 }
 </script>
@@ -234,12 +255,7 @@ async function runTrace() {
         />
 
         <div class="trace-panel__label">{{ t('trace.inputLabel') }}</div>
-        <textarea
-          v-model="inputJson"
-          class="trace-json-input"
-          rows="14"
-          spellcheck="false"
-        />
+        <textarea v-model="inputJson" class="trace-json-input" rows="14" spellcheck="false" />
 
         <!-- Test cases collapsible -->
         <div v-if="selectedRuleset" class="test-cases-section">
@@ -264,7 +280,9 @@ async function runTrace() {
             >
               <t-icon name="file-paste" size="12px" class="test-case-row__icon" />
               <span class="test-case-row__name">{{ tc.name }}</span>
-              <t-tag v-if="tc.expect.code" size="small" class="test-case-row__tag">{{ tc.expect.code }}</t-tag>
+              <t-tag v-if="tc.expect.code" size="small" class="test-case-row__tag">{{
+                tc.expect.code
+              }}</t-tag>
             </button>
           </div>
         </div>
@@ -289,7 +307,9 @@ async function runTrace() {
           class="right-tab"
           :class="{ 'right-tab--active': rightTab === 'result' }"
           @click="rightTab = 'result'"
-        >{{ t('trace.tabResult') }}</button>
+        >
+          {{ t('trace.tabResult') }}
+        </button>
         <button
           class="right-tab"
           :class="{ 'right-tab--active': rightTab === 'history' }"
@@ -319,14 +339,20 @@ async function runTrace() {
           >
             <div class="trace-result-card__code">
               <span class="code-badge">{{ result.code }}</span>
-              <span class="trace-result-card__duration">{{ formatDuration(result.duration_us) }}</span>
+              <span class="trace-result-card__duration">{{
+                formatDuration(result.duration_us)
+              }}</span>
               <span v-if="activeTestCase" class="test-case-label">
                 <t-icon name="file-paste" size="12px" />
                 {{ activeTestCase.name }}
               </span>
             </div>
             <div class="trace-result-card__message">{{ result.message }}</div>
-            <pre v-if="Object.keys(result.output ?? {}).length > 0" class="trace-result-card__output">{{ JSON.stringify(result.output, null, 2) }}</pre>
+            <pre
+              v-if="Object.keys(result.output ?? {}).length > 0"
+              class="trace-result-card__output"
+              >{{ JSON.stringify(result.output, null, 2) }}</pre
+            >
 
             <!-- Expectation comparison (only when loaded from test case) -->
             <template v-if="expectationMatch">
@@ -337,7 +363,9 @@ async function runTrace() {
                 >
                   {{ expectationMatch.pass ? '✓ PASS' : '✗ FAIL' }}
                 </span>
-                <span class="expect-label">{{ t('trace.expected') }}: {{ activeTestCase?.expect.code }}</span>
+                <span class="expect-label"
+                  >{{ t('trace.expected') }}: {{ activeTestCase?.expect.code }}</span
+                >
               </div>
               <div v-if="expectationMatch.outputDiffs.length > 0" class="expect-diffs">
                 <div
@@ -347,7 +375,7 @@ async function runTrace() {
                 >
                   <span class="expect-diff-key">{{ diff.key }}</span>
                   <span class="expect-diff-exp">{{ JSON.stringify(diff.expected) }}</span>
-                  <t-icon name="arrow-right" size="10px" style="opacity:0.4" />
+                  <t-icon name="arrow-right" size="10px" style="opacity: 0.4" />
                   <span class="expect-diff-act">{{ JSON.stringify(diff.actual) }}</span>
                 </div>
               </div>
@@ -355,11 +383,7 @@ async function runTrace() {
 
             <!-- Save as test case -->
             <div class="result-actions">
-              <t-button
-                size="small"
-                variant="outline"
-                @click="openSaveDialog"
-              >
+              <t-button size="small" variant="outline" @click="openSaveDialog">
                 <template #icon><t-icon name="save" /></template>
                 {{ t('trace.saveAsTest') }}
               </t-button>
@@ -381,7 +405,11 @@ async function runTrace() {
             >
               <span v-if="idx > 0" class="trace-step__connector" />
               <div class="trace-step__row">
-                <t-icon :name="stepIconName(idx, result.trace!.steps)" size="14px" class="trace-step__icon" />
+                <t-icon
+                  :name="stepIconName(idx, result.trace!.steps)"
+                  size="14px"
+                  class="trace-step__icon"
+                />
                 <span class="trace-step__name">{{ step.name }}</span>
                 <span class="trace-step__duration">{{ formatDuration(step.duration_us) }}</span>
               </div>
@@ -416,9 +444,12 @@ async function runTrace() {
               v-if="entry.result"
               class="code-badge code-badge--sm"
               :style="entry.result.code === 'error' ? 'color:#ff4d4f' : ''"
-            >{{ entry.result.code }}</span>
-            <span v-else class="code-badge code-badge--sm" style="color:#ff4d4f">error</span>
-            <span class="history-entry__duration" v-if="entry.result">{{ formatDuration(entry.result.duration_us) }}</span>
+              >{{ entry.result.code }}</span
+            >
+            <span v-else class="code-badge code-badge--sm" style="color: #ff4d4f">error</span>
+            <span class="history-entry__duration" v-if="entry.result">{{
+              formatDuration(entry.result.duration_us)
+            }}</span>
           </div>
         </div>
       </template>
diff --git a/ordo-editor/apps/studio/src/components/ui/StudioPageHeader.vue b/ordo-editor/apps/studio/src/components/ui/StudioPageHeader.vue
index 6141fb90..852b3e9b 100644
--- a/ordo-editor/apps/studio/src/components/ui/StudioPageHeader.vue
+++ b/ordo-editor/apps/studio/src/components/ui/StudioPageHeader.vue
@@ -1,13 +1,13 @@
 <script setup lang="ts">
 const props = withDefaults(
   defineProps<{
-    title: string
-    subtitle?: string
+    title: string;
+    subtitle?: string;
   }>(),
   {
     subtitle: '',
-  },
-)
+  }
+);
 </script>
 
 <template>
diff --git a/ordo-editor/apps/studio/src/components/ui/index.ts b/ordo-editor/apps/studio/src/components/ui/index.ts
index d2625a46..6dfc0c02 100644
--- a/ordo-editor/apps/studio/src/components/ui/index.ts
+++ b/ordo-editor/apps/studio/src/components/ui/index.ts
@@ -1,2 +1,2 @@
-export { default as StudioPageHeader } from './StudioPageHeader.vue'
-export { default as StudioDialogActions } from './StudioDialogActions.vue'
+export { default as StudioPageHeader } from './StudioPageHeader.vue';
+export { default as StudioDialogActions } from './StudioDialogActions.vue';
diff --git a/ordo-editor/apps/studio/src/constants/rbac.ts b/ordo-editor/apps/studio/src/constants/rbac.ts
index 39aa6b0c..46bca6d3 100644
--- a/ordo-editor/apps/studio/src/constants/rbac.ts
+++ b/ordo-editor/apps/studio/src/constants/rbac.ts
@@ -1,13 +1,16 @@
 export interface PermissionGroup {
-  key: string
-  permissions: string[]
+  key: string;
+  permissions: string[];
 }
 
 export const RBAC_PERMISSION_GROUPS: PermissionGroup[] = [
   { key: 'org', permissions: ['org:view', 'org:manage'] },
   { key: 'members', permissions: ['member:view', 'member:invite', 'member:remove'] },
   { key: 'roles', permissions: ['role:view', 'role:manage'] },
-  { key: 'projects', permissions: ['project:view', 'project:create', 'project:manage', 'project:delete'] },
+  {
+    key: 'projects',
+    permissions: ['project:view', 'project:create', 'project:manage', 'project:delete'],
+  },
   { key: 'rulesets', permissions: ['ruleset:view', 'ruleset:edit', 'ruleset:publish'] },
   { key: 'environments', permissions: ['environment:view', 'environment:manage'] },
   { key: 'servers', permissions: ['server:view', 'server:manage'] },
@@ -29,12 +32,12 @@ export const RBAC_PERMISSION_GROUPS: PermissionGroup[] = [
       'release:instance.view',
     ],
   },
-]
+];
 
 export function permissionI18nKey(permission: string) {
-  return permission.replace(':', '_').replace(/\./g, '_')
+  return permission.replace(':', '_').replace(/\./g, '_');
 }
 
 export function permissionGroup(permission: string): string | undefined {
-  return RBAC_PERMISSION_GROUPS.find((g) => g.permissions.includes(permission))?.key
+  return RBAC_PERMISSION_GROUPS.find((g) => g.permissions.includes(permission))?.key;
 }
diff --git a/ordo-editor/apps/studio/src/constants/release-center.ts b/ordo-editor/apps/studio/src/constants/release-center.ts
index e1a6604c..2eddfc81 100644
--- a/ordo-editor/apps/studio/src/constants/release-center.ts
+++ b/ordo-editor/apps/studio/src/constants/release-center.ts
@@ -1,16 +1,21 @@
-import { useI18n } from 'vue-i18n'
-import type { ReleaseExecutionStatus, ReleaseInstanceStatus, ReleaseRequestStatus, RolloutStrategy } from '@/api/types'
+import { useI18n } from 'vue-i18n';
+import type {
+  ReleaseExecutionStatus,
+  ReleaseInstanceStatus,
+  ReleaseRequestStatus,
+  RolloutStrategy,
+} from '@/api/types';
 
 export function labelReleaseRequestStatus(status: ReleaseRequestStatus) {
-  return status
+  return status;
 }
 
 export function labelReleaseExecutionStatus(status: ReleaseExecutionStatus) {
-  return status
+  return status;
 }
 
 export function labelInstanceStatus(status: ReleaseInstanceStatus) {
-  return status
+  return status;
 }
 
 /**
@@ -18,38 +23,42 @@ export function labelInstanceStatus(status: ReleaseInstanceStatus) {
  * Must be called inside a Vue component setup context.
  */
 export function useRolloutStrategyLabel() {
-  const { t } = useI18n()
+  const { t } = useI18n();
   return (strategy: RolloutStrategy) => {
     switch (strategy.kind) {
       case 'all_at_once':
-        return t('releaseCenter.rolloutStrategyLabel.allAtOnce')
+        return t('releaseCenter.rolloutStrategyLabel.allAtOnce');
       case 'fixed_batch':
-        return t('releaseCenter.rolloutStrategyLabel.fixedBatch', { count: strategy.batch_size ?? 0 })
+        return t('releaseCenter.rolloutStrategyLabel.fixedBatch', {
+          count: strategy.batch_size ?? 0,
+        });
       case 'percentage_batch':
-        return t('releaseCenter.rolloutStrategyLabel.percentageBatch', { pct: strategy.batch_percentage ?? 0 })
+        return t('releaseCenter.rolloutStrategyLabel.percentageBatch', {
+          pct: strategy.batch_percentage ?? 0,
+        });
       case 'time_interval_batch':
         return t('releaseCenter.rolloutStrategyLabel.timeIntervalBatch', {
           count: strategy.batch_size ?? 0,
           seconds: strategy.batch_interval_seconds ?? 0,
-        })
+        });
       default:
-        return strategy.kind ?? '—'
+        return strategy.kind ?? '—';
     }
-  }
+  };
 }
 
 /** Legacy alias for non-reactive/non-component contexts (English fallback). */
 export function labelRolloutStrategy(strategy: RolloutStrategy) {
   switch (strategy.kind) {
     case 'all_at_once':
-      return 'All at once'
+      return 'All at once';
     case 'fixed_batch':
-      return `${strategy.batch_size ?? 0} instances / batch`
+      return `${strategy.batch_size ?? 0} instances / batch`;
     case 'percentage_batch':
-      return `${strategy.batch_percentage ?? 0}% / batch`
+      return `${strategy.batch_percentage ?? 0}% / batch`;
     case 'time_interval_batch':
-      return `${strategy.batch_size ?? 0} instances every ${strategy.batch_interval_seconds ?? 0}s`
+      return `${strategy.batch_size ?? 0} instances every ${strategy.batch_interval_seconds ?? 0}s`;
     default:
-      return strategy.kind ?? '—'
+      return strategy.kind ?? '—';
   }
 }
diff --git a/ordo-editor/apps/studio/src/i18n/index.ts b/ordo-editor/apps/studio/src/i18n/index.ts
index bc50bb68..7db5a090 100644
--- a/ordo-editor/apps/studio/src/i18n/index.ts
+++ b/ordo-editor/apps/studio/src/i18n/index.ts
@@ -1,25 +1,25 @@
-import { createI18n } from 'vue-i18n'
-import en from './locales/en'
-import zhCN from './locales/zh-CN'
-import zhTW from './locales/zh-TW'
+import { createI18n } from 'vue-i18n';
+import en from './locales/en';
+import zhCN from './locales/zh-CN';
+import zhTW from './locales/zh-TW';
 
-export type Locale = 'en' | 'zh-CN' | 'zh-TW'
+export type Locale = 'en' | 'zh-CN' | 'zh-TW';
 
-const STORAGE_KEY = 'ordo-locale'
+const STORAGE_KEY = 'ordo-locale';
 
 export const LOCALE_OPTIONS: { label: string; value: Locale }[] = [
   { label: 'EN', value: 'en' },
   { label: '简中', value: 'zh-CN' },
   { label: '繁中', value: 'zh-TW' },
-]
+];
 
 function detectLocale(): Locale {
-  const saved = localStorage.getItem(STORAGE_KEY) as Locale | null
-  if (saved && ['en', 'zh-CN', 'zh-TW'].includes(saved)) return saved
-  const browser = navigator.language
-  if (browser.startsWith('zh-TW') || browser.startsWith('zh-HK')) return 'zh-TW'
-  if (browser.startsWith('zh')) return 'zh-CN'
-  return 'en'
+  const saved = localStorage.getItem(STORAGE_KEY) as Locale | null;
+  if (saved && ['en', 'zh-CN', 'zh-TW'].includes(saved)) return saved;
+  const browser = navigator.language;
+  if (browser.startsWith('zh-TW') || browser.startsWith('zh-HK')) return 'zh-TW';
+  if (browser.startsWith('zh')) return 'zh-CN';
+  return 'en';
 }
 
 export const i18n = createI18n({
@@ -31,10 +31,10 @@ export const i18n = createI18n({
     'zh-CN': zhCN,
     'zh-TW': zhTW,
   },
-})
+});
 
 export function setLocale(locale: Locale) {
-  ;(i18n.global.locale as any).value = locale
-  localStorage.setItem(STORAGE_KEY, locale)
-  document.documentElement.lang = locale
+  (i18n.global.locale as any).value = locale;
+  localStorage.setItem(STORAGE_KEY, locale);
+  document.documentElement.lang = locale;
 }
diff --git a/ordo-editor/apps/studio/src/i18n/locales/en.ts b/ordo-editor/apps/studio/src/i18n/locales/en.ts
index 7d33914e..4602e37a 100644
--- a/ordo-editor/apps/studio/src/i18n/locales/en.ts
+++ b/ordo-editor/apps/studio/src/i18n/locales/en.ts
@@ -25,7 +25,8 @@ export default {
   },
   auth: {
     subtitle: 'Decision Management Platform',
-    tagline: 'Ship decisions with confidence — version, review, and roll out rule changes with an enterprise-grade control plane.',
+    tagline:
+      'Ship decisions with confidence — version, review, and roll out rule changes with an enterprise-grade control plane.',
     feature1: 'Visual rule editor with graph & table modes',
     feature2: 'Approval workflows and policy-gated rollouts',
     feature3: 'Multi-environment deployment with instant rollback',
@@ -51,7 +52,8 @@ export default {
     joinStudio: 'Join Ordo Studio',
     registerBtn: 'Create Account',
     registrationDisabled: 'Registration is closed',
-    registrationDisabledDesc: 'New accounts on this platform require an invitation. Ask your organization admin to invite you via email.',
+    registrationDisabledDesc:
+      'New accounts on this platform require an invitation. Ask your organization admin to invite you via email.',
     backToLogin: 'Back to sign in',
     forgotPassword: 'Forgot password?',
     orLoginWith: 'Or continue with',
@@ -85,10 +87,12 @@ export default {
     orgSettingsSubtitle: 'Manage organization metadata, descriptions, and workspace defaults.',
     projectsSubtitle: 'Browse decision projects, create new ones, or start from a template.',
     editorSubtitle: 'Edit rulesets, inspect execution paths, and keep project context in view.',
-    testsSubtitle: 'Run tests and inspect whether your decision behavior still matches expectations.',
+    testsSubtitle:
+      'Run tests and inspect whether your decision behavior still matches expectations.',
     versionsSubtitle: 'Review saved versions, restore points, and history for the current project.',
     settingsSubtitle: 'Personal preferences, language, and appearance controls for your account.',
-    serversSubtitle: 'Inspect registered servers, check availability, and review health and metrics inline.',
+    serversSubtitle:
+      'Inspect registered servers, check availability, and review health and metrics inline.',
     searchPlaceholder: 'Search projects, pages, or actions',
     searchShortcut: 'Ctrl K',
     commandTitle: 'Search and Jump',
@@ -139,7 +143,8 @@ export default {
       deleteDesc: 'All projects and rule data will be permanently deleted and cannot be recovered.',
       deleteBtn: 'Delete Organization',
       deleteDialog: 'Delete Organization',
-      deleteConfirm: 'Are you sure you want to delete organization "{name}"? This action is irreversible and all project data will be cleared.',
+      deleteConfirm:
+        'Are you sure you want to delete organization "{name}"? This action is irreversible and all project data will be cleared.',
       nameRequired: 'Organization name cannot be empty',
       saveSuccess: 'Saved successfully',
       deleteSuccess: 'Organization deleted',
@@ -232,7 +237,8 @@ export default {
     createSuccess: 'Project created',
     deleteSuccess: 'Project deleted',
     deleteDialog: 'Delete Project',
-    deleteConfirm: 'Are you sure you want to delete project "{name}"? This action is irreversible and all rules will be deleted.',
+    deleteConfirm:
+      'Are you sure you want to delete project "{name}"? This action is irreversible and all rules will be deleted.',
   },
   template: {
     fromTemplate: 'Start from Template',
@@ -304,7 +310,8 @@ export default {
     loadFailed: 'Load failed',
     saveSuccess: 'Saved',
     versionRequired: 'Set a version before saving',
-    versionBumpRequired: 'Version {version} is already published. Bump the version before saving more edits.',
+    versionBumpRequired:
+      'Version {version} is already published. Bump the version before saving more edits.',
     publishedVersionTag: 'Published {version}',
     noPermission: 'You do not have edit permission',
     closeConfirm: 'Unsaved Changes',
@@ -421,7 +428,8 @@ export default {
     exprRequired: 'Expression is required',
     cycleError: 'Circular dependency detected, please fix before saving',
     deleteDialog: 'Delete Concept',
-    deleteConfirm: 'Are you sure you want to delete "{name}"? Other concepts that depend on it may be affected.',
+    deleteConfirm:
+      'Are you sure you want to delete "{name}"? Other concepts that depend on it may be affected.',
     deleteSuccess: 'Deleted',
     depCount: 'Depends on {count} fields',
   },
@@ -507,7 +515,8 @@ export default {
     currentTag: 'Current',
     rollbackBtn: 'Roll back to this version',
     rollbackDialog: 'Roll Back Version',
-    rollbackConfirm: 'Are you sure you want to roll back "{name}" to version #{seq}? This will overwrite the current version.',
+    rollbackConfirm:
+      'Are you sure you want to roll back "{name}" to version #{seq}? This will overwrite the current version.',
     rollbackConfirmBtn: 'Confirm Rollback',
     rollbackCancel: 'Cancel',
     rollbackSuccess: 'Rolled back to version #{seq}',
@@ -544,8 +553,10 @@ export default {
   },
   dashboard: {
     workspaceTitle: 'Project Workspace',
-    workspaceSubtitle: 'You are working inside {org}. Jump back into a project, start from a template, or review the engine fleet.',
-    workspaceSubtitleNoOrg: 'Select an organization first, then open a project or start from a template.',
+    workspaceSubtitle:
+      'You are working inside {org}. Jump back into a project, start from a template, or review the engine fleet.',
+    workspaceSubtitleNoOrg:
+      'Select an organization first, then open a project or start from a template.',
     newProject: 'New Project',
     statOrgs: 'Organizations',
     statProjects: 'Projects',
@@ -601,7 +612,8 @@ export default {
     serverRegistry: {
       title: 'Servers',
       desc: 'Inspect the ordo-server nodes currently registered to this platform.',
-      cleanupHint: 'Nodes degrade after 90 seconds without heartbeat, go offline after 10 minutes, and stale offline records are pruned after 30 minutes.',
+      cleanupHint:
+        'Nodes degrade after 90 seconds without heartbeat, go offline after 10 minutes, and stale offline records are pruned after 30 minutes.',
       refresh: 'Refresh',
       empty: 'No registered servers are visible to this account yet.',
       loadFailed: 'Failed to load server registry',
@@ -650,7 +662,8 @@ export default {
     },
     github: {
       title: 'GitHub Integration',
-      description: 'Connect your GitHub account to access the template marketplace and install community templates directly into your projects.',
+      description:
+        'Connect your GitHub account to access the template marketplace and install community templates directly into your projects.',
       connectBtn: 'Connect with GitHub',
       disconnectBtn: 'Disconnect',
       connected: 'GitHub connected successfully',
@@ -702,7 +715,8 @@ export default {
     engineDegraded: 'Degraded',
     engineDisconnected: 'Disconnected',
     serverBinding: 'Server Binding',
-    serverBindingDesc: 'Route this project through a registered ordo-server, or keep using the platform default engine.',
+    serverBindingDesc:
+      'Route this project through a registered ordo-server, or keep using the platform default engine.',
     serverLabel: 'Bound Server',
     serverDefault: 'Use platform default',
     serverSave: 'Save Routing',
@@ -749,8 +763,10 @@ export default {
     title: 'Marketplace',
     subtitle: 'Browse community templates from GitHub',
     detail: 'Template Detail',
-    connectPrompt: 'Connect your GitHub account for higher rate limits and private repository access',
-    connectOptional: 'GitHub connection is optional. Public templates can be browsed and installed without it.',
+    connectPrompt:
+      'Connect your GitHub account for higher rate limits and private repository access',
+    connectOptional:
+      'GitHub connection is optional. Public templates can be browsed and installed without it.',
     connectBtn: 'Connect GitHub',
     connectError: 'Failed to connect GitHub',
     notConnected: 'GitHub connection is optional for public marketplace templates',
@@ -831,19 +847,24 @@ export default {
       title: 'Project Tests',
       runAll: 'Run All Project Tests',
       summary: '{passed}/{total} passed',
-      diagnosticsSubtitle: 'Run draft rules locally, inspect mismatches, and replay the execution path in readonly flow mode.',
+      diagnosticsSubtitle:
+        'Run draft rules locally, inspect mismatches, and replay the execution path in readonly flow mode.',
       localDraftMode: 'Local draft execution',
       localDraftHint: 'Runs inside ordo-platform with the latest draft, not against live servers.',
       runningLocal: 'Running draft tests locally...',
       noRulesets: 'No rulesets in this project',
-      noRulesetsHint: 'Create a ruleset first, then this workspace can run local diagnostics and flow replay.',
+      noRulesetsHint:
+        'Create a ruleset first, then this workspace can run local diagnostics and flow replay.',
       selectRuleset: 'Select a ruleset',
       testCount: '{total} test cases',
       runPromptTitle: 'Run tests to generate diagnostics',
-      runPromptBody: 'This workspace shows expected vs actual output, trace details, and readonly flow replay after a run.',
-      pendingNote: 'This test case is available but has not been executed in the current local run yet.',
+      runPromptBody:
+        'This workspace shows expected vs actual output, trace details, and readonly flow replay after a run.',
+      pendingNote:
+        'This test case is available but has not been executed in the current local run yet.',
       diagnosticsTitle: 'Diagnostics',
-      diagnosticsHint: 'Select a failed or passed test result to inspect output diffs, trace steps, and flow replay.',
+      diagnosticsHint:
+        'Select a failed or passed test result to inspect output diffs, trace steps, and flow replay.',
       expectedActual: 'Expected vs Actual',
       traceDetails: 'Trace Details',
       flowReplay: 'Flow Replay',
@@ -862,9 +883,11 @@ export default {
       variablesSnapshot: 'Variables snapshot',
       noTrace: 'This test run did not return trace data',
       noFlowReplay: 'Flow replay unavailable',
-      noFlowReplayHint: 'Run the test again after trace capture finishes, or open a ruleset that still has its draft available.',
+      noFlowReplayHint:
+        'Run the test again after trace capture finishes, or open a ruleset that still has its draft available.',
       noDecisionTableTrace: 'Decision table trace unavailable',
-      noDecisionTableTraceHint: 'This ruleset is not a standard decision table, or the selected result has no matching test input to replay.',
+      noDecisionTableTraceHint:
+        'This ruleset is not a standard decision table, or the selected result has no matching test input to replay.',
       noTests: 'No test cases in this project',
     },
     export: {
@@ -897,7 +920,8 @@ export default {
   },
   conflict: {
     title: 'Draft Conflict',
-    description: 'Someone else saved a newer version. Review the differences and choose how to proceed.',
+    description:
+      'Someone else saved a newer version. Review the differences and choose how to proceed.',
     local: 'Your draft',
     server: 'Server draft',
     useLocal: 'Use Mine',
@@ -932,12 +956,15 @@ export default {
     selectedNodesTitle: 'Selected nodes',
     selectionEmpty: 'No nodes selected',
     labelsEmpty: 'No labels',
-    degradedWarning: 'Degraded nodes selected: {names}. Publishing can continue, but verify node health first.',
-    mismatchWarning: 'Some selected nodes do not look like they belong to this environment: {names}. Verify you are not binding test nodes to production.',
+    degradedWarning:
+      'Degraded nodes selected: {names}. Publishing can continue, but verify node health first.',
+    mismatchWarning:
+      'Some selected nodes do not look like they belong to this environment: {names}. Verify you are not binding test nodes to production.',
     delete: 'Delete',
     confirmDelete: 'Delete environment "{name}"?',
     natsPrefix: 'NATS Subject Prefix',
-    natsPrefixHelp: 'This usually does not need manual input. It is auto-generated from the environment name and scopes rule delivery subjects for this environment.',
+    natsPrefixHelp:
+      'This usually does not need manual input. It is auto-generated from the environment name and scopes rule delivery subjects for this environment.',
     save: 'Save',
     cancel: 'Cancel',
     noEnvs: 'No environments yet',
@@ -1000,7 +1027,8 @@ export default {
   },
   releaseCenter: {
     title: 'Release Center',
-    subtitle: 'Manage approval workflows, batch rollouts, rollback policies, and release visibility.',
+    subtitle:
+      'Manage approval workflows, batch rollouts, rollback policies, and release visibility.',
     navOverview: 'Overview',
     navRequests: 'Requests',
     navPolicies: 'Policies',
@@ -1044,7 +1072,8 @@ export default {
     tabExecution: 'Execution',
     backToRequests: 'Back to Requests',
     requestDetailTitle: 'Release Request Detail',
-    requestDetailSubtitle: 'Review release context, approval chain, and ruleset diff before execution.',
+    requestDetailSubtitle:
+      'Review release context, approval chain, and ruleset diff before execution.',
     requestNotFound: 'Release request not found',
     diffSectionTitle: 'Ruleset diff summary',
     diffStepsBefore: 'Steps before',
@@ -1063,11 +1092,13 @@ export default {
     diffDescriptionChanged: 'Description changed',
     diffEmpty: 'No changes',
     requestsTitle: 'Release Requests',
-    requestsSubtitle: 'Track approval progress, rollout strategy, and rollback baseline before execution.',
+    requestsSubtitle:
+      'Track approval progress, rollout strategy, and rollback baseline before execution.',
     policiesTitle: 'Release Policies',
     policiesSubtitle: 'Bind approvers, rollout strategy, and rollback guards to project targets.',
     historyTitle: 'Release History',
-    historySubtitle: 'Browse completed publish and redeploy records while the new release flow is phased in.',
+    historySubtitle:
+      'Browse completed publish and redeploy records while the new release flow is phased in.',
     createRequest: 'Create Request',
     createPolicy: 'Create Policy',
     affectedInstances: 'Affected instances',
@@ -1123,22 +1154,29 @@ export default {
     batchIntervalField: 'Batch interval (seconds)',
     maxFailedInstancesField: 'Max failed instances',
     noPolicyForRequestTitle: 'No release policy is configured yet',
-    noPolicyForRequestDesc: 'Create a policy first so this release request can bind approvers, rollout, and rollback rules.',
-    noBoundServer: 'This environment has no bound execution node. The request will record 0 affected instances.',
+    noPolicyForRequestDesc:
+      'Create a policy first so this release request can bind approvers, rollout, and rollback rules.',
+    noBoundServer:
+      'This environment has no bound execution node. The request will record 0 affected instances.',
     serverStatusLabel: 'Node status',
     serverStatusMap: {
       online: 'Online',
       degraded: 'Degraded',
       offline: 'Offline',
     },
-    policyNameHelp: 'Use a stable, recognizable name so approvers can quickly understand where this policy applies.',
-    targetFieldHelp: 'Pick the environment this policy governs. Release requests targeting this environment will use it by default.',
+    policyNameHelp:
+      'Use a stable, recognizable name so approvers can quickly understand where this policy applies.',
+    targetFieldHelp:
+      'Pick the environment this policy governs. Release requests targeting this environment will use it by default.',
     minApprovalsHelp: 'The request cannot move forward until this many approvers have approved it.',
-    approversHelp: 'Only these members can review and approve release requests matched by this policy.',
+    approversHelp:
+      'Only these members can review and approve release requests matched by this policy.',
     batchSizeHelp: 'How many instances are released in each rollout batch.',
     batchIntervalHelp: 'How long the system waits before moving to the next batch.',
-    maxFailedInstancesHelp: 'Auto rollback is triggered once failures in this release exceed this count.',
-    metricGuardHelp: 'Optional guard expression, for example error rate or latency thresholds that should pause or rollback the release.',
+    maxFailedInstancesHelp:
+      'Auto rollback is triggered once failures in this release exceed this count.',
+    metricGuardHelp:
+      'Optional guard expression, for example error rate or latency thresholds that should pause or rollback the release.',
     statusMap: {
       draft: 'Draft',
       pending_approval: 'Pending approval',
@@ -1330,4 +1368,4 @@ export default {
       release_instance_view: 'Inspect per-instance rollout status and telemetry.',
     },
   },
-}
+};
diff --git a/ordo-editor/apps/studio/src/i18n/locales/zh-CN.ts b/ordo-editor/apps/studio/src/i18n/locales/zh-CN.ts
index a1c4db5b..d935b37b 100644
--- a/ordo-editor/apps/studio/src/i18n/locales/zh-CN.ts
+++ b/ordo-editor/apps/studio/src/i18n/locales/zh-CN.ts
@@ -544,7 +544,8 @@ export default {
   },
   dashboard: {
     workspaceTitle: '项目工作台',
-    workspaceSubtitle: '你当前在 {org} 中工作。可以快速回到项目、从模板开始，或查看 engine 节点状态。',
+    workspaceSubtitle:
+      '你当前在 {org} 中工作。可以快速回到项目、从模板开始，或查看 engine 节点状态。',
     workspaceSubtitleNoOrg: '请先选择一个组织，然后打开项目或从模板开始。',
     newProject: '新建项目',
     statOrgs: '组织',
@@ -601,7 +602,8 @@ export default {
     serverRegistry: {
       title: 'Servers',
       desc: '查看当前已注册到此平台的 ordo-server 节点。',
-      cleanupHint: '节点超过 90 秒无心跳会先退化，10 分钟后标记离线，30 分钟后自动清理离线僵尸记录。',
+      cleanupHint:
+        '节点超过 90 秒无心跳会先退化，10 分钟后标记离线，30 分钟后自动清理离线僵尸记录。',
       refresh: '刷新',
       empty: '当前账号还看不到任何已注册 Server。',
       loadFailed: '加载 Server 注册表失败',
@@ -933,11 +935,13 @@ export default {
     selectionEmpty: '尚未选择节点',
     labelsEmpty: '无 labels',
     degradedWarning: '已选择退化节点：{names}。发布仍可继续，但建议先确认节点健康状态。',
-    mismatchWarning: '已选节点与环境名称看起来不匹配：{names}。请确认没有把测试节点绑定到生产环境。',
+    mismatchWarning:
+      '已选节点与环境名称看起来不匹配：{names}。请确认没有把测试节点绑定到生产环境。',
     delete: '删除',
     confirmDelete: '删除环境 "{name}"？',
     natsPrefix: 'NATS 主题前缀',
-    natsPrefixHelp: '通常不需要手动填写。系统会按环境名称自动生成，用于该环境下规则下发的主题命名空间。',
+    natsPrefixHelp:
+      '通常不需要手动填写。系统会按环境名称自动生成，用于该环境下规则下发的主题命名空间。',
     save: '保存',
     cancel: '取消',
     noEnvs: '暂无环境',
@@ -1330,4 +1334,4 @@ export default {
       release_instance_view: '查看单实例发布状态与遥测。',
     },
   },
-}
+};
diff --git a/ordo-editor/apps/studio/src/i18n/locales/zh-TW.ts b/ordo-editor/apps/studio/src/i18n/locales/zh-TW.ts
index facc0776..078c1075 100644
--- a/ordo-editor/apps/studio/src/i18n/locales/zh-TW.ts
+++ b/ordo-editor/apps/studio/src/i18n/locales/zh-TW.ts
@@ -544,7 +544,8 @@ export default {
   },
   dashboard: {
     workspaceTitle: '專案工作台',
-    workspaceSubtitle: '你目前在 {org} 中工作。可以快速回到專案、從模板開始，或查看 engine 節點狀態。',
+    workspaceSubtitle:
+      '你目前在 {org} 中工作。可以快速回到專案、從模板開始，或查看 engine 節點狀態。',
     workspaceSubtitleNoOrg: '請先選擇一個組織，然後開啟專案或從模板開始。',
     newProject: '新建專案',
     statOrgs: '組織',
@@ -601,7 +602,8 @@ export default {
     serverRegistry: {
       title: 'Servers',
       desc: '查看目前已註冊到此平台的 ordo-server 節點。',
-      cleanupHint: '節點超過 90 秒無心跳會先退化，10 分鐘後標記離線，30 分鐘後自動清理離線殭屍記錄。',
+      cleanupHint:
+        '節點超過 90 秒無心跳會先退化，10 分鐘後標記離線，30 分鐘後自動清理離線殭屍記錄。',
       refresh: '重新整理',
       empty: '目前此帳號還看不到任何已註冊 Server。',
       loadFailed: '載入 Server 註冊表失敗',
@@ -933,11 +935,13 @@ export default {
     selectionEmpty: '尚未選擇節點',
     labelsEmpty: '無 labels',
     degradedWarning: '已選擇退化節點：{names}。發佈仍可繼續，但建議先確認節點健康狀態。',
-    mismatchWarning: '已選節點與環境名稱看起來不匹配：{names}。請確認沒有把測試節點綁定到生產環境。',
+    mismatchWarning:
+      '已選節點與環境名稱看起來不匹配：{names}。請確認沒有把測試節點綁定到生產環境。',
     delete: '刪除',
     confirmDelete: '刪除環境 "{name}"？',
     natsPrefix: 'NATS 主題前綴',
-    natsPrefixHelp: '通常不需要手動填寫。系統會依環境名稱自動產生，用於該環境下規則下發的主題命名空間。',
+    natsPrefixHelp:
+      '通常不需要手動填寫。系統會依環境名稱自動產生，用於該環境下規則下發的主題命名空間。',
     save: '儲存',
     cancel: '取消',
     noEnvs: '尚無環境',
@@ -1330,4 +1334,4 @@ export default {
       release_instance_view: '查看單一實例發佈狀態與遙測。',
     },
   },
-}
+};
diff --git a/ordo-editor/apps/studio/src/main.ts b/ordo-editor/apps/studio/src/main.ts
index 1219f55d..60df5267 100644
--- a/ordo-editor/apps/studio/src/main.ts
+++ b/ordo-editor/apps/studio/src/main.ts
@@ -1,17 +1,17 @@
-import { createApp } from 'vue'
-import { createPinia } from 'pinia'
-import TDesign from 'tdesign-vue-next'
-import router from './router'
-import App from './App.vue'
-import { i18n } from './i18n'
+import { createApp } from 'vue';
+import { createPinia } from 'pinia';
+import TDesign from 'tdesign-vue-next';
+import router from './router';
+import App from './App.vue';
+import { i18n } from './i18n';
 
 // Styles
-import 'tdesign-vue-next/es/style/index.css'
-import './styles/main.css'
+import 'tdesign-vue-next/es/style/index.css';
+import './styles/main.css';
 
-const app = createApp(App)
-app.use(createPinia())
-app.use(router)
-app.use(TDesign)
-app.use(i18n)
-app.mount('#app')
+const app = createApp(App);
+app.use(createPinia());
+app.use(router);
+app.use(TDesign);
+app.use(i18n);
+app.mount('#app');
diff --git a/ordo-editor/apps/studio/src/router/index.ts b/ordo-editor/apps/studio/src/router/index.ts
index e9d80024..31f2fb8e 100644
--- a/ordo-editor/apps/studio/src/router/index.ts
+++ b/ordo-editor/apps/studio/src/router/index.ts
@@ -1,5 +1,5 @@
-import { createRouter, createWebHistory } from 'vue-router'
-import { useAuthStore } from '@/stores/auth'
+import { createRouter, createWebHistory } from 'vue-router';
+import { useAuthStore } from '@/stores/auth';
 
 const router = createRouter({
   history: createWebHistory(),
@@ -227,17 +227,17 @@ const router = createRouter({
     // Catch-all
     { path: '/:pathMatch(.*)*', redirect: '/' },
   ],
-})
+});
 
 // Navigation guard: redirect to login if not authenticated
 router.beforeEach((to) => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
   if (!to.meta.public && !auth.isLoggedIn) {
-    return { name: 'login', query: { redirect: to.fullPath } }
+    return { name: 'login', query: { redirect: to.fullPath } };
   }
   if (to.meta.public && auth.isLoggedIn && (to.name === 'login' || to.name === 'register')) {
-    return { path: '/' }
+    return { path: '/' };
   }
-})
+});
 
-export default router
+export default router;
diff --git a/ordo-editor/apps/studio/src/stores/auth.ts b/ordo-editor/apps/studio/src/stores/auth.ts
index 4daea32c..3340e3b8 100644
--- a/ordo-editor/apps/studio/src/stores/auth.ts
+++ b/ordo-editor/apps/studio/src/stores/auth.ts
@@ -1,63 +1,73 @@
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import { authApi } from '@/api/platform-client'
-import type { UserInfo } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { authApi } from '@/api/platform-client';
+import type { UserInfo } from '@/api/types';
 
-const TOKEN_KEY = 'ordo_studio_token'
+const TOKEN_KEY = 'ordo_studio_token';
 
 export const useAuthStore = defineStore('auth', () => {
-  const token = ref<string | null>(localStorage.getItem(TOKEN_KEY))
-  const user = ref<UserInfo | null>(null)
+  const token = ref<string | null>(localStorage.getItem(TOKEN_KEY));
+  const user = ref<UserInfo | null>(null);
 
-  const isLoggedIn = computed(() => !!token.value)
+  const isLoggedIn = computed(() => !!token.value);
 
   function setToken(t: string) {
-    token.value = t
-    localStorage.setItem(TOKEN_KEY, t)
+    token.value = t;
+    localStorage.setItem(TOKEN_KEY, t);
   }
 
   function clearAuth() {
-    token.value = null
-    user.value = null
-    localStorage.removeItem(TOKEN_KEY)
+    token.value = null;
+    user.value = null;
+    localStorage.removeItem(TOKEN_KEY);
   }
 
   async function login(email: string, password: string) {
-    const resp = await authApi.login(email, password)
-    setToken(resp.token)
-    user.value = resp.user
-    return resp
+    const resp = await authApi.login(email, password);
+    setToken(resp.token);
+    user.value = resp.user;
+    return resp;
   }
 
   async function register(email: string, password: string, displayName: string) {
-    const resp = await authApi.register(email, password, displayName)
-    setToken(resp.token)
-    user.value = resp.user
-    return resp
+    const resp = await authApi.register(email, password, displayName);
+    setToken(resp.token);
+    user.value = resp.user;
+    return resp;
   }
 
   async function fetchMe() {
-    if (!token.value) return
+    if (!token.value) return;
     try {
-      user.value = await authApi.me(token.value)
+      user.value = await authApi.me(token.value);
     } catch (e: any) {
-      if (e.status === 401) clearAuth()
+      if (e.status === 401) clearAuth();
     }
   }
 
   async function updateProfile(patch: { display_name?: string }) {
-    if (!token.value) return
-    user.value = await authApi.updateProfile(token.value, patch)
+    if (!token.value) return;
+    user.value = await authApi.updateProfile(token.value, patch);
   }
 
   async function changePassword(currentPassword: string, newPassword: string) {
-    if (!token.value) return
-    await authApi.changePassword(token.value, currentPassword, newPassword)
+    if (!token.value) return;
+    await authApi.changePassword(token.value, currentPassword, newPassword);
   }
 
   function logout() {
-    clearAuth()
+    clearAuth();
   }
 
-  return { token, user, isLoggedIn, login, register, fetchMe, updateProfile, changePassword, logout }
-})
+  return {
+    token,
+    user,
+    isLoggedIn,
+    login,
+    register,
+    fetchMe,
+    updateProfile,
+    changePassword,
+    logout,
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/catalog.ts b/ordo-editor/apps/studio/src/stores/catalog.ts
index d5a005ec..d4792d9e 100644
--- a/ordo-editor/apps/studio/src/stores/catalog.ts
+++ b/ordo-editor/apps/studio/src/stores/catalog.ts
@@ -1,109 +1,119 @@
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import { catalogApi } from '@/api/catalog-client'
-import { useAuthStore } from './auth'
-import type { ConceptDefinition, DecisionContract, FactDataType, FactDefinition } from '@/api/types'
-import type { SchemaField } from '@ordo-engine/editor-core'
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { catalogApi } from '@/api/catalog-client';
+import { useAuthStore } from './auth';
+import type {
+  ConceptDefinition,
+  DecisionContract,
+  FactDataType,
+  FactDefinition,
+} from '@/api/types';
+import type { SchemaField } from '@ordo-engine/editor-core';
 
 // Maps FactDataType → editor SchemaFieldType
 function mapDataType(dt: FactDataType): SchemaField['type'] {
   switch (dt) {
-    case 'number': return 'number'
-    case 'boolean': return 'boolean'
-    case 'object': return 'object'
-    case 'date': return 'string'   // dates serialise as strings
-    default: return 'string'
+    case 'number':
+      return 'number';
+    case 'boolean':
+      return 'boolean';
+    case 'object':
+      return 'object';
+    case 'date':
+      return 'string'; // dates serialise as strings
+    default:
+      return 'string';
   }
 }
 
 export const useCatalogStore = defineStore('catalog', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const facts = ref<FactDefinition[]>([])
-  const concepts = ref<ConceptDefinition[]>([])
-  const contracts = ref<DecisionContract[]>([])
-  const loading = ref(false)
-  const currentProjectId = ref<string | null>(null)
+  const facts = ref<FactDefinition[]>([]);
+  const concepts = ref<ConceptDefinition[]>([]);
+  const contracts = ref<DecisionContract[]>([]);
+  const loading = ref(false);
+  const currentProjectId = ref<string | null>(null);
 
   /**
    * Fetch all catalog assets for a project (parallel).
    * Safe to call multiple times — idempotent if projectId unchanged.
    */
   async function fetchAll(projectId: string) {
-    if (!auth.token) return
-    loading.value = true
-    currentProjectId.value = projectId
+    if (!auth.token) return;
+    loading.value = true;
+    currentProjectId.value = projectId;
     try {
       const [f, c, ct] = await Promise.all([
         catalogApi.listFacts(auth.token, projectId),
         catalogApi.listConcepts(auth.token, projectId),
         catalogApi.listContracts(auth.token, projectId),
-      ])
-      facts.value = f
-      concepts.value = c
-      contracts.value = ct
+      ]);
+      facts.value = f;
+      concepts.value = c;
+      contracts.value = ct;
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   // ── Facts ──────────────────────────────────────────────────────────────────
 
   async function upsertFact(fact: Omit<FactDefinition, 'created_at' | 'updated_at'>) {
-    if (!auth.token || !currentProjectId.value) return
-    const saved = await catalogApi.upsertFact(auth.token, currentProjectId.value, fact)
-    const idx = facts.value.findIndex((f) => f.name === saved.name)
-    if (idx >= 0) facts.value[idx] = saved
-    else facts.value.push(saved)
-    return saved
+    if (!auth.token || !currentProjectId.value) return;
+    const saved = await catalogApi.upsertFact(auth.token, currentProjectId.value, fact);
+    const idx = facts.value.findIndex((f) => f.name === saved.name);
+    if (idx >= 0) facts.value[idx] = saved;
+    else facts.value.push(saved);
+    return saved;
   }
 
   async function deleteFact(name: string) {
-    if (!auth.token || !currentProjectId.value) return
-    await catalogApi.deleteFact(auth.token, currentProjectId.value, name)
-    facts.value = facts.value.filter((f) => f.name !== name)
+    if (!auth.token || !currentProjectId.value) return;
+    await catalogApi.deleteFact(auth.token, currentProjectId.value, name);
+    facts.value = facts.value.filter((f) => f.name !== name);
   }
 
   // ── Concepts ───────────────────────────────────────────────────────────────
 
   async function upsertConcept(concept: Omit<ConceptDefinition, 'created_at' | 'updated_at'>) {
-    if (!auth.token || !currentProjectId.value) return
-    const saved = await catalogApi.upsertConcept(auth.token, currentProjectId.value, concept)
-    const idx = concepts.value.findIndex((c) => c.name === saved.name)
-    if (idx >= 0) concepts.value[idx] = saved
-    else concepts.value.push(saved)
-    return saved
+    if (!auth.token || !currentProjectId.value) return;
+    const saved = await catalogApi.upsertConcept(auth.token, currentProjectId.value, concept);
+    const idx = concepts.value.findIndex((c) => c.name === saved.name);
+    if (idx >= 0) concepts.value[idx] = saved;
+    else concepts.value.push(saved);
+    return saved;
   }
 
   async function deleteConcept(name: string) {
-    if (!auth.token || !currentProjectId.value) return
-    await catalogApi.deleteConcept(auth.token, currentProjectId.value, name)
-    concepts.value = concepts.value.filter((c) => c.name !== name)
+    if (!auth.token || !currentProjectId.value) return;
+    await catalogApi.deleteConcept(auth.token, currentProjectId.value, name);
+    concepts.value = concepts.value.filter((c) => c.name !== name);
   }
 
   // ── Contracts ──────────────────────────────────────────────────────────────
 
   async function upsertContract(
     rulesetName: string,
-    contract: Omit<DecisionContract, 'ruleset_name' | 'updated_at'>,
+    contract: Omit<DecisionContract, 'ruleset_name' | 'updated_at'>
   ) {
-    if (!auth.token || !currentProjectId.value) return
+    if (!auth.token || !currentProjectId.value) return;
     const saved = await catalogApi.upsertContract(
       auth.token,
       currentProjectId.value,
       rulesetName,
-      contract,
-    )
-    const idx = contracts.value.findIndex((c) => c.ruleset_name === saved.ruleset_name)
-    if (idx >= 0) contracts.value[idx] = saved
-    else contracts.value.push(saved)
-    return saved
+      contract
+    );
+    const idx = contracts.value.findIndex((c) => c.ruleset_name === saved.ruleset_name);
+    if (idx >= 0) contracts.value[idx] = saved;
+    else contracts.value.push(saved);
+    return saved;
   }
 
   async function deleteContract(rulesetName: string) {
-    if (!auth.token || !currentProjectId.value) return
-    await catalogApi.deleteContract(auth.token, currentProjectId.value, rulesetName)
-    contracts.value = contracts.value.filter((c) => c.ruleset_name !== rulesetName)
+    if (!auth.token || !currentProjectId.value) return;
+    await catalogApi.deleteContract(auth.token, currentProjectId.value, rulesetName);
+    contracts.value = contracts.value.filter((c) => c.ruleset_name !== rulesetName);
   }
 
   // ── Derived ────────────────────────────────────────────────────────────────
@@ -121,19 +131,19 @@ export const useCatalogStore = defineStore('catalog', () => {
       type: mapDataType(c.data_type),
       description: c.description,
     })),
-  ])
+  ]);
 
   /** All known field names (facts + concepts) for dependency pickers */
   const allFieldNames = computed(() => [
     ...facts.value.map((f) => f.name),
     ...concepts.value.map((c) => c.name),
-  ])
+  ]);
 
   function reset() {
-    facts.value = []
-    concepts.value = []
-    contracts.value = []
-    currentProjectId.value = null
+    facts.value = [];
+    concepts.value = [];
+    contracts.value = [];
+    currentProjectId.value = null;
   }
 
   return {
@@ -152,5 +162,5 @@ export const useCatalogStore = defineStore('catalog', () => {
     upsertContract,
     deleteContract,
     reset,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/dashboard.ts b/ordo-editor/apps/studio/src/stores/dashboard.ts
index ca8f4225..26d62da8 100644
--- a/ordo-editor/apps/studio/src/stores/dashboard.ts
+++ b/ordo-editor/apps/studio/src/stores/dashboard.ts
@@ -1,35 +1,35 @@
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import { useOrgStore } from './org'
-import { useProjectStore } from './project'
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { useOrgStore } from './org';
+import { useProjectStore } from './project';
 
 export const useDashboardStore = defineStore('dashboard', () => {
-  const orgStore = useOrgStore()
-  const projectStore = useProjectStore()
+  const orgStore = useOrgStore();
+  const projectStore = useProjectStore();
 
-  const loading = ref(false)
+  const loading = ref(false);
 
-  const totalOrgs = computed(() => orgStore.orgs.length)
-  const totalProjects = computed(() => projectStore.projects.length)
-  const totalRulesets = computed(() => projectStore.rulesets?.length ?? 0)
+  const totalOrgs = computed(() => orgStore.orgs.length);
+  const totalProjects = computed(() => projectStore.projects.length);
+  const totalRulesets = computed(() => projectStore.rulesets?.length ?? 0);
 
   const recentProjects = computed(() =>
     [...projectStore.projects]
       .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())
-      .slice(0, 6),
-  )
+      .slice(0, 6)
+  );
 
   async function fetchDashboardData() {
-    loading.value = true
+    loading.value = true;
     try {
-      await orgStore.fetchOrgs()
+      await orgStore.fetchOrgs();
       if (orgStore.currentOrg) {
-        await projectStore.fetchProjects(orgStore.currentOrg.id)
+        await projectStore.fetchProjects(orgStore.currentOrg.id);
       }
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
-  return { loading, totalOrgs, totalProjects, totalRulesets, recentProjects, fetchDashboardData }
-})
+  return { loading, totalOrgs, totalProjects, totalRulesets, recentProjects, fetchDashboardData };
+});
diff --git a/ordo-editor/apps/studio/src/stores/environment.ts b/ordo-editor/apps/studio/src/stores/environment.ts
index a83ebc12..096fda28 100644
--- a/ordo-editor/apps/studio/src/stores/environment.ts
+++ b/ordo-editor/apps/studio/src/stores/environment.ts
@@ -1,75 +1,75 @@
-import { defineStore } from 'pinia'
-import { ref } from 'vue'
-import { environmentApi } from '@/api/platform-client'
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { environmentApi } from '@/api/platform-client';
 import type {
   CreateEnvironmentRequest,
   ProjectEnvironment,
   SetCanaryRequest,
   UpdateEnvironmentRequest,
-} from '@/api/types'
-import { useAuthStore } from './auth'
+} from '@/api/types';
+import { useAuthStore } from './auth';
 
 export const useEnvironmentStore = defineStore('environment', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const environments = ref<ProjectEnvironment[]>([])
-  const loading = ref(false)
-  const error = ref<string | null>(null)
+  const environments = ref<ProjectEnvironment[]>([]);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
 
   async function fetchEnvironments(orgId: string, projectId: string) {
-    loading.value = true
-    error.value = null
+    loading.value = true;
+    error.value = null;
     try {
-      environments.value = await environmentApi.list(auth.token!, orgId, projectId)
+      environments.value = await environmentApi.list(auth.token!, orgId, projectId);
     } catch (e: any) {
-      error.value = e.message
+      error.value = e.message;
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function createEnvironment(
     orgId: string,
     projectId: string,
-    req: CreateEnvironmentRequest,
+    req: CreateEnvironmentRequest
   ): Promise<ProjectEnvironment> {
-    const env = await environmentApi.create(auth.token!, orgId, projectId, req)
-    environments.value.push(env)
-    return env
+    const env = await environmentApi.create(auth.token!, orgId, projectId, req);
+    environments.value.push(env);
+    return env;
   }
 
   async function updateEnvironment(
     orgId: string,
     projectId: string,
     envId: string,
-    req: UpdateEnvironmentRequest,
+    req: UpdateEnvironmentRequest
   ): Promise<ProjectEnvironment> {
-    const updated = await environmentApi.update(auth.token!, orgId, projectId, envId, req)
-    const idx = environments.value.findIndex((e) => e.id === envId)
-    if (idx !== -1) environments.value[idx] = updated
-    return updated
+    const updated = await environmentApi.update(auth.token!, orgId, projectId, envId, req);
+    const idx = environments.value.findIndex((e) => e.id === envId);
+    if (idx !== -1) environments.value[idx] = updated;
+    return updated;
   }
 
   async function deleteEnvironment(orgId: string, projectId: string, envId: string) {
-    await environmentApi.delete(auth.token!, orgId, projectId, envId)
-    environments.value = environments.value.filter((e) => e.id !== envId)
+    await environmentApi.delete(auth.token!, orgId, projectId, envId);
+    environments.value = environments.value.filter((e) => e.id !== envId);
   }
 
   async function setCanary(
     orgId: string,
     projectId: string,
     envId: string,
-    req: SetCanaryRequest,
+    req: SetCanaryRequest
   ): Promise<ProjectEnvironment> {
-    const updated = await environmentApi.setCanary(auth.token!, orgId, projectId, envId, req)
-    const idx = environments.value.findIndex((e) => e.id === envId)
-    if (idx !== -1) environments.value[idx] = updated
-    return updated
+    const updated = await environmentApi.setCanary(auth.token!, orgId, projectId, envId, req);
+    const idx = environments.value.findIndex((e) => e.id === envId);
+    if (idx !== -1) environments.value[idx] = updated;
+    return updated;
   }
 
   function reset() {
-    environments.value = []
-    error.value = null
+    environments.value = [];
+    error.value = null;
   }
 
   return {
@@ -82,5 +82,5 @@ export const useEnvironmentStore = defineStore('environment', () => {
     deleteEnvironment,
     setCanary,
     reset,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/github.ts b/ordo-editor/apps/studio/src/stores/github.ts
index 33f81451..eb2d81d4 100644
--- a/ordo-editor/apps/studio/src/stores/github.ts
+++ b/ordo-editor/apps/studio/src/stores/github.ts
@@ -1,82 +1,82 @@
-import { defineStore } from 'pinia'
-import { ref } from 'vue'
-import { githubApi } from '@/api/platform-client'
-import { useAuthStore } from './auth'
-import type { GitHubStatus } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { githubApi } from '@/api/platform-client';
+import { useAuthStore } from './auth';
+import type { GitHubStatus } from '@/api/types';
 
 export const useGithubStore = defineStore('github', () => {
-  const status = ref<GitHubStatus>({ connected: false })
-  const loading = ref(false)
+  const status = ref<GitHubStatus>({ connected: false });
+  const loading = ref(false);
 
   async function fetchStatus() {
-    const auth = useAuthStore()
-    if (!auth.token) return
-    loading.value = true
+    const auth = useAuthStore();
+    if (!auth.token) return;
+    loading.value = true;
     try {
-      status.value = await githubApi.getStatus(auth.token)
+      status.value = await githubApi.getStatus(auth.token);
     } catch {
-      status.value = { connected: false }
+      status.value = { connected: false };
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function getConnectUrl(): Promise<string> {
-    const auth = useAuthStore()
-    const { url } = await githubApi.getConnectUrl(auth.token!)
-    return url
+    const auth = useAuthStore();
+    const { url } = await githubApi.getConnectUrl(auth.token!);
+    return url;
   }
 
   async function connect(): Promise<void> {
-    const url = await getConnectUrl()
-    let callbackOrigin = window.location.origin
+    const url = await getConnectUrl();
+    let callbackOrigin = window.location.origin;
     try {
-      const authUrl = new URL(url)
-      const redirectUri = authUrl.searchParams.get('redirect_uri')
+      const authUrl = new URL(url);
+      const redirectUri = authUrl.searchParams.get('redirect_uri');
       if (redirectUri) {
-        callbackOrigin = new URL(redirectUri).origin
+        callbackOrigin = new URL(redirectUri).origin;
       }
     } catch {
-      callbackOrigin = window.location.origin
+      callbackOrigin = window.location.origin;
     }
 
     return new Promise((resolve, reject) => {
-      const popup = window.open(url, 'github-oauth', 'width=600,height=700,scrollbars=yes')
+      const popup = window.open(url, 'github-oauth', 'width=600,height=700,scrollbars=yes');
       if (!popup) {
-        reject(new Error('Popup blocked — please allow popups for this site'))
-        return
+        reject(new Error('Popup blocked — please allow popups for this site'));
+        return;
       }
 
       const onMessage = async (event: MessageEvent) => {
-        if (event.origin !== window.location.origin && event.origin !== callbackOrigin) return
+        if (event.origin !== window.location.origin && event.origin !== callbackOrigin) return;
         if (event.data?.type === 'github_connected') {
-          window.removeEventListener('message', onMessage)
-          await fetchStatus()
-          resolve()
+          window.removeEventListener('message', onMessage);
+          await fetchStatus();
+          resolve();
         } else if (event.data?.type === 'github_error') {
-          window.removeEventListener('message', onMessage)
-          reject(new Error(event.data.error || 'GitHub connection failed'))
+          window.removeEventListener('message', onMessage);
+          reject(new Error(event.data.error || 'GitHub connection failed'));
         }
-      }
-      window.addEventListener('message', onMessage)
+      };
+      window.addEventListener('message', onMessage);
 
       // Fallback: if popup closes without message, re-check status
       const timer = setInterval(() => {
         if (popup.closed) {
-          clearInterval(timer)
-          window.removeEventListener('message', onMessage)
-          fetchStatus().then(resolve).catch(reject)
+          clearInterval(timer);
+          window.removeEventListener('message', onMessage);
+          fetchStatus().then(resolve).catch(reject);
         }
-      }, 500)
-    })
+      }, 500);
+    });
   }
 
   async function disconnect() {
-    const auth = useAuthStore()
-    if (!auth.token) return
-    await githubApi.disconnect(auth.token)
-    status.value = { connected: false }
+    const auth = useAuthStore();
+    if (!auth.token) return;
+    await githubApi.disconnect(auth.token);
+    status.value = { connected: false };
   }
 
-  return { status, loading, fetchStatus, connect, disconnect }
-})
+  return { status, loading, fetchStatus, connect, disconnect };
+});
diff --git a/ordo-editor/apps/studio/src/stores/notification.ts b/ordo-editor/apps/studio/src/stores/notification.ts
index 05ed8d2e..334e072e 100644
--- a/ordo-editor/apps/studio/src/stores/notification.ts
+++ b/ordo-editor/apps/studio/src/stores/notification.ts
@@ -1,20 +1,20 @@
-import { defineStore } from 'pinia'
-import { computed, ref } from 'vue'
+import { defineStore } from 'pinia';
+import { computed, ref } from 'vue';
 
-export type NotifType = 'success' | 'error' | 'warning' | 'info'
+export type NotifType = 'success' | 'error' | 'warning' | 'info';
 
 export interface Notification {
-  id: string
-  type: NotifType
-  title: string
-  message?: string
-  timestamp: Date
-  read: boolean
+  id: string;
+  type: NotifType;
+  title: string;
+  message?: string;
+  timestamp: Date;
+  read: boolean;
 }
 
 export const useNotificationStore = defineStore('notification', () => {
-  const notifications = ref<Notification[]>([])
-  const unreadCount = computed(() => notifications.value.filter((n) => !n.read).length)
+  const notifications = ref<Notification[]>([]);
+  const unreadCount = computed(() => notifications.value.filter((n) => !n.read).length);
 
   function push(type: NotifType, title: string, message?: string) {
     notifications.value.unshift({
@@ -24,17 +24,17 @@ export const useNotificationStore = defineStore('notification', () => {
       message,
       timestamp: new Date(),
       read: false,
-    })
-    if (notifications.value.length > 50) notifications.value.pop()
+    });
+    if (notifications.value.length > 50) notifications.value.pop();
   }
 
   function markAllRead() {
-    notifications.value.forEach((n) => (n.read = true))
+    notifications.value.forEach((n) => (n.read = true));
   }
 
   function clear() {
-    notifications.value = []
+    notifications.value = [];
   }
 
-  return { notifications, unreadCount, push, markAllRead, clear }
-})
+  return { notifications, unreadCount, push, markAllRead, clear };
+});
diff --git a/ordo-editor/apps/studio/src/stores/org.ts b/ordo-editor/apps/studio/src/stores/org.ts
index d95caf00..43037cd0 100644
--- a/ordo-editor/apps/studio/src/stores/org.ts
+++ b/ordo-editor/apps/studio/src/stores/org.ts
@@ -1,181 +1,184 @@
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import { orgApi, memberApi, subOrgMemberApi } from '@/api/platform-client'
-import { useAuthStore } from './auth'
-import type { Member, OrgResponse, Organization, Role } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { orgApi, memberApi, subOrgMemberApi } from '@/api/platform-client';
+import { useAuthStore } from './auth';
+import type { Member, OrgResponse, Organization, Role } from '@/api/types';
 
-const CURRENT_ORG_KEY = 'ordo_studio_current_org'
+const CURRENT_ORG_KEY = 'ordo_studio_current_org';
 
 export const useOrgStore = defineStore('org', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const orgs = ref<OrgResponse[]>([])
-  const currentOrg = ref<Organization | null>(null)
-  const members = ref<Member[]>([])
-  const loading = ref(false)
+  const orgs = ref<OrgResponse[]>([]);
+  const currentOrg = ref<Organization | null>(null);
+  const members = ref<Member[]>([]);
+  const loading = ref(false);
 
   /** Sub-orgs keyed by parent org id. Populated on demand. */
-  const subOrgs = ref<Record<string, OrgResponse[]>>({})
+  const subOrgs = ref<Record<string, OrgResponse[]>>({});
 
   /** Sub-org members keyed by sub-org id. Populated on demand via parent org context. */
-  const subOrgMembers = ref<Record<string, Member[]>>({})
+  const subOrgMembers = ref<Record<string, Member[]>>({});
 
-  const currentOrgId = computed(() => currentOrg.value?.id ?? null)
+  const currentOrgId = computed(() => currentOrg.value?.id ?? null);
 
   // Restore last selected org from localStorage
-  const _savedOrgId = localStorage.getItem(CURRENT_ORG_KEY)
+  const _savedOrgId = localStorage.getItem(CURRENT_ORG_KEY);
 
   async function fetchOrgs() {
-    if (!auth.token) return
-    loading.value = true
+    if (!auth.token) return;
+    loading.value = true;
     try {
-      orgs.value = await orgApi.list(auth.token)
+      orgs.value = await orgApi.list(auth.token);
       // Auto-select saved org or first
       if (!currentOrg.value && orgs.value.length > 0) {
-        const target = orgs.value.find((o) => o.id === _savedOrgId) ?? orgs.value[0]
-        await selectOrg(target.id)
+        const target = orgs.value.find((o) => o.id === _savedOrgId) ?? orgs.value[0];
+        await selectOrg(target.id);
       }
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function selectOrg(orgId: string) {
-    if (!auth.token) return
-    currentOrg.value = await orgApi.get(auth.token, orgId)
-    members.value = currentOrg.value.members
-    localStorage.setItem(CURRENT_ORG_KEY, orgId)
+    if (!auth.token) return;
+    currentOrg.value = await orgApi.get(auth.token, orgId);
+    members.value = currentOrg.value.members;
+    localStorage.setItem(CURRENT_ORG_KEY, orgId);
   }
 
   async function createOrg(name: string, description?: string, parent_org_id?: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    const org = await orgApi.create(auth.token, name, description, parent_org_id)
-    orgs.value.push(org)
-    await selectOrg(org.id)
-    return org
+    if (!auth.token) throw new Error('Not authenticated');
+    const org = await orgApi.create(auth.token, name, description, parent_org_id);
+    orgs.value.push(org);
+    await selectOrg(org.id);
+    return org;
   }
 
   async function fetchSubOrgs(parentOrgId: string) {
-    if (!auth.token) return
-    const children = await orgApi.listSubOrgs(auth.token, parentOrgId)
-    subOrgs.value[parentOrgId] = children
+    if (!auth.token) return;
+    const children = await orgApi.listSubOrgs(auth.token, parentOrgId);
+    subOrgs.value[parentOrgId] = children;
     // Merge into flat orgs list so hierarchy computed props work
     for (const child of children) {
       if (!orgs.value.find((o) => o.id === child.id)) {
-        orgs.value.push(child)
+        orgs.value.push(child);
       }
     }
   }
 
   async function createSubOrg(parentOrgId: string, name: string, description?: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    const org = await orgApi.create(auth.token, name, description, parentOrgId)
-    orgs.value.push(org)
-    subOrgs.value[parentOrgId] = [...(subOrgs.value[parentOrgId] ?? []), org]
+    if (!auth.token) throw new Error('Not authenticated');
+    const org = await orgApi.create(auth.token, name, description, parentOrgId);
+    orgs.value.push(org);
+    subOrgs.value[parentOrgId] = [...(subOrgs.value[parentOrgId] ?? []), org];
     // Increment child_count on parent in list
-    const parent = orgs.value.find((o) => o.id === parentOrgId)
-    if (parent) parent.child_count = (parent.child_count ?? 0) + 1
-    return org
+    const parent = orgs.value.find((o) => o.id === parentOrgId);
+    if (parent) parent.child_count = (parent.child_count ?? 0) + 1;
+    return org;
   }
 
   async function deleteSubOrg(subOrgId: string, parentOrgId: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await orgApi.delete(auth.token, subOrgId)
-    orgs.value = orgs.value.filter((o) => o.id !== subOrgId)
+    if (!auth.token) throw new Error('Not authenticated');
+    await orgApi.delete(auth.token, subOrgId);
+    orgs.value = orgs.value.filter((o) => o.id !== subOrgId);
     subOrgs.value[parentOrgId] = (subOrgs.value[parentOrgId] ?? []).filter(
-      (o) => o.id !== subOrgId,
-    )
-    const parent = orgs.value.find((o) => o.id === parentOrgId)
-    if (parent && parent.child_count > 0) parent.child_count -= 1
+      (o) => o.id !== subOrgId
+    );
+    const parent = orgs.value.find((o) => o.id === parentOrgId);
+    if (parent && parent.child_count > 0) parent.child_count -= 1;
     if (currentOrg.value?.id === subOrgId) {
-      currentOrg.value = null
-      members.value = []
-      localStorage.removeItem(CURRENT_ORG_KEY)
+      currentOrg.value = null;
+      members.value = [];
+      localStorage.removeItem(CURRENT_ORG_KEY);
     }
   }
 
   async function fetchSubOrgMembers(parentOrgId: string, subOrgId: string) {
-    if (!auth.token) return
-    const list = await subOrgMemberApi.list(auth.token, parentOrgId, subOrgId)
-    subOrgMembers.value[subOrgId] = list
+    if (!auth.token) return;
+    const list = await subOrgMemberApi.list(auth.token, parentOrgId, subOrgId);
+    subOrgMembers.value[subOrgId] = list;
   }
 
   async function addSubOrgMember(
     parentOrgId: string,
     subOrgId: string,
     userId: string,
-    role: Role,
+    role: Role
   ) {
-    if (!auth.token) throw new Error('Not authenticated')
-    const m = await subOrgMemberApi.add(auth.token, parentOrgId, subOrgId, { user_id: userId, role })
-    subOrgMembers.value[subOrgId] = [...(subOrgMembers.value[subOrgId] ?? []), m]
-    return m
+    if (!auth.token) throw new Error('Not authenticated');
+    const m = await subOrgMemberApi.add(auth.token, parentOrgId, subOrgId, {
+      user_id: userId,
+      role,
+    });
+    subOrgMembers.value[subOrgId] = [...(subOrgMembers.value[subOrgId] ?? []), m];
+    return m;
   }
 
   async function removeSubOrgMember(parentOrgId: string, subOrgId: string, userId: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await subOrgMemberApi.remove(auth.token, parentOrgId, subOrgId, userId)
+    if (!auth.token) throw new Error('Not authenticated');
+    await subOrgMemberApi.remove(auth.token, parentOrgId, subOrgId, userId);
     subOrgMembers.value[subOrgId] = (subOrgMembers.value[subOrgId] ?? []).filter(
-      (m) => m.user_id !== userId,
-    )
+      (m) => m.user_id !== userId
+    );
   }
 
   async function updateOrg(orgId: string, patch: { name?: string; description?: string }) {
-    if (!auth.token) throw new Error('Not authenticated')
-    const updated = await orgApi.update(auth.token, orgId, patch)
-    const idx = orgs.value.findIndex((o) => o.id === orgId)
-    if (idx !== -1) orgs.value[idx] = updated
+    if (!auth.token) throw new Error('Not authenticated');
+    const updated = await orgApi.update(auth.token, orgId, patch);
+    const idx = orgs.value.findIndex((o) => o.id === orgId);
+    if (idx !== -1) orgs.value[idx] = updated;
     if (currentOrg.value?.id === orgId) {
-      currentOrg.value = { ...currentOrg.value, ...updated }
+      currentOrg.value = { ...currentOrg.value, ...updated };
     }
-    return updated
+    return updated;
   }
 
   async function deleteOrg(orgId: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await orgApi.delete(auth.token, orgId)
-    orgs.value = orgs.value.filter((o) => o.id !== orgId)
+    if (!auth.token) throw new Error('Not authenticated');
+    await orgApi.delete(auth.token, orgId);
+    orgs.value = orgs.value.filter((o) => o.id !== orgId);
     if (currentOrg.value?.id === orgId) {
-      currentOrg.value = null
-      members.value = []
-      localStorage.removeItem(CURRENT_ORG_KEY)
-      if (orgs.value.length > 0) await selectOrg(orgs.value[0].id)
+      currentOrg.value = null;
+      members.value = [];
+      localStorage.removeItem(CURRENT_ORG_KEY);
+      if (orgs.value.length > 0) await selectOrg(orgs.value[0].id);
     }
   }
 
   async function inviteMember(orgId: string, email: string, role: Role) {
-    if (!auth.token) throw new Error('Not authenticated')
-    const member = await memberApi.invite(auth.token, orgId, email, role)
-    members.value.push(member)
-    return member
+    if (!auth.token) throw new Error('Not authenticated');
+    const member = await memberApi.invite(auth.token, orgId, email, role);
+    members.value.push(member);
+    return member;
   }
 
   async function updateMemberRole(orgId: string, userId: string, role: Role) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await memberApi.updateRole(auth.token, orgId, userId, role)
-    const m = members.value.find((m) => m.user_id === userId)
-    if (m) m.role = role
+    if (!auth.token) throw new Error('Not authenticated');
+    await memberApi.updateRole(auth.token, orgId, userId, role);
+    const m = members.value.find((m) => m.user_id === userId);
+    if (m) m.role = role;
   }
 
   async function removeMember(orgId: string, userId: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await memberApi.remove(auth.token, orgId, userId)
-    members.value = members.value.filter((m) => m.user_id !== userId)
+    if (!auth.token) throw new Error('Not authenticated');
+    await memberApi.remove(auth.token, orgId, userId);
+    members.value = members.value.filter((m) => m.user_id !== userId);
   }
 
   /** Get the current user's role in the current org */
   function myRole(userId: string): Role | null {
-    return members.value.find((m) => m.user_id === userId)?.role ?? null
+    return members.value.find((m) => m.user_id === userId)?.role ?? null;
   }
 
   function canEdit(userId: string): boolean {
-    const r = myRole(userId)
-    return r === 'owner' || r === 'admin' || r === 'editor'
+    const r = myRole(userId);
+    return r === 'owner' || r === 'admin' || r === 'editor';
   }
 
   function canAdmin(userId: string): boolean {
-    const r = myRole(userId)
-    return r === 'owner' || r === 'admin'
+    const r = myRole(userId);
+    return r === 'owner' || r === 'admin';
   }
 
   return {
@@ -203,5 +206,5 @@ export const useOrgStore = defineStore('org', () => {
     myRole,
     canEdit,
     canAdmin,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/persistentNotifications.ts b/ordo-editor/apps/studio/src/stores/persistentNotifications.ts
index a0af96b7..f092efca 100644
--- a/ordo-editor/apps/studio/src/stores/persistentNotifications.ts
+++ b/ordo-editor/apps/studio/src/stores/persistentNotifications.ts
@@ -1,70 +1,70 @@
-import { defineStore } from 'pinia'
-import { ref } from 'vue'
-import { notificationApi } from '@/api/platform-client'
-import { useAuthStore } from './auth'
-import type { PlatformNotification } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { notificationApi } from '@/api/platform-client';
+import { useAuthStore } from './auth';
+import type { PlatformNotification } from '@/api/types';
 
 export const usePersistentNotificationStore = defineStore('persistentNotifications', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const notifications = ref<PlatformNotification[]>([])
-  const unreadCount = ref(0)
-  let pollTimer: ReturnType<typeof setInterval> | null = null
+  const notifications = ref<PlatformNotification[]>([]);
+  const unreadCount = ref(0);
+  let pollTimer: ReturnType<typeof setInterval> | null = null;
 
   async function fetchCount(orgId: string) {
-    if (!auth.token || !orgId) return
+    if (!auth.token || !orgId) return;
     try {
-      const result = await notificationApi.count(auth.token, orgId)
-      unreadCount.value = result.unread
+      const result = await notificationApi.count(auth.token, orgId);
+      unreadCount.value = result.unread;
     } catch {
       // ignore poll errors
     }
   }
 
   async function fetchNotifications(orgId: string, unreadOnly = false) {
-    if (!auth.token || !orgId) return
+    if (!auth.token || !orgId) return;
     try {
       notifications.value = await notificationApi.list(auth.token, orgId, {
         unread_only: unreadOnly,
         limit: 50,
-      })
+      });
       unreadCount.value = unreadOnly
         ? notifications.value.length
-        : notifications.value.filter((n) => !n.read_at).length
+        : notifications.value.filter((n) => !n.read_at).length;
     } catch {
       // ignore
     }
   }
 
   async function markRead(orgId: string, notifId: string) {
-    if (!auth.token) return
-    await notificationApi.markRead(auth.token, orgId, notifId)
-    const n = notifications.value.find((n) => n.id === notifId)
+    if (!auth.token) return;
+    await notificationApi.markRead(auth.token, orgId, notifId);
+    const n = notifications.value.find((n) => n.id === notifId);
     if (n) {
-      n.read_at = new Date().toISOString()
-      unreadCount.value = Math.max(0, unreadCount.value - 1)
+      n.read_at = new Date().toISOString();
+      unreadCount.value = Math.max(0, unreadCount.value - 1);
     }
   }
 
   async function markAllRead(orgId: string) {
-    if (!auth.token) return
-    await notificationApi.markAllRead(auth.token, orgId)
+    if (!auth.token) return;
+    await notificationApi.markAllRead(auth.token, orgId);
     notifications.value.forEach((n) => {
-      if (!n.read_at) n.read_at = new Date().toISOString()
-    })
-    unreadCount.value = 0
+      if (!n.read_at) n.read_at = new Date().toISOString();
+    });
+    unreadCount.value = 0;
   }
 
   function startPolling(orgId: string) {
-    if (pollTimer) return
-    fetchCount(orgId)
-    pollTimer = setInterval(() => fetchCount(orgId), 60_000)
+    if (pollTimer) return;
+    fetchCount(orgId);
+    pollTimer = setInterval(() => fetchCount(orgId), 60_000);
   }
 
   function stopPolling() {
     if (pollTimer) {
-      clearInterval(pollTimer)
-      pollTimer = null
+      clearInterval(pollTimer);
+      pollTimer = null;
     }
   }
 
@@ -77,5 +77,5 @@ export const usePersistentNotificationStore = defineStore('persistentNotificatio
     markAllRead,
     startPolling,
     stopPolling,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/preferences.ts b/ordo-editor/apps/studio/src/stores/preferences.ts
index 55684d62..5244add5 100644
--- a/ordo-editor/apps/studio/src/stores/preferences.ts
+++ b/ordo-editor/apps/studio/src/stores/preferences.ts
@@ -1,16 +1,16 @@
-import { defineStore } from 'pinia'
-import { ref, watch } from 'vue'
+import { defineStore } from 'pinia';
+import { ref, watch } from 'vue';
 
-type Theme = 'light' | 'dark' | 'system'
+type Theme = 'light' | 'dark' | 'system';
 
 export const usePreferencesStore = defineStore('preferences', () => {
-  const theme = ref<Theme>((localStorage.getItem('ordo_theme') as Theme) ?? 'light')
-  const sidebarCollapsed = ref(false)
+  const theme = ref<Theme>((localStorage.getItem('ordo_theme') as Theme) ?? 'light');
+  const sidebarCollapsed = ref(false);
 
   function setTheme(t: Theme) {
-    theme.value = t
-    localStorage.setItem('ordo_theme', t)
-    applyTheme(t)
+    theme.value = t;
+    localStorage.setItem('ordo_theme', t);
+    applyTheme(t);
   }
 
   function applyTheme(t: Theme) {
@@ -19,22 +19,22 @@ export const usePreferencesStore = defineStore('preferences', () => {
         ? window.matchMedia('(prefers-color-scheme: dark)').matches
           ? 'dark'
           : 'light'
-        : t
+        : t;
     // Our custom ordo CSS tokens (ordo-theme.css, tdesign-override.css)
-    document.documentElement.setAttribute('data-theme', effectiveTheme)
+    document.documentElement.setAttribute('data-theme', effectiveTheme);
     // TDesign Vue Next 1.x activates dark mode via `theme-mode` attribute on <html>
-    document.documentElement.setAttribute('theme-mode', effectiveTheme)
+    document.documentElement.setAttribute('theme-mode', effectiveTheme);
   }
 
   // Re-apply when OS dark/light preference changes (only relevant for 'system' mode)
   window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
-    if (theme.value === 'system') applyTheme('system')
-  })
+    if (theme.value === 'system') applyTheme('system');
+  });
 
   // Apply on init
-  applyTheme(theme.value)
+  applyTheme(theme.value);
 
-  watch(theme, applyTheme)
+  watch(theme, applyTheme);
 
-  return { theme, sidebarCollapsed, setTheme }
-})
+  return { theme, sidebarCollapsed, setTheme };
+});
diff --git a/ordo-editor/apps/studio/src/stores/project.ts b/ordo-editor/apps/studio/src/stores/project.ts
index 72b31bec..39cd3753 100644
--- a/ordo-editor/apps/studio/src/stores/project.ts
+++ b/ordo-editor/apps/studio/src/stores/project.ts
@@ -1,42 +1,44 @@
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import { projectApi, rulesetDraftApi } from '@/api/platform-client'
-import { normalizeRuleset } from '@/utils/ruleset'
-import { useAuthStore } from './auth'
-import { useOrgStore } from './org'
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { projectApi, rulesetDraftApi } from '@/api/platform-client';
+import { normalizeRuleset } from '@/utils/ruleset';
+import { useAuthStore } from './auth';
+import { useOrgStore } from './org';
 import type {
   DraftConflictResponse,
   Project,
   ProjectRuleset,
   ProjectRulesetMeta,
   RuleSetInfo,
-} from '@/api/types'
-import type { RuleSet } from '@ordo-engine/editor-core'
+} from '@/api/types';
+import type { RuleSet } from '@ordo-engine/editor-core';
 
-const CURRENT_PROJECT_KEY = 'ordo_studio_current_project'
+const CURRENT_PROJECT_KEY = 'ordo_studio_current_project';
 
 export interface OpenTab {
-  name: string
-  ruleset: RuleSet
-  dirty: boolean
+  name: string;
+  ruleset: RuleSet;
+  dirty: boolean;
   /** Platform draft sequence number for optimistic locking */
-  draft_seq: number
+  draft_seq: number;
 }
 
 export const useProjectStore = defineStore('project', () => {
-  const auth = useAuthStore()
-  const orgStore = useOrgStore()
+  const auth = useAuthStore();
+  const orgStore = useOrgStore();
 
-  const projects = ref<Project[]>([])
-  const currentProject = ref<Project | null>(null)
-  const rulesets = ref<RuleSetInfo[]>([])
-  const draftMetas = ref<ProjectRulesetMeta[]>([])
-  const openTabs = ref<OpenTab[]>([])
-  const activeTabName = ref<string | null>(null)
-  const loading = ref(false)
+  const projects = ref<Project[]>([]);
+  const currentProject = ref<Project | null>(null);
+  const rulesets = ref<RuleSetInfo[]>([]);
+  const draftMetas = ref<ProjectRulesetMeta[]>([]);
+  const openTabs = ref<OpenTab[]>([]);
+  const activeTabName = ref<string | null>(null);
+  const loading = ref(false);
 
-  const currentProjectId = computed(() => currentProject.value?.id ?? null)
-  const activeTab = computed(() => openTabs.value.find((t) => t.name === activeTabName.value) ?? null)
+  const currentProjectId = computed(() => currentProject.value?.id ?? null);
+  const activeTab = computed(
+    () => openTabs.value.find((t) => t.name === activeTabName.value) ?? null
+  );
 
   function rebuildRulesets() {
     rulesets.value = draftMetas.value
@@ -46,17 +48,17 @@ export const useProjectStore = defineStore('project', () => {
         published_version: draft.published_version,
         description: '',
       }))
-      .sort((left, right) => left.name.localeCompare(right.name))
+      .sort((left, right) => left.name.localeCompare(right.name));
   }
 
   function upsertDraftMeta(meta: ProjectRulesetMeta) {
-    const index = draftMetas.value.findIndex((item) => item.name === meta.name)
+    const index = draftMetas.value.findIndex((item) => item.name === meta.name);
     if (index === -1) {
-      draftMetas.value.push(meta)
+      draftMetas.value.push(meta);
     } else {
-      draftMetas.value[index] = meta
+      draftMetas.value[index] = meta;
     }
-    rebuildRulesets()
+    rebuildRulesets();
   }
 
   function pickDraftMeta(ruleset: ProjectRuleset): ProjectRulesetMeta {
@@ -71,79 +73,79 @@ export const useProjectStore = defineStore('project', () => {
       published_version: ruleset.published_version,
       published_at: ruleset.published_at,
       created_at: ruleset.created_at,
-    }
+    };
   }
 
   async function fetchProjects(orgId: string) {
-    if (!auth.token) return
-    loading.value = true
+    if (!auth.token) return;
+    loading.value = true;
     try {
-      projects.value = await projectApi.list(auth.token, orgId)
-      const savedId = localStorage.getItem(CURRENT_PROJECT_KEY)
+      projects.value = await projectApi.list(auth.token, orgId);
+      const savedId = localStorage.getItem(CURRENT_PROJECT_KEY);
       if (!currentProject.value && projects.value.length > 0) {
-        const target = projects.value.find((p) => p.id === savedId) ?? projects.value[0]
-        await selectProject(target)
+        const target = projects.value.find((p) => p.id === savedId) ?? projects.value[0];
+        await selectProject(target);
       }
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function selectProject(project: Project) {
-    currentProject.value = project
-    localStorage.setItem(CURRENT_PROJECT_KEY, project.id)
-    await fetchRulesets()
+    currentProject.value = project;
+    localStorage.setItem(CURRENT_PROJECT_KEY, project.id);
+    await fetchRulesets();
   }
 
   async function fetchRulesets() {
-    if (!auth.token || !currentProject.value) return
-    const org = orgStore.currentOrg
+    if (!auth.token || !currentProject.value) return;
+    const org = orgStore.currentOrg;
     if (org) {
       try {
-        draftMetas.value = await rulesetDraftApi.list(auth.token, org.id, currentProject.value.id)
+        draftMetas.value = await rulesetDraftApi.list(auth.token, org.id, currentProject.value.id);
       } catch {
-        draftMetas.value = []
+        draftMetas.value = [];
       }
     } else {
-      draftMetas.value = []
+      draftMetas.value = [];
     }
 
-    rebuildRulesets()
+    rebuildRulesets();
   }
 
   async function openRuleset(name: string) {
-    if (!auth.token || !currentProject.value) return
+    if (!auth.token || !currentProject.value) return;
     // Already open?
-    const existing = openTabs.value.find((t) => t.name === name)
+    const existing = openTabs.value.find((t) => t.name === name);
     if (existing) {
-      activeTabName.value = name
-      return
+      activeTabName.value = name;
+      return;
     }
 
-    const org = orgStore.currentOrg
-    if (!org) throw new Error('No active org')
-    const draft = await rulesetDraftApi.get(auth.token, org.id, currentProject.value.id, name)
-    const ruleset = normalizeRuleset(draft.draft, name)
-    const draft_seq = draft.draft_seq
-    upsertDraftMeta(pickDraftMeta(draft))
+    const org = orgStore.currentOrg;
+    if (!org) throw new Error('No active org');
+    const draft = await rulesetDraftApi.get(auth.token, org.id, currentProject.value.id, name);
+    const ruleset = normalizeRuleset(draft.draft, name);
+    const draft_seq = draft.draft_seq;
+    upsertDraftMeta(pickDraftMeta(draft));
 
-    openTabs.value.push({ name, ruleset, dirty: false, draft_seq })
-    activeTabName.value = name
+    openTabs.value.push({ name, ruleset, dirty: false, draft_seq });
+    activeTabName.value = name;
   }
 
   function updateActiveRuleset(ruleset: RuleSet) {
-    const tab = openTabs.value.find((t) => t.name === activeTabName.value)
+    const tab = openTabs.value.find((t) => t.name === activeTabName.value);
     if (tab) {
-      tab.ruleset = ruleset
-      tab.dirty = true
+      tab.ruleset = ruleset;
+      tab.dirty = true;
     }
   }
 
   function setTabRuleset(name: string, ruleset: RuleSet, dirty = true) {
-    const tab = openTabs.value.find((t) => t.name === name)
-    if (!tab) return
-    tab.ruleset = ruleset
-    tab.dirty = dirty
+    const tab = openTabs.value.find((t) => t.name === name);
+    if (!tab) return;
+    tab.ruleset = ruleset;
+    tab.dirty = dirty;
   }
 
   /**
@@ -151,80 +153,80 @@ export const useProjectStore = defineStore('project', () => {
    * Returns null on success or a DraftConflictResponse if there's a seq conflict.
    */
   async function saveRuleset(name: string): Promise<DraftConflictResponse | null> {
-    if (!auth.token || !currentProject.value) throw new Error('No active project')
-    const tab = openTabs.value.find((t) => t.name === name)
-    if (!tab) throw new Error('Ruleset not open')
+    if (!auth.token || !currentProject.value) throw new Error('No active project');
+    const tab = openTabs.value.find((t) => t.name === name);
+    if (!tab) throw new Error('Ruleset not open');
 
-    const org = orgStore.currentOrg
-    if (!org) throw new Error('No active org')
+    const org = orgStore.currentOrg;
+    if (!org) throw new Error('No active org');
 
     const result = await rulesetDraftApi.save(auth.token, org.id, currentProject.value.id, name, {
       ruleset: tab.ruleset as any,
       expected_seq: tab.draft_seq,
-    })
+    });
 
     if ('conflict' in result) {
-      return result
+      return result;
     }
 
-    tab.dirty = false
-    tab.draft_seq = result.draft_seq
-    upsertDraftMeta(pickDraftMeta(result))
-    return null
+    tab.dirty = false;
+    tab.draft_seq = result.draft_seq;
+    upsertDraftMeta(pickDraftMeta(result));
+    return null;
   }
 
   async function createRuleset(ruleset: RuleSet) {
-    if (!auth.token || !currentProject.value) throw new Error('No active project')
-    const org = orgStore.currentOrg
-    const name = ruleset.config.name?.trim()
-    if (!org) throw new Error('No active org')
-    if (!name) throw new Error('Ruleset name is required')
+    if (!auth.token || !currentProject.value) throw new Error('No active project');
+    const org = orgStore.currentOrg;
+    const name = ruleset.config.name?.trim();
+    if (!org) throw new Error('No active org');
+    if (!name) throw new Error('Ruleset name is required');
 
     const result = await rulesetDraftApi.save(auth.token, org.id, currentProject.value.id, name, {
       ruleset: ruleset as any,
       expected_seq: 0,
-    })
+    });
     if ('conflict' in result) {
-      throw new Error('Ruleset already exists')
+      throw new Error('Ruleset already exists');
     }
-    await fetchRulesets()
+    await fetchRulesets();
   }
 
   async function deleteRuleset(name: string) {
-    if (!auth.token || !currentProject.value) throw new Error('No active project')
-    const org = orgStore.currentOrg
-    if (!org) throw new Error('No active org')
-    await rulesetDraftApi.delete(auth.token, org.id, currentProject.value.id, name)
-    closeTab(name)
-    await fetchRulesets()
+    if (!auth.token || !currentProject.value) throw new Error('No active project');
+    const org = orgStore.currentOrg;
+    if (!org) throw new Error('No active org');
+    await rulesetDraftApi.delete(auth.token, org.id, currentProject.value.id, name);
+    closeTab(name);
+    await fetchRulesets();
   }
 
   function closeTab(name: string) {
-    const idx = openTabs.value.findIndex((t) => t.name === name)
-    if (idx === -1) return
-    openTabs.value.splice(idx, 1)
+    const idx = openTabs.value.findIndex((t) => t.name === name);
+    if (idx === -1) return;
+    openTabs.value.splice(idx, 1);
     if (activeTabName.value === name) {
-      activeTabName.value = openTabs.value[Math.max(0, idx - 1)]?.name ?? null
+      activeTabName.value = openTabs.value[Math.max(0, idx - 1)]?.name ?? null;
     }
   }
 
   async function createProject(orgId: string, name: string, description?: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    const p = await projectApi.create(auth.token, orgId, name, description)
-    projects.value.push(p)
-    return p
+    if (!auth.token) throw new Error('Not authenticated');
+    const p = await projectApi.create(auth.token, orgId, name, description);
+    projects.value.push(p);
+    return p;
   }
 
   async function deleteProject(orgId: string, projectId: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await projectApi.delete(auth.token, orgId, projectId)
-    projects.value = projects.value.filter((p) => p.id !== projectId)
+    if (!auth.token) throw new Error('Not authenticated');
+    await projectApi.delete(auth.token, orgId, projectId);
+    projects.value = projects.value.filter((p) => p.id !== projectId);
     if (currentProject.value?.id === projectId) {
-      currentProject.value = null
-      rulesets.value = []
-      draftMetas.value = []
-      openTabs.value = []
-      activeTabName.value = null
+      currentProject.value = null;
+      rulesets.value = [];
+      draftMetas.value = [];
+      openTabs.value = [];
+      activeTabName.value = null;
     }
   }
 
@@ -250,5 +252,5 @@ export const useProjectStore = defineStore('project', () => {
     closeTab,
     createProject,
     deleteProject,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/rbac.ts b/ordo-editor/apps/studio/src/stores/rbac.ts
index 8c73eb2a..70a8b247 100644
--- a/ordo-editor/apps/studio/src/stores/rbac.ts
+++ b/ordo-editor/apps/studio/src/stores/rbac.ts
@@ -1,93 +1,93 @@
-import { defineStore } from 'pinia'
-import { computed, ref } from 'vue'
-import { memberRoleApi, roleApi } from '@/api/platform-client'
+import { defineStore } from 'pinia';
+import { computed, ref } from 'vue';
+import { memberRoleApi, roleApi } from '@/api/platform-client';
 import type {
   AssignRoleRequest,
   CreateRoleRequest,
   OrgRole,
   UpdateRoleRequest,
   UserRoleAssignment,
-} from '@/api/types'
-import { useAuthStore } from './auth'
+} from '@/api/types';
+import { useAuthStore } from './auth';
 
 export const useRbacStore = defineStore('rbac', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const roles = ref<OrgRole[]>([])
-  const myAssignments = ref<UserRoleAssignment[]>([])
-  const loading = ref(false)
-  const error = ref<string | null>(null)
+  const roles = ref<OrgRole[]>([]);
+  const myAssignments = ref<UserRoleAssignment[]>([]);
+  const loading = ref(false);
+  const error = ref<string | null>(null);
 
   const myPermissions = computed<Set<string>>(() => {
-    const perms = new Set<string>()
+    const perms = new Set<string>();
     for (const assignment of myAssignments.value) {
-      const role = roles.value.find((r) => r.id === assignment.role_id)
+      const role = roles.value.find((r) => r.id === assignment.role_id);
       if (role) {
-        for (const p of role.permissions) perms.add(p)
+        for (const p of role.permissions) perms.add(p);
       }
     }
-    return perms
-  })
+    return perms;
+  });
 
   function can(permission: string): boolean {
-    return myPermissions.value.has(permission)
+    return myPermissions.value.has(permission);
   }
 
   async function fetchRoles(orgId: string) {
-    loading.value = true
-    error.value = null
+    loading.value = true;
+    error.value = null;
     try {
-      roles.value = await roleApi.list(auth.token!, orgId)
+      roles.value = await roleApi.list(auth.token!, orgId);
     } catch (e: any) {
-      error.value = e.message
+      error.value = e.message;
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function fetchMyRoles(orgId: string) {
-    if (!auth.user) return
+    if (!auth.user) return;
     try {
-      myAssignments.value = await memberRoleApi.list(auth.token!, orgId, auth.user.id)
+      myAssignments.value = await memberRoleApi.list(auth.token!, orgId, auth.user.id);
     } catch {
-      myAssignments.value = []
+      myAssignments.value = [];
     }
   }
 
   async function createRole(orgId: string, req: CreateRoleRequest): Promise<OrgRole> {
-    const role = await roleApi.create(auth.token!, orgId, req)
-    roles.value.push(role)
-    return role
+    const role = await roleApi.create(auth.token!, orgId, req);
+    roles.value.push(role);
+    return role;
   }
 
   async function updateRole(
     orgId: string,
     roleId: string,
-    req: UpdateRoleRequest,
+    req: UpdateRoleRequest
   ): Promise<OrgRole> {
-    const updated = await roleApi.update(auth.token!, orgId, roleId, req)
-    const idx = roles.value.findIndex((r) => r.id === roleId)
-    if (idx !== -1) roles.value[idx] = updated
-    return updated
+    const updated = await roleApi.update(auth.token!, orgId, roleId, req);
+    const idx = roles.value.findIndex((r) => r.id === roleId);
+    if (idx !== -1) roles.value[idx] = updated;
+    return updated;
   }
 
   async function deleteRole(orgId: string, roleId: string) {
-    await roleApi.delete(auth.token!, orgId, roleId)
-    roles.value = roles.value.filter((r) => r.id !== roleId)
+    await roleApi.delete(auth.token!, orgId, roleId);
+    roles.value = roles.value.filter((r) => r.id !== roleId);
   }
 
   async function assignRole(orgId: string, userId: string, req: AssignRoleRequest) {
-    await memberRoleApi.assign(auth.token!, orgId, userId, req)
+    await memberRoleApi.assign(auth.token!, orgId, userId, req);
   }
 
   async function revokeRole(orgId: string, userId: string, roleId: string) {
-    await memberRoleApi.revoke(auth.token!, orgId, userId, roleId)
+    await memberRoleApi.revoke(auth.token!, orgId, userId, roleId);
   }
 
   function reset() {
-    roles.value = []
-    myAssignments.value = []
-    error.value = null
+    roles.value = [];
+    myAssignments.value = [];
+    error.value = null;
   }
 
   return {
@@ -105,5 +105,5 @@ export const useRbacStore = defineStore('rbac', () => {
     assignRole,
     revokeRole,
     reset,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/server.ts b/ordo-editor/apps/studio/src/stores/server.ts
index 3a3353a7..05e54d78 100644
--- a/ordo-editor/apps/studio/src/stores/server.ts
+++ b/ordo-editor/apps/studio/src/stores/server.ts
@@ -1,34 +1,34 @@
-import { defineStore } from 'pinia'
-import { ref } from 'vue'
-import { serverApi } from '@/api/platform-client'
-import { useAuthStore } from './auth'
-import type { ServerInfo } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { serverApi } from '@/api/platform-client';
+import { useAuthStore } from './auth';
+import type { ServerInfo } from '@/api/types';
 
 export const useServerStore = defineStore('server', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const servers = ref<ServerInfo[]>([])
-  const loading = ref(false)
+  const servers = ref<ServerInfo[]>([]);
+  const loading = ref(false);
 
   async function fetchServers() {
-    if (!auth.token) return
-    loading.value = true
+    if (!auth.token) return;
+    loading.value = true;
     try {
-      servers.value = await serverApi.list(auth.token)
+      servers.value = await serverApi.list(auth.token);
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function deleteServer(id: string) {
-    if (!auth.token) throw new Error('Not authenticated')
-    await serverApi.delete(auth.token, id)
-    servers.value = servers.value.filter((s) => s.id !== id)
+    if (!auth.token) throw new Error('Not authenticated');
+    await serverApi.delete(auth.token, id);
+    servers.value = servers.value.filter((s) => s.id !== id);
   }
 
   function getById(id: string): ServerInfo | undefined {
-    return servers.value.find((s) => s.id === id)
+    return servers.value.find((s) => s.id === id);
   }
 
-  return { servers, loading, fetchServers, deleteServer, getById }
-})
+  return { servers, loading, fetchServers, deleteServer, getById };
+});
diff --git a/ordo-editor/apps/studio/src/stores/system.ts b/ordo-editor/apps/studio/src/stores/system.ts
index f33f3389..7291f6a9 100644
--- a/ordo-editor/apps/studio/src/stores/system.ts
+++ b/ordo-editor/apps/studio/src/stores/system.ts
@@ -1,26 +1,26 @@
-import { defineStore } from 'pinia'
-import { ref, computed } from 'vue'
-import { systemApi } from '@/api/platform-client'
-import type { SystemConfig } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+import { systemApi } from '@/api/platform-client';
+import type { SystemConfig } from '@/api/types';
 
 export const useSystemStore = defineStore('system', () => {
-  const config = ref<SystemConfig | null>(null)
-  const loading = ref(false)
+  const config = ref<SystemConfig | null>(null);
+  const loading = ref(false);
 
-  const allowOrgCreation = computed(() => config.value?.allow_org_creation ?? false)
-  const allowRegistration = computed(() => config.value?.allow_registration ?? false)
+  const allowOrgCreation = computed(() => config.value?.allow_org_creation ?? false);
+  const allowRegistration = computed(() => config.value?.allow_registration ?? false);
 
   async function fetchConfig() {
-    if (config.value) return
-    loading.value = true
+    if (config.value) return;
+    loading.value = true;
     try {
-      config.value = await systemApi.getConfig()
+      config.value = await systemApi.getConfig();
     } catch {
       // Non-critical: fall back to restrictive defaults
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
-  return { config, loading, allowOrgCreation, allowRegistration, fetchConfig }
-})
+  return { config, loading, allowOrgCreation, allowRegistration, fetchConfig };
+});
diff --git a/ordo-editor/apps/studio/src/stores/template.ts b/ordo-editor/apps/studio/src/stores/template.ts
index 7e75f895..6a83cc68 100644
--- a/ordo-editor/apps/studio/src/stores/template.ts
+++ b/ordo-editor/apps/studio/src/stores/template.ts
@@ -1,68 +1,68 @@
-import { defineStore } from 'pinia'
-import { ref } from 'vue'
-import { templateApi } from '@/api/platform-client'
-import { useAuthStore } from './auth'
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { templateApi } from '@/api/platform-client';
+import { useAuthStore } from './auth';
 import type {
   CreateFromTemplatePayload,
   Project,
   TemplateDetail,
   TemplateMetadata,
-} from '@/api/types'
+} from '@/api/types';
 
 export const useTemplateStore = defineStore('template', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
-  const templates = ref<TemplateMetadata[]>([])
-  const currentDetail = ref<TemplateDetail | null>(null)
-  const loading = ref(false)
-  const detailLoading = ref(false)
-  const creating = ref(false)
-  const error = ref<string | null>(null)
+  const templates = ref<TemplateMetadata[]>([]);
+  const currentDetail = ref<TemplateDetail | null>(null);
+  const loading = ref(false);
+  const detailLoading = ref(false);
+  const creating = ref(false);
+  const error = ref<string | null>(null);
 
   async function fetchTemplates() {
-    if (!auth.token) return
-    loading.value = true
-    error.value = null
+    if (!auth.token) return;
+    loading.value = true;
+    error.value = null;
     try {
-      templates.value = await templateApi.list(auth.token)
+      templates.value = await templateApi.list(auth.token);
     } catch (e: any) {
-      error.value = e?.message ?? String(e)
-      templates.value = []
+      error.value = e?.message ?? String(e);
+      templates.value = [];
     } finally {
-      loading.value = false
+      loading.value = false;
     }
   }
 
   async function fetchDetail(id: string) {
-    if (!auth.token) return
-    detailLoading.value = true
-    error.value = null
+    if (!auth.token) return;
+    detailLoading.value = true;
+    error.value = null;
     try {
-      currentDetail.value = await templateApi.get(auth.token, id)
+      currentDetail.value = await templateApi.get(auth.token, id);
     } catch (e: any) {
-      error.value = e?.message ?? String(e)
-      currentDetail.value = null
+      error.value = e?.message ?? String(e);
+      currentDetail.value = null;
     } finally {
-      detailLoading.value = false
+      detailLoading.value = false;
     }
   }
 
   async function createFromTemplate(
     orgId: string,
-    payload: CreateFromTemplatePayload,
+    payload: CreateFromTemplatePayload
   ): Promise<Project> {
-    if (!auth.token) throw new Error('Not authenticated')
-    creating.value = true
-    error.value = null
+    if (!auth.token) throw new Error('Not authenticated');
+    creating.value = true;
+    error.value = null;
     try {
-      return await templateApi.createProject(auth.token, orgId, payload)
+      return await templateApi.createProject(auth.token, orgId, payload);
     } finally {
-      creating.value = false
+      creating.value = false;
     }
   }
 
   function clearDetail() {
-    currentDetail.value = null
+    currentDetail.value = null;
   }
 
   return {
@@ -76,5 +76,5 @@ export const useTemplateStore = defineStore('template', () => {
     fetchDetail,
     createFromTemplate,
     clearDetail,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/stores/test.ts b/ordo-editor/apps/studio/src/stores/test.ts
index 740b7c88..eaeabf1e 100644
--- a/ordo-editor/apps/studio/src/stores/test.ts
+++ b/ordo-editor/apps/studio/src/stores/test.ts
@@ -1,145 +1,141 @@
-import { defineStore } from 'pinia'
-import { ref } from 'vue'
-import { convertToEngineFormat } from '@ordo-engine/editor-core'
-import { rulesetDraftApi, testApi } from '@/api/platform-client'
-import { isEngineRuleset, normalizeRuleset } from '@/utils/ruleset'
-import { useAuthStore } from './auth'
-import type { ProjectTestRunResult, TestCase, TestCaseInput, TestRunResult } from '@/api/types'
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { convertToEngineFormat } from '@ordo-engine/editor-core';
+import { rulesetDraftApi, testApi } from '@/api/platform-client';
+import { isEngineRuleset, normalizeRuleset } from '@/utils/ruleset';
+import { useAuthStore } from './auth';
+import type { ProjectTestRunResult, TestCase, TestCaseInput, TestRunResult } from '@/api/types';
 
 export const useTestStore = defineStore('test', () => {
-  const auth = useAuthStore()
+  const auth = useAuthStore();
 
   // Ruleset-level state (keyed by rulesetName)
-  const testsByRuleset = ref<Map<string, TestCase[]>>(new Map())
-  const runResults = ref<Map<string, TestRunResult[]>>(new Map())
-  const loadingRuleset = ref<Map<string, boolean>>(new Map())
-  const running = ref(false)
+  const testsByRuleset = ref<Map<string, TestCase[]>>(new Map());
+  const runResults = ref<Map<string, TestRunResult[]>>(new Map());
+  const loadingRuleset = ref<Map<string, boolean>>(new Map());
+  const running = ref(false);
 
   // Project-level state
-  const projectRunResult = ref<ProjectTestRunResult | null>(null)
-  const projectRunning = ref(false)
+  const projectRunResult = ref<ProjectTestRunResult | null>(null);
+  const projectRunning = ref(false);
 
   async function buildEngineRuleset(
     orgId: string,
     projectId: string,
-    rulesetName: string,
+    rulesetName: string
   ): Promise<Record<string, unknown>> {
-    if (!auth.token) throw new Error('Not authenticated')
-    const draft = await rulesetDraftApi.get(auth.token, orgId, projectId, rulesetName)
+    if (!auth.token) throw new Error('Not authenticated');
+    const draft = await rulesetDraftApi.get(auth.token, orgId, projectId, rulesetName);
     if (isEngineRuleset(draft.draft)) {
-      return draft.draft as unknown as Record<string, unknown>
+      return draft.draft as unknown as Record<string, unknown>;
     }
-    const normalized = normalizeRuleset(draft.draft, rulesetName)
-    return convertToEngineFormat(normalized) as unknown as Record<string, unknown>
+    const normalized = normalizeRuleset(draft.draft, rulesetName);
+    return convertToEngineFormat(normalized) as unknown as Record<string, unknown>;
   }
 
   // ── Ruleset-level operations ──────────────────────────────────────────────
 
   async function fetchTests(projectId: string, rulesetName: string): Promise<void> {
-    if (!auth.token) return
-    loadingRuleset.value.set(rulesetName, true)
+    if (!auth.token) return;
+    loadingRuleset.value.set(rulesetName, true);
     try {
-      const tests = await testApi.list(auth.token, projectId, rulesetName)
-      testsByRuleset.value.set(rulesetName, tests)
+      const tests = await testApi.list(auth.token, projectId, rulesetName);
+      testsByRuleset.value.set(rulesetName, tests);
     } finally {
-      loadingRuleset.value.set(rulesetName, false)
+      loadingRuleset.value.set(rulesetName, false);
     }
   }
 
   async function createTest(
     projectId: string,
     rulesetName: string,
-    input: TestCaseInput,
+    input: TestCaseInput
   ): Promise<TestCase | undefined> {
-    if (!auth.token) return
-    const tc = await testApi.create(auth.token, projectId, rulesetName, input)
-    const list = testsByRuleset.value.get(rulesetName) ?? []
-    testsByRuleset.value.set(rulesetName, [...list, tc])
-    return tc
+    if (!auth.token) return;
+    const tc = await testApi.create(auth.token, projectId, rulesetName, input);
+    const list = testsByRuleset.value.get(rulesetName) ?? [];
+    testsByRuleset.value.set(rulesetName, [...list, tc]);
+    return tc;
   }
 
   async function updateTest(
     projectId: string,
     rulesetName: string,
     id: string,
-    input: TestCaseInput,
+    input: TestCaseInput
   ): Promise<TestCase | undefined> {
-    if (!auth.token) return
-    const tc = await testApi.update(auth.token, projectId, rulesetName, id, input)
-    const list = testsByRuleset.value.get(rulesetName) ?? []
+    if (!auth.token) return;
+    const tc = await testApi.update(auth.token, projectId, rulesetName, id, input);
+    const list = testsByRuleset.value.get(rulesetName) ?? [];
     testsByRuleset.value.set(
       rulesetName,
-      list.map((t) => (t.id === id ? tc : t)),
-    )
-    return tc
+      list.map((t) => (t.id === id ? tc : t))
+    );
+    return tc;
   }
 
-  async function deleteTest(
-    projectId: string,
-    rulesetName: string,
-    id: string,
-  ): Promise<void> {
-    if (!auth.token) return
-    await testApi.delete(auth.token, projectId, rulesetName, id)
-    const list = testsByRuleset.value.get(rulesetName) ?? []
+  async function deleteTest(projectId: string, rulesetName: string, id: string): Promise<void> {
+    if (!auth.token) return;
+    await testApi.delete(auth.token, projectId, rulesetName, id);
+    const list = testsByRuleset.value.get(rulesetName) ?? [];
     testsByRuleset.value.set(
       rulesetName,
-      list.filter((t) => t.id !== id),
-    )
+      list.filter((t) => t.id !== id)
+    );
     // Clear stale run result for this test
-    const results = runResults.value.get(rulesetName) ?? []
+    const results = runResults.value.get(rulesetName) ?? [];
     runResults.value.set(
       rulesetName,
-      results.filter((r) => r.test_id !== id),
-    )
+      results.filter((r) => r.test_id !== id)
+    );
   }
 
   async function runTests(orgId: string, projectId: string, rulesetName: string): Promise<void> {
-    if (!auth.token) return
-    running.value = true
+    if (!auth.token) return;
+    running.value = true;
     try {
-      const ruleset = await buildEngineRuleset(orgId, projectId, rulesetName)
+      const ruleset = await buildEngineRuleset(orgId, projectId, rulesetName);
       const results = await testApi.runAll(auth.token, projectId, rulesetName, {
         ruleset,
         include_trace: true,
-      })
-      runResults.value.set(rulesetName, results)
+      });
+      runResults.value.set(rulesetName, results);
     } finally {
-      running.value = false
+      running.value = false;
     }
   }
 
-  const runningOne = ref<Set<string>>(new Set())
+  const runningOne = ref<Set<string>>(new Set());
 
   async function runOneTest(
     orgId: string,
     projectId: string,
     rulesetName: string,
-    testId: string,
+    testId: string
   ): Promise<TestRunResult | undefined> {
-    if (!auth.token) return
-    runningOne.value = new Set([...runningOne.value, testId])
+    if (!auth.token) return;
+    runningOne.value = new Set([...runningOne.value, testId]);
     try {
-      const ruleset = await buildEngineRuleset(orgId, projectId, rulesetName)
+      const ruleset = await buildEngineRuleset(orgId, projectId, rulesetName);
       const result = await testApi.runOne(auth.token, projectId, rulesetName, testId, {
         ruleset,
         include_trace: true,
-      })
+      });
       // Merge into existing results list
-      const list = runResults.value.get(rulesetName) ?? []
-      const idx = list.findIndex((r) => r.test_id === testId)
+      const list = runResults.value.get(rulesetName) ?? [];
+      const idx = list.findIndex((r) => r.test_id === testId);
       if (idx >= 0) {
-        const updated = [...list]
-        updated[idx] = result
-        runResults.value.set(rulesetName, updated)
+        const updated = [...list];
+        updated[idx] = result;
+        runResults.value.set(rulesetName, updated);
       } else {
-        runResults.value.set(rulesetName, [...list, result])
+        runResults.value.set(rulesetName, [...list, result]);
       }
-      return result
+      return result;
     } finally {
-      const next = new Set(runningOne.value)
-      next.delete(testId)
-      runningOne.value = next
+      const next = new Set(runningOne.value);
+      next.delete(testId);
+      runningOne.value = next;
     }
   }
 
@@ -148,28 +144,28 @@ export const useTestStore = defineStore('test', () => {
   async function runProjectTests(
     orgId: string,
     projectId: string,
-    rulesetNames: string[],
+    rulesetNames: string[]
   ): Promise<void> {
-    if (!auth.token) return
-    projectRunning.value = true
+    if (!auth.token) return;
+    projectRunning.value = true;
     try {
       const rulesetEntries = await Promise.all(
         rulesetNames.map(async (rulesetName) => {
-          const ruleset = await buildEngineRuleset(orgId, projectId, rulesetName)
-          return [rulesetName, ruleset] as const
-        }),
-      )
+          const ruleset = await buildEngineRuleset(orgId, projectId, rulesetName);
+          return [rulesetName, ruleset] as const;
+        })
+      );
 
       projectRunResult.value = await testApi.runProject(auth.token, projectId, {
         rulesets: Object.fromEntries(rulesetEntries),
         include_trace: true,
-      })
+      });
       // Sync ruleset-level results from project run
       for (const rs of projectRunResult.value.rulesets) {
-        runResults.value.set(rs.ruleset_name, rs.results)
+        runResults.value.set(rs.ruleset_name, rs.results);
       }
     } finally {
-      projectRunning.value = false
+      projectRunning.value = false;
     }
   }
 
@@ -188,5 +184,5 @@ export const useTestStore = defineStore('test', () => {
     runTests,
     runOneTest,
     runProjectTests,
-  }
-})
+  };
+});
diff --git a/ordo-editor/apps/studio/src/utils/ruleset-version.ts b/ordo-editor/apps/studio/src/utils/ruleset-version.ts
index 35c83e95..276d97a5 100644
--- a/ordo-editor/apps/studio/src/utils/ruleset-version.ts
+++ b/ordo-editor/apps/studio/src/utils/ruleset-version.ts
@@ -1,27 +1,27 @@
-import type { RulesetHistoryEntry } from '@/api/types'
+import type { RulesetHistoryEntry } from '@/api/types';
 
-const CHECKPOINT_SOURCES = new Set(['create', 'save', 'restore', 'publish'])
+const CHECKPOINT_SOURCES = new Set(['create', 'save', 'restore', 'publish']);
 
 export interface CheckpointVersionEntry {
-  entry: RulesetHistoryEntry
-  version: string
-  subversion: number
-  display_version: string
+  entry: RulesetHistoryEntry;
+  version: string;
+  subversion: number;
+  display_version: string;
 }
 
 export function stripVersionSuffix(version?: string | null) {
-  return (version ?? '').replace(/\(\d+\)\s*$/, '').trim()
+  return (version ?? '').replace(/\(\d+\)\s*$/, '').trim();
 }
 
 export function extractRulesetVersion(snapshot?: Record<string, any> | null) {
-  const version = stripVersionSuffix(snapshot?.config?.version)
-  return version || 'draft'
+  const version = stripVersionSuffix(snapshot?.config?.version);
+  return version || 'draft';
 }
 
 export function formatRulesetVersion(version?: string | null, subversion?: number | null) {
-  const baseVersion = stripVersionSuffix(version) || 'draft'
-  if (!subversion || subversion < 1) return baseVersion
-  return `${baseVersion}(${subversion})`
+  const baseVersion = stripVersionSuffix(version) || 'draft';
+  if (!subversion || subversion < 1) return baseVersion;
+  return `${baseVersion}(${subversion})`;
 }
 
 export function buildCheckpointVersionEntries(entries: RulesetHistoryEntry[]) {
@@ -31,29 +31,31 @@ export function buildCheckpointVersionEntries(entries: RulesetHistoryEntry[]) {
       entry,
       version: extractRulesetVersion(entry.snapshot as Record<string, any>),
     }))
-    .reverse()
+    .reverse();
 
-  const counters = new Map<string, number>()
+  const counters = new Map<string, number>();
 
   const withSubversion = checkpoints.map(({ entry, version }) => {
-    const nextSubversion = (counters.get(version) ?? 0) + 1
-    counters.set(version, nextSubversion)
+    const nextSubversion = (counters.get(version) ?? 0) + 1;
+    counters.set(version, nextSubversion);
     return {
       entry,
       version,
       subversion: nextSubversion,
       display_version: formatRulesetVersion(version, nextSubversion),
-    } satisfies CheckpointVersionEntry
-  })
+    } satisfies CheckpointVersionEntry;
+  });
 
-  return withSubversion.reverse()
+  return withSubversion.reverse();
 }
 
 export function getCurrentVersionDisplay(entries: RulesetHistoryEntry[], version?: string | null) {
-  const baseVersion = stripVersionSuffix(version)
-  if (!baseVersion) return 'draft'
-
-  const matches = buildCheckpointVersionEntries(entries).filter((item) => item.version === baseVersion)
-  if (matches.length === 0) return baseVersion
-  return matches[0].display_version
+  const baseVersion = stripVersionSuffix(version);
+  if (!baseVersion) return 'draft';
+
+  const matches = buildCheckpointVersionEntries(entries).filter(
+    (item) => item.version === baseVersion
+  );
+  if (matches.length === 0) return baseVersion;
+  return matches[0].display_version;
 }
diff --git a/ordo-editor/apps/studio/src/utils/ruleset.ts b/ordo-editor/apps/studio/src/utils/ruleset.ts
index 5d9dcf83..989685a5 100644
--- a/ordo-editor/apps/studio/src/utils/ruleset.ts
+++ b/ordo-editor/apps/studio/src/utils/ruleset.ts
@@ -1,26 +1,26 @@
-import { convertFromEngineFormat, type RuleSet } from '@ordo-engine/editor-core'
+import { convertFromEngineFormat, type RuleSet } from '@ordo-engine/editor-core';
 
-type UnknownRecord = Record<string, unknown>
+type UnknownRecord = Record<string, unknown>;
 
 function isRecord(value: unknown): value is UnknownRecord {
-  return typeof value === 'object' && value !== null
+  return typeof value === 'object' && value !== null;
 }
 
 function isEditorRuleset(value: unknown): value is RuleSet {
   if (!isRecord(value) || !isRecord(value.config)) {
-    return false
+    return false;
   }
-  return Array.isArray(value.steps)
+  return Array.isArray(value.steps);
 }
 
 export function isEngineRuleset(value: unknown): value is {
-  config: Record<string, unknown> & { entry_step?: unknown }
-  steps: Record<string, unknown>
+  config: Record<string, unknown> & { entry_step?: unknown };
+  steps: Record<string, unknown>;
 } {
   if (!isRecord(value) || !isRecord(value.config) || !isRecord(value.steps)) {
-    return false
+    return false;
   }
-  return 'entry_step' in value.config && !Array.isArray(value.steps)
+  return 'entry_step' in value.config && !Array.isArray(value.steps);
 }
 
 export function normalizeRuleset(input: unknown, fallbackName = 'untitled'): RuleSet {
@@ -30,15 +30,15 @@ export function normalizeRuleset(input: unknown, fallbackName = 'untitled'): Rul
       steps: input.steps,
       groups: Array.isArray(input.groups) ? input.groups : [],
       metadata: isRecord(input.metadata) ? input.metadata : undefined,
-    }
+    };
   }
 
   if (isEngineRuleset(input)) {
-    const normalized = convertFromEngineFormat(input as any)
+    const normalized = convertFromEngineFormat(input as any);
     return {
       ...normalized,
       groups: Array.isArray(normalized.groups) ? normalized.groups : [],
-    }
+    };
   }
 
   return {
@@ -51,5 +51,5 @@ export function normalizeRuleset(input: unknown, fallbackName = 'untitled'): Rul
     startStepId: '',
     steps: [],
     groups: [],
-  }
+  };
 }
diff --git a/ordo-editor/apps/studio/src/views/auth/LoginView.vue b/ordo-editor/apps/studio/src/views/auth/LoginView.vue
index 0af16973..e40ecdbe 100644
--- a/ordo-editor/apps/studio/src/views/auth/LoginView.vue
+++ b/ordo-editor/apps/studio/src/views/auth/LoginView.vue
@@ -1,37 +1,37 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue'
-import { useRouter, useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useSystemStore } from '@/stores/system'
-import { MessagePlugin } from 'tdesign-vue-next'
-import platformLogo from '@/assets/platform-logo.png'
-
-const router = useRouter()
-const route = useRoute()
-const auth = useAuthStore()
-const systemStore = useSystemStore()
-const { t } = useI18n()
-
-const email = ref('')
-const password = ref('')
-const loading = ref(false)
+import { onMounted, ref } from 'vue';
+import { useRouter, useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useSystemStore } from '@/stores/system';
+import { MessagePlugin } from 'tdesign-vue-next';
+import platformLogo from '@/assets/platform-logo.png';
+
+const router = useRouter();
+const route = useRoute();
+const auth = useAuthStore();
+const systemStore = useSystemStore();
+const { t } = useI18n();
+
+const email = ref('');
+const password = ref('');
+const loading = ref(false);
 
 onMounted(() => {
-  systemStore.fetchConfig()
-})
+  systemStore.fetchConfig();
+});
 
 async function handleLogin() {
-  if (!email.value || !password.value) return
-  loading.value = true
+  if (!email.value || !password.value) return;
+  loading.value = true;
   try {
-    await auth.login(email.value, password.value)
-    const redirect = (route.query.redirect as string) || '/'
-    router.push(redirect)
+    await auth.login(email.value, password.value);
+    const redirect = (route.query.redirect as string) || '/';
+    router.push(redirect);
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('auth.loginFailed'))
+    MessagePlugin.error(e.message || t('auth.loginFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
 }
 </script>
@@ -53,22 +53,40 @@ async function handleLogin() {
       <ul class="brand-features">
         <li>
           <svg class="feat-check" viewBox="0 0 16 16" fill="none">
-            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15"/>
-            <path d="M4.5 8l2.5 2.5 4.5-4.5" stroke="#16a34a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15" />
+            <path
+              d="M4.5 8l2.5 2.5 4.5-4.5"
+              stroke="#16a34a"
+              stroke-width="1.5"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
           </svg>
           {{ t('auth.feature1') }}
         </li>
         <li>
           <svg class="feat-check" viewBox="0 0 16 16" fill="none">
-            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15"/>
-            <path d="M4.5 8l2.5 2.5 4.5-4.5" stroke="#16a34a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15" />
+            <path
+              d="M4.5 8l2.5 2.5 4.5-4.5"
+              stroke="#16a34a"
+              stroke-width="1.5"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
           </svg>
           {{ t('auth.feature2') }}
         </li>
         <li>
           <svg class="feat-check" viewBox="0 0 16 16" fill="none">
-            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15"/>
-            <path d="M4.5 8l2.5 2.5 4.5-4.5" stroke="#16a34a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15" />
+            <path
+              d="M4.5 8l2.5 2.5 4.5-4.5"
+              stroke="#16a34a"
+              stroke-width="1.5"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
           </svg>
           {{ t('auth.feature3') }}
         </li>
@@ -97,7 +115,9 @@ async function handleLogin() {
         <div class="field">
           <div class="field-label-row">
             <label class="field-label">{{ t('auth.passwordLabel') }}</label>
-            <router-link to="/forgot-password" class="forgot-link">{{ t('auth.forgotPassword') }}</router-link>
+            <router-link to="/forgot-password" class="forgot-link">{{
+              t('auth.forgotPassword')
+            }}</router-link>
           </div>
           <t-input
             v-model="password"
@@ -129,17 +149,31 @@ async function handleLogin() {
         <button class="alt-btn" @click="MessagePlugin.info(t('auth.ssoNotConfigured'))">
           <!-- GitHub mark -->
           <svg viewBox="0 0 24 24" width="18" height="18" fill="#1a1714">
-            <path d="M12 2C6.477 2 2 6.477 2 12c0 4.418 2.865 8.166 6.839 9.489.5.092.682-.217.682-.482 0-.237-.008-.866-.013-1.7-2.782.603-3.369-1.34-3.369-1.34-.454-1.155-1.11-1.462-1.11-1.462-.908-.62.069-.608.069-.608 1.003.07 1.531 1.03 1.531 1.03.892 1.529 2.341 1.087 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.11-4.555-4.943 0-1.091.39-1.984 1.029-2.683-.103-.253-.446-1.27.098-2.647 0 0 .84-.269 2.75 1.025A9.578 9.578 0 0 1 12 6.836c.85.004 1.705.114 2.504.336 1.909-1.294 2.747-1.025 2.747-1.025.546 1.377.202 2.394.1 2.647.64.699 1.028 1.592 1.028 2.683 0 3.842-2.339 4.687-4.566 4.935.359.309.678.919.678 1.852 0 1.336-.012 2.415-.012 2.743 0 .267.18.578.688.48C19.138 20.163 22 16.418 22 12c0-5.523-4.477-10-10-10z"/>
+            <path
+              d="M12 2C6.477 2 2 6.477 2 12c0 4.418 2.865 8.166 6.839 9.489.5.092.682-.217.682-.482 0-.237-.008-.866-.013-1.7-2.782.603-3.369-1.34-3.369-1.34-.454-1.155-1.11-1.462-1.11-1.462-.908-.62.069-.608.069-.608 1.003.07 1.531 1.03 1.531 1.03.892 1.529 2.341 1.087 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.11-4.555-4.943 0-1.091.39-1.984 1.029-2.683-.103-.253-.446-1.27.098-2.647 0 0 .84-.269 2.75 1.025A9.578 9.578 0 0 1 12 6.836c.85.004 1.705.114 2.504.336 1.909-1.294 2.747-1.025 2.747-1.025.546 1.377.202 2.394.1 2.647.64.699 1.028 1.592 1.028 2.683 0 3.842-2.339 4.687-4.566 4.935.359.309.678.919.678 1.852 0 1.336-.012 2.415-.012 2.743 0 .267.18.578.688.48C19.138 20.163 22 16.418 22 12c0-5.523-4.477-10-10-10z"
+            />
           </svg>
           GitHub
         </button>
         <button class="alt-btn" @click="MessagePlugin.info(t('auth.ssoNotConfigured'))">
           <!-- Google G logo (official colors) -->
           <svg viewBox="0 0 24 24" width="18" height="18" xmlns="http://www.w3.org/2000/svg">
-            <path d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z" fill="#4285F4"/>
-            <path d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z" fill="#34A853"/>
-            <path d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l3.66-2.84z" fill="#FBBC05"/>
-            <path d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z" fill="#EA4335"/>
+            <path
+              d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"
+              fill="#4285F4"
+            />
+            <path
+              d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
+              fill="#34A853"
+            />
+            <path
+              d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l3.66-2.84z"
+              fill="#FBBC05"
+            />
+            <path
+              d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
+              fill="#EA4335"
+            />
           </svg>
           Google
         </button>
@@ -243,7 +277,9 @@ async function handleLogin() {
   flex-shrink: 0;
   background: #ffffff;
   border-radius: 16px;
-  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.04), 0 10px 40px rgba(0, 0, 0, 0.08);
+  box-shadow:
+    0 4px 6px rgba(0, 0, 0, 0.04),
+    0 10px 40px rgba(0, 0, 0, 0.08);
   padding: 40px;
   display: flex;
   flex-direction: column;
@@ -348,7 +384,10 @@ async function handleLogin() {
   font-size: 13px;
   font-weight: 500;
   cursor: pointer;
-  transition: border-color 0.15s, box-shadow 0.15s, background 0.15s;
+  transition:
+    border-color 0.15s,
+    box-shadow 0.15s,
+    background 0.15s;
 }
 
 .alt-btn:hover {
diff --git a/ordo-editor/apps/studio/src/views/auth/RegisterView.vue b/ordo-editor/apps/studio/src/views/auth/RegisterView.vue
index fac68213..3052582b 100644
--- a/ordo-editor/apps/studio/src/views/auth/RegisterView.vue
+++ b/ordo-editor/apps/studio/src/views/auth/RegisterView.vue
@@ -1,48 +1,48 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue'
-import { useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useSystemStore } from '@/stores/system'
-import { MessagePlugin } from 'tdesign-vue-next'
-import platformLogo from '@/assets/platform-logo.png'
-
-const router = useRouter()
-const auth = useAuthStore()
-const systemStore = useSystemStore()
-const { t } = useI18n()
-
-const displayName = ref('')
-const email = ref('')
-const password = ref('')
-const password2 = ref('')
-const loading = ref(false)
+import { onMounted, ref } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useSystemStore } from '@/stores/system';
+import { MessagePlugin } from 'tdesign-vue-next';
+import platformLogo from '@/assets/platform-logo.png';
+
+const router = useRouter();
+const auth = useAuthStore();
+const systemStore = useSystemStore();
+const { t } = useI18n();
+
+const displayName = ref('');
+const email = ref('');
+const password = ref('');
+const password2 = ref('');
+const loading = ref(false);
 
 onMounted(() => {
-  systemStore.fetchConfig()
-})
+  systemStore.fetchConfig();
+});
 
 async function handleRegister() {
   if (!email.value || !password.value || !displayName.value) {
-    MessagePlugin.warning(t('auth.fillRequired'))
-    return
+    MessagePlugin.warning(t('auth.fillRequired'));
+    return;
   }
   if (password.value !== password2.value) {
-    MessagePlugin.warning(t('auth.passwordMismatch'))
-    return
+    MessagePlugin.warning(t('auth.passwordMismatch'));
+    return;
   }
   if (password.value.length < 8) {
-    MessagePlugin.warning(t('auth.passwordTooShort'))
-    return
+    MessagePlugin.warning(t('auth.passwordTooShort'));
+    return;
   }
-  loading.value = true
+  loading.value = true;
   try {
-    await auth.register(email.value, password.value, displayName.value)
-    router.push('/')
+    await auth.register(email.value, password.value, displayName.value);
+    router.push('/');
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('auth.registerFailed'))
+    MessagePlugin.error(e.message || t('auth.registerFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
 }
 </script>
@@ -64,22 +64,40 @@ async function handleRegister() {
       <ul class="brand-features">
         <li>
           <svg class="feat-check" viewBox="0 0 16 16" fill="none">
-            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15"/>
-            <path d="M4.5 8l2.5 2.5 4.5-4.5" stroke="#16a34a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15" />
+            <path
+              d="M4.5 8l2.5 2.5 4.5-4.5"
+              stroke="#16a34a"
+              stroke-width="1.5"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
           </svg>
           {{ t('auth.feature1') }}
         </li>
         <li>
           <svg class="feat-check" viewBox="0 0 16 16" fill="none">
-            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15"/>
-            <path d="M4.5 8l2.5 2.5 4.5-4.5" stroke="#16a34a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15" />
+            <path
+              d="M4.5 8l2.5 2.5 4.5-4.5"
+              stroke="#16a34a"
+              stroke-width="1.5"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
           </svg>
           {{ t('auth.feature2') }}
         </li>
         <li>
           <svg class="feat-check" viewBox="0 0 16 16" fill="none">
-            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15"/>
-            <path d="M4.5 8l2.5 2.5 4.5-4.5" stroke="#16a34a" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+            <circle cx="8" cy="8" r="8" fill="#22c55e" fill-opacity="0.15" />
+            <path
+              d="M4.5 8l2.5 2.5 4.5-4.5"
+              stroke="#16a34a"
+              stroke-width="1.5"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            />
           </svg>
           {{ t('auth.feature3') }}
         </li>
@@ -88,10 +106,13 @@ async function handleRegister() {
 
     <!-- Right: floating form card -->
     <div class="form-card">
-
       <!-- Loading skeleton -->
       <div v-if="systemStore.loading" class="loading-state">
-        <t-skeleton theme="paragraph" animation="gradient" :row-col="[{ width: '40%' }, { width: '100%' }, { width: '100%' }, { width: '100%' }]" />
+        <t-skeleton
+          theme="paragraph"
+          animation="gradient"
+          :row-col="[{ width: '40%' }, { width: '100%' }, { width: '100%' }, { width: '100%' }]"
+        />
       </div>
 
       <!-- Registration disabled -->
@@ -99,15 +120,16 @@ async function handleRegister() {
         <div class="disabled-header">
           <div class="disabled-icon">
             <svg viewBox="0 0 24 24" fill="none" width="24" height="24">
-              <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z" fill="currentColor"/>
+              <path
+                d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z"
+                fill="currentColor"
+              />
             </svg>
           </div>
           <h2 class="form-title">{{ t('auth.registrationDisabled') }}</h2>
         </div>
         <p class="disabled-desc">{{ t('auth.registrationDisabledDesc') }}</p>
-        <router-link to="/login" class="back-btn">
-          ← {{ t('auth.backToLogin') }}
-        </router-link>
+        <router-link to="/login" class="back-btn"> ← {{ t('auth.backToLogin') }} </router-link>
       </template>
 
       <!-- Registration form -->
@@ -173,7 +195,6 @@ async function handleRegister() {
           <router-link to="/login" class="form-link">{{ t('auth.loginLink') }}</router-link>
         </div>
       </template>
-
     </div>
   </div>
 </template>
@@ -268,7 +289,9 @@ async function handleRegister() {
   flex-shrink: 0;
   background: #ffffff;
   border-radius: 16px;
-  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.04), 0 10px 40px rgba(0, 0, 0, 0.08);
+  box-shadow:
+    0 4px 6px rgba(0, 0, 0, 0.04),
+    0 10px 40px rgba(0, 0, 0, 0.08);
   padding: 40px;
   display: flex;
   flex-direction: column;
diff --git a/ordo-editor/apps/studio/src/views/dashboard/DashboardView.vue b/ordo-editor/apps/studio/src/views/dashboard/DashboardView.vue
index 863cc61c..c203ae8d 100644
--- a/ordo-editor/apps/studio/src/views/dashboard/DashboardView.vue
+++ b/ordo-editor/apps/studio/src/views/dashboard/DashboardView.vue
@@ -1,32 +1,36 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useDashboardStore } from '@/stores/dashboard'
-import { useOrgStore } from '@/stores/org'
-import { useProjectStore } from '@/stores/project'
-import { useTemplateStore } from '@/stores/template'
-import { serverApi } from '@/api/platform-client'
-import type { Project, ServerInfo } from '@/api/types'
-import CreateFromTemplateDialog from '@/components/project/CreateFromTemplateDialog.vue'
-
-const router = useRouter()
-const { t, locale } = useI18n()
-const auth = useAuthStore()
-const dash = useDashboardStore()
-const orgStore = useOrgStore()
-const projectStore = useProjectStore()
-const templateStore = useTemplateStore()
-
-const showTemplateDialog = ref(false)
-const serverLoading = ref(false)
-const servers = ref<ServerInfo[]>([])
-
-const currentOrgId = computed(() => orgStore.currentOrg?.id ?? '')
-const recentProjects = computed(() => dash.recentProjects)
-const onlineServers = computed(() => servers.value.filter((server) => server.status === 'online').length)
-const offlineServers = computed(() => servers.value.filter((server) => server.status !== 'online').length)
+import { computed, onMounted, ref } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useDashboardStore } from '@/stores/dashboard';
+import { useOrgStore } from '@/stores/org';
+import { useProjectStore } from '@/stores/project';
+import { useTemplateStore } from '@/stores/template';
+import { serverApi } from '@/api/platform-client';
+import type { Project, ServerInfo } from '@/api/types';
+import CreateFromTemplateDialog from '@/components/project/CreateFromTemplateDialog.vue';
+
+const router = useRouter();
+const { t, locale } = useI18n();
+const auth = useAuthStore();
+const dash = useDashboardStore();
+const orgStore = useOrgStore();
+const projectStore = useProjectStore();
+const templateStore = useTemplateStore();
+
+const showTemplateDialog = ref(false);
+const serverLoading = ref(false);
+const servers = ref<ServerInfo[]>([]);
+
+const currentOrgId = computed(() => orgStore.currentOrg?.id ?? '');
+const recentProjects = computed(() => dash.recentProjects);
+const onlineServers = computed(
+  () => servers.value.filter((server) => server.status === 'online').length
+);
+const offlineServers = computed(
+  () => servers.value.filter((server) => server.status !== 'online').length
+);
 
 const workspaceStats = computed(() => [
   {
@@ -44,87 +48,87 @@ const workspaceStats = computed(() => [
     value: dash.totalOrgs,
     hint: t('dashboard.orgHint'),
   },
-])
+]);
 
 const isAdmin = computed(() => {
-  if (!auth.user) return false
-  return orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return orgStore.canAdmin(auth.user.id);
+});
 
 onMounted(async () => {
-  await dash.fetchDashboardData()
-  await Promise.all([loadTemplates(), loadServers()])
-})
+  await dash.fetchDashboardData();
+  await Promise.all([loadTemplates(), loadServers()]);
+});
 
 async function loadTemplates() {
-  await templateStore.fetchTemplates()
+  await templateStore.fetchTemplates();
 }
 
 async function loadServers() {
-  if (!auth.token) return
-  serverLoading.value = true
+  if (!auth.token) return;
+  serverLoading.value = true;
   try {
-    servers.value = await serverApi.list(auth.token)
+    servers.value = await serverApi.list(auth.token);
   } catch {
-    servers.value = []
+    servers.value = [];
   } finally {
-    serverLoading.value = false
+    serverLoading.value = false;
   }
 }
 
 async function openProject(projectId: string) {
-  const orgId = orgStore.currentOrg?.id
-  if (!orgId) return
+  const orgId = orgStore.currentOrg?.id;
+  if (!orgId) return;
   const project =
     projectStore.projects.find((item) => item.id === projectId) ??
-    recentProjects.value.find((item) => item.id === projectId)
+    recentProjects.value.find((item) => item.id === projectId);
   if (project) {
-    await projectStore.selectProject(project)
+    await projectStore.selectProject(project);
   }
-  router.push(`/orgs/${orgId}/projects/${projectId}/editor`)
+  router.push(`/orgs/${orgId}/projects/${projectId}/editor`);
 }
 
 function goToProjects(query?: Record<string, string>) {
-  const orgId = orgStore.currentOrg?.id
+  const orgId = orgStore.currentOrg?.id;
   if (orgId) {
-    router.push({ path: `/orgs/${orgId}/projects`, query })
-    return
+    router.push({ path: `/orgs/${orgId}/projects`, query });
+    return;
   }
-  router.push('/orgs')
+  router.push('/orgs');
 }
 
 function goToMarketplace() {
-  router.push('/marketplace')
+  router.push('/marketplace');
 }
 
 function goToCreateOrg() {
-  router.push('/orgs')
+  router.push('/orgs');
 }
 
 function goToMembers() {
-  const orgId = orgStore.currentOrg?.id
+  const orgId = orgStore.currentOrg?.id;
   if (orgId) {
-    router.push(`/orgs/${orgId}/members`)
-    return
+    router.push(`/orgs/${orgId}/members`);
+    return;
   }
-  router.push('/orgs')
+  router.push('/orgs');
 }
 
 function openServerRegistry() {
-  router.push('/servers')
+  router.push('/servers');
 }
 
 async function handleTemplateCreated(project: Project) {
-  projectStore.projects.unshift(project)
-  await projectStore.selectProject(project)
-  router.push(`/orgs/${project.org_id}/projects/${project.id}/editor`)
+  projectStore.projects.unshift(project);
+  await projectStore.selectProject(project);
+  router.push(`/orgs/${project.org_id}/projects/${project.id}/editor`);
 }
 
 function formatDate(iso: string) {
   return new Date(iso).toLocaleDateString(
     locale.value === 'zh-TW' ? 'zh-TW' : locale.value === 'zh-CN' ? 'zh-CN' : 'en-US',
-    { year: 'numeric', month: 'short', day: 'numeric' },
-  )
+    { year: 'numeric', month: 'short', day: 'numeric' }
+  );
 }
 </script>
 
@@ -246,7 +250,11 @@ function formatDate(iso: string) {
           </div>
 
           <div v-if="serverLoading" class="stack-loading">
-            <t-skeleton theme="paragraph" animation="gradient" :row-col="[{ width: '70%' }, { width: '55%' }]" />
+            <t-skeleton
+              theme="paragraph"
+              animation="gradient"
+              :row-col="[{ width: '70%' }, { width: '55%' }]"
+            />
           </div>
 
           <template v-else>
diff --git a/ordo-editor/apps/studio/src/views/editor/EditorView.vue b/ordo-editor/apps/studio/src/views/editor/EditorView.vue
index de705883..e0033098 100644
--- a/ordo-editor/apps/studio/src/views/editor/EditorView.vue
+++ b/ordo-editor/apps/studio/src/views/editor/EditorView.vue
@@ -1,26 +1,26 @@
 <script setup lang="ts">
-import { ref, computed, onMounted, onUnmounted, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { useProjectStore } from '@/stores/project'
-import { useCatalogStore } from '@/stores/catalog'
-import { useEnvironmentStore } from '@/stores/environment'
-import { useRbacStore } from '@/stores/rbac'
-import ChangeHistoryPanel from '@/components/ChangeHistoryPanel.vue'
-import TestCasePanel from './TestCasePanel.vue'
-import { rulesetHistoryApi } from '@/api/platform-client'
-import DraftConflictDialog from '@/components/project/DraftConflictDialog.vue'
-import { normalizeRuleset } from '@/utils/ruleset'
-import { getCurrentVersionDisplay, stripVersionSuffix } from '@/utils/ruleset-version'
+import { ref, computed, onMounted, onUnmounted, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { useProjectStore } from '@/stores/project';
+import { useCatalogStore } from '@/stores/catalog';
+import { useEnvironmentStore } from '@/stores/environment';
+import { useRbacStore } from '@/stores/rbac';
+import ChangeHistoryPanel from '@/components/ChangeHistoryPanel.vue';
+import TestCasePanel from './TestCasePanel.vue';
+import { rulesetHistoryApi } from '@/api/platform-client';
+import DraftConflictDialog from '@/components/project/DraftConflictDialog.vue';
+import { normalizeRuleset } from '@/utils/ruleset';
+import { getCurrentVersionDisplay, stripVersionSuffix } from '@/utils/ruleset-version';
 import type {
   AppendRulesetHistoryEntry,
   DraftConflictResponse,
   RulesetHistoryEntry,
   RulesetHistorySource,
-} from '@/api/types'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
+} from '@/api/types';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
 import {
   OrdoFormEditor,
   OrdoFlowEditor,
@@ -35,69 +35,69 @@ import {
   Step,
   type RuleSet,
   type DecisionTable,
-} from '@ordo-engine/editor-vue'
+} from '@ordo-engine/editor-vue';
 
-const route = useRoute()
-const router = useRouter()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const projectStore = useProjectStore()
-const catalogStore = useCatalogStore()
-const environmentStore = useEnvironmentStore()
-const rbacStore = useRbacStore()
-const { t } = useI18n()
+const route = useRoute();
+const router = useRouter();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const projectStore = useProjectStore();
+const catalogStore = useCatalogStore();
+const environmentStore = useEnvironmentStore();
+const rbacStore = useRbacStore();
+const { t } = useI18n();
 
-const LOCAL_HISTORY_LIMIT = 120
-const HISTORY_SYNC_DELAY_MS = 700
-const EDIT_HISTORY_COMMIT_DELAY_MS = 450
+const LOCAL_HISTORY_LIMIT = 120;
+const HISTORY_SYNC_DELAY_MS = 700;
+const EDIT_HISTORY_COMMIT_DELAY_MS = 450;
 
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
-const rulesetNameParam = computed(() => route.params.rulesetName as string | undefined)
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
+const rulesetNameParam = computed(() => route.params.rulesetName as string | undefined);
 
-const projectBase = computed(() => `/orgs/${orgId.value}/projects/${projectId.value}`)
+const projectBase = computed(() => `/orgs/${orgId.value}/projects/${projectId.value}`);
 
 // ── Editor mode — stored per-tab so switching tabs restores correct mode ─────
-const editorMode = ref<'form' | 'flow' | 'table'>('form')
-const tabModes = new Map<string, 'form' | 'flow' | 'table'>()
-const openMenu = ref<'file' | 'edit' | 'select' | 'view' | 'window' | null>(null)
-const showHistoryPanel = ref(false)
+const editorMode = ref<'form' | 'flow' | 'table'>('form');
+const tabModes = new Map<string, 'form' | 'flow' | 'table'>();
+const openMenu = ref<'file' | 'edit' | 'select' | 'view' | 'window' | null>(null);
+const showHistoryPanel = ref(false);
 
 function switchToTab(name: string) {
   if (projectStore.activeTabName) {
-    flushPendingEditHistory(projectStore.activeTabName)
+    flushPendingEditHistory(projectStore.activeTabName);
   }
-  projectStore.activeTabName = name
-  editorMode.value = tabModes.get(name) ?? 'form'
+  projectStore.activeTabName = name;
+  editorMode.value = tabModes.get(name) ?? 'form';
 }
 
 // ── Local history (per-tab, PS-style) ────────────────────────────────────────
 interface TabHistoryState {
-  entries: RulesetHistoryEntry[]
-  currentIndex: number
-  loaded: boolean
-  loading: boolean
-  syncing: boolean
+  entries: RulesetHistoryEntry[];
+  currentIndex: number;
+  loaded: boolean;
+  loading: boolean;
+  syncing: boolean;
 }
 
-const historyStates = ref<Record<string, TabHistoryState>>({})
-const historyPanelCollapsed = ref(false)
-const pendingHistoryEntries = new Map<string, AppendRulesetHistoryEntry[]>()
-const historyFlushTimers = new Map<string, ReturnType<typeof setTimeout>>()
-const savedRulesetSnapshots = new Map<string, string>()
-const pendingEditHistory = new Map<string, { ruleset: RuleSet; action: string }>()
-const editHistoryTimers = new Map<string, ReturnType<typeof setTimeout>>()
+const historyStates = ref<Record<string, TabHistoryState>>({});
+const historyPanelCollapsed = ref(false);
+const pendingHistoryEntries = new Map<string, AppendRulesetHistoryEntry[]>();
+const historyFlushTimers = new Map<string, ReturnType<typeof setTimeout>>();
+const savedRulesetSnapshots = new Map<string, string>();
+const pendingEditHistory = new Map<string, { ruleset: RuleSet; action: string }>();
+const editHistoryTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
 function cloneRuleset(ruleset: RuleSet): RuleSet {
-  return JSON.parse(JSON.stringify(ruleset))
+  return JSON.parse(JSON.stringify(ruleset));
 }
 
 function serializeRuleset(ruleset: RuleSet): string {
-  return JSON.stringify(ruleset)
+  return JSON.stringify(ruleset);
 }
 
 function isSameRuleset(a: RuleSet, b: RuleSet): boolean {
-  return serializeRuleset(a) === serializeRuleset(b)
+  return serializeRuleset(a) === serializeRuleset(b);
 }
 
 function getHistoryState(name: string): TabHistoryState {
@@ -108,31 +108,31 @@ function getHistoryState(name: string): TabHistoryState {
       loaded: false,
       loading: false,
       syncing: false,
-    }
+    };
   }
-  return historyStates.value[name]
+  return historyStates.value[name];
 }
 
 const activeHistoryState = computed(() => {
-  const tab = projectStore.activeTab
-  if (!tab) return null
-  return getHistoryState(tab.name)
-})
-
-const activeHistoryEntries = computed(() => activeHistoryState.value?.entries ?? [])
-const activeHistoryIndex = computed(() => activeHistoryState.value?.currentIndex ?? -1)
-const canUndoHistory = computed(() => (activeHistoryState.value?.currentIndex ?? 0) > 0)
+  const tab = projectStore.activeTab;
+  if (!tab) return null;
+  return getHistoryState(tab.name);
+});
+
+const activeHistoryEntries = computed(() => activeHistoryState.value?.entries ?? []);
+const activeHistoryIndex = computed(() => activeHistoryState.value?.currentIndex ?? -1);
+const canUndoHistory = computed(() => (activeHistoryState.value?.currentIndex ?? 0) > 0);
 const canRedoHistory = computed(() => {
-  const state = activeHistoryState.value
-  if (!state) return false
-  return state.currentIndex < state.entries.length - 1
-})
+  const state = activeHistoryState.value;
+  if (!state) return false;
+  return state.currentIndex < state.entries.length - 1;
+});
 
 function createHistoryEntry(
   rulesetName: string,
   ruleset: RuleSet,
   action: string,
-  source: RulesetHistorySource,
+  source: RulesetHistorySource
 ): RulesetHistoryEntry {
   return {
     id: `history_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
@@ -144,143 +144,143 @@ function createHistoryEntry(
     author_email: auth.user?.email ?? '',
     author_display_name: auth.user?.display_name ?? '',
     snapshot: cloneRuleset(ruleset),
-  }
+  };
 }
 
 function syncDecisionTableFromRuleset(name: string, ruleset: RuleSet) {
-  const metaTableStr = ruleset.config.metadata?._table
+  const metaTableStr = ruleset.config.metadata?._table;
   if (metaTableStr) {
     try {
-      decisionTables.value[name] = JSON.parse(metaTableStr)
-      return
+      decisionTables.value[name] = JSON.parse(metaTableStr);
+      return;
     } catch {
       // fall through to decompile
     }
   }
 
-  const table = decompileStepsToTable(ruleset.steps, ruleset.startStepId)
+  const table = decompileStepsToTable(ruleset.steps, ruleset.startStepId);
   if (table) {
-    decisionTables.value[name] = table
+    decisionTables.value[name] = table;
   } else {
-    delete decisionTables.value[name]
+    delete decisionTables.value[name];
   }
 }
 
 function updateRulesetState(name: string, ruleset: RuleSet) {
-  const snapshot = cloneRuleset(ruleset)
-  const savedSnapshot = savedRulesetSnapshots.get(name)
-  const dirty = savedSnapshot ? savedSnapshot !== serializeRuleset(snapshot) : true
-  projectStore.setTabRuleset(name, snapshot, dirty)
-  syncDecisionTableFromRuleset(name, snapshot)
+  const snapshot = cloneRuleset(ruleset);
+  const savedSnapshot = savedRulesetSnapshots.get(name);
+  const dirty = savedSnapshot ? savedSnapshot !== serializeRuleset(snapshot) : true;
+  projectStore.setTabRuleset(name, snapshot, dirty);
+  syncDecisionTableFromRuleset(name, snapshot);
 }
 
 function buildHistoryAction(previous: RuleSet, next: RuleSet) {
   if (next.steps.length > previous.steps.length) {
-    return t('historyPanel.actionAddStep')
+    return t('historyPanel.actionAddStep');
   }
   if (next.steps.length < previous.steps.length) {
-    return t('historyPanel.actionRemoveStep')
+    return t('historyPanel.actionRemoveStep');
   }
   if (previous.startStepId !== next.startStepId) {
-    return t('historyPanel.actionSetStart')
+    return t('historyPanel.actionSetStart');
   }
   if (
     previous.config.name !== next.config.name ||
     previous.config.version !== next.config.version ||
     previous.config.description !== next.config.description
   ) {
-    return t('historyPanel.actionUpdateSettings')
+    return t('historyPanel.actionUpdateSettings');
   }
   if (editorMode.value === 'table') {
-    return t('historyPanel.actionEditTable')
+    return t('historyPanel.actionEditTable');
   }
   if (editorMode.value === 'flow') {
-    return t('historyPanel.actionEditFlow')
+    return t('historyPanel.actionEditFlow');
   }
-  return t('historyPanel.actionEditRuleset')
+  return t('historyPanel.actionEditRuleset');
 }
 
 function queueHistoryPersistence(name: string, entry: RulesetHistoryEntry) {
-  if (!canEdit.value) return
+  if (!canEdit.value) return;
 
-  const queue = pendingHistoryEntries.get(name) ?? []
+  const queue = pendingHistoryEntries.get(name) ?? [];
   queue.push({
     id: entry.id,
     action: entry.action,
     source: entry.source,
     created_at: entry.created_at,
     snapshot: cloneRuleset(entry.snapshot),
-  })
-  pendingHistoryEntries.set(name, queue)
+  });
+  pendingHistoryEntries.set(name, queue);
 
-  const timer = historyFlushTimers.get(name)
-  if (timer) clearTimeout(timer)
+  const timer = historyFlushTimers.get(name);
+  if (timer) clearTimeout(timer);
 
-  const state = getHistoryState(name)
-  state.syncing = true
+  const state = getHistoryState(name);
+  state.syncing = true;
 
   historyFlushTimers.set(
     name,
     setTimeout(() => {
-      void flushHistoryQueue(name)
-    }, HISTORY_SYNC_DELAY_MS),
-  )
+      void flushHistoryQueue(name);
+    }, HISTORY_SYNC_DELAY_MS)
+  );
 }
 
 function flushPendingEditHistory(name: string) {
-  const timer = editHistoryTimers.get(name)
+  const timer = editHistoryTimers.get(name);
   if (timer) {
-    clearTimeout(timer)
-    editHistoryTimers.delete(name)
+    clearTimeout(timer);
+    editHistoryTimers.delete(name);
   }
 
-  const pending = pendingEditHistory.get(name)
-  if (!pending) return
+  const pending = pendingEditHistory.get(name);
+  if (!pending) return;
 
-  pendingEditHistory.delete(name)
-  pushHistoryEntry(name, pending.ruleset, pending.action, 'edit')
+  pendingEditHistory.delete(name);
+  pushHistoryEntry(name, pending.ruleset, pending.action, 'edit');
 }
 
 function scheduleEditHistoryEntry(name: string, ruleset: RuleSet, action: string) {
   pendingEditHistory.set(name, {
     ruleset: cloneRuleset(ruleset),
     action,
-  })
+  });
 
-  const timer = editHistoryTimers.get(name)
-  if (timer) clearTimeout(timer)
+  const timer = editHistoryTimers.get(name);
+  if (timer) clearTimeout(timer);
 
   editHistoryTimers.set(
     name,
     setTimeout(() => {
-      flushPendingEditHistory(name)
-    }, EDIT_HISTORY_COMMIT_DELAY_MS),
-  )
+      flushPendingEditHistory(name);
+    }, EDIT_HISTORY_COMMIT_DELAY_MS)
+  );
 }
 
 async function flushHistoryQueue(name: string) {
-  const timer = historyFlushTimers.get(name)
+  const timer = historyFlushTimers.get(name);
   if (timer) {
-    clearTimeout(timer)
-    historyFlushTimers.delete(name)
+    clearTimeout(timer);
+    historyFlushTimers.delete(name);
   }
 
-  const queue = pendingHistoryEntries.get(name)
-  const state = getHistoryState(name)
+  const queue = pendingHistoryEntries.get(name);
+  const state = getHistoryState(name);
   if (!queue?.length || !auth.token || !projectStore.currentProject) {
-    state.syncing = false
-    return
+    state.syncing = false;
+    return;
   }
 
-  pendingHistoryEntries.delete(name)
+  pendingHistoryEntries.delete(name);
 
   try {
-    await rulesetHistoryApi.append(auth.token, projectStore.currentProject.id, name, queue)
-    state.syncing = false
+    await rulesetHistoryApi.append(auth.token, projectStore.currentProject.id, name, queue);
+    state.syncing = false;
   } catch (error) {
-    const retryQueue = [...queue, ...(pendingHistoryEntries.get(name) ?? [])]
-    pendingHistoryEntries.set(name, retryQueue)
-    state.syncing = true
+    const retryQueue = [...queue, ...(pendingHistoryEntries.get(name) ?? [])];
+    pendingHistoryEntries.set(name, retryQueue);
+    state.syncing = true;
   }
 }
 
@@ -289,245 +289,261 @@ function pushHistoryEntry(
   ruleset: RuleSet,
   action: string,
   source: RulesetHistorySource,
-  persist = true,
+  persist = true
 ) {
-  const state = getHistoryState(name)
-  const currentEntry = state.entries[state.currentIndex]
+  const state = getHistoryState(name);
+  const currentEntry = state.entries[state.currentIndex];
 
-  if (source === 'edit' && currentEntry?.snapshot && isSameRuleset(currentEntry.snapshot, ruleset)) {
-    return
+  if (
+    source === 'edit' &&
+    currentEntry?.snapshot &&
+    isSameRuleset(currentEntry.snapshot, ruleset)
+  ) {
+    return;
   }
 
   if (state.currentIndex < state.entries.length - 1) {
-    state.entries = state.entries.slice(0, state.currentIndex + 1)
+    state.entries = state.entries.slice(0, state.currentIndex + 1);
   }
 
-  state.entries.push(createHistoryEntry(name, ruleset, action, source))
+  state.entries.push(createHistoryEntry(name, ruleset, action, source));
   if (state.entries.length > LOCAL_HISTORY_LIMIT) {
-    state.entries = state.entries.slice(state.entries.length - LOCAL_HISTORY_LIMIT)
+    state.entries = state.entries.slice(state.entries.length - LOCAL_HISTORY_LIMIT);
   }
-  state.currentIndex = state.entries.length - 1
+  state.currentIndex = state.entries.length - 1;
 
   if (persist) {
-    queueHistoryPersistence(name, state.entries[state.currentIndex])
+    queueHistoryPersistence(name, state.entries[state.currentIndex]);
   }
 }
 
 function applyHistoryIndex(name: string, index: number) {
-  const state = getHistoryState(name)
-  const entry = state.entries[index]
-  if (!entry) return
+  const state = getHistoryState(name);
+  const entry = state.entries[index];
+  if (!entry) return;
 
-  state.currentIndex = index
-  updateRulesetState(name, entry.snapshot)
+  state.currentIndex = index;
+  updateRulesetState(name, entry.snapshot);
 }
 
 function undoHistory() {
-  const tab = projectStore.activeTab
-  if (!tab || !canUndoHistory.value) return
-  flushPendingEditHistory(tab.name)
-  applyHistoryIndex(tab.name, activeHistoryIndex.value - 1)
+  const tab = projectStore.activeTab;
+  if (!tab || !canUndoHistory.value) return;
+  flushPendingEditHistory(tab.name);
+  applyHistoryIndex(tab.name, activeHistoryIndex.value - 1);
 }
 
 function redoHistory() {
-  const tab = projectStore.activeTab
-  if (!tab || !canRedoHistory.value) return
-  flushPendingEditHistory(tab.name)
-  applyHistoryIndex(tab.name, activeHistoryIndex.value + 1)
+  const tab = projectStore.activeTab;
+  if (!tab || !canRedoHistory.value) return;
+  flushPendingEditHistory(tab.name);
+  applyHistoryIndex(tab.name, activeHistoryIndex.value + 1);
 }
 
 function restoreHistory(index: number) {
-  const tab = projectStore.activeTab
-  if (!tab) return
-  flushPendingEditHistory(tab.name)
+  const tab = projectStore.activeTab;
+  if (!tab) return;
+  flushPendingEditHistory(tab.name);
 
-  const state = getHistoryState(tab.name)
-  const entry = state.entries[index]
-  if (!entry) return
+  const state = getHistoryState(tab.name);
+  const entry = state.entries[index];
+  if (!entry) return;
 
   if (isSameRuleset(tab.ruleset, entry.snapshot)) {
-    state.currentIndex = index
-    return
+    state.currentIndex = index;
+    return;
   }
 
-  updateRulesetState(tab.name, entry.snapshot)
+  updateRulesetState(tab.name, entry.snapshot);
   pushHistoryEntry(
     tab.name,
     entry.snapshot,
     t('historyPanel.actionRestoreSnapshot', { action: entry.action }),
-    'restore',
-  )
+    'restore'
+  );
 }
 
 function resetTabHistory(name: string) {
-  const editTimer = editHistoryTimers.get(name)
+  const editTimer = editHistoryTimers.get(name);
   if (editTimer) {
-    clearTimeout(editTimer)
-    editHistoryTimers.delete(name)
+    clearTimeout(editTimer);
+    editHistoryTimers.delete(name);
   }
-  pendingEditHistory.delete(name)
+  pendingEditHistory.delete(name);
 
-  const timer = historyFlushTimers.get(name)
+  const timer = historyFlushTimers.get(name);
   if (timer) {
-    clearTimeout(timer)
-    historyFlushTimers.delete(name)
+    clearTimeout(timer);
+    historyFlushTimers.delete(name);
   }
-  pendingHistoryEntries.delete(name)
-  savedRulesetSnapshots.delete(name)
-  delete historyStates.value[name]
+  pendingHistoryEntries.delete(name);
+  savedRulesetSnapshots.delete(name);
+  delete historyStates.value[name];
 }
 
 async function disposeTabHistory(name: string) {
-  await flushHistoryQueue(name)
-  resetTabHistory(name)
+  await flushHistoryQueue(name);
+  resetTabHistory(name);
 }
 
 async function ensureHistoryLoaded(name: string, ruleset: RuleSet) {
-  const state = getHistoryState(name)
-  if (state.loaded || state.loading) return
+  const state = getHistoryState(name);
+  if (state.loaded || state.loading) return;
 
-  state.loading = true
-  const currentSnapshot = cloneRuleset(ruleset)
-  const loadedEntries: RulesetHistoryEntry[] = []
+  state.loading = true;
+  const currentSnapshot = cloneRuleset(ruleset);
+  const loadedEntries: RulesetHistoryEntry[] = [];
 
   try {
     if (auth.token && projectStore.currentProject) {
-      const response = await rulesetHistoryApi.list(auth.token, projectStore.currentProject.id, name)
+      const response = await rulesetHistoryApi.list(
+        auth.token,
+        projectStore.currentProject.id,
+        name
+      );
       loadedEntries.push(
         ...response.entries.map((entry) => ({
           ...entry,
           snapshot: cloneRuleset(entry.snapshot),
-        })),
-      )
+        }))
+      );
     }
   } catch (error) {
-    console.error('[history] failed to load ruleset history:', error)
+    console.error('[history] failed to load ruleset history:', error);
   }
 
-  if (loadedEntries.length === 0 || !isSameRuleset(loadedEntries[loadedEntries.length - 1].snapshot, currentSnapshot)) {
+  if (
+    loadedEntries.length === 0 ||
+    !isSameRuleset(loadedEntries[loadedEntries.length - 1].snapshot, currentSnapshot)
+  ) {
     loadedEntries.push(
-      createHistoryEntry(name, currentSnapshot, t('historyPanel.actionOpenCurrent'), 'sync'),
-    )
+      createHistoryEntry(name, currentSnapshot, t('historyPanel.actionOpenCurrent'), 'sync')
+    );
   }
 
-  state.entries = loadedEntries
-  state.currentIndex = loadedEntries.length - 1
-  state.loaded = true
-  state.loading = false
-  state.syncing = false
+  state.entries = loadedEntries;
+  state.currentIndex = loadedEntries.length - 1;
+  state.loaded = true;
+  state.loading = false;
+  state.syncing = false;
 
-  savedRulesetSnapshots.set(name, serializeRuleset(currentSnapshot))
+  savedRulesetSnapshots.set(name, serializeRuleset(currentSnapshot));
 }
 
 // ── Execution panel ──────────────────────────────────────────────────────────
-const showExecution = ref(false)
-const executionHeight = ref(280)
+const showExecution = ref(false);
+const executionHeight = ref(280);
 
 // ── Test case panel ───────────────────────────────────────────────────────────
-const showTests = ref(false)
-const testsHeight = ref(280)
+const showTests = ref(false);
+const testsHeight = ref(280);
 
 function toggleTests() {
-  showTests.value = !showTests.value
-  if (showTests.value) showExecution.value = false
+  showTests.value = !showTests.value;
+  if (showTests.value) showExecution.value = false;
 }
 
 function toggleExecution() {
-  showExecution.value = !showExecution.value
-  if (showExecution.value) showTests.value = false
+  showExecution.value = !showExecution.value;
+  if (showExecution.value) showTests.value = false;
 }
 
 // ── Execution trace overlay (for "show in flow") ─────────────────────────────
 const executionTrace = ref<{
-  path: string[]
-  steps: Array<{ id: string; name: string; duration_us: number; result?: string | null }>
-  resultCode: string
-  resultMessage: string
-  output?: Record<string, any>
-} | null>(null)
-const flowTraceMode = ref(false)
+  path: string[];
+  steps: Array<{ id: string; name: string; duration_us: number; result?: string | null }>;
+  resultCode: string;
+  resultMessage: string;
+  output?: Record<string, any>;
+} | null>(null);
+const flowTraceMode = ref(false);
 
 function handleShowInFlow(trace: typeof executionTrace.value) {
-  executionTrace.value = trace ? { ...trace, steps: [...trace.steps], path: [...trace.path] } : null
-  flowTraceMode.value = true
-  setEditorMode('flow')
+  executionTrace.value = trace
+    ? { ...trace, steps: [...trace.steps], path: [...trace.path] }
+    : null;
+  flowTraceMode.value = true;
+  setEditorMode('flow');
 }
 
 function handleClearFlowTrace() {
-  executionTrace.value = null
-  flowTraceMode.value = false
+  executionTrace.value = null;
+  flowTraceMode.value = false;
 }
 
 function handleShowAsFlow() {
-  setEditorMode('flow')
+  setEditorMode('flow');
 }
 
 // ── Create dialog ─────────────────────────────────────────────────────────────
-const showCreate = ref(false)
-const creating = ref(false)
-const newName = ref('')
-const newType = ref<'flow' | 'table'>('flow')
-const saving = ref(false)
+const showCreate = ref(false);
+const creating = ref(false);
+const newName = ref('');
+const newType = ref<'flow' | 'table'>('flow');
+const saving = ref(false);
 const conflictState = ref<{
-  rulesetName: string
-  localDraft: RuleSet
-  serverDraft: RuleSet
-  serverSeq: number
-} | null>(null)
+  rulesetName: string;
+  localDraft: RuleSet;
+  serverDraft: RuleSet;
+  serverSeq: number;
+} | null>(null);
 
 // ── Permissions ───────────────────────────────────────────────────────────────
 const canEdit = computed(() => {
-  if (!auth.user) return false
-  return rbacStore.can('ruleset:edit') || orgStore.canEdit(auth.user.id)
-})
+  if (!auth.user) return false;
+  return rbacStore.can('ruleset:edit') || orgStore.canEdit(auth.user.id);
+});
 
 const canAdmin = computed(() => {
-  if (!auth.user) return false
-  return rbacStore.can('project:manage') || orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return rbacStore.can('project:manage') || orgStore.canAdmin(auth.user.id);
+});
 
 const canPublish = computed(() => {
-  if (!auth.user) return false
-  return rbacStore.can('ruleset:publish') || orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return rbacStore.can('ruleset:publish') || orgStore.canAdmin(auth.user.id);
+});
 
 const activeRulesetMeta = computed(() => {
-  const tab = projectStore.activeTab
-  if (!tab) return null
-  return projectStore.draftMetas.find((item) => item.name === tab.name) ?? null
-})
+  const tab = projectStore.activeTab;
+  if (!tab) return null;
+  return projectStore.draftMetas.find((item) => item.name === tab.name) ?? null;
+});
 
 const activeDraftVersion = computed(() =>
-  stripVersionSuffix(projectStore.activeTab?.ruleset.config.version),
-)
+  stripVersionSuffix(projectStore.activeTab?.ruleset.config.version)
+);
 
 const activePublishedVersion = computed(() =>
-  stripVersionSuffix(activeRulesetMeta.value?.published_version),
-)
+  stripVersionSuffix(activeRulesetMeta.value?.published_version)
+);
 
 const activeVersionDisplay = computed(() =>
-  getCurrentVersionDisplay(activeHistoryEntries.value, projectStore.activeTab?.ruleset.config.version),
-)
+  getCurrentVersionDisplay(
+    activeHistoryEntries.value,
+    projectStore.activeTab?.ruleset.config.version
+  )
+);
 
-const requiresVersionBump = computed(() =>
-  !!activePublishedVersion.value && activePublishedVersion.value === activeDraftVersion.value,
-)
+const requiresVersionBump = computed(
+  () => !!activePublishedVersion.value && activePublishedVersion.value === activeDraftVersion.value
+);
 
 // ── Table support ──────────────────────────────────────────────────────────────
-const decisionTables = ref<Record<string, DecisionTable>>({})
+const decisionTables = ref<Record<string, DecisionTable>>({});
 
 const activeDecisionTable = computed(() => {
-  const tab = projectStore.activeTab
-  if (!tab) return null
-  return decisionTables.value[tab.name] ?? null
-})
+  const tab = projectStore.activeTab;
+  if (!tab) return null;
+  return decisionTables.value[tab.name] ?? null;
+});
 
 function handleTableChange(table: DecisionTable) {
-  const tab = projectStore.activeTab
-  if (!tab) return
-  decisionTables.value[tab.name] = table
+  const tab = projectStore.activeTab;
+  if (!tab) return;
+  decisionTables.value[tab.name] = table;
 
-  const result = compileTableToSteps(table)
+  const result = compileTableToSteps(table);
 
   const nextRuleset: RuleSet = {
     ...tab.ruleset,
@@ -540,240 +556,238 @@ function handleTableChange(table: DecisionTable) {
         _table: JSON.stringify(table),
       },
     },
-  }
+  };
 
-  updateRulesetState(tab.name, nextRuleset)
-  scheduleEditHistoryEntry(tab.name, nextRuleset, t('historyPanel.actionEditTable'))
+  updateRulesetState(tab.name, nextRuleset);
+  scheduleEditHistoryEntry(tab.name, nextRuleset, t('historyPanel.actionEditTable'));
 }
 
 // ── Lifecycle ──────────────────────────────────────────────────────────────────
 onMounted(async () => {
   if (!projectStore.currentProject || projectStore.currentProject.id !== projectId.value) {
-    const project = projectStore.projects.find((p) => p.id === projectId.value)
+    const project = projectStore.projects.find((p) => p.id === projectId.value);
     if (project) {
-      await projectStore.selectProject(project)
+      await projectStore.selectProject(project);
     }
   }
-  await projectStore.fetchRulesets()
-  await rbacStore.fetchRoles(orgId.value)
-  await rbacStore.fetchMyRoles(orgId.value)
-  await environmentStore.fetchEnvironments(orgId.value, projectId.value)
+  await projectStore.fetchRulesets();
+  await rbacStore.fetchRoles(orgId.value);
+  await rbacStore.fetchMyRoles(orgId.value);
+  await environmentStore.fetchEnvironments(orgId.value, projectId.value);
 
   // Open ruleset from URL param
   if (rulesetNameParam.value) {
-    await openRuleset(rulesetNameParam.value)
+    await openRuleset(rulesetNameParam.value);
   } else if (projectStore.rulesets.length > 0 && projectStore.openTabs.length === 0) {
-    await openRuleset(projectStore.rulesets[0].name)
+    await openRuleset(projectStore.rulesets[0].name);
   }
-})
+});
 
 watch(
   () => rulesetNameParam.value,
   async (name) => {
-    if (name) await openRuleset(name)
-  },
-)
+    if (name) await openRuleset(name);
+  }
+);
 
 function onKeydown(e: KeyboardEvent) {
-  const key = e.key.toLowerCase()
-  const isPrimary = e.ctrlKey || e.metaKey
+  const key = e.key.toLowerCase();
+  const isPrimary = e.ctrlKey || e.metaKey;
 
-  if (!isPrimary) return
+  if (!isPrimary) return;
 
   if (key === 's') {
-    e.preventDefault()
-    if (projectStore.activeTab) handleSave(projectStore.activeTab.name)
-    return
+    e.preventDefault();
+    if (projectStore.activeTab) handleSave(projectStore.activeTab.name);
+    return;
   }
 
   if (key === 'z') {
-    e.preventDefault()
+    e.preventDefault();
     if (e.shiftKey) {
-      redoHistory()
+      redoHistory();
     } else {
-      undoHistory()
+      undoHistory();
     }
-    return
+    return;
   }
 
   if (key === 'y') {
-    e.preventDefault()
-    redoHistory()
+    e.preventDefault();
+    redoHistory();
   }
 }
 
 function closeMenus() {
-  openMenu.value = null
+  openMenu.value = null;
 }
 
 function toggleMenu(menu: 'file' | 'edit' | 'select' | 'view' | 'window') {
-  openMenu.value = openMenu.value === menu ? null : menu
+  openMenu.value = openMenu.value === menu ? null : menu;
 }
 
 function hoverMenu(menu: 'file' | 'edit' | 'select' | 'view' | 'window') {
   if (openMenu.value) {
-    openMenu.value = menu
+    openMenu.value = menu;
   }
 }
 
 function onDocumentPointerDown(event: MouseEvent) {
-  const target = event.target as HTMLElement | null
+  const target = event.target as HTMLElement | null;
   if (!target?.closest('.editor-menubar')) {
-    closeMenus()
+    closeMenus();
   }
 }
 
 function runMenuAction(action: () => void) {
-  closeMenus()
-  action()
+  closeMenus();
+  action();
 }
 
-onMounted(() => document.addEventListener('keydown', onKeydown))
-onUnmounted(() => document.removeEventListener('keydown', onKeydown))
-onMounted(() => document.addEventListener('mousedown', onDocumentPointerDown))
-onUnmounted(() => document.removeEventListener('mousedown', onDocumentPointerDown))
+onMounted(() => document.addEventListener('keydown', onKeydown));
+onUnmounted(() => document.removeEventListener('keydown', onKeydown));
+onMounted(() => document.addEventListener('mousedown', onDocumentPointerDown));
+onUnmounted(() => document.removeEventListener('mousedown', onDocumentPointerDown));
 
 // ── Actions ───────────────────────────────────────────────────────────────────
 async function openRuleset(name: string) {
   try {
-    await projectStore.openRuleset(name)
-    const tab = projectStore.openTabs.find((t) => t.name === name)
+    await projectStore.openRuleset(name);
+    const tab = projectStore.openTabs.find((t) => t.name === name);
     if (tab) {
-      syncDecisionTableFromRuleset(name, tab.ruleset)
-      editorMode.value = canBeTable(tab.ruleset) ? 'table' : 'form'
-      await ensureHistoryLoaded(name, tab.ruleset)
+      syncDecisionTableFromRuleset(name, tab.ruleset);
+      editorMode.value = canBeTable(tab.ruleset) ? 'table' : 'form';
+      await ensureHistoryLoaded(name, tab.ruleset);
     }
-    tabModes.set(name, editorMode.value)
-    router.replace(`${projectBase.value}/editor/${encodeURIComponent(name)}`)
+    tabModes.set(name, editorMode.value);
+    router.replace(`${projectBase.value}/editor/${encodeURIComponent(name)}`);
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('editor.loadFailed'))
+    MessagePlugin.error(e.message || t('editor.loadFailed'));
   }
 }
 
 function canBeTable(rs: RuleSet): boolean {
   try {
-    return !!decompileStepsToTable(rs.steps, rs.startStepId)
+    return !!decompileStepsToTable(rs.steps, rs.startStepId);
   } catch {
-    return false
+    return false;
   }
 }
 
 function handleRulesetChange(ruleset: RuleSet) {
-  const tab = projectStore.activeTab
-  if (!tab) return
+  const tab = projectStore.activeTab;
+  if (!tab) return;
 
-  const action = buildHistoryAction(tab.ruleset, ruleset)
-  updateRulesetState(tab.name, ruleset)
-  scheduleEditHistoryEntry(tab.name, ruleset, action)
+  const action = buildHistoryAction(tab.ruleset, ruleset);
+  updateRulesetState(tab.name, ruleset);
+  scheduleEditHistoryEntry(tab.name, ruleset, action);
 }
 
 function handleVersionChange(event: Event) {
-  const tab = projectStore.activeTab
-  if (!tab) return
+  const tab = projectStore.activeTab;
+  if (!tab) return;
 
-  const target = event.target as HTMLInputElement
-  const nextVersion = stripVersionSuffix(target.value)
+  const target = event.target as HTMLInputElement;
+  const nextVersion = stripVersionSuffix(target.value);
   const nextRuleset: RuleSet = {
     ...tab.ruleset,
     config: {
       ...tab.ruleset.config,
       version: nextVersion,
     },
-  }
+  };
 
-  const action = buildHistoryAction(tab.ruleset, nextRuleset)
-  updateRulesetState(tab.name, nextRuleset)
-  scheduleEditHistoryEntry(tab.name, nextRuleset, action)
+  const action = buildHistoryAction(tab.ruleset, nextRuleset);
+  updateRulesetState(tab.name, nextRuleset);
+  scheduleEditHistoryEntry(tab.name, nextRuleset, action);
 }
 
 async function handleSave(name: string) {
   if (!canEdit.value) {
-    MessagePlugin.warning(t('editor.noPermission'))
-    return
+    MessagePlugin.warning(t('editor.noPermission'));
+    return;
   }
-  const tab = projectStore.openTabs.find((item) => item.name === name)
-  if (!tab) return
+  const tab = projectStore.openTabs.find((item) => item.name === name);
+  if (!tab) return;
 
-  const nextVersion = stripVersionSuffix(tab.ruleset.config.version)
-  const meta = projectStore.draftMetas.find((item) => item.name === name) ?? null
-  const publishedVersion = stripVersionSuffix(meta?.published_version)
+  const nextVersion = stripVersionSuffix(tab.ruleset.config.version);
+  const meta = projectStore.draftMetas.find((item) => item.name === name) ?? null;
+  const publishedVersion = stripVersionSuffix(meta?.published_version);
   if (!nextVersion) {
-    MessagePlugin.warning(t('editor.versionRequired'))
-    return
+    MessagePlugin.warning(t('editor.versionRequired'));
+    return;
   }
   if (publishedVersion && publishedVersion === nextVersion) {
-    MessagePlugin.warning(
-      t('editor.versionBumpRequired', { version: publishedVersion }),
-    )
-    return
+    MessagePlugin.warning(t('editor.versionBumpRequired', { version: publishedVersion }));
+    return;
   }
-  saving.value = true
+  saving.value = true;
   try {
-    flushPendingEditHistory(name)
-    const result = await projectStore.saveRuleset(name)
+    flushPendingEditHistory(name);
+    const result = await projectStore.saveRuleset(name);
     if (result?.conflict) {
-      const tab = projectStore.openTabs.find((item) => item.name === name)
+      const tab = projectStore.openTabs.find((item) => item.name === name);
       if (!tab) {
-        MessagePlugin.error(t('editor.saveFailed'))
-        return
+        MessagePlugin.error(t('editor.saveFailed'));
+        return;
       }
       conflictState.value = {
         rulesetName: name,
         localDraft: cloneRuleset(tab.ruleset),
         serverDraft: cloneRuleset(normalizeRuleset(result.server_draft, name)),
         serverSeq: result.server_seq,
-      }
-      return
+      };
+      return;
     }
-    const tab = projectStore.openTabs.find((item) => item.name === name)
+    const tab = projectStore.openTabs.find((item) => item.name === name);
     if (tab) {
-      savedRulesetSnapshots.set(name, serializeRuleset(tab.ruleset))
-      projectStore.setTabRuleset(name, cloneRuleset(tab.ruleset), false)
-      pushHistoryEntry(name, tab.ruleset, t('historyPanel.actionSaveCheckpoint'), 'save')
-      await flushHistoryQueue(name)
+      savedRulesetSnapshots.set(name, serializeRuleset(tab.ruleset));
+      projectStore.setTabRuleset(name, cloneRuleset(tab.ruleset), false);
+      pushHistoryEntry(name, tab.ruleset, t('historyPanel.actionSaveCheckpoint'), 'save');
+      await flushHistoryQueue(name);
     }
-    MessagePlugin.success(t('editor.saveSuccess'))
+    MessagePlugin.success(t('editor.saveSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('editor.saveFailed'))
+    MessagePlugin.error(e.message || t('editor.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 async function resolveConflictUseServer() {
-  const conflict = conflictState.value
-  if (!conflict) return
-  const tab = projectStore.openTabs.find((item) => item.name === conflict.rulesetName)
+  const conflict = conflictState.value;
+  if (!conflict) return;
+  const tab = projectStore.openTabs.find((item) => item.name === conflict.rulesetName);
   if (!tab) {
-    conflictState.value = null
-    return
+    conflictState.value = null;
+    return;
   }
 
-  tab.draft_seq = conflict.serverSeq
-  savedRulesetSnapshots.set(conflict.rulesetName, serializeRuleset(conflict.serverDraft))
-  projectStore.setTabRuleset(conflict.rulesetName, cloneRuleset(conflict.serverDraft), false)
-  syncDecisionTableFromRuleset(conflict.rulesetName, conflict.serverDraft)
-  conflictState.value = null
-  MessagePlugin.success(t('conflict.useServerSuccess'))
+  tab.draft_seq = conflict.serverSeq;
+  savedRulesetSnapshots.set(conflict.rulesetName, serializeRuleset(conflict.serverDraft));
+  projectStore.setTabRuleset(conflict.rulesetName, cloneRuleset(conflict.serverDraft), false);
+  syncDecisionTableFromRuleset(conflict.rulesetName, conflict.serverDraft);
+  conflictState.value = null;
+  MessagePlugin.success(t('conflict.useServerSuccess'));
 }
 
 async function resolveConflictUseLocal() {
-  const conflict = conflictState.value
-  if (!conflict) return
-  const tab = projectStore.openTabs.find((item) => item.name === conflict.rulesetName)
+  const conflict = conflictState.value;
+  if (!conflict) return;
+  const tab = projectStore.openTabs.find((item) => item.name === conflict.rulesetName);
   if (!tab) {
-    conflictState.value = null
-    return
+    conflictState.value = null;
+    return;
   }
 
-  tab.draft_seq = conflict.serverSeq
-  projectStore.setTabRuleset(conflict.rulesetName, cloneRuleset(conflict.localDraft), true)
-  conflictState.value = null
-  await handleSave(conflict.rulesetName)
+  tab.draft_seq = conflict.serverSeq;
+  projectStore.setTabRuleset(conflict.rulesetName, cloneRuleset(conflict.localDraft), true);
+  conflictState.value = null;
+  await handleSave(conflict.rulesetName);
 }
 
 function openReleaseCenter() {
-  if (!projectStore.activeTab) return
+  if (!projectStore.activeTab) return;
   router.push({
     name: 'project-release-request-create',
     params: {
@@ -781,11 +795,11 @@ function openReleaseCenter() {
       projectId: route.params.projectId,
     },
     query: { ruleset: projectStore.activeTab.name },
-  })
+  });
 }
 
 function handleCloseTab(name: string) {
-  const tab = projectStore.openTabs.find((t) => t.name === name)
+  const tab = projectStore.openTabs.find((t) => t.name === name);
   if (tab?.dirty) {
     const dlg = DialogPlugin.confirm({
       header: t('editor.closeConfirm'),
@@ -793,40 +807,40 @@ function handleCloseTab(name: string) {
       confirmBtn: { content: t('editor.closeConfirmBtn'), theme: 'danger' },
       cancelBtn: t('common.cancel'),
       onConfirm: async () => {
-        projectStore.closeTab(name)
-        await disposeTabHistory(name)
-        dlg.hide()
+        projectStore.closeTab(name);
+        await disposeTabHistory(name);
+        dlg.hide();
         if (!projectStore.activeTabName) {
-          router.replace(`${projectBase.value}/editor`)
+          router.replace(`${projectBase.value}/editor`);
         }
       },
-    })
+    });
   } else {
-    projectStore.closeTab(name)
-    void disposeTabHistory(name)
+    projectStore.closeTab(name);
+    void disposeTabHistory(name);
     if (!projectStore.activeTabName) {
-      router.replace(`${projectBase.value}/editor`)
+      router.replace(`${projectBase.value}/editor`);
     }
   }
 }
 
 async function handleCreateRuleset() {
   if (!newName.value.trim()) {
-    MessagePlugin.warning(t('editor.nameRequired'))
-    return
+    MessagePlugin.warning(t('editor.nameRequired'));
+    return;
   }
-  creating.value = true
+  creating.value = true;
   try {
-    let rs: RuleSet
-    const name = newName.value.trim()
+    let rs: RuleSet;
+    const name = newName.value.trim();
 
     if (newType.value === 'table') {
-      const doc = createEmptyTableDocument(name)
-      rs = documentToRuleSet(doc)
+      const doc = createEmptyTableDocument(name);
+      rs = documentToRuleSet(doc);
     } else {
       // Flow: Decision → Terminal
-      const decisionId = generateId()
-      const terminalId = generateId()
+      const decisionId = generateId();
+      const terminalId = generateId();
       rs = {
         config: { name, version: '1.0.0' },
         startStepId: decisionId,
@@ -843,20 +857,20 @@ async function handleCreateRuleset() {
             code: 'DEFAULT',
           }),
         ],
-      }
+      };
     }
 
-    await projectStore.createRuleset(rs)
-    showCreate.value = false
-    newName.value = ''
-    MessagePlugin.success(t('editor.createSuccess'))
-    await openRuleset(name)
-    pushHistoryEntry(name, rs, t('historyPanel.actionCreateRuleset'), 'create')
-    showHistoryPanel.value = true
+    await projectStore.createRuleset(rs);
+    showCreate.value = false;
+    newName.value = '';
+    MessagePlugin.success(t('editor.createSuccess'));
+    await openRuleset(name);
+    pushHistoryEntry(name, rs, t('historyPanel.actionCreateRuleset'), 'create');
+    showHistoryPanel.value = true;
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('editor.createFailed'))
+    MessagePlugin.error(e.message || t('editor.createFailed'));
   } finally {
-    creating.value = false
+    creating.value = false;
   }
 }
 
@@ -868,39 +882,39 @@ function handleDeleteRuleset(name: string) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await projectStore.deleteRuleset(name)
-        await disposeTabHistory(name)
-        dlg.hide()
-        MessagePlugin.success(t('editor.deleteSuccess'))
+        await projectStore.deleteRuleset(name);
+        await disposeTabHistory(name);
+        dlg.hide();
+        MessagePlugin.success(t('editor.deleteSuccess'));
         if (!projectStore.activeTabName && projectStore.rulesets.length > 0) {
-          await openRuleset(projectStore.rulesets[0].name)
+          await openRuleset(projectStore.rulesets[0].name);
         }
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 function setEditorMode(mode: 'form' | 'flow' | 'table') {
-  const tab = projectStore.activeTab
-  if (!tab) return
+  const tab = projectStore.activeTab;
+  if (!tab) return;
   if (mode === 'table' && !canBeTable(tab.ruleset)) {
-    MessagePlugin.warning(t('editor.tableUnsupported'))
-    return
+    MessagePlugin.warning(t('editor.tableUnsupported'));
+    return;
   }
-  editorMode.value = mode
-  tabModes.set(tab.name, mode)
+  editorMode.value = mode;
+  tabModes.set(tab.name, mode);
 }
 
 onUnmounted(() => {
   for (const name of Array.from(editHistoryTimers.keys())) {
-    flushPendingEditHistory(name)
+    flushPendingEditHistory(name);
   }
   for (const name of Array.from(historyFlushTimers.keys())) {
-    void flushHistoryQueue(name)
+    void flushHistoryQueue(name);
   }
-})
+});
 </script>
 
 <template>
@@ -936,11 +950,7 @@ onUnmounted(() => {
           @click="openRuleset(rs.name)"
           @contextmenu.prevent="() => {}"
         >
-          <t-icon
-            name="file-code"
-            size="14px"
-            class="ruleset-item__icon"
-          />
+          <t-icon name="file-code" size="14px" class="ruleset-item__icon" />
           <span class="ruleset-item__name">{{ rs.name }}</span>
           <span
             v-if="projectStore.openTabs.find((t) => t.name === rs.name)?.dirty"
@@ -962,21 +972,30 @@ onUnmounted(() => {
     <!-- ── Main area ── -->
     <div class="editor-main">
       <div class="editor-menubar" v-if="projectStore.openTabs.length > 0">
-        <div
-          class="editor-menu"
-          @mouseenter="hoverMenu('file')"
-        >
-          <button class="editor-menu__trigger" :class="{ 'is-open': openMenu === 'file' }" @click="toggleMenu('file')">
+        <div class="editor-menu" @mouseenter="hoverMenu('file')">
+          <button
+            class="editor-menu__trigger"
+            :class="{ 'is-open': openMenu === 'file' }"
+            @click="toggleMenu('file')"
+          >
             {{ t('menuBar.file') }}
           </button>
           <div v-if="openMenu === 'file'" class="editor-menu__dropdown">
-            <button class="editor-menu__item" :disabled="!canEdit" @click="runMenuAction(() => (showCreate = true))">
+            <button
+              class="editor-menu__item"
+              :disabled="!canEdit"
+              @click="runMenuAction(() => (showCreate = true))"
+            >
               <span>{{ t('menuBar.newRuleset') }}</span>
             </button>
             <button
               class="editor-menu__item"
               :disabled="!canEdit || !projectStore.activeTab"
-              @click="runMenuAction(() => projectStore.activeTab && handleSave(projectStore.activeTab.name))"
+              @click="
+                runMenuAction(
+                  () => projectStore.activeTab && handleSave(projectStore.activeTab.name)
+                )
+              "
             >
               <span>{{ t('menuBar.save') }}</span>
               <span class="editor-menu__shortcut">Ctrl+S</span>
@@ -992,15 +1011,27 @@ onUnmounted(() => {
         </div>
 
         <div class="editor-menu" @mouseenter="hoverMenu('edit')">
-          <button class="editor-menu__trigger" :class="{ 'is-open': openMenu === 'edit' }" @click="toggleMenu('edit')">
+          <button
+            class="editor-menu__trigger"
+            :class="{ 'is-open': openMenu === 'edit' }"
+            @click="toggleMenu('edit')"
+          >
             {{ t('menuBar.edit') }}
           </button>
           <div v-if="openMenu === 'edit'" class="editor-menu__dropdown">
-            <button class="editor-menu__item" :disabled="!canUndoHistory" @click="runMenuAction(undoHistory)">
+            <button
+              class="editor-menu__item"
+              :disabled="!canUndoHistory"
+              @click="runMenuAction(undoHistory)"
+            >
               <span>{{ t('menuBar.undo') }}</span>
               <span class="editor-menu__shortcut">Ctrl+Z</span>
             </button>
-            <button class="editor-menu__item" :disabled="!canRedoHistory" @click="runMenuAction(redoHistory)">
+            <button
+              class="editor-menu__item"
+              :disabled="!canRedoHistory"
+              @click="runMenuAction(redoHistory)"
+            >
               <span>{{ t('menuBar.redo') }}</span>
               <span class="editor-menu__shortcut">Ctrl+Shift+Z</span>
             </button>
@@ -1008,7 +1039,11 @@ onUnmounted(() => {
         </div>
 
         <div class="editor-menu" @mouseenter="hoverMenu('select')">
-          <button class="editor-menu__trigger" :class="{ 'is-open': openMenu === 'select' }" @click="toggleMenu('select')">
+          <button
+            class="editor-menu__trigger"
+            :class="{ 'is-open': openMenu === 'select' }"
+            @click="toggleMenu('select')"
+          >
             {{ t('menuBar.select') }}
           </button>
           <div v-if="openMenu === 'select'" class="editor-menu__dropdown">
@@ -1019,33 +1054,55 @@ onUnmounted(() => {
         </div>
 
         <div class="editor-menu" @mouseenter="hoverMenu('view')">
-          <button class="editor-menu__trigger" :class="{ 'is-open': openMenu === 'view' }" @click="toggleMenu('view')">
+          <button
+            class="editor-menu__trigger"
+            :class="{ 'is-open': openMenu === 'view' }"
+            @click="toggleMenu('view')"
+          >
             {{ t('menuBar.view') }}
           </button>
           <div v-if="openMenu === 'view'" class="editor-menu__dropdown">
-            <button class="editor-menu__item" :disabled="editorMode === 'form'" @click="runMenuAction(() => setEditorMode('form'))">
+            <button
+              class="editor-menu__item"
+              :disabled="editorMode === 'form'"
+              @click="runMenuAction(() => setEditorMode('form'))"
+            >
               <span>{{ t('editor.formMode') }}</span>
             </button>
-            <button class="editor-menu__item" :disabled="editorMode === 'flow'" @click="runMenuAction(() => setEditorMode('flow'))">
+            <button
+              class="editor-menu__item"
+              :disabled="editorMode === 'flow'"
+              @click="runMenuAction(() => setEditorMode('flow'))"
+            >
               <span>{{ t('editor.flowMode') }}</span>
             </button>
-            <button class="editor-menu__item" :disabled="editorMode === 'table'" @click="runMenuAction(() => setEditorMode('table'))">
+            <button
+              class="editor-menu__item"
+              :disabled="editorMode === 'table'"
+              @click="runMenuAction(() => setEditorMode('table'))"
+            >
               <span>{{ t('editor.tableMode') }}</span>
             </button>
           </div>
         </div>
 
         <div class="editor-menu" @mouseenter="hoverMenu('window')">
-          <button class="editor-menu__trigger" :class="{ 'is-open': openMenu === 'window' }" @click="toggleMenu('window')">
+          <button
+            class="editor-menu__trigger"
+            :class="{ 'is-open': openMenu === 'window' }"
+            @click="toggleMenu('window')"
+          >
             {{ t('menuBar.window') }}
           </button>
           <div v-if="openMenu === 'window'" class="editor-menu__dropdown">
             <button
               class="editor-menu__item"
-              @click="runMenuAction(() => {
-                showHistoryPanel = !showHistoryPanel
-                if (showHistoryPanel) historyPanelCollapsed = false
-              })"
+              @click="
+                runMenuAction(() => {
+                  showHistoryPanel = !showHistoryPanel;
+                  if (showHistoryPanel) historyPanelCollapsed = false;
+                })
+              "
             >
               <span>{{ t('menuBar.history') }}</span>
               <t-icon v-if="showHistoryPanel" name="check" size="13px" />
@@ -1181,35 +1238,43 @@ onUnmounted(() => {
       <div v-else class="editor-body">
         <div
           class="editor-canvas"
-          :style="showExecution ? { flex: 'none', height: `calc(100% - ${executionHeight}px - 2px)` } : showTests ? { flex: 'none', height: `calc(100% - ${testsHeight}px - 2px)` } : {}"
+          :style="
+            showExecution
+              ? { flex: 'none', height: `calc(100% - ${executionHeight}px - 2px)` }
+              : showTests
+                ? { flex: 'none', height: `calc(100% - ${testsHeight}px - 2px)` }
+                : {}
+          "
         >
           <template v-if="projectStore.activeTab">
             <div class="editor-view-shell">
-            <!-- Form mode -->
-            <OrdoFormEditor
-              v-if="editorMode === 'form'"
-              :model-value="projectStore.activeTab.ruleset"
-              :disabled="!canEdit"
-              :input-schema="catalogStore.schemaFields.length ? catalogStore.schemaFields : undefined"
-              @update:model-value="handleRulesetChange"
-            />
-            <!-- Flow mode -->
-            <OrdoFlowEditor
-              v-else-if="editorMode === 'flow'"
-              :model-value="projectStore.activeTab.ruleset"
-              :disabled="!canEdit"
-              :execution-trace="executionTrace"
-              :trace-mode="flowTraceMode"
-              @update:model-value="handleRulesetChange"
-            />
-            <!-- Decision table mode -->
-            <OrdoDecisionTable
-              v-else-if="editorMode === 'table' && activeDecisionTable"
-              :model-value="activeDecisionTable"
-              :disabled="!canEdit"
-              @update:model-value="handleTableChange"
-              @show-as-flow="handleShowAsFlow"
-            />
+              <!-- Form mode -->
+              <OrdoFormEditor
+                v-if="editorMode === 'form'"
+                :model-value="projectStore.activeTab.ruleset"
+                :disabled="!canEdit"
+                :input-schema="
+                  catalogStore.schemaFields.length ? catalogStore.schemaFields : undefined
+                "
+                @update:model-value="handleRulesetChange"
+              />
+              <!-- Flow mode -->
+              <OrdoFlowEditor
+                v-else-if="editorMode === 'flow'"
+                :model-value="projectStore.activeTab.ruleset"
+                :disabled="!canEdit"
+                :execution-trace="executionTrace"
+                :trace-mode="flowTraceMode"
+                @update:model-value="handleRulesetChange"
+              />
+              <!-- Decision table mode -->
+              <OrdoDecisionTable
+                v-else-if="editorMode === 'table' && activeDecisionTable"
+                :model-value="activeDecisionTable"
+                :disabled="!canEdit"
+                @update:model-value="handleTableChange"
+                @show-as-flow="handleShowAsFlow"
+              />
             </div>
           </template>
         </div>
@@ -1246,7 +1311,9 @@ onUnmounted(() => {
       <div
         v-if="projectStore.activeTab && showHistoryPanel"
         class="history-panel-wrap"
-        :style="{ bottom: (showExecution ? executionHeight : showTests ? testsHeight : 0) + 20 + 'px' }"
+        :style="{
+          bottom: (showExecution ? executionHeight : showTests ? testsHeight : 0) + 20 + 'px',
+        }"
       >
         <ChangeHistoryPanel
           :entries="activeHistoryEntries"
@@ -1703,7 +1770,9 @@ onUnmounted(() => {
   display: flex;
   align-items: center;
   justify-content: center;
-  transition: background 0.1s, color 0.1s;
+  transition:
+    background 0.1s,
+    color 0.1s;
 }
 
 .mode-btn:hover {
@@ -1734,7 +1803,9 @@ onUnmounted(() => {
   display: flex;
   align-items: center;
   justify-content: center;
-  transition: background 0.1s, color 0.1s;
+  transition:
+    background 0.1s,
+    color 0.1s;
 }
 
 .toolbar-btn:hover {
diff --git a/ordo-editor/apps/studio/src/views/editor/TestCasePanel.vue b/ordo-editor/apps/studio/src/views/editor/TestCasePanel.vue
index 1cebec69..5138be9c 100644
--- a/ordo-editor/apps/studio/src/views/editor/TestCasePanel.vue
+++ b/ordo-editor/apps/studio/src/views/editor/TestCasePanel.vue
@@ -1,42 +1,42 @@
 <script setup lang="ts">
-import { ref, computed, watch } from 'vue'
-import { useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import { useTestStore } from '@/stores/test'
-import { useCatalogStore } from '@/stores/catalog'
-import { useAuthStore } from '@/stores/auth'
-import type { TestCase, TestCaseInput, TestRunResult } from '@/api/types'
+import { ref, computed, watch } from 'vue';
+import { useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import { useTestStore } from '@/stores/test';
+import { useCatalogStore } from '@/stores/catalog';
+import { useAuthStore } from '@/stores/auth';
+import type { TestCase, TestCaseInput, TestRunResult } from '@/api/types';
 
 const props = defineProps<{
-  projectId: string
-  rulesetName: string
-  visible: boolean
-  height: number
-}>()
+  projectId: string;
+  rulesetName: string;
+  visible: boolean;
+  height: number;
+}>();
 
 const emit = defineEmits<{
-  (e: 'update:visible', v: boolean): void
-  (e: 'update:height', v: number): void
-}>()
+  (e: 'update:visible', v: boolean): void;
+  (e: 'update:height', v: number): void;
+}>();
 
-const { t } = useI18n()
-const route = useRoute()
-const testStore = useTestStore()
-const catalog = useCatalogStore()
-const auth = useAuthStore()
-const orgId = computed(() => route.params.orgId as string)
+const { t } = useI18n();
+const route = useRoute();
+const testStore = useTestStore();
+const catalog = useCatalogStore();
+const auth = useAuthStore();
+const orgId = computed(() => route.params.orgId as string);
 
 // ── State ────────────────────────────────────────────────────────────────────
 
-const expandedId = ref<string | null>(null)
-const editingId = ref<string | null>(null)
-const showEditor = ref(false)
-const form = ref<TestCaseInput>(emptyForm())
-const inputJson = ref('{}')
-const expectOutputJson = ref('')
-const saving = ref(false)
-const jsonError = ref('')
+const expandedId = ref<string | null>(null);
+const editingId = ref<string | null>(null);
+const showEditor = ref(false);
+const form = ref<TestCaseInput>(emptyForm());
+const inputJson = ref('{}');
+const expectOutputJson = ref('');
+const saving = ref(false);
+const jsonError = ref('');
 
 function emptyForm(): TestCaseInput {
   return {
@@ -45,25 +45,25 @@ function emptyForm(): TestCaseInput {
     input: {},
     expect: { code: undefined, message: undefined, output: undefined },
     tags: [],
-  }
+  };
 }
 
-const tests = computed(() => testStore.testsByRuleset.get(props.rulesetName) ?? [])
-const results = computed(() => testStore.runResults.get(props.rulesetName) ?? [])
-const running = computed(() => testStore.running)
-const runningOne = computed(() => testStore.runningOne)
-const loading = computed(() => testStore.loadingRuleset.get(props.rulesetName) ?? false)
+const tests = computed(() => testStore.testsByRuleset.get(props.rulesetName) ?? []);
+const results = computed(() => testStore.runResults.get(props.rulesetName) ?? []);
+const running = computed(() => testStore.running);
+const runningOne = computed(() => testStore.runningOne);
+const loading = computed(() => testStore.loadingRuleset.get(props.rulesetName) ?? false);
 
-const passCount = computed(() => results.value.filter((r) => r.passed).length)
-const failCount = computed(() => results.value.filter((r) => !r.passed).length)
-const hasResults = computed(() => results.value.length > 0)
+const passCount = computed(() => results.value.filter((r) => r.passed).length);
+const failCount = computed(() => results.value.filter((r) => !r.passed).length);
+const hasResults = computed(() => results.value.length > 0);
 
 function resultFor(id: string): TestRunResult | undefined {
-  return results.value.find((r) => r.test_id === id)
+  return results.value.find((r) => r.test_id === id);
 }
 
 function toggleExpand(id: string) {
-  expandedId.value = expandedId.value === id ? null : id
+  expandedId.value = expandedId.value === id ? null : id;
 }
 
 // ── Load tests ────────────────────────────────────────────────────────────────
@@ -71,125 +71,138 @@ function toggleExpand(id: string) {
 watch(
   () => [props.projectId, props.rulesetName],
   ([pid, name]) => {
-    if (pid && name) testStore.fetchTests(pid as string, name as string)
+    if (pid && name) testStore.fetchTests(pid as string, name as string);
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 // ── Resize ────────────────────────────────────────────────────────────────────
 
-let dragStartY = 0
-let dragStartH = 0
+let dragStartY = 0;
+let dragStartH = 0;
 
 function onResizeMousedown(e: MouseEvent) {
-  dragStartY = e.clientY
-  dragStartH = props.height
-  window.addEventListener('mousemove', onResizeMousemove)
-  window.addEventListener('mouseup', onResizeMouseup)
+  dragStartY = e.clientY;
+  dragStartH = props.height;
+  window.addEventListener('mousemove', onResizeMousemove);
+  window.addEventListener('mouseup', onResizeMouseup);
 }
 function onResizeMousemove(e: MouseEvent) {
-  emit('update:height', Math.max(200, Math.min(640, dragStartH + dragStartY - e.clientY)))
+  emit('update:height', Math.max(200, Math.min(640, dragStartH + dragStartY - e.clientY)));
 }
 function onResizeMouseup() {
-  window.removeEventListener('mousemove', onResizeMousemove)
-  window.removeEventListener('mouseup', onResizeMouseup)
+  window.removeEventListener('mousemove', onResizeMousemove);
+  window.removeEventListener('mouseup', onResizeMouseup);
 }
 
 // ── Actions ───────────────────────────────────────────────────────────────────
 
 async function runAll() {
   try {
-    await testStore.runTests(orgId.value, props.projectId, props.rulesetName)
-    MessagePlugin.success(t('test.runSuccess'))
+    await testStore.runTests(orgId.value, props.projectId, props.rulesetName);
+    MessagePlugin.success(t('test.runSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('test.saveFailed'))
+    MessagePlugin.error(e?.message ?? t('test.saveFailed'));
   }
 }
 
 async function runOne(tc: TestCase) {
   try {
-    await testStore.runOneTest(orgId.value, props.projectId, props.rulesetName, tc.id)
+    await testStore.runOneTest(orgId.value, props.projectId, props.rulesetName, tc.id);
     // Auto-expand to show result
-    expandedId.value = tc.id
+    expandedId.value = tc.id;
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('test.saveFailed'))
+    MessagePlugin.error(e?.message ?? t('test.saveFailed'));
   }
 }
 
 function doExport(format: 'yaml' | 'json') {
-  if (!auth.token) return
-  const url = `/api/v1/projects/${props.projectId}/rulesets/${encodeURIComponent(props.rulesetName)}/tests/export?format=${format}`
+  if (!auth.token) return;
+  const url = `/api/v1/projects/${props.projectId}/rulesets/${encodeURIComponent(
+    props.rulesetName
+  )}/tests/export?format=${format}`;
   fetch(url, { headers: { Authorization: `Bearer ${auth.token}` } })
     .then((r) => r.blob())
     .then((blob) => {
-      const a = document.createElement('a')
-      a.href = URL.createObjectURL(blob)
-      a.download = `${props.rulesetName}_tests.${format}`
-      a.click()
-      URL.revokeObjectURL(a.href)
-    })
+      const a = document.createElement('a');
+      a.href = URL.createObjectURL(blob);
+      a.download = `${props.rulesetName}_tests.${format}`;
+      a.click();
+      URL.revokeObjectURL(a.href);
+    });
 }
 
 // ── CRUD ─────────────────────────────────────────────────────────────────────
 
 function openCreate() {
-  editingId.value = null
-  form.value = emptyForm()
-  inputJson.value = '{}'
-  expectOutputJson.value = ''
-  jsonError.value = ''
-  showEditor.value = true
-  expandedId.value = null
+  editingId.value = null;
+  form.value = emptyForm();
+  inputJson.value = '{}';
+  expectOutputJson.value = '';
+  jsonError.value = '';
+  showEditor.value = true;
+  expandedId.value = null;
 }
 
 function openEdit(tc: TestCase) {
-  editingId.value = tc.id
+  editingId.value = tc.id;
   form.value = {
     name: tc.name,
     description: tc.description,
     input: tc.input,
     expect: { ...tc.expect },
     tags: [...tc.tags],
-  }
-  inputJson.value = JSON.stringify(tc.input, null, 2)
-  expectOutputJson.value = tc.expect.output ? JSON.stringify(tc.expect.output, null, 2) : ''
-  jsonError.value = ''
-  showEditor.value = true
+  };
+  inputJson.value = JSON.stringify(tc.input, null, 2);
+  expectOutputJson.value = tc.expect.output ? JSON.stringify(tc.expect.output, null, 2) : '';
+  jsonError.value = '';
+  showEditor.value = true;
 }
 
 function cancelEdit() {
-  showEditor.value = false
+  showEditor.value = false;
 }
 
 async function saveTest() {
-  jsonError.value = ''
-  const name = form.value.name.trim()
-  if (!name) { MessagePlugin.warning(t('test.nameRequired')); return }
+  jsonError.value = '';
+  const name = form.value.name.trim();
+  if (!name) {
+    MessagePlugin.warning(t('test.nameRequired'));
+    return;
+  }
 
-  try { form.value.input = JSON.parse(inputJson.value || '{}') }
-  catch { jsonError.value = 'input'; return }
+  try {
+    form.value.input = JSON.parse(inputJson.value || '{}');
+  } catch {
+    jsonError.value = 'input';
+    return;
+  }
 
   if (expectOutputJson.value.trim()) {
-    try { form.value.expect.output = JSON.parse(expectOutputJson.value) }
-    catch { jsonError.value = 'output'; return }
+    try {
+      form.value.expect.output = JSON.parse(expectOutputJson.value);
+    } catch {
+      jsonError.value = 'output';
+      return;
+    }
   } else {
-    form.value.expect.output = undefined
+    form.value.expect.output = undefined;
   }
 
-  saving.value = true
+  saving.value = true;
   try {
     if (editingId.value) {
-      await testStore.updateTest(props.projectId, props.rulesetName, editingId.value, form.value)
-      MessagePlugin.success(t('test.updateSuccess'))
+      await testStore.updateTest(props.projectId, props.rulesetName, editingId.value, form.value);
+      MessagePlugin.success(t('test.updateSuccess'));
     } else {
-      await testStore.createTest(props.projectId, props.rulesetName, form.value)
-      MessagePlugin.success(t('test.createSuccess'))
+      await testStore.createTest(props.projectId, props.rulesetName, form.value);
+      MessagePlugin.success(t('test.createSuccess'));
     }
-    showEditor.value = false
+    showEditor.value = false;
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('test.saveFailed'))
+    MessagePlugin.error(e?.message ?? t('test.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
@@ -201,41 +214,52 @@ async function deleteTest(tc: TestCase) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await testStore.deleteTest(props.projectId, props.rulesetName, tc.id)
-        if (expandedId.value === tc.id) expandedId.value = null
-        MessagePlugin.success(t('test.deleteSuccess'))
+        await testStore.deleteTest(props.projectId, props.rulesetName, tc.id);
+        if (expandedId.value === tc.id) expandedId.value = null;
+        MessagePlugin.success(t('test.deleteSuccess'));
       } catch (e: any) {
-        MessagePlugin.error(e?.message ?? t('common.saveFailed'))
-      } finally { dialog.hide() }
+        MessagePlugin.error(e?.message ?? t('common.saveFailed'));
+      } finally {
+        dialog.hide();
+      }
     },
     onClose: () => dialog.hide(),
-  })
+  });
 }
 
 function generateFromContract() {
-  const contract = catalog.contracts.find((c) => c.ruleset_name === props.rulesetName)
-  if (!contract) return
-  const skeleton: Record<string, unknown> = {}
+  const contract = catalog.contracts.find((c) => c.ruleset_name === props.rulesetName);
+  if (!contract) return;
+  const skeleton: Record<string, unknown> = {};
   for (const field of contract.input_fields) {
     switch (field.data_type) {
-      case 'number': skeleton[field.name] = 0; break
-      case 'boolean': skeleton[field.name] = false; break
-      case 'date': skeleton[field.name] = new Date().toISOString().slice(0, 10); break
-      case 'object': skeleton[field.name] = {}; break
-      default: skeleton[field.name] = ''
+      case 'number':
+        skeleton[field.name] = 0;
+        break;
+      case 'boolean':
+        skeleton[field.name] = false;
+        break;
+      case 'date':
+        skeleton[field.name] = new Date().toISOString().slice(0, 10);
+        break;
+      case 'object':
+        skeleton[field.name] = {};
+        break;
+      default:
+        skeleton[field.name] = '';
     }
   }
-  inputJson.value = JSON.stringify(skeleton, null, 2)
+  inputJson.value = JSON.stringify(skeleton, null, 2);
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function fmtJson(v: unknown): string {
-  return JSON.stringify(v, null, 2)
+  return JSON.stringify(v, null, 2);
 }
 
 function durationMs(us: number): string {
-  return (us / 1000).toFixed(1) + 'ms'
+  return (us / 1000).toFixed(1) + 'ms';
 }
 </script>
 
@@ -261,8 +285,13 @@ function durationMs(us: number): string {
         <t-button size="small" variant="outline" @click="openCreate" :disabled="!rulesetName">
           <t-icon name="add" size="12px" />{{ t('test.newCase') }}
         </t-button>
-        <t-button size="small" variant="outline" :loading="running"
-          :disabled="!rulesetName || tests.length === 0" @click="runAll">
+        <t-button
+          size="small"
+          variant="outline"
+          :loading="running"
+          :disabled="!rulesetName || tests.length === 0"
+          @click="runAll"
+        >
           <t-icon name="play-circle" size="12px" />{{ t('test.runAll') }}
         </t-button>
         <t-dropdown trigger="click">
@@ -271,8 +300,12 @@ function durationMs(us: number): string {
           </t-button>
           <template #dropdown>
             <t-dropdown-menu>
-              <t-dropdown-item @click="doExport('yaml')">{{ t('test.export.yaml') }}</t-dropdown-item>
-              <t-dropdown-item @click="doExport('json')">{{ t('test.export.json') }}</t-dropdown-item>
+              <t-dropdown-item @click="doExport('yaml')">{{
+                t('test.export.yaml')
+              }}</t-dropdown-item>
+              <t-dropdown-item @click="doExport('json')">{{
+                t('test.export.json')
+              }}</t-dropdown-item>
             </t-dropdown-menu>
           </template>
         </t-dropdown>
@@ -285,7 +318,7 @@ function durationMs(us: number): string {
 
     <!-- No ruleset -->
     <div v-if="!rulesetName" class="panel-empty">
-      <t-icon name="task-checked" size="32px" style="opacity:0.25" />
+      <t-icon name="task-checked" size="32px" style="opacity: 0.25" />
       <p>{{ t('test.panel.noRuleset') }}</p>
     </div>
 
@@ -293,22 +326,26 @@ function durationMs(us: number): string {
     <div v-else class="test-panel__body">
       <!-- Test list -->
       <div class="test-list" :class="{ 'test-list--narrow': showEditor }">
-
         <div v-if="loading" class="panel-loading"><t-loading size="small" /></div>
 
         <div v-else-if="tests.length === 0" class="panel-empty-small">
           <span>{{ t('test.noTests') }}</span>
-          <t-button size="small" variant="text" @click="openCreate">{{ t('test.addFirst') }}</t-button>
+          <t-button size="small" variant="text" @click="openCreate">{{
+            t('test.addFirst')
+          }}</t-button>
         </div>
 
         <template v-else>
-          <div v-for="tc in tests" :key="tc.id" class="test-item"
+          <div
+            v-for="tc in tests"
+            :key="tc.id"
+            class="test-item"
             :class="{
               'test-item--pass': resultFor(tc.id)?.passed === true,
               'test-item--fail': resultFor(tc.id)?.passed === false,
               'test-item--expanded': expandedId === tc.id,
-            }">
-
+            }"
+          >
             <!-- Row summary (always visible) -->
             <div class="test-item__row" @click="toggleExpand(tc.id)">
               <span class="status-icon">
@@ -330,9 +367,12 @@ function durationMs(us: number): string {
               </span>
 
               <div class="test-item__btns" @click.stop>
-                <t-button size="small" variant="text"
+                <t-button
+                  size="small"
+                  variant="text"
                   :loading="runningOne.has(tc.id)"
-                  @click="runOne(tc)">
+                  @click="runOne(tc)"
+                >
                   <t-icon name="play-circle" size="12px" />
                 </t-button>
                 <t-button size="small" variant="text" @click="openEdit(tc)">
@@ -343,13 +383,15 @@ function durationMs(us: number): string {
                 </t-button>
               </div>
 
-              <t-icon :name="expandedId === tc.id ? 'chevron-up' : 'chevron-down'"
-                size="12px" class="expand-chevron" />
+              <t-icon
+                :name="expandedId === tc.id ? 'chevron-up' : 'chevron-down'"
+                size="12px"
+                class="expand-chevron"
+              />
             </div>
 
             <!-- Expanded detail -->
             <div v-if="expandedId === tc.id" class="test-item__detail">
-
               <!-- Input -->
               <div class="detail-section">
                 <div class="detail-label">{{ t('test.fieldInput') }}</div>
@@ -360,21 +402,27 @@ function durationMs(us: number): string {
               <div class="detail-section">
                 <div class="detail-label">{{ t('test.fieldExpectCode') }}</div>
                 <div class="expect-row">
-                  <span class="expect-pill">code: <strong>{{ tc.expect.code ?? '—' }}</strong></span>
+                  <span class="expect-pill"
+                    >code: <strong>{{ tc.expect.code ?? '—' }}</strong></span
+                  >
                   <span v-if="tc.expect.message" class="expect-pill">
                     message: <strong>{{ tc.expect.message }}</strong>
                   </span>
                 </div>
-                <div v-if="tc.expect.output" class="detail-label" style="margin-top:6px">
+                <div v-if="tc.expect.output" class="detail-label" style="margin-top: 6px">
                   {{ t('test.fieldExpectOutput') }}
                 </div>
-                <pre v-if="tc.expect.output" class="detail-code">{{ fmtJson(tc.expect.output) }}</pre>
+                <pre v-if="tc.expect.output" class="detail-code">{{
+                  fmtJson(tc.expect.output)
+                }}</pre>
               </div>
 
               <!-- Result (if run) -->
               <template v-if="resultFor(tc.id)">
-                <div class="detail-section detail-section--result"
-                  :class="resultFor(tc.id)!.passed ? 'result--pass' : 'result--fail'">
+                <div
+                  class="detail-section detail-section--result"
+                  :class="resultFor(tc.id)!.passed ? 'result--pass' : 'result--fail'"
+                >
                   <div class="detail-label">
                     {{ resultFor(tc.id)!.passed ? t('test.result.pass') : t('test.result.fail') }}
                   </div>
@@ -392,7 +440,11 @@ function durationMs(us: number): string {
                       code: <strong>{{ resultFor(tc.id)!.actual_code }}</strong>
                     </span>
                   </div>
-                  <pre v-if="resultFor(tc.id)!.actual_output" class="detail-code detail-code--actual">{{ fmtJson(resultFor(tc.id)!.actual_output) }}</pre>
+                  <pre
+                    v-if="resultFor(tc.id)!.actual_output"
+                    class="detail-code detail-code--actual"
+                    >{{ fmtJson(resultFor(tc.id)!.actual_output) }}</pre
+                  >
                 </div>
               </template>
             </div>
@@ -418,8 +470,11 @@ function durationMs(us: number): string {
               <label class="form-label">{{ t('test.fieldInput') }}</label>
               <t-button
                 v-if="catalog.contracts.some((c) => c.ruleset_name === rulesetName)"
-                size="small" variant="text" style="font-size:11px;padding:0"
-                @click="generateFromContract">
+                size="small"
+                variant="text"
+                style="font-size: 11px; padding: 0"
+                @click="generateFromContract"
+              >
                 {{ t('test.generateFromContract') }}
               </t-button>
             </div>
@@ -441,8 +496,13 @@ function durationMs(us: number): string {
           <div class="form-row">
             <label class="form-label">{{ t('test.fieldExpectOutput') }}</label>
             <div class="json-wrap" :class="{ 'has-error': jsonError === 'output' }">
-              <textarea v-model="expectOutputJson" class="json-editor" rows="3"
-                spellcheck="false" placeholder='{"coupon_type":"vip"}' />
+              <textarea
+                v-model="expectOutputJson"
+                class="json-editor"
+                rows="3"
+                spellcheck="false"
+                placeholder='{"coupon_type":"vip"}'
+              />
             </div>
           </div>
 
@@ -452,8 +512,12 @@ function durationMs(us: number): string {
           </div>
 
           <div class="form-actions">
-            <t-button size="small" variant="outline" @click="cancelEdit">{{ t('common.cancel') }}</t-button>
-            <t-button size="small" theme="primary" :loading="saving" @click="saveTest">{{ t('common.save') }}</t-button>
+            <t-button size="small" variant="outline" @click="cancelEdit">{{
+              t('common.cancel')
+            }}</t-button>
+            <t-button size="small" theme="primary" :loading="saving" @click="saveTest">{{
+              t('common.save')
+            }}</t-button>
           </div>
         </div>
       </div>
@@ -475,7 +539,10 @@ function durationMs(us: number): string {
   cursor: ns-resize;
   flex-shrink: 0;
 }
-.test-panel__handle:hover { background: var(--ordo-accent); opacity: 0.35; }
+.test-panel__handle:hover {
+  background: var(--ordo-accent);
+  opacity: 0.35;
+}
 
 /* ── Header ── */
 .test-panel__header {
@@ -510,7 +577,10 @@ function durationMs(us: number): string {
   white-space: nowrap;
 }
 
-.summary-badges { display: flex; gap: 4px; }
+.summary-badges {
+  display: flex;
+  gap: 4px;
+}
 
 .badge {
   font-size: 11px;
@@ -519,10 +589,20 @@ function durationMs(us: number): string {
   background: var(--ordo-hover-bg);
   color: var(--ordo-text-tertiary);
 }
-.badge--pass { background: rgba(34,197,94,.12); color: #16a34a; }
-.badge--fail { background: rgba(239,68,68,.12); color: #dc2626; }
+.badge--pass {
+  background: rgba(34, 197, 94, 0.12);
+  color: #16a34a;
+}
+.badge--fail {
+  background: rgba(239, 68, 68, 0.12);
+  color: #dc2626;
+}
 
-.test-panel__actions { display: flex; gap: 4px; margin-left: auto; }
+.test-panel__actions {
+  display: flex;
+  gap: 4px;
+  margin-left: auto;
+}
 
 .close-btn {
   background: none;
@@ -533,7 +613,9 @@ function durationMs(us: number): string {
   display: flex;
   align-items: center;
 }
-.close-btn:hover { color: var(--ordo-text-primary); }
+.close-btn:hover {
+  color: var(--ordo-text-primary);
+}
 
 /* ── Body layout ── */
 .test-panel__body {
@@ -582,8 +664,12 @@ function durationMs(us: number): string {
   border-left: 2px solid transparent;
   transition: border-color 0.1s;
 }
-.test-item--pass { border-left-color: #22c55e; }
-.test-item--fail { border-left-color: #ef4444; }
+.test-item--pass {
+  border-left-color: #22c55e;
+}
+.test-item--fail {
+  border-left-color: #ef4444;
+}
 
 .test-item__row {
   display: flex;
@@ -595,10 +681,17 @@ function durationMs(us: number): string {
   transition: background 0.1s;
   user-select: none;
 }
-.test-item__row:hover { background: var(--ordo-hover-bg); }
-.test-item--expanded .test-item__row { background: var(--ordo-hover-bg); }
+.test-item__row:hover {
+  background: var(--ordo-hover-bg);
+}
+.test-item--expanded .test-item__row {
+  background: var(--ordo-hover-bg);
+}
 
-.status-icon { width: 16px; flex-shrink: 0; }
+.status-icon {
+  width: 16px;
+  flex-shrink: 0;
+}
 
 .dot {
   display: inline-flex;
@@ -610,9 +703,18 @@ function durationMs(us: number): string {
   font-size: 9px;
   font-weight: bold;
 }
-.dot--pending { background: var(--ordo-hover-bg); border: 1px solid var(--ordo-border-color); }
-.dot--pass { background: rgba(34,197,94,.15); color: #16a34a; }
-.dot--fail { background: rgba(239,68,68,.15); color: #dc2626; }
+.dot--pending {
+  background: var(--ordo-hover-bg);
+  border: 1px solid var(--ordo-border-color);
+}
+.dot--pass {
+  background: rgba(34, 197, 94, 0.15);
+  color: #16a34a;
+}
+.dot--fail {
+  background: rgba(239, 68, 68, 0.15);
+  color: #dc2626;
+}
 
 .test-item__info {
   flex: 1;
@@ -628,7 +730,11 @@ function durationMs(us: number): string {
   text-overflow: ellipsis;
   white-space: nowrap;
 }
-.test-item__tags { display: flex; gap: 3px; flex-shrink: 0; }
+.test-item__tags {
+  display: flex;
+  gap: 3px;
+  flex-shrink: 0;
+}
 .tag {
   background: var(--ordo-hover-bg);
   border-radius: 3px;
@@ -659,15 +765,23 @@ function durationMs(us: number): string {
   gap: 10px;
 }
 
-.detail-section { display: flex; flex-direction: column; gap: 4px; }
+.detail-section {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
 
 .detail-section--result {
   border-radius: 5px;
   padding: 8px 10px;
   background: var(--ordo-bg-main, var(--ordo-hover-bg));
 }
-.result--pass { border: 1px solid rgba(34,197,94,.3); }
-.result--fail { border: 1px solid rgba(239,68,68,.25); }
+.result--pass {
+  border: 1px solid rgba(34, 197, 94, 0.3);
+}
+.result--fail {
+  border: 1px solid rgba(239, 68, 68, 0.25);
+}
 
 .detail-label {
   font-size: 10px;
@@ -683,20 +797,24 @@ function durationMs(us: number): string {
   font-family: 'JetBrains Mono', monospace;
   font-size: 11px;
   color: var(--ordo-text-primary);
-  background: var(--ordo-bg-deep, rgba(0,0,0,.06));
+  background: var(--ordo-bg-deep, rgba(0, 0, 0, 0.06));
   border-radius: 4px;
   white-space: pre-wrap;
   word-break: break-all;
   line-height: 1.5;
 }
 .detail-code--actual {
-  background: rgba(239,68,68,.05);
-  border: 1px solid rgba(239,68,68,.15);
+  background: rgba(239, 68, 68, 0.05);
+  border: 1px solid rgba(239, 68, 68, 0.15);
 }
 
-.expect-row { display: flex; gap: 6px; flex-wrap: wrap; }
+.expect-row {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
 .expect-pill {
-  background: rgba(99,102,241,.1);
+  background: rgba(99, 102, 241, 0.1);
   border-radius: 4px;
   padding: 2px 7px;
   font-size: 11px;
@@ -704,11 +822,16 @@ function durationMs(us: number): string {
   color: var(--ordo-text-secondary);
 }
 .expect-pill--actual {
-  background: rgba(239,68,68,.1);
+  background: rgba(239, 68, 68, 0.1);
   color: #dc2626;
 }
 
-.failures { display: flex; flex-direction: column; gap: 3px; margin: 4px 0; }
+.failures {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  margin: 4px 0;
+}
 .failure-line {
   display: flex;
   align-items: flex-start;
@@ -717,9 +840,15 @@ function durationMs(us: number): string {
   color: #ef4444;
   line-height: 1.4;
 }
-.failure-icon { flex-shrink: 0; margin-top: 1px; color: #ef4444; }
+.failure-icon {
+  flex-shrink: 0;
+  margin-top: 1px;
+  color: #ef4444;
+}
 
-.actual-row { margin-top: 6px; }
+.actual-row {
+  margin-top: 6px;
+}
 
 /* ── Editor panel ── */
 .test-editor {
@@ -751,16 +880,30 @@ function durationMs(us: number): string {
   gap: 10px;
 }
 
-.form-row { display: flex; flex-direction: column; gap: 4px; }
-.form-label-row { display: flex; align-items: center; justify-content: space-between; }
-.form-label { font-size: 11px; color: var(--ordo-text-secondary); font-weight: 500; }
+.form-row {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.form-label-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+.form-label {
+  font-size: 11px;
+  color: var(--ordo-text-secondary);
+  font-weight: 500;
+}
 
 .json-wrap {
   border: 1px solid var(--ordo-border-color);
   border-radius: 4px;
   overflow: hidden;
 }
-.json-wrap.has-error { border-color: #ef4444; }
+.json-wrap.has-error {
+  border-color: #ef4444;
+}
 
 .json-editor {
   width: 100%;
diff --git a/ordo-editor/apps/studio/src/views/marketplace/MarketplaceDetailView.vue b/ordo-editor/apps/studio/src/views/marketplace/MarketplaceDetailView.vue
index a866eaa0..5469556f 100644
--- a/ordo-editor/apps/studio/src/views/marketplace/MarketplaceDetailView.vue
+++ b/ordo-editor/apps/studio/src/views/marketplace/MarketplaceDetailView.vue
@@ -7,7 +7,7 @@
 
     <!-- Error -->
     <div v-else-if="error" class="marketplace-detail__error">
-      <t-icon name="close-circle" size="48" style="color:var(--td-error-color)" />
+      <t-icon name="close-circle" size="48" style="color: var(--td-error-color)" />
       <p>{{ error }}</p>
       <t-button @click="router.back()">{{ t('common.back') }}</t-button>
     </div>
@@ -33,7 +33,12 @@
         <div class="marketplace-detail__info">
           <h1 class="marketplace-detail__name">{{ detail.name }}</h1>
           <div class="marketplace-detail__meta">
-            <a :href="detail.github_url" target="_blank" rel="noopener" class="marketplace-detail__repo-link">
+            <a
+              :href="detail.github_url"
+              target="_blank"
+              rel="noopener"
+              class="marketplace-detail__repo-link"
+            >
               <t-icon name="logo-github" size="14" />
               {{ detail.full_name }}
             </a>
@@ -44,10 +49,21 @@
           </div>
           <p class="marketplace-detail__desc">{{ detail.description }}</p>
           <div class="marketplace-detail__tags">
-            <t-tag v-for="tag in detail.tags" :key="tag" size="small" theme="primary" variant="light">
+            <t-tag
+              v-for="tag in detail.tags"
+              :key="tag"
+              size="small"
+              theme="primary"
+              variant="light"
+            >
               {{ tag }}
             </t-tag>
-            <t-tag v-for="topic in (detail.topics || []).slice(0, 6)" :key="topic" size="small" variant="outline">
+            <t-tag
+              v-for="topic in (detail.topics || []).slice(0, 6)"
+              :key="topic"
+              size="small"
+              variant="outline"
+            >
               {{ topic }}
             </t-tag>
           </div>
@@ -120,7 +136,10 @@
           </div>
         </t-tab-panel>
 
-        <t-tab-panel value="tests" :label="`${t('marketplace.tabTests')} (${detail.tests?.length || 0})`">
+        <t-tab-panel
+          value="tests"
+          :label="`${t('marketplace.tabTests')} (${detail.tests?.length || 0})`"
+        >
           <div class="marketplace-detail__section">
             <t-table
               v-if="detail.tests?.length"
@@ -137,13 +156,29 @@
         <t-tab-panel v-if="detail.contract" value="contract" :label="t('marketplace.tabContract')">
           <div class="marketplace-detail__section marketplace-detail__contract">
             <div class="contract-meta">
-              <span><b>{{ t('marketplace.contractOwner') }}:</b> {{ detail.contract.owner }}</span>
-              <span v-if="detail.contract.sla_p99_ms"><b>SLA p99:</b> {{ detail.contract.sla_p99_ms }}ms</span>
+              <span
+                ><b>{{ t('marketplace.contractOwner') }}:</b> {{ detail.contract.owner }}</span
+              >
+              <span v-if="detail.contract.sla_p99_ms"
+                ><b>SLA p99:</b> {{ detail.contract.sla_p99_ms }}ms</span
+              >
             </div>
             <h4>{{ t('marketplace.contractInputs') }}</h4>
-            <t-table :data="detail.contract.input_fields" :columns="contractFieldColumns" size="small" row-key="name" stripe />
+            <t-table
+              :data="detail.contract.input_fields"
+              :columns="contractFieldColumns"
+              size="small"
+              row-key="name"
+              stripe
+            />
             <h4>{{ t('marketplace.contractOutputs') }}</h4>
-            <t-table :data="detail.contract.output_fields" :columns="contractFieldColumns" size="small" row-key="name" stripe />
+            <t-table
+              :data="detail.contract.output_fields"
+              :columns="contractFieldColumns"
+              size="small"
+              row-key="name"
+              stripe
+            />
           </div>
         </t-tab-panel>
       </t-tabs>
@@ -152,47 +187,47 @@
 </template>
 
 <script setup lang="ts">
-import { ref, onMounted, computed } from 'vue'
-import { useRouter, useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { marketplaceApi } from '@/api/platform-client'
-import type { MarketplaceDetail } from '@/api/types'
-
-const { t } = useI18n()
-const router = useRouter()
-const route = useRoute()
-const authStore = useAuthStore()
-const orgStore = useOrgStore()
-
-const owner = route.params.owner as string
-const repo = route.params.repo as string
-
-const detail = ref<MarketplaceDetail | null>(null)
-const loading = ref(true)
-const error = ref<string | null>(null)
-const activeTab = ref('overview')
-
-const selectedOrgId = ref('')
-const projectName = ref('')
-const projectDesc = ref('')
-const installing = ref(false)
+import { ref, onMounted, computed } from 'vue';
+import { useRouter, useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { marketplaceApi } from '@/api/platform-client';
+import type { MarketplaceDetail } from '@/api/types';
+
+const { t } = useI18n();
+const router = useRouter();
+const route = useRoute();
+const authStore = useAuthStore();
+const orgStore = useOrgStore();
+
+const owner = route.params.owner as string;
+const repo = route.params.repo as string;
+
+const detail = ref<MarketplaceDetail | null>(null);
+const loading = ref(true);
+const error = ref<string | null>(null);
+const activeTab = ref('overview');
+
+const selectedOrgId = ref('');
+const projectName = ref('');
+const projectDesc = ref('');
+const installing = ref(false);
 
 const factColumns = [
   { colKey: 'name', title: t('marketplace.colName'), width: 180 },
   { colKey: 'data_type', title: t('marketplace.colType'), width: 100 },
   { colKey: 'source', title: t('marketplace.colSource') },
   { colKey: 'description', title: t('marketplace.colDescription') },
-]
+];
 
 const conceptColumns = [
   { colKey: 'name', title: t('marketplace.colName'), width: 180 },
   { colKey: 'data_type', title: t('marketplace.colType'), width: 100 },
   { colKey: 'expression', title: t('marketplace.colExpression') },
   { colKey: 'description', title: t('marketplace.colDescription') },
-]
+];
 
 const testColumns = [
   { colKey: 'name', title: t('marketplace.colName') },
@@ -202,54 +237,54 @@ const testColumns = [
     title: t('marketplace.colTags'),
     cell: (_: any, { row }: any) => (row.tags || []).join(', '),
   },
-]
+];
 
 const contractFieldColumns = [
   { colKey: 'name', title: t('marketplace.colName'), width: 180 },
   { colKey: 'data_type', title: t('marketplace.colType'), width: 100 },
   { colKey: 'required', title: t('marketplace.colRequired'), width: 80 },
   { colKey: 'description', title: t('marketplace.colDescription') },
-]
+];
 
 async function loadDetail() {
-  loading.value = true
-  error.value = null
+  loading.value = true;
+  error.value = null;
   try {
-    detail.value = await marketplaceApi.getItem(authStore.token!, owner, repo)
-    projectName.value = detail.value.name || repo
+    detail.value = await marketplaceApi.getItem(authStore.token!, owner, repo);
+    projectName.value = detail.value.name || repo;
   } catch (e: any) {
-    error.value = e.message || t('marketplace.loadError')
+    error.value = e.message || t('marketplace.loadError');
   } finally {
-    loading.value = false
+    loading.value = false;
   }
 }
 
 async function handleInstall() {
-  if (!selectedOrgId.value || !projectName.value.trim()) return
-  installing.value = true
+  if (!selectedOrgId.value || !projectName.value.trim()) return;
+  installing.value = true;
   try {
     const project = await marketplaceApi.install(authStore.token!, owner, repo, {
       org_id: selectedOrgId.value,
       project_name: projectName.value.trim(),
       project_description: projectDesc.value.trim() || undefined,
-    })
-    MessagePlugin.success(t('marketplace.installSuccess', { name: project.name }))
+    });
+    MessagePlugin.success(t('marketplace.installSuccess', { name: project.name }));
     router.push({
       name: 'project-editor',
       params: { orgId: selectedOrgId.value, projectId: project.id },
-    })
+    });
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('marketplace.installError'))
+    MessagePlugin.error(e.message || t('marketplace.installError'));
   } finally {
-    installing.value = false
+    installing.value = false;
   }
 }
 
 onMounted(async () => {
-  await orgStore.fetchOrgs()
-  if (orgStore.orgs.length) selectedOrgId.value = orgStore.orgs[0].id
-  await loadDetail()
-})
+  await orgStore.fetchOrgs();
+  if (orgStore.orgs.length) selectedOrgId.value = orgStore.orgs[0].id;
+  await loadDetail();
+});
 </script>
 
 <style scoped>
diff --git a/ordo-editor/apps/studio/src/views/marketplace/MarketplaceView.vue b/ordo-editor/apps/studio/src/views/marketplace/MarketplaceView.vue
index b3e456d0..4182191a 100644
--- a/ordo-editor/apps/studio/src/views/marketplace/MarketplaceView.vue
+++ b/ordo-editor/apps/studio/src/views/marketplace/MarketplaceView.vue
@@ -31,7 +31,7 @@
       >
         <template #prefix-icon><t-icon name="search" /></template>
       </t-input>
-      <t-select v-model="sort" style="width:160px" @change="onSearch">
+      <t-select v-model="sort" style="width: 160px" @change="onSearch">
         <t-option value="stars" :label="t('marketplace.sortStars')" />
         <t-option value="updated" :label="t('marketplace.sortUpdated')" />
       </t-select>
@@ -39,12 +39,17 @@
 
     <!-- Loading skeleton -->
     <div v-if="loading" class="marketplace-grid">
-      <t-skeleton v-for="i in 8" :key="i" class="marketplace-card-skeleton" :row-col="skeletonRow" />
+      <t-skeleton
+        v-for="i in 8"
+        :key="i"
+        class="marketplace-card-skeleton"
+        :row-col="skeletonRow"
+      />
     </div>
 
     <!-- Empty state -->
     <div v-else-if="!items.length" class="marketplace-placeholder">
-      <t-icon name="map" size="64" style="color:var(--td-text-color-placeholder)" />
+      <t-icon name="map" size="64" style="color: var(--td-text-color-placeholder)" />
       <p>{{ t('marketplace.noResults') }}</p>
     </div>
 
@@ -70,7 +75,12 @@
           <p>{{ item.description || t('marketplace.noDescription') }}</p>
         </div>
         <div class="marketplace-card__footer">
-          <t-tag v-for="topic in item.topics.slice(0, 4)" :key="topic" size="small" variant="outline">
+          <t-tag
+            v-for="topic in item.topics.slice(0, 4)"
+            :key="topic"
+            size="small"
+            variant="outline"
+          >
             {{ topic }}
           </t-tag>
           <span class="marketplace-card__updated">{{ formatDate(item.updated_at) }}</span>
@@ -92,89 +102,89 @@
 </template>
 
 <script setup lang="ts">
-import { ref, onMounted } from 'vue'
-import { useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useGithubStore } from '@/stores/github'
-import { marketplaceApi } from '@/api/platform-client'
-import { useAuthStore } from '@/stores/auth'
-import type { MarketplaceItem } from '@/api/types'
-
-const { t } = useI18n()
-const router = useRouter()
-const authStore = useAuthStore()
-const githubStore = useGithubStore()
-
-const query = ref('')
-const sort = ref<'stars' | 'updated'>('stars')
-const page = ref(1)
-const perPage = 24
-const items = ref<MarketplaceItem[]>([])
-const totalCount = ref(0)
-const loading = ref(false)
-const connecting = ref(false)
-
-const skeletonRow = [{ width: '100%', height: '140px' }]
+import { ref, onMounted } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useGithubStore } from '@/stores/github';
+import { marketplaceApi } from '@/api/platform-client';
+import { useAuthStore } from '@/stores/auth';
+import type { MarketplaceItem } from '@/api/types';
+
+const { t } = useI18n();
+const router = useRouter();
+const authStore = useAuthStore();
+const githubStore = useGithubStore();
+
+const query = ref('');
+const sort = ref<'stars' | 'updated'>('stars');
+const page = ref(1);
+const perPage = 24;
+const items = ref<MarketplaceItem[]>([]);
+const totalCount = ref(0);
+const loading = ref(false);
+const connecting = ref(false);
+
+const skeletonRow = [{ width: '100%', height: '140px' }];
 
 async function fetchItems() {
-  if (!authStore.token) return
-  loading.value = true
+  if (!authStore.token) return;
+  loading.value = true;
   try {
     const resp = await marketplaceApi.search(authStore.token, {
       q: query.value || undefined,
       sort: sort.value,
       page: page.value,
       per_page: perPage,
-    })
-    items.value = resp.items
-    totalCount.value = resp.total_count
+    });
+    items.value = resp.items;
+    totalCount.value = resp.total_count;
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('marketplace.loadError'))
+    MessagePlugin.error(e.message || t('marketplace.loadError'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
 }
 
 function onSearch() {
-  page.value = 1
-  fetchItems()
+  page.value = 1;
+  fetchItems();
 }
 
 function onPageChange(p: number) {
-  page.value = p
-  fetchItems()
+  page.value = p;
+  fetchItems();
 }
 
 function openDetail(item: MarketplaceItem) {
-  const [owner, repo] = item.full_name.split('/')
-  router.push({ name: 'marketplace-detail', params: { owner, repo } })
+  const [owner, repo] = item.full_name.split('/');
+  router.push({ name: 'marketplace-detail', params: { owner, repo } });
 }
 
 function formatDate(iso: string): string {
   try {
-    return new Date(iso).toLocaleDateString()
+    return new Date(iso).toLocaleDateString();
   } catch {
-    return iso
+    return iso;
   }
 }
 
 async function handleConnect() {
-  connecting.value = true
+  connecting.value = true;
   try {
-    await githubStore.connect()
-    fetchItems()
+    await githubStore.connect();
+    fetchItems();
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('marketplace.connectError'))
+    MessagePlugin.error(e.message || t('marketplace.connectError'));
   } finally {
-    connecting.value = false
+    connecting.value = false;
   }
 }
 
 onMounted(async () => {
-  await githubStore.fetchStatus()
-  fetchItems()
-})
+  await githubStore.fetchStatus();
+  fetchItems();
+});
 </script>
 
 <style scoped>
@@ -265,7 +275,9 @@ onMounted(async () => {
   border: 1px solid var(--td-component-border);
   border-radius: var(--td-radius-medium);
   cursor: pointer;
-  transition: box-shadow 0.2s, border-color 0.2s;
+  transition:
+    box-shadow 0.2s,
+    border-color 0.2s;
   display: flex;
   flex-direction: column;
   gap: 10px;
diff --git a/ordo-editor/apps/studio/src/views/notifications/NotificationsView.vue b/ordo-editor/apps/studio/src/views/notifications/NotificationsView.vue
index 72dcd6fe..3e6eba4c 100644
--- a/ordo-editor/apps/studio/src/views/notifications/NotificationsView.vue
+++ b/ordo-editor/apps/studio/src/views/notifications/NotificationsView.vue
@@ -1,74 +1,77 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { usePersistentNotificationStore } from '@/stores/persistentNotifications'
-import { useOrgStore } from '@/stores/org'
+import { computed, onMounted, ref } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { usePersistentNotificationStore } from '@/stores/persistentNotifications';
+import { useOrgStore } from '@/stores/org';
 
-const { t } = useI18n()
-const router = useRouter()
-const orgStore = useOrgStore()
-const store = usePersistentNotificationStore()
+const { t } = useI18n();
+const router = useRouter();
+const orgStore = useOrgStore();
+const store = usePersistentNotificationStore();
 
-const orgId = computed(() => orgStore.currentOrg?.id ?? '')
-const unreadOnly = ref(false)
-const loading = ref(false)
+const orgId = computed(() => orgStore.currentOrg?.id ?? '');
+const unreadOnly = ref(false);
+const loading = ref(false);
 
 onMounted(async () => {
-  if (!orgId.value) return
-  loading.value = true
+  if (!orgId.value) return;
+  loading.value = true;
   try {
-    await store.fetchNotifications(orgId.value, false)
+    await store.fetchNotifications(orgId.value, false);
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 const filtered = computed(() =>
-  unreadOnly.value ? store.notifications.filter((n) => !n.read_at) : store.notifications,
-)
+  unreadOnly.value ? store.notifications.filter((n) => !n.read_at) : store.notifications
+);
 
 function notifIcon(type: string) {
-  if (type === 'release_approved') return 'check-circle'
-  if (type === 'release_rejected') return 'close-circle'
-  if (type === 'release_review_requested') return 'notification'
-  return 'info-circle'
+  if (type === 'release_approved') return 'check-circle';
+  if (type === 'release_rejected') return 'close-circle';
+  if (type === 'release_review_requested') return 'notification';
+  return 'info-circle';
 }
 
 function notifIconClass(type: string) {
-  if (type === 'release_approved') return 'notif-icon--success'
-  if (type === 'release_rejected') return 'notif-icon--error'
-  return 'notif-icon--info'
+  if (type === 'release_approved') return 'notif-icon--success';
+  if (type === 'release_rejected') return 'notif-icon--error';
+  return 'notif-icon--info';
 }
 
 function notifTitle(type: string, payload: Record<string, unknown>) {
-  const releaseTitle = (payload.title as string) ?? ''
-  if (type === 'release_review_requested') return t('notifications.types.releaseReviewRequested', { title: releaseTitle })
-  if (type === 'release_approved') return t('notifications.types.releaseApproved', { title: releaseTitle })
-  if (type === 'release_rejected') return t('notifications.types.releaseRejected', { title: releaseTitle })
-  return type
+  const releaseTitle = (payload.title as string) ?? '';
+  if (type === 'release_review_requested')
+    return t('notifications.types.releaseReviewRequested', { title: releaseTitle });
+  if (type === 'release_approved')
+    return t('notifications.types.releaseApproved', { title: releaseTitle });
+  if (type === 'release_rejected')
+    return t('notifications.types.releaseRejected', { title: releaseTitle });
+  return type;
 }
 
 function formatTime(isoDate: string) {
-  const diff = Date.now() - new Date(isoDate).getTime()
-  if (diff < 60_000) return t('shell.justNow')
-  if (diff < 3_600_000) return t('shell.minutesAgo', { n: Math.floor(diff / 60_000) })
-  if (diff < 86_400_000) return t('shell.hoursAgo', { n: Math.floor(diff / 3_600_000) })
-  return new Date(isoDate).toLocaleDateString()
+  const diff = Date.now() - new Date(isoDate).getTime();
+  if (diff < 60_000) return t('shell.justNow');
+  if (diff < 3_600_000) return t('shell.minutesAgo', { n: Math.floor(diff / 60_000) });
+  if (diff < 86_400_000) return t('shell.hoursAgo', { n: Math.floor(diff / 3_600_000) });
+  return new Date(isoDate).toLocaleDateString();
 }
 
 async function handleMarkAllRead() {
-  await store.markAllRead(orgId.value)
+  await store.markAllRead(orgId.value);
 }
 
 async function handleMarkRead(notifId: string) {
-  await store.markRead(orgId.value, notifId)
+  await store.markRead(orgId.value, notifId);
 }
 
 function navigateToRelease(n: { ref_id?: string; payload: Record<string, unknown> }) {
-  const projectId = n.payload.project_id as string | undefined
+  const projectId = n.payload.project_id as string | undefined;
   if (n.ref_id && projectId && orgId.value) {
-    router.push(`/orgs/${orgId.value}/projects/${projectId}/releases`)
+    router.push(`/orgs/${orgId.value}/projects/${projectId}/releases`);
   }
 }
 </script>
@@ -114,11 +117,7 @@ function navigateToRelease(n: { ref_id?: string; payload: Record<string, unknown
           <div class="notif-row__title">{{ notifTitle(n.type, n.payload) }}</div>
           <div class="notif-row__time">{{ formatTime(n.created_at) }}</div>
         </div>
-        <button
-          v-if="!n.read_at"
-          class="notif-row__mark-read"
-          @click.stop="handleMarkRead(n.id)"
-        >
+        <button v-if="!n.read_at" class="notif-row__mark-read" @click.stop="handleMarkRead(n.id)">
           <t-icon name="check" size="14px" />
         </button>
       </div>
diff --git a/ordo-editor/apps/studio/src/views/org/MembersView.vue b/ordo-editor/apps/studio/src/views/org/MembersView.vue
index 2f552911..a3cf3258 100644
--- a/ordo-editor/apps/studio/src/views/org/MembersView.vue
+++ b/ordo-editor/apps/studio/src/views/org/MembersView.vue
@@ -1,50 +1,50 @@
 <script setup lang="ts">
-import { ref, computed, onMounted } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import type { Role } from '@/api/types'
+import { ref, computed, onMounted } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import type { Role } from '@/api/types';
 
-const route = useRoute()
-const router = useRouter()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const { t, locale } = useI18n()
+const route = useRoute();
+const router = useRouter();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const { t, locale } = useI18n();
 
-const orgId = computed(() => route.params.orgId as string)
+const orgId = computed(() => route.params.orgId as string);
 
-const showInvite = ref(false)
-const inviting = ref(false)
-const inviteEmail = ref('')
-const inviteRole = ref<Role>('editor')
+const showInvite = ref(false);
+const inviting = ref(false);
+const inviteEmail = ref('');
+const inviteRole = ref<Role>('editor');
 
 const isAdmin = computed(() => {
-  if (!auth.user) return false
-  return orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return orgStore.canAdmin(auth.user.id);
+});
 
 const roleOptions = [
   { label: 'Owner', value: 'owner' },
   { label: 'Admin', value: 'admin' },
   { label: 'Editor', value: 'editor' },
   { label: 'Viewer', value: 'viewer' },
-]
+];
 
 const roleLabel: Record<Role, string> = {
   owner: 'Owner',
   admin: 'Admin',
   editor: 'Editor',
   viewer: 'Viewer',
-}
+};
 
 const roleTheme: Record<Role, string> = {
   owner: 'primary',
   admin: 'warning',
   editor: 'success',
   viewer: 'default',
-}
+};
 
 const columns = computed(() => {
   const cols: any[] = [
@@ -52,44 +52,44 @@ const columns = computed(() => {
     { colKey: 'email', title: t('member.colEmail'), minWidth: 200 },
     { colKey: 'role', title: t('member.colRole'), width: 120 },
     { colKey: 'invited_at', title: t('member.colJoinedAt'), width: 160 },
-  ]
+  ];
   if (isAdmin.value) {
-    cols.push({ colKey: 'actions', title: t('member.colActions'), width: 120, fixed: 'right' })
+    cols.push({ colKey: 'actions', title: t('member.colActions'), width: 120, fixed: 'right' });
   }
-  return cols
-})
+  return cols;
+});
 
 onMounted(async () => {
   if (!orgStore.currentOrg || orgStore.currentOrg.id !== orgId.value) {
-    await orgStore.selectOrg(orgId.value)
+    await orgStore.selectOrg(orgId.value);
   }
-})
+});
 
 async function handleInvite() {
   if (!inviteEmail.value.trim()) {
-    MessagePlugin.warning(t('member.emailRequired'))
-    return
+    MessagePlugin.warning(t('member.emailRequired'));
+    return;
   }
-  inviting.value = true
+  inviting.value = true;
   try {
-    await orgStore.inviteMember(orgId.value, inviteEmail.value.trim(), inviteRole.value)
-    showInvite.value = false
-    inviteEmail.value = ''
-    inviteRole.value = 'editor'
-    MessagePlugin.success(t('member.inviteSuccess'))
+    await orgStore.inviteMember(orgId.value, inviteEmail.value.trim(), inviteRole.value);
+    showInvite.value = false;
+    inviteEmail.value = '';
+    inviteRole.value = 'editor';
+    MessagePlugin.success(t('member.inviteSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    inviting.value = false
+    inviting.value = false;
   }
 }
 
 async function handleRoleChange(userId: string, role: Role) {
   try {
-    await orgStore.updateMemberRole(orgId.value, userId, role)
-    MessagePlugin.success(t('member.roleUpdated'))
+    await orgStore.updateMemberRole(orgId.value, userId, role);
+    MessagePlugin.success(t('member.roleUpdated'));
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   }
 }
 
@@ -101,30 +101,37 @@ function handleRemove(userId: string, displayName: string) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await orgStore.removeMember(orgId.value, userId)
-        dlg.hide()
-        MessagePlugin.success(t('member.removeSuccess'))
+        await orgStore.removeMember(orgId.value, userId);
+        dlg.hide();
+        MessagePlugin.success(t('member.removeSuccess'));
       } catch (err: any) {
-        MessagePlugin.error(err.message)
+        MessagePlugin.error(err.message);
       }
     },
-  })
+  });
 }
 
 function formatDate(iso: string) {
-  return new Date(iso).toLocaleDateString(locale.value === 'zh-TW' ? 'zh-TW' : locale.value === 'zh-CN' ? 'zh-CN' : 'en-US', {
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-  })
+  return new Date(iso).toLocaleDateString(
+    locale.value === 'zh-TW' ? 'zh-TW' : locale.value === 'zh-CN' ? 'zh-CN' : 'en-US',
+    {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+    }
+  );
 }
 </script>
 
 <template>
   <div class="view-page">
     <t-breadcrumb class="page-breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push('/orgs')">{{ t('breadcrumb.orgs') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/orgs')">{{
+        t('breadcrumb.orgs')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ orgStore.currentOrg?.name }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('breadcrumb.members') }}</t-breadcrumb-item>
     </t-breadcrumb>
@@ -132,7 +139,12 @@ function formatDate(iso: string) {
       <div>
         <h2 class="page-title">{{ t('member.title') }}</h2>
         <p class="page-subtitle">
-          {{ t('member.subtitle', { org: orgStore.currentOrg?.name ?? '', count: orgStore.members.length }) }}
+          {{
+            t('member.subtitle', {
+              org: orgStore.currentOrg?.name ?? '',
+              count: orgStore.members.length,
+            })
+          }}
         </p>
       </div>
       <t-button v-if="isAdmin" theme="primary" @click="showInvite = true">
@@ -164,7 +176,7 @@ function formatDate(iso: string) {
         <t-select
           v-if="isAdmin && row.user_id !== auth.user?.id && row.role !== 'owner'"
           :value="row.role"
-          :options="roleOptions.filter(o => o.value !== 'owner')"
+          :options="roleOptions.filter((o) => o.value !== 'owner')"
           size="small"
           @change="(v: any) => handleRoleChange(row.user_id, v)"
         />
@@ -210,7 +222,10 @@ function formatDate(iso: string) {
           />
         </t-form-item>
         <t-form-item :label="t('member.roleLabel')">
-          <t-select v-model="inviteRole" :options="roleOptions.filter(o => o.value !== 'owner')" />
+          <t-select
+            v-model="inviteRole"
+            :options="roleOptions.filter((o) => o.value !== 'owner')"
+          />
         </t-form-item>
       </t-form>
     </t-dialog>
diff --git a/ordo-editor/apps/studio/src/views/org/OrgListView.vue b/ordo-editor/apps/studio/src/views/org/OrgListView.vue
index 085a41d8..0d3ec1cf 100644
--- a/ordo-editor/apps/studio/src/views/org/OrgListView.vue
+++ b/ordo-editor/apps/studio/src/views/org/OrgListView.vue
@@ -1,124 +1,124 @@
 <script setup lang="ts">
-import { ref, computed, onMounted } from 'vue'
-import { useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { useSystemStore } from '@/stores/system'
-import { useProjectStore } from '@/stores/project'
-import { MessagePlugin } from 'tdesign-vue-next'
-import type { Role } from '@/api/types'
-
-const router = useRouter()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const systemStore = useSystemStore()
-const projectStore = useProjectStore()
-const { t } = useI18n()
+import { ref, computed, onMounted } from 'vue';
+import { useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { useSystemStore } from '@/stores/system';
+import { useProjectStore } from '@/stores/project';
+import { MessagePlugin } from 'tdesign-vue-next';
+import type { Role } from '@/api/types';
+
+const router = useRouter();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const systemStore = useSystemStore();
+const projectStore = useProjectStore();
+const { t } = useI18n();
 
 // Dialog state
-const showCreate = ref(false)
-const creating = ref(false)
-const newOrgName = ref('')
-const newOrgDesc = ref('')
+const showCreate = ref(false);
+const creating = ref(false);
+const newOrgName = ref('');
+const newOrgDesc = ref('');
 // When set, dialog creates a sub-org under this parent id
-const createParentId = ref<string | null>(null)
+const createParentId = ref<string | null>(null);
 // Optionally designate an admin when creating a sub-org
-const assignAdmin = ref(false)
-const assignAdminUserId = ref('')
-const assignAdminRole = ref<Role>('admin')
+const assignAdmin = ref(false);
+const assignAdminUserId = ref('');
+const assignAdminRole = ref<Role>('admin');
 
-const rootOrgs = computed(() => orgStore.orgs.filter((o) => o.depth === 0))
+const rootOrgs = computed(() => orgStore.orgs.filter((o) => o.depth === 0));
 
 // Exclude current user from "designate admin" dropdown (creator is auto-added as Owner)
 const parentMembersForAssign = computed(() =>
-  orgStore.members.filter((m) => m.user_id !== auth.user?.id),
-)
+  orgStore.members.filter((m) => m.user_id !== auth.user?.id)
+);
 
 function subOrgsOf(parentId: string) {
-  return orgStore.orgs.filter((o) => o.parent_org_id === parentId)
+  return orgStore.orgs.filter((o) => o.parent_org_id === parentId);
 }
 
 function isAdmin(orgId: string): boolean {
-  if (!auth.user) return false
-  const org = orgStore.orgs.find((o) => o.id === orgId)
-  if (!org) return false
+  if (!auth.user) return false;
+  const org = orgStore.orgs.find((o) => o.id === orgId);
+  if (!org) return false;
   // Check via currentOrg members if this is the currently loaded org
   if (orgStore.currentOrg?.id === orgId) {
-    return orgStore.canAdmin(auth.user.id)
+    return orgStore.canAdmin(auth.user.id);
   }
-  return false
+  return false;
 }
 
 onMounted(async () => {
-  await systemStore.fetchConfig()
+  await systemStore.fetchConfig();
   // For each root org the user has loaded, pre-fetch sub-orgs
   for (const org of rootOrgs.value) {
     if (org.child_count > 0) {
-      await orgStore.fetchSubOrgs(org.id)
+      await orgStore.fetchSubOrgs(org.id);
     }
   }
-})
+});
 
 function openCreateRoot() {
-  createParentId.value = null
-  newOrgName.value = ''
-  newOrgDesc.value = ''
-  showCreate.value = true
+  createParentId.value = null;
+  newOrgName.value = '';
+  newOrgDesc.value = '';
+  showCreate.value = true;
 }
 
 function openCreateSubOrg(parentId: string) {
-  createParentId.value = parentId
-  newOrgName.value = ''
-  newOrgDesc.value = ''
-  assignAdmin.value = false
-  assignAdminUserId.value = ''
-  assignAdminRole.value = 'admin'
-  showCreate.value = true
+  createParentId.value = parentId;
+  newOrgName.value = '';
+  newOrgDesc.value = '';
+  assignAdmin.value = false;
+  assignAdminUserId.value = '';
+  assignAdminRole.value = 'admin';
+  showCreate.value = true;
 }
 
 async function handleCreate() {
   if (!newOrgName.value.trim()) {
-    MessagePlugin.warning(t('org.nameRequired'))
-    return
+    MessagePlugin.warning(t('org.nameRequired'));
+    return;
   }
-  creating.value = true
+  creating.value = true;
   try {
     if (createParentId.value) {
       const org = await orgStore.createSubOrg(
         createParentId.value,
         newOrgName.value.trim(),
-        newOrgDesc.value || undefined,
-      )
+        newOrgDesc.value || undefined
+      );
       if (assignAdmin.value && assignAdminUserId.value) {
         try {
           await orgStore.addSubOrgMember(
             createParentId.value,
             org.id,
             assignAdminUserId.value,
-            assignAdminRole.value,
-          )
+            assignAdminRole.value
+          );
         } catch (e: any) {
-          if (!e.message?.toLowerCase().includes('already a member')) throw e
+          if (!e.message?.toLowerCase().includes('already a member')) throw e;
         }
       }
-      MessagePlugin.success(t('org.createSubOrgSuccess'))
+      MessagePlugin.success(t('org.createSubOrgSuccess'));
     } else {
-      await orgStore.createOrg(newOrgName.value.trim(), newOrgDesc.value || undefined)
-      MessagePlugin.success(t('org.createSuccess'))
+      await orgStore.createOrg(newOrgName.value.trim(), newOrgDesc.value || undefined);
+      MessagePlugin.success(t('org.createSuccess'));
     }
-    showCreate.value = false
+    showCreate.value = false;
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    creating.value = false
+    creating.value = false;
   }
 }
 
 async function selectAndGo(orgId: string) {
-  await orgStore.selectOrg(orgId)
-  await projectStore.fetchProjects(orgId)
-  router.push(`/orgs/${orgId}/projects`)
+  await orgStore.selectOrg(orgId);
+  await projectStore.fetchProjects(orgId);
+  router.push(`/orgs/${orgId}/projects`);
 }
 </script>
 
@@ -129,11 +129,7 @@ async function selectAndGo(orgId: string) {
         <h2 class="page-title">{{ t('org.title') }}</h2>
         <p class="page-subtitle">{{ t('org.subtitle') }}</p>
       </div>
-      <t-button
-        v-if="systemStore.allowOrgCreation"
-        theme="primary"
-        @click="openCreateRoot"
-      >
+      <t-button v-if="systemStore.allowOrgCreation" theme="primary" @click="openCreateRoot">
         <t-icon name="add" />
         {{ t('org.new') }}
       </t-button>
@@ -141,8 +137,13 @@ async function selectAndGo(orgId: string) {
 
     <!-- Loading -->
     <div v-if="orgStore.loading" class="org-skeleton-list">
-      <t-skeleton v-for="i in 3" :key="i" theme="paragraph" animation="gradient"
-        :row-col="[{ width: '40%' }, { width: '60%' }, { width: '30%' }]" />
+      <t-skeleton
+        v-for="i in 3"
+        :key="i"
+        theme="paragraph"
+        animation="gradient"
+        :row-col="[{ width: '40%' }, { width: '60%' }, { width: '30%' }]"
+      />
     </div>
 
     <!-- Empty -->
@@ -157,7 +158,6 @@ async function selectAndGo(orgId: string) {
     <!-- Hierarchy list -->
     <div v-else class="org-list">
       <div v-for="root in rootOrgs" :key="root.id" class="org-group">
-
         <!-- Root org card -->
         <div class="org-card org-card--root" @click="selectAndGo(root.id)">
           <div class="org-card__icon org-card__icon--root">
@@ -168,7 +168,9 @@ async function selectAndGo(orgId: string) {
             <div class="org-card__meta">
               {{ t('org.memberCount', { count: root.member_count }) }}
               <span v-if="root.project_count > 0" class="meta-sep">·</span>
-              <span v-if="root.project_count > 0">{{ t('org.projectCount', { count: root.project_count }) }}</span>
+              <span v-if="root.project_count > 0">{{
+                t('org.projectCount', { count: root.project_count })
+              }}</span>
               <span v-if="root.child_count > 0" class="meta-sep">·</span>
               <span v-if="root.child_count > 0">
                 {{ t('org.subOrgCount', { count: root.child_count }) }}
@@ -176,11 +178,7 @@ async function selectAndGo(orgId: string) {
             </div>
           </div>
           <div class="org-card__actions" @click.stop>
-            <t-button
-              size="small"
-              variant="outline"
-              @click="openCreateSubOrg(root.id)"
-            >
+            <t-button size="small" variant="outline" @click="openCreateSubOrg(root.id)">
               <t-icon name="add" />
               {{ t('org.addSubOrg') }}
             </t-button>
@@ -207,13 +205,14 @@ async function selectAndGo(orgId: string) {
               <div class="org-card__meta">
                 {{ t('org.memberCount', { count: sub.member_count }) }}
                 <span v-if="sub.project_count > 0" class="meta-sep">·</span>
-                <span v-if="sub.project_count > 0">{{ t('org.projectCount', { count: sub.project_count }) }}</span>
+                <span v-if="sub.project_count > 0">{{
+                  t('org.projectCount', { count: sub.project_count })
+                }}</span>
               </div>
             </div>
             <t-icon name="chevron-right" class="org-card__arrow" />
           </div>
         </div>
-
       </div>
     </div>
 
@@ -325,7 +324,9 @@ async function selectAndGo(orgId: string) {
   align-items: center;
   gap: 14px;
   cursor: pointer;
-  transition: border-color 0.15s, box-shadow 0.15s;
+  transition:
+    border-color 0.15s,
+    box-shadow 0.15s;
 }
 
 .org-card:hover {
diff --git a/ordo-editor/apps/studio/src/views/org/OrgSettingsView.vue b/ordo-editor/apps/studio/src/views/org/OrgSettingsView.vue
index cf659b16..918b6667 100644
--- a/ordo-editor/apps/studio/src/views/org/OrgSettingsView.vue
+++ b/ordo-editor/apps/studio/src/views/org/OrgSettingsView.vue
@@ -1,110 +1,108 @@
 <script setup lang="ts">
-import { ref, computed, onMounted } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { memberApi } from '@/api/platform-client'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import type { Role } from '@/api/types'
-
-const route = useRoute()
-const router = useRouter()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const { t, locale } = useI18n()
+import { ref, computed, onMounted } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { memberApi } from '@/api/platform-client';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import type { Role } from '@/api/types';
+
+const route = useRoute();
+const router = useRouter();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const { t, locale } = useI18n();
 
 // Sub-org management
-const showCreateSubOrg = ref(false)
-const creatingSubOrg = ref(false)
-const newSubOrgName = ref('')
-const newSubOrgDesc = ref('')
-const assignAdmin = ref(false)
-const assignAdminUserId = ref('')
-const assignAdminRole = ref<Role>('admin')
+const showCreateSubOrg = ref(false);
+const creatingSubOrg = ref(false);
+const newSubOrgName = ref('');
+const newSubOrgDesc = ref('');
+const assignAdmin = ref(false);
+const assignAdminUserId = ref('');
+const assignAdminRole = ref<Role>('admin');
 
 // Sub-org member panel
-const expandedSubOrgId = ref<string | null>(null)
-const showAddMemberDialog = ref(false)
-const addMemberTargetSubOrgId = ref('')
-const addMemberUserId = ref('')
-const addMemberRole = ref<Role>('editor')
-const addingMember = ref(false)
-
-const isRootOrg = computed(() => (orgStore.currentOrg?.depth ?? 0) === 0)
-const parentOrgId = computed(() => orgStore.currentOrg?.parent_org_id ?? null)
+const expandedSubOrgId = ref<string | null>(null);
+const showAddMemberDialog = ref(false);
+const addMemberTargetSubOrgId = ref('');
+const addMemberUserId = ref('');
+const addMemberRole = ref<Role>('editor');
+const addingMember = ref(false);
+
+const isRootOrg = computed(() => (orgStore.currentOrg?.depth ?? 0) === 0);
+const parentOrgId = computed(() => orgStore.currentOrg?.parent_org_id ?? null);
 const parentOrg = computed(() =>
-  parentOrgId.value ? orgStore.orgs.find((o) => o.id === parentOrgId.value) ?? null : null,
-)
-const currentSubOrgs = computed(() =>
-  orgId.value ? (orgStore.subOrgs[orgId.value] ?? []) : [],
-)
+  parentOrgId.value ? orgStore.orgs.find((o) => o.id === parentOrgId.value) ?? null : null
+);
+const currentSubOrgs = computed(() => (orgId.value ? orgStore.subOrgs[orgId.value] ?? [] : []));
 
 // Parent org members not yet in the target sub-org (for "Add from parent" dropdown)
 const parentMembersNotInSubOrg = computed(() => {
   const subMembers = new Set(
-    (orgStore.subOrgMembers[addMemberTargetSubOrgId.value] ?? []).map((m) => m.user_id),
-  )
-  return orgStore.members.filter((m) => !subMembers.has(m.user_id))
-})
+    (orgStore.subOrgMembers[addMemberTargetSubOrgId.value] ?? []).map((m) => m.user_id)
+  );
+  return orgStore.members.filter((m) => !subMembers.has(m.user_id));
+});
 
 // For "designate admin on create": exclude the current user (they become Owner automatically)
 const parentMembersForAssign = computed(() =>
-  orgStore.members.filter((m) => m.user_id !== auth.user?.id),
-)
+  orgStore.members.filter((m) => m.user_id !== auth.user?.id)
+);
 
-const orgId = computed(() => route.params.orgId as string)
-const saving = ref(false)
-const deleting = ref(false)
-const leaving = ref(false)
+const orgId = computed(() => route.params.orgId as string);
+const saving = ref(false);
+const deleting = ref(false);
+const leaving = ref(false);
 
-const name = ref('')
-const description = ref('')
+const name = ref('');
+const description = ref('');
 
 const isAdmin = computed(() => {
-  if (!auth.user) return false
-  return orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return orgStore.canAdmin(auth.user.id);
+});
 
 const isMember = computed(() => {
-  if (!auth.user) return false
-  return orgStore.currentOrg?.members.some((m) => m.user_id === auth.user!.id) ?? false
-})
+  if (!auth.user) return false;
+  return orgStore.currentOrg?.members.some((m) => m.user_id === auth.user!.id) ?? false;
+});
 
 const createdAtFormatted = computed(() => {
-  const raw = orgStore.currentOrg?.created_at
-  if (!raw) return '—'
+  const raw = orgStore.currentOrg?.created_at;
+  if (!raw) return '—';
   return new Intl.DateTimeFormat(locale.value, {
     year: 'numeric',
     month: 'long',
     day: 'numeric',
-  }).format(new Date(raw))
-})
+  }).format(new Date(raw));
+});
 
 onMounted(async () => {
   if (!orgStore.currentOrg || orgStore.currentOrg.id !== orgId.value) {
-    await orgStore.selectOrg(orgId.value)
+    await orgStore.selectOrg(orgId.value);
   }
-  name.value = orgStore.currentOrg?.name ?? ''
-  description.value = orgStore.currentOrg?.description ?? ''
+  name.value = orgStore.currentOrg?.name ?? '';
+  description.value = orgStore.currentOrg?.description ?? '';
   // Pre-load sub-orgs if this is a root org
   if (isRootOrg.value) {
-    await orgStore.fetchSubOrgs(orgId.value)
+    await orgStore.fetchSubOrgs(orgId.value);
   }
-})
+});
 
 async function handleCreateSubOrg() {
   if (!newSubOrgName.value.trim()) {
-    MessagePlugin.warning(t('org.nameRequired'))
-    return
+    MessagePlugin.warning(t('org.nameRequired'));
+    return;
   }
-  creatingSubOrg.value = true
+  creatingSubOrg.value = true;
   try {
     const org = await orgStore.createSubOrg(
       orgId.value,
       newSubOrgName.value.trim(),
-      newSubOrgDesc.value || undefined,
-    )
+      newSubOrgDesc.value || undefined
+    );
     // Optionally designate an admin from the parent org
     if (assignAdmin.value && assignAdminUserId.value) {
       try {
@@ -112,62 +110,62 @@ async function handleCreateSubOrg() {
           orgId.value,
           org.id,
           assignAdminUserId.value,
-          assignAdminRole.value,
-        )
+          assignAdminRole.value
+        );
       } catch (e: any) {
         // If the user is already a member (e.g. was auto-added as creator), ignore
-        if (!e.message?.toLowerCase().includes('already a member')) throw e
+        if (!e.message?.toLowerCase().includes('already a member')) throw e;
       }
     }
-    showCreateSubOrg.value = false
-    newSubOrgName.value = ''
-    newSubOrgDesc.value = ''
-    assignAdmin.value = false
-    assignAdminUserId.value = ''
-    assignAdminRole.value = 'admin'
-    MessagePlugin.success(t('org.createSubOrgSuccess'))
+    showCreateSubOrg.value = false;
+    newSubOrgName.value = '';
+    newSubOrgDesc.value = '';
+    assignAdmin.value = false;
+    assignAdminUserId.value = '';
+    assignAdminRole.value = 'admin';
+    MessagePlugin.success(t('org.createSubOrgSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    creatingSubOrg.value = false
+    creatingSubOrg.value = false;
   }
 }
 
 async function toggleSubOrgMembers(subOrgId: string) {
   if (expandedSubOrgId.value === subOrgId) {
-    expandedSubOrgId.value = null
-    return
+    expandedSubOrgId.value = null;
+    return;
   }
-  expandedSubOrgId.value = subOrgId
-  await orgStore.fetchSubOrgMembers(orgId.value, subOrgId)
+  expandedSubOrgId.value = subOrgId;
+  await orgStore.fetchSubOrgMembers(orgId.value, subOrgId);
 }
 
 function openAddMemberDialog(subOrgId: string) {
-  addMemberTargetSubOrgId.value = subOrgId
-  addMemberUserId.value = ''
-  addMemberRole.value = 'editor'
-  showAddMemberDialog.value = true
+  addMemberTargetSubOrgId.value = subOrgId;
+  addMemberUserId.value = '';
+  addMemberRole.value = 'editor';
+  showAddMemberDialog.value = true;
 }
 
 async function handleAddSubOrgMember() {
   if (!addMemberUserId.value) {
-    MessagePlugin.warning(t('org.subOrgMember.selectRequired'))
-    return
+    MessagePlugin.warning(t('org.subOrgMember.selectRequired'));
+    return;
   }
-  addingMember.value = true
+  addingMember.value = true;
   try {
     await orgStore.addSubOrgMember(
       orgId.value,
       addMemberTargetSubOrgId.value,
       addMemberUserId.value,
-      addMemberRole.value,
-    )
-    showAddMemberDialog.value = false
-    MessagePlugin.success(t('org.subOrgMember.addSuccess'))
+      addMemberRole.value
+    );
+    showAddMemberDialog.value = false;
+    MessagePlugin.success(t('org.subOrgMember.addSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    addingMember.value = false
+    addingMember.value = false;
   }
 }
 
@@ -179,14 +177,14 @@ function handleRemoveSubOrgMember(subOrgId: string, userId: string, userName: st
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await orgStore.removeSubOrgMember(orgId.value, subOrgId, userId)
-        dlg.hide()
-        MessagePlugin.success(t('org.subOrgMember.removeSuccess'))
+        await orgStore.removeSubOrgMember(orgId.value, subOrgId, userId);
+        dlg.hide();
+        MessagePlugin.success(t('org.subOrgMember.removeSuccess'));
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 function handleDeleteSubOrg(subOrgId: string, subOrgName: string) {
@@ -197,65 +195,65 @@ function handleDeleteSubOrg(subOrgId: string, subOrgName: string) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await orgStore.deleteSubOrg(subOrgId, orgId.value)
-        dlg.hide()
-        MessagePlugin.success(t('org.deleteSubOrgSuccess'))
+        await orgStore.deleteSubOrg(subOrgId, orgId.value);
+        dlg.hide();
+        MessagePlugin.success(t('org.deleteSubOrgSuccess'));
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 async function handleSave() {
   if (!name.value.trim()) {
-    MessagePlugin.warning(t('org.settings.nameRequired'))
-    return
+    MessagePlugin.warning(t('org.settings.nameRequired'));
+    return;
   }
-  saving.value = true
+  saving.value = true;
   try {
     await orgStore.updateOrg(orgId.value, {
       name: name.value.trim(),
       description: description.value || undefined,
-    })
-    MessagePlugin.success(t('org.settings.saveSuccess'))
+    });
+    MessagePlugin.success(t('org.settings.saveSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 function copyOrgId() {
   navigator.clipboard.writeText(orgId.value).then(() => {
-    MessagePlugin.success(t('org.settings.orgIdCopied'))
-  })
+    MessagePlugin.success(t('org.settings.orgIdCopied'));
+  });
 }
 
 function handleLeave() {
-  if (!auth.token || !auth.user?.id) return
-  const token = auth.token
-  const userId = auth.user.id
-  const orgName = orgStore.currentOrg?.name ?? ''
+  if (!auth.token || !auth.user?.id) return;
+  const token = auth.token;
+  const userId = auth.user.id;
+  const orgName = orgStore.currentOrg?.name ?? '';
   const dialog = DialogPlugin.confirm({
     header: t('org.settings.leaveOrgDialog'),
     body: t('org.settings.leaveOrgConfirm', { name: orgName }),
     confirmBtn: { content: t('org.settings.leaveOrgBtn'), theme: 'danger', loading: leaving.value },
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
-      leaving.value = true
+      leaving.value = true;
       try {
-        await memberApi.remove(token, orgId.value, userId)
-        dialog.hide()
-        MessagePlugin.success(t('org.settings.leaveOrgSuccess'))
-        router.push('/orgs')
+        await memberApi.remove(token, orgId.value, userId);
+        dialog.hide();
+        MessagePlugin.success(t('org.settings.leaveOrgSuccess'));
+        router.push('/orgs');
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       } finally {
-        leaving.value = false
+        leaving.value = false;
       }
     },
-  })
+  });
 }
 
 const roleTheme: Record<string, string> = {
@@ -263,29 +261,29 @@ const roleTheme: Record<string, string> = {
   admin: 'warning',
   editor: 'success',
   viewer: 'default',
-}
+};
 
 function handleDelete() {
-  const orgName = orgStore.currentOrg?.name ?? ''
+  const orgName = orgStore.currentOrg?.name ?? '';
   const dialog = DialogPlugin.confirm({
     header: t('org.settings.deleteDialog'),
     body: t('org.settings.deleteConfirm', { name: orgName }),
     confirmBtn: { content: t('org.settings.deleteBtn'), theme: 'danger', loading: deleting.value },
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
-      deleting.value = true
+      deleting.value = true;
       try {
-        await orgStore.deleteOrg(orgId.value)
-        dialog.hide()
-        MessagePlugin.success(t('org.settings.deleteSuccess'))
-        router.push('/orgs')
+        await orgStore.deleteOrg(orgId.value);
+        dialog.hide();
+        MessagePlugin.success(t('org.settings.deleteSuccess'));
+        router.push('/orgs');
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       } finally {
-        deleting.value = false
+        deleting.value = false;
       }
     },
-  })
+  });
 }
 </script>
 
@@ -355,7 +353,9 @@ function handleDelete() {
             <div class="org-mini-icon">{{ parentOrg.name[0]?.toUpperCase() }}</div>
             <div class="parent-org-info">
               <div class="parent-org-name">{{ parentOrg.name }}</div>
-              <div class="parent-org-meta">{{ t('org.memberCount', { count: parentOrg.member_count }) }}</div>
+              <div class="parent-org-meta">
+                {{ t('org.memberCount', { count: parentOrg.member_count }) }}
+              </div>
             </div>
             <t-icon name="chevron-right" class="parent-org-arrow" />
           </div>
@@ -368,7 +368,12 @@ function handleDelete() {
               <h3 class="section-title">{{ t('org.subOrgs') }}</h3>
               <p class="section-desc">{{ t('org.subOrgsDesc') }}</p>
             </div>
-            <t-button v-if="isAdmin" size="small" variant="outline" @click="showCreateSubOrg = true">
+            <t-button
+              v-if="isAdmin"
+              size="small"
+              variant="outline"
+              @click="showCreateSubOrg = true"
+            >
               <t-icon name="add" />
               {{ t('org.addSubOrg') }}
             </t-button>
@@ -386,7 +391,9 @@ function handleDelete() {
                   <div class="suborg-meta">
                     {{ t('org.memberCount', { count: sub.member_count }) }}
                     <span v-if="sub.project_count > 0" class="suborg-meta-sep">·</span>
-                    <span v-if="sub.project_count > 0">{{ t('org.projectCount', { count: sub.project_count }) }}</span>
+                    <span v-if="sub.project_count > 0">{{
+                      t('org.projectCount', { count: sub.project_count })
+                    }}</span>
                   </div>
                 </div>
                 <div class="suborg-actions">
@@ -396,7 +403,11 @@ function handleDelete() {
                     variant="text"
                     @click="toggleSubOrgMembers(sub.id)"
                   >
-                    {{ expandedSubOrgId === sub.id ? t('common.collapse') : t('org.subOrgMember.manage') }}
+                    {{
+                      expandedSubOrgId === sub.id
+                        ? t('common.collapse')
+                        : t('org.subOrgMember.manage')
+                    }}
                   </t-button>
                   <t-button
                     size="small"
diff --git a/ordo-editor/apps/studio/src/views/org/RoleFormView.vue b/ordo-editor/apps/studio/src/views/org/RoleFormView.vue
index 255b3fdb..2be8b72f 100644
--- a/ordo-editor/apps/studio/src/views/org/RoleFormView.vue
+++ b/ordo-editor/apps/studio/src/views/org/RoleFormView.vue
@@ -1,139 +1,139 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { StudioPageHeader } from '@/components/ui'
-import { RBAC_PERMISSION_GROUPS, permissionI18nKey } from '@/constants/rbac'
-import { useRbacStore } from '@/stores/rbac'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const rbacStore = useRbacStore()
-
-const orgId = computed(() => route.params.orgId as string)
-const roleId = computed(() => route.params.roleId as string | undefined)
-const isEdit = computed(() => Boolean(roleId.value))
-
-const loading = ref(false)
-const saving = ref(false)
-const formName = ref('')
-const formDesc = ref('')
-const formPerms = ref<string[]>([])
-const permissionFilter = ref<'all' | 'selected' | 'unselected'>('all')
+import { computed, onMounted, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { StudioPageHeader } from '@/components/ui';
+import { RBAC_PERMISSION_GROUPS, permissionI18nKey } from '@/constants/rbac';
+import { useRbacStore } from '@/stores/rbac';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const rbacStore = useRbacStore();
+
+const orgId = computed(() => route.params.orgId as string);
+const roleId = computed(() => route.params.roleId as string | undefined);
+const isEdit = computed(() => Boolean(roleId.value));
+
+const loading = ref(false);
+const saving = ref(false);
+const formName = ref('');
+const formDesc = ref('');
+const formPerms = ref<string[]>([]);
+const permissionFilter = ref<'all' | 'selected' | 'unselected'>('all');
 
 const editingRole = computed(() =>
-  roleId.value ? rbacStore.roles.find((role) => role.id === roleId.value) ?? null : null,
-)
-
-const pageTitle = computed(() => (isEdit.value ? t('rbac.editRole') : t('rbac.addRole')))
-const pageSubtitle = computed(() => (isEdit.value ? t('rbac.editSubtitle') : t('rbac.createSubtitle')))
-const allPermissions = computed(() =>
-  RBAC_PERMISSION_GROUPS.flatMap((group) => group.permissions),
-)
+  roleId.value ? rbacStore.roles.find((role) => role.id === roleId.value) ?? null : null
+);
+
+const pageTitle = computed(() => (isEdit.value ? t('rbac.editRole') : t('rbac.addRole')));
+const pageSubtitle = computed(() =>
+  isEdit.value ? t('rbac.editSubtitle') : t('rbac.createSubtitle')
+);
+const allPermissions = computed(() => RBAC_PERMISSION_GROUPS.flatMap((group) => group.permissions));
 const visibleGroups = computed(() =>
   RBAC_PERMISSION_GROUPS.map((group) => ({
     ...group,
     visiblePermissions: group.permissions.filter((perm) => {
-      if (permissionFilter.value === 'selected') return formPerms.value.includes(perm)
-      if (permissionFilter.value === 'unselected') return !formPerms.value.includes(perm)
-      return true
+      if (permissionFilter.value === 'selected') return formPerms.value.includes(perm);
+      if (permissionFilter.value === 'unselected') return !formPerms.value.includes(perm);
+      return true;
     }),
-  })).filter((group) => group.visiblePermissions.length > 0),
-)
+  })).filter((group) => group.visiblePermissions.length > 0)
+);
 
 onMounted(async () => {
-  loading.value = true
+  loading.value = true;
   try {
-    await rbacStore.fetchRoles(orgId.value)
+    await rbacStore.fetchRoles(orgId.value);
     if (editingRole.value) {
       if (editingRole.value.is_system) {
-        MessagePlugin.warning(t('rbac.systemRoleReadonly'))
-        backToList()
-        return
+        MessagePlugin.warning(t('rbac.systemRoleReadonly'));
+        backToList();
+        return;
       }
-      formName.value = editingRole.value.name
-      formDesc.value = editingRole.value.description ?? ''
-      formPerms.value = [...editingRole.value.permissions]
+      formName.value = editingRole.value.name;
+      formDesc.value = editingRole.value.description ?? '';
+      formPerms.value = [...editingRole.value.permissions];
     }
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 async function handleSave() {
-  const trimmedName = formName.value.trim()
+  const trimmedName = formName.value.trim();
   if (!trimmedName) {
-    MessagePlugin.warning(t('rbac.roleNameRequired'))
-    return
+    MessagePlugin.warning(t('rbac.roleNameRequired'));
+    return;
   }
 
-  saving.value = true
+  saving.value = true;
   try {
     if (isEdit.value && editingRole.value) {
       await rbacStore.updateRole(orgId.value, editingRole.value.id, {
         name: trimmedName,
         description: formDesc.value.trim() || undefined,
         permissions: formPerms.value,
-      })
-      MessagePlugin.success(t('rbac.updated'))
+      });
+      MessagePlugin.success(t('rbac.updated'));
     } else {
       await rbacStore.createRole(orgId.value, {
         name: trimmedName,
         description: formDesc.value.trim() || undefined,
         permissions: formPerms.value,
-      })
-      MessagePlugin.success(t('rbac.created'))
+      });
+      MessagePlugin.success(t('rbac.created'));
     }
-    backToList()
+    backToList();
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 function selectedCountForGroup(perms: string[]) {
-  return perms.filter((perm) => formPerms.value.includes(perm)).length
+  return perms.filter((perm) => formPerms.value.includes(perm)).length;
 }
 
 function selectAllPermissions() {
-  formPerms.value = [...allPermissions.value]
+  formPerms.value = [...allPermissions.value];
 }
 
 function clearAllPermissions() {
-  formPerms.value = []
+  formPerms.value = [];
 }
 
 function selectGroupPermissions(perms: string[]) {
-  const merged = new Set([...formPerms.value, ...perms])
-  formPerms.value = Array.from(merged)
+  const merged = new Set([...formPerms.value, ...perms]);
+  formPerms.value = Array.from(merged);
 }
 
 function clearGroupPermissions(perms: string[]) {
-  const target = new Set(perms)
-  formPerms.value = formPerms.value.filter((perm) => !target.has(perm))
+  const target = new Set(perms);
+  formPerms.value = formPerms.value.filter((perm) => !target.has(perm));
 }
 
 function setFilter(mode: 'all' | 'selected' | 'unselected') {
-  permissionFilter.value = mode
+  permissionFilter.value = mode;
 }
 
 function permissionLabel(perm: string) {
-  return t(`rbac.permissionLabels.${permissionI18nKey(perm)}`)
+  return t(`rbac.permissionLabels.${permissionI18nKey(perm)}`);
 }
 
 function permissionDesc(perm: string) {
-  return t(`rbac.permissionDescriptions.${permissionI18nKey(perm)}`)
+  return t(`rbac.permissionDescriptions.${permissionI18nKey(perm)}`);
 }
 
 function groupLabel(groupKey: string) {
-  return t(`rbac.permissionGroups.${groupKey}`)
+  return t(`rbac.permissionGroups.${groupKey}`);
 }
 
 function backToList() {
-  router.push(`/orgs/${orgId.value}/roles`)
+  router.push(`/orgs/${orgId.value}/roles`);
 }
 </script>
 
@@ -160,7 +160,9 @@ function backToList() {
             <t-input v-model="formDesc" :placeholder="$t('rbac.roleDescPlaceholder')" />
           </t-form-item>
 
-          <t-form-item :label="`${$t('rbac.permissions')} (${formPerms.length} ${$t('rbac.selected')})`">
+          <t-form-item
+            :label="`${$t('rbac.permissions')} (${formPerms.length} ${$t('rbac.selected')})`"
+          >
             <div class="perm-table-shell">
               <div class="perm-table-tools">
                 <t-space size="8px" break-line>
@@ -204,14 +206,24 @@ function backToList() {
                           <div class="group-row__title">
                             <span>{{ groupLabel(group.key) }}</span>
                             <t-tag size="small" variant="light">
-                              {{ selectedCountForGroup(group.permissions) }}/{{ group.permissions.length }}
+                              {{ selectedCountForGroup(group.permissions) }}/{{
+                                group.permissions.length
+                              }}
                             </t-tag>
                           </div>
                           <div class="group-row__actions">
-                            <t-button size="small" variant="text" @click="selectGroupPermissions(group.permissions)">
+                            <t-button
+                              size="small"
+                              variant="text"
+                              @click="selectGroupPermissions(group.permissions)"
+                            >
                               {{ $t('rbac.selectGroup') }}
                             </t-button>
-                            <t-button size="small" variant="text" @click="clearGroupPermissions(group.permissions)">
+                            <t-button
+                              size="small"
+                              variant="text"
+                              @click="clearGroupPermissions(group.permissions)"
+                            >
                               {{ $t('rbac.clearGroup') }}
                             </t-button>
                           </div>
@@ -233,12 +245,18 @@ function backToList() {
 
           <div class="form-actions">
             <t-button variant="outline" @click="backToList">{{ $t('common.cancel') }}</t-button>
-            <t-button theme="primary" :loading="saving" @click="handleSave">{{ $t('rbac.save') }}</t-button>
+            <t-button theme="primary" :loading="saving" @click="handleSave">{{
+              $t('rbac.save')
+            }}</t-button>
           </div>
         </t-form>
 
         <div v-else class="list-skeleton">
-          <t-skeleton theme="paragraph" animation="gradient" :row-col="[{ width: '40%' }, 1, 1, 1]" />
+          <t-skeleton
+            theme="paragraph"
+            animation="gradient"
+            :row-col="[{ width: '40%' }, 1, 1, 1]"
+          />
         </div>
       </t-card>
     </div>
@@ -383,6 +401,5 @@ function backToList() {
   .form-card :deep(.t-card__body) {
     padding: 16px;
   }
-
 }
 </style>
diff --git a/ordo-editor/apps/studio/src/views/org/RolesView.vue b/ordo-editor/apps/studio/src/views/org/RolesView.vue
index dfac2f1d..9dea9e2c 100644
--- a/ordo-editor/apps/studio/src/views/org/RolesView.vue
+++ b/ordo-editor/apps/studio/src/views/org/RolesView.vue
@@ -1,42 +1,42 @@
 <script setup lang="ts">
-import { ref, onMounted } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { DialogPlugin, MessagePlugin } from 'tdesign-vue-next'
-import { useRbacStore } from '@/stores/rbac'
-import { StudioPageHeader } from '@/components/ui'
-import { RBAC_PERMISSION_GROUPS, permissionI18nKey } from '@/constants/rbac'
-import type { OrgRole } from '@/api/types'
+import { ref, onMounted } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { DialogPlugin, MessagePlugin } from 'tdesign-vue-next';
+import { useRbacStore } from '@/stores/rbac';
+import { StudioPageHeader } from '@/components/ui';
+import { RBAC_PERMISSION_GROUPS, permissionI18nKey } from '@/constants/rbac';
+import type { OrgRole } from '@/api/types';
 
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const rbacStore = useRbacStore()
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const rbacStore = useRbacStore();
 
-const orgId = route.params.orgId as string
-const expandedRoles = ref<Set<string>>(new Set())
+const orgId = route.params.orgId as string;
+const expandedRoles = ref<Set<string>>(new Set());
 
-onMounted(() => rbacStore.fetchRoles(orgId))
+onMounted(() => rbacStore.fetchRoles(orgId));
 
 function toggleExpand(roleId: string) {
   if (expandedRoles.value.has(roleId)) {
-    expandedRoles.value.delete(roleId)
+    expandedRoles.value.delete(roleId);
   } else {
-    expandedRoles.value.add(roleId)
+    expandedRoles.value.add(roleId);
   }
 }
 
 function startCreate() {
-  router.push(`/orgs/${orgId}/roles/new`)
+  router.push(`/orgs/${orgId}/roles/new`);
 }
 
 function startEdit(role: OrgRole) {
-  if (role.is_system) return
-  router.push(`/orgs/${orgId}/roles/${role.id}/edit`)
+  if (role.is_system) return;
+  router.push(`/orgs/${orgId}/roles/${role.id}/edit`);
 }
 
 function deleteRole(role: OrgRole) {
-  if (role.is_system) return
+  if (role.is_system) return;
   const dialog = DialogPlugin.confirm({
     header: t('rbac.deleteRole'),
     body: t('rbac.confirmDelete', { name: role.name }),
@@ -44,49 +44,49 @@ function deleteRole(role: OrgRole) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await rbacStore.deleteRole(orgId, role.id)
-        MessagePlugin.success(t('rbac.deleted'))
-        dialog.hide()
+        await rbacStore.deleteRole(orgId, role.id);
+        MessagePlugin.success(t('rbac.deleted'));
+        dialog.hide();
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 function permissionLabel(perm: string) {
-  return t(`rbac.permissionLabels.${permissionI18nKey(perm)}`)
+  return t(`rbac.permissionLabels.${permissionI18nKey(perm)}`);
 }
 
 function groupLabel(key: string) {
-  return t(`rbac.permissionGroups.${key}`)
+  return t(`rbac.permissionGroups.${key}`);
 }
 
 function groupedPermissions(perms: string[]) {
-  const permSet = new Set(perms)
-  const groups: { key: string; label: string; perms: string[] }[] = []
+  const permSet = new Set(perms);
+  const groups: { key: string; label: string; perms: string[] }[] = [];
 
   for (const group of RBAC_PERMISSION_GROUPS) {
-    const matched = group.permissions.filter((p) => permSet.has(p))
+    const matched = group.permissions.filter((p) => permSet.has(p));
     if (matched.length > 0) {
-      groups.push({ key: group.key, label: groupLabel(group.key), perms: matched })
+      groups.push({ key: group.key, label: groupLabel(group.key), perms: matched });
     }
   }
 
-  const known = new Set(RBAC_PERMISSION_GROUPS.flatMap((g) => g.permissions))
-  const other = perms.filter((p) => !known.has(p))
+  const known = new Set(RBAC_PERMISSION_GROUPS.flatMap((g) => g.permissions));
+  const other = perms.filter((p) => !known.has(p));
   if (other.length > 0) {
-    groups.push({ key: '_other', label: t('common.other', 'Other'), perms: other })
+    groups.push({ key: '_other', label: t('common.other', 'Other'), perms: other });
   }
 
-  return groups
+  return groups;
 }
 
 // Summary: "组织 ×2 · 规则集 ×3 · 发布中心 ×8"
 function permissionSummary(perms: string[]) {
   return groupedPermissions(perms)
     .map((g) => `${g.label} ×${g.perms.length}`)
-    .join(' · ')
+    .join(' · ');
 }
 </script>
 
@@ -117,12 +117,7 @@ function permissionSummary(perms: string[]) {
       </div>
 
       <div v-else class="role-list">
-        <t-card
-          v-for="role in rbacStore.roles"
-          :key="role.id"
-          :bordered="false"
-          class="role-card"
-        >
+        <t-card v-for="role in rbacStore.roles" :key="role.id" :bordered="false" class="role-card">
           <!-- Header row -->
           <div class="role-header">
             <div class="role-name-row">
diff --git a/ordo-editor/apps/studio/src/views/project/ConceptRegistryView.vue b/ordo-editor/apps/studio/src/views/project/ConceptRegistryView.vue
index ce5980c3..726abf81 100644
--- a/ordo-editor/apps/studio/src/views/project/ConceptRegistryView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ConceptRegistryView.vue
@@ -1,27 +1,27 @@
 <script setup lang="ts">
-import { ref, computed } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useRouter, useRoute } from 'vue-router'
-import { useCatalogStore } from '@/stores/catalog'
-import { useOrgStore } from '@/stores/org'
-import { useAuthStore } from '@/stores/auth'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import type { ConceptDefinition, FactDataType } from '@/api/types'
-
-const catalog = useCatalogStore()
-const orgStore = useOrgStore()
-const auth = useAuthStore()
-const { t } = useI18n()
-const router = useRouter()
-const route = useRoute()
-const orgId = computed(() => route.params.orgId as string)
-
-const canEdit = computed(() => auth.user ? orgStore.canAdmin(auth.user.id) : false)
+import { ref, computed } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter, useRoute } from 'vue-router';
+import { useCatalogStore } from '@/stores/catalog';
+import { useOrgStore } from '@/stores/org';
+import { useAuthStore } from '@/stores/auth';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import type { ConceptDefinition, FactDataType } from '@/api/types';
+
+const catalog = useCatalogStore();
+const orgStore = useOrgStore();
+const auth = useAuthStore();
+const { t } = useI18n();
+const router = useRouter();
+const route = useRoute();
+const orgId = computed(() => route.params.orgId as string);
+
+const canEdit = computed(() => (auth.user ? orgStore.canAdmin(auth.user.id) : false));
 
 // ── Edit panel ────────────────────────────────────────────────────────────────
-const selected = ref<ConceptDefinition | null>(null)
-const saving = ref(false)
-const isNew = ref(false)
+const selected = ref<ConceptDefinition | null>(null);
+const saving = ref(false);
+const isNew = ref(false);
 
 const emptyForm = (): Omit<ConceptDefinition, 'created_at' | 'updated_at'> => ({
   name: '',
@@ -29,70 +29,70 @@ const emptyForm = (): Omit<ConceptDefinition, 'created_at' | 'updated_at'> => ({
   expression: '',
   dependencies: [],
   description: '',
-})
+});
 
-const form = ref(emptyForm())
+const form = ref(emptyForm());
 
 function openNew() {
-  isNew.value = true
-  selected.value = null
-  form.value = emptyForm()
+  isNew.value = true;
+  selected.value = null;
+  form.value = emptyForm();
 }
 
 function openEdit(concept: ConceptDefinition) {
-  isNew.value = false
-  selected.value = concept
+  isNew.value = false;
+  selected.value = concept;
   form.value = {
     name: concept.name,
     data_type: concept.data_type,
     expression: concept.expression,
     dependencies: [...concept.dependencies],
     description: concept.description ?? '',
-  }
+  };
 }
 
 // Simple cycle detection: DFS from new concept's dependencies
 function hasCycle(name: string, deps: string[]): boolean {
-  const visited = new Set<string>()
+  const visited = new Set<string>();
   function dfs(node: string): boolean {
-    if (node === name) return true
-    if (visited.has(node)) return false
-    visited.add(node)
-    const concept = catalog.concepts.find((c) => c.name === node)
-    if (!concept) return false
-    return concept.dependencies.some(dfs)
+    if (node === name) return true;
+    if (visited.has(node)) return false;
+    visited.add(node);
+    const concept = catalog.concepts.find((c) => c.name === node);
+    if (!concept) return false;
+    return concept.dependencies.some(dfs);
   }
-  return deps.some(dfs)
+  return deps.some(dfs);
 }
 
 async function handleSave() {
   if (!form.value.name.trim()) {
-    MessagePlugin.warning(t('concepts.nameRequired'))
-    return
+    MessagePlugin.warning(t('concepts.nameRequired'));
+    return;
   }
   if (!form.value.expression.trim()) {
-    MessagePlugin.warning(t('concepts.exprRequired'))
-    return
+    MessagePlugin.warning(t('concepts.exprRequired'));
+    return;
   }
   if (hasCycle(form.value.name, form.value.dependencies)) {
-    MessagePlugin.error(t('concepts.cycleError'))
-    return
+    MessagePlugin.error(t('concepts.cycleError'));
+    return;
   }
-  saving.value = true
+  saving.value = true;
   try {
     await catalog.upsertConcept({
       ...form.value,
       name: form.value.name.trim(),
       expression: form.value.expression.trim(),
       description: form.value.description?.trim() || undefined,
-    })
-    MessagePlugin.success(isNew.value ? t('concepts.createSuccess') : t('concepts.updateSuccess'))
-    isNew.value = false
-    selected.value = catalog.concepts.find((c) => c.name === form.value.name) ?? null
+    });
+    MessagePlugin.success(isNew.value ? t('concepts.createSuccess') : t('concepts.updateSuccess'));
+    isNew.value = false;
+    selected.value = catalog.concepts.find((c) => c.name === form.value.name) ?? null;
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.saveFailed'))
+    MessagePlugin.error(e.message || t('common.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
@@ -104,17 +104,17 @@ function handleDelete(concept: ConceptDefinition) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await catalog.deleteConcept(concept.name)
+        await catalog.deleteConcept(concept.name);
         if (selected.value?.name === concept.name) {
-          selected.value = null
+          selected.value = null;
         }
-        dlg.hide()
-        MessagePlugin.success(t('concepts.deleteSuccess'))
+        dlg.hide();
+        MessagePlugin.success(t('concepts.deleteSuccess'));
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
@@ -123,14 +123,18 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
   boolean: t('facts.typeBoolean'),
   date: t('facts.typeDate'),
   object: t('facts.typeObject'),
-}))
+}));
 </script>
 
 <template>
   <div class="concept-view">
     <t-breadcrumb class="asset-breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{ t('breadcrumb.projects') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{
+        t('breadcrumb.projects')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('projectNav.concepts') }}</t-breadcrumb-item>
     </t-breadcrumb>
     <div class="asset-header">
@@ -148,7 +152,7 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
       <div class="concept-list">
         <div v-if="catalog.loading" class="asset-loading"><t-loading size="small" /></div>
         <div v-else-if="catalog.concepts.length === 0" class="asset-empty">
-          <t-icon name="share" size="32px" style="opacity:0.3" />
+          <t-icon name="share" size="32px" style="opacity: 0.3" />
           <p>{{ t('concepts.empty') }}</p>
         </div>
         <div
@@ -165,16 +169,16 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
               {{ t('concepts.depCount', { count: c.dependencies.length }) }}
             </span>
           </div>
-          <button
-            v-if="canEdit"
-            class="concept-item__del"
-            @click.stop="handleDelete(c)"
-          ><t-icon name="close" size="12px" /></button>
+          <button v-if="canEdit" class="concept-item__del" @click.stop="handleDelete(c)">
+            <t-icon name="close" size="12px" />
+          </button>
         </div>
 
         <!-- New concept placeholder -->
         <div v-if="isNew" class="concept-item is-active">
-          <div class="concept-item__name" style="opacity:0.5">{{ t('concepts.newPlaceholder') }}</div>
+          <div class="concept-item__name" style="opacity: 0.5">
+            {{ t('concepts.newPlaceholder') }}
+          </div>
         </div>
       </div>
 
@@ -209,24 +213,35 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
             <t-select
               v-model="form.dependencies"
               multiple
-              :options="catalog.allFieldNames.map(n => ({ label: n, value: n }))"
+              :options="catalog.allFieldNames.map((n) => ({ label: n, value: n }))"
               :placeholder="t('concepts.depsPlaceholder')"
             />
           </t-form-item>
           <t-form-item :label="t('concepts.descLabel')">
-            <t-textarea v-model="form.description" :rows="2" :placeholder="t('concepts.descPlaceholder')" />
+            <t-textarea
+              v-model="form.description"
+              :rows="2"
+              :placeholder="t('concepts.descPlaceholder')"
+            />
           </t-form-item>
         </t-form>
         <div class="concept-editor__footer">
           <t-button v-if="canEdit" theme="primary" :loading="saving" @click="handleSave">
             {{ isNew ? t('concepts.createBtn') : t('concepts.saveBtn') }}
           </t-button>
-          <t-button variant="outline" @click="selected = null; isNew = false">{{ t('concepts.cancel') }}</t-button>
+          <t-button
+            variant="outline"
+            @click="
+              selected = null;
+              isNew = false;
+            "
+            >{{ t('concepts.cancel') }}</t-button
+          >
         </div>
       </div>
 
       <div v-else class="concept-placeholder">
-        <t-icon name="share" size="36px" style="opacity:0.15" />
+        <t-icon name="share" size="36px" style="opacity: 0.15" />
         <p>{{ t('concepts.placeholder') }}</p>
       </div>
     </div>
@@ -286,8 +301,12 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
   position: relative;
 }
 
-.concept-item:hover { background: var(--ordo-hover-bg); }
-.concept-item.is-active { background: var(--ordo-active-bg); }
+.concept-item:hover {
+  background: var(--ordo-hover-bg);
+}
+.concept-item.is-active {
+  background: var(--ordo-active-bg);
+}
 
 .concept-item__name {
   font-size: 13px;
@@ -323,8 +342,13 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
   justify-content: center;
 }
 
-.concept-item:hover .concept-item__del { display: flex; }
-.concept-item__del:hover { background: rgba(255,80,80,0.15); color: #e34d59; }
+.concept-item:hover .concept-item__del {
+  display: flex;
+}
+.concept-item__del:hover {
+  background: rgba(255, 80, 80, 0.15);
+  color: #e34d59;
+}
 
 .concept-editor {
   flex: 1;
@@ -351,7 +375,8 @@ const dataTypeLabels = computed<Record<FactDataType, string>>(() => ({
   font-size: 13px;
 }
 
-.asset-loading, .asset-empty {
+.asset-loading,
+.asset-empty {
   display: flex;
   flex-direction: column;
   align-items: center;
diff --git a/ordo-editor/apps/studio/src/views/project/ContractView.vue b/ordo-editor/apps/studio/src/views/project/ContractView.vue
index db077632..6873a2e9 100644
--- a/ordo-editor/apps/studio/src/views/project/ContractView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ContractView.vue
@@ -1,61 +1,53 @@
 <script setup lang="ts">
-import { computed, ref, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useRouter, useRoute } from 'vue-router'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import { useCatalogStore } from '@/stores/catalog'
-import { useProjectStore } from '@/stores/project'
-import { useOrgStore } from '@/stores/org'
-import { useAuthStore } from '@/stores/auth'
-import { rulesetDraftApi } from '@/api/platform-client'
-import { normalizeRuleset } from '@/utils/ruleset'
-import {
-  conditionToString,
-  exprToString,
-} from '@ordo-engine/editor-core'
-import type {
-  Condition,
-  Expr,
-  RuleSet,
-  SchemaField,
-} from '@ordo-engine/editor-core'
-import type { ContractField, DecisionContract, FactDataType } from '@/api/types'
-
-type ContractForm = Omit<DecisionContract, 'updated_at'>
-type SectionKey = 'overview' | 'inputs' | 'outputs' | 'notes'
-type ValidationLevel = 'error' | 'warning'
+import { computed, ref, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter, useRoute } from 'vue-router';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import { useCatalogStore } from '@/stores/catalog';
+import { useProjectStore } from '@/stores/project';
+import { useOrgStore } from '@/stores/org';
+import { useAuthStore } from '@/stores/auth';
+import { rulesetDraftApi } from '@/api/platform-client';
+import { normalizeRuleset } from '@/utils/ruleset';
+import { conditionToString, exprToString } from '@ordo-engine/editor-core';
+import type { Condition, Expr, RuleSet, SchemaField } from '@ordo-engine/editor-core';
+import type { ContractField, DecisionContract, FactDataType } from '@/api/types';
+
+type ContractForm = Omit<DecisionContract, 'updated_at'>;
+type SectionKey = 'overview' | 'inputs' | 'outputs' | 'notes';
+type ValidationLevel = 'error' | 'warning';
 
 interface ValidationIssue {
-  id: string
-  level: ValidationLevel
-  message: string
+  id: string;
+  level: ValidationLevel;
+  message: string;
   action?: {
-    kind: 'create-fact'
-    name: string
-    label: string
-  }
-}
-
-const catalog = useCatalogStore()
-const projectStore = useProjectStore()
-const orgStore = useOrgStore()
-const auth = useAuthStore()
-const { t } = useI18n()
-const router = useRouter()
-const route = useRoute()
-
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
-const canEdit = computed(() => auth.user ? orgStore.canAdmin(auth.user.id) : false)
-
-const selectedRulesetName = ref('')
-const activeSection = ref<SectionKey>('overview')
-const saving = ref(false)
-const loadingRuleset = ref(false)
-const rulesetLoadError = ref<string | null>(null)
-const rulesetCache = ref<Record<string, RuleSet>>({})
-const form = ref<ContractForm>(emptyContract(''))
-const baselineSignature = ref('')
+    kind: 'create-fact';
+    name: string;
+    label: string;
+  };
+}
+
+const catalog = useCatalogStore();
+const projectStore = useProjectStore();
+const orgStore = useOrgStore();
+const auth = useAuthStore();
+const { t } = useI18n();
+const router = useRouter();
+const route = useRoute();
+
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
+const canEdit = computed(() => (auth.user ? orgStore.canAdmin(auth.user.id) : false));
+
+const selectedRulesetName = ref('');
+const activeSection = ref<SectionKey>('overview');
+const saving = ref(false);
+const loadingRuleset = ref(false);
+const rulesetLoadError = ref<string | null>(null);
+const rulesetCache = ref<Record<string, RuleSet>>({});
+const form = ref<ContractForm>(emptyContract(''));
+const baselineSignature = ref('');
 
 const dataTypeOptions = computed<{ label: string; value: FactDataType }[]>(() => [
   { label: t('facts.typeString'), value: 'string' },
@@ -63,66 +55,59 @@ const dataTypeOptions = computed<{ label: string; value: FactDataType }[]>(() =>
   { label: t('facts.typeBoolean'), value: 'boolean' },
   { label: t('facts.typeDate'), value: 'date' },
   { label: t('facts.typeObject'), value: 'object' },
-])
+]);
 
 const sortedRulesets = computed(() => {
-  const withContract = new Set(catalog.contracts.map((c) => c.ruleset_name))
-  const all = projectStore.rulesets.map((r) => r.name)
-  return [
-    ...all.filter((n) => withContract.has(n)),
-    ...all.filter((n) => !withContract.has(n)),
-  ]
-})
+  const withContract = new Set(catalog.contracts.map((c) => c.ruleset_name));
+  const all = projectStore.rulesets.map((r) => r.name);
+  return [...all.filter((n) => withContract.has(n)), ...all.filter((n) => !withContract.has(n))];
+});
 
 const contractMap = computed(() => {
-  const map = new Map<string, DecisionContract>()
+  const map = new Map<string, DecisionContract>();
   for (const contract of catalog.contracts) {
-    map.set(contract.ruleset_name, contract)
+    map.set(contract.ruleset_name, contract);
   }
-  return map
-})
+  return map;
+});
 
 const selectedRulesetInfo = computed(
-  () => projectStore.rulesets.find((ruleset) => ruleset.name === selectedRulesetName.value) ?? null,
-)
+  () => projectStore.rulesets.find((ruleset) => ruleset.name === selectedRulesetName.value) ?? null
+);
 
-const selectedContract = computed(
-  () => contractMap.value.get(selectedRulesetName.value) ?? null,
-)
+const selectedContract = computed(() => contractMap.value.get(selectedRulesetName.value) ?? null);
 
-const selectedRuleset = computed(
-  () => rulesetCache.value[selectedRulesetName.value] ?? null,
-)
+const selectedRuleset = computed(() => rulesetCache.value[selectedRulesetName.value] ?? null);
 
 const factLookup = computed(() => {
-  const map = new Map<string, { type: FactDataType; description?: string; required?: boolean }>()
+  const map = new Map<string, { type: FactDataType; description?: string; required?: boolean }>();
   for (const fact of catalog.facts) {
     map.set(fact.name, {
       type: fact.data_type,
       description: fact.description,
       required: fact.null_policy === 'error',
-    })
+    });
   }
-  return map
-})
+  return map;
+});
 
 const inputSuggestions = computed(() =>
-  selectedRuleset.value ? inferInputFields(selectedRuleset.value) : [],
-)
+  selectedRuleset.value ? inferInputFields(selectedRuleset.value) : []
+);
 
 const outputSuggestions = computed(() =>
-  selectedRuleset.value ? inferOutputFields(selectedRuleset.value) : [],
-)
+  selectedRuleset.value ? inferOutputFields(selectedRuleset.value) : []
+);
 
 const rulesetStats = computed(() => {
-  const ruleset = selectedRuleset.value
+  const ruleset = selectedRuleset.value;
   if (!ruleset) {
     return {
       steps: 0,
       decisions: 0,
       actions: 0,
       terminals: 0,
-    }
+    };
   }
 
   return {
@@ -130,38 +115,38 @@ const rulesetStats = computed(() => {
     decisions: ruleset.steps.filter((step) => step.type === 'decision').length,
     actions: ruleset.steps.filter((step) => step.type === 'action').length,
     terminals: ruleset.steps.filter((step) => step.type === 'terminal').length,
-  }
-})
+  };
+});
 
 const terminalCodes = computed(() => {
-  const ruleset = selectedRuleset.value
-  if (!ruleset) return []
-  const codes = new Set<string>()
+  const ruleset = selectedRuleset.value;
+  if (!ruleset) return [];
+  const codes = new Set<string>();
   for (const step of ruleset.steps) {
     if (step.type === 'terminal' && step.code) {
-      codes.add(step.code)
+      codes.add(step.code);
     }
   }
-  return Array.from(codes)
-})
+  return Array.from(codes);
+});
 
 const baselineContract = computed(() =>
   selectedContract.value
     ? toForm(selectedContract.value)
-    : buildDraftContract(selectedRulesetName.value, selectedRuleset.value),
-)
+    : buildDraftContract(selectedRulesetName.value, selectedRuleset.value)
+);
 
-const isDirty = computed(() => contractSignature(form.value) !== baselineSignature.value)
+const isDirty = computed(() => contractSignature(form.value) !== baselineSignature.value);
 
 const validationIssues = computed<ValidationIssue[]>(() => {
-  const issues: ValidationIssue[] = []
+  const issues: ValidationIssue[] = [];
 
   if (!form.value.version_pattern.trim()) {
     issues.push({
       id: 'missing-version',
       level: 'error',
       message: t('contracts.validationMissingVersion'),
-    })
+    });
   }
 
   if (!form.value.owner.trim()) {
@@ -169,7 +154,7 @@ const validationIssues = computed<ValidationIssue[]>(() => {
       id: 'missing-owner',
       level: 'warning',
       message: t('contracts.validationMissingOwner'),
-    })
+    });
   }
 
   if (!form.value.sla_p99_ms && form.value.sla_p99_ms !== 0) {
@@ -177,7 +162,7 @@ const validationIssues = computed<ValidationIssue[]>(() => {
       id: 'missing-sla',
       level: 'warning',
       message: t('contracts.validationMissingSla'),
-    })
+    });
   }
 
   if (form.value.input_fields.length === 0) {
@@ -185,7 +170,7 @@ const validationIssues = computed<ValidationIssue[]>(() => {
       id: 'missing-inputs',
       level: 'error',
       message: t('contracts.validationNoInputFields'),
-    })
+    });
   }
 
   if (form.value.output_fields.length === 0) {
@@ -193,7 +178,7 @@ const validationIssues = computed<ValidationIssue[]>(() => {
       id: 'missing-outputs',
       level: 'error',
       message: t('contracts.validationNoOutputFields'),
-    })
+    });
   }
 
   for (const duplicate of findDuplicateNames(form.value.input_fields)) {
@@ -201,7 +186,7 @@ const validationIssues = computed<ValidationIssue[]>(() => {
       id: `dup-input-${duplicate}`,
       level: 'error',
       message: t('contracts.validationDuplicateField', { name: duplicate }),
-    })
+    });
   }
 
   for (const duplicate of findDuplicateNames(form.value.output_fields)) {
@@ -209,17 +194,17 @@ const validationIssues = computed<ValidationIssue[]>(() => {
       id: `dup-output-${duplicate}`,
       level: 'error',
       message: t('contracts.validationDuplicateField', { name: duplicate }),
-    })
+    });
   }
 
   const knownInputNames = new Set([
     ...inputSuggestions.value.map((field) => field.name),
     ...catalog.facts.map((fact) => fact.name),
-  ])
-  const knownOutputNames = new Set(outputSuggestions.value.map((field) => field.name))
+  ]);
+  const knownOutputNames = new Set(outputSuggestions.value.map((field) => field.name));
 
   for (const field of form.value.input_fields) {
-    const name = field.name.trim()
+    const name = field.name.trim();
     if (name && !knownInputNames.has(name)) {
       issues.push({
         id: `unknown-input-${name}`,
@@ -232,27 +217,27 @@ const validationIssues = computed<ValidationIssue[]>(() => {
               label: t('contracts.actionCreateFact'),
             }
           : undefined,
-      })
+      });
     }
   }
 
   for (const field of form.value.output_fields) {
-    const name = field.name.trim()
+    const name = field.name.trim();
     if (name && knownOutputNames.size > 0 && !knownOutputNames.has(name)) {
       issues.push({
         id: `unknown-output-${name}`,
         level: 'warning',
         message: t('contracts.validationUnknownOutput', { name }),
-      })
+      });
     }
   }
 
-  return issues
-})
+  return issues;
+});
 
 const requestExample = computed(() =>
-  JSON.stringify(buildExampleObject(form.value.input_fields), null, 2),
-)
+  JSON.stringify(buildExampleObject(form.value.input_fields), null, 2)
+);
 
 const responseExample = computed(() =>
   JSON.stringify(
@@ -261,52 +246,52 @@ const responseExample = computed(() =>
       output: buildExampleObject(form.value.output_fields),
     },
     null,
-    2,
-  ),
-)
+    2
+  )
+);
 
 const sidebarRulesets = computed(() =>
   sortedRulesets.value.map((name) => {
-    const contract = contractMap.value.get(name)
+    const contract = contractMap.value.get(name);
     return {
       name,
       hasContract: Boolean(contract),
       inputCount: contract?.input_fields.length ?? 0,
       outputCount: contract?.output_fields.length ?? 0,
-    }
-  }),
-)
+    };
+  })
+);
 
 watch(
   [sortedRulesets, () => route.query.ruleset],
   () => {
     if (sortedRulesets.value.length === 0) {
-      selectedRulesetName.value = ''
-      return
+      selectedRulesetName.value = '';
+      return;
     }
 
-    const queryRuleset = typeof route.query.ruleset === 'string' ? route.query.ruleset : ''
+    const queryRuleset = typeof route.query.ruleset === 'string' ? route.query.ruleset : '';
     if (queryRuleset && sortedRulesets.value.includes(queryRuleset)) {
       if (selectedRulesetName.value !== queryRuleset) {
-        selectedRulesetName.value = queryRuleset
+        selectedRulesetName.value = queryRuleset;
       }
-      return
+      return;
     }
 
     if (!selectedRulesetName.value || !sortedRulesets.value.includes(selectedRulesetName.value)) {
-      selectedRulesetName.value = sortedRulesets.value[0]
+      selectedRulesetName.value = sortedRulesets.value[0];
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 watch(
   selectedRulesetName,
   async (name) => {
-    activeSection.value = 'overview'
-    rulesetLoadError.value = null
+    activeSection.value = 'overview';
+    rulesetLoadError.value = null;
 
-    if (!name) return
+    if (!name) return;
 
     if (route.query.ruleset !== name) {
       void router.replace({
@@ -314,20 +299,20 @@ watch(
           ...route.query,
           ruleset: name,
         },
-      })
+      });
     }
 
-    await ensureRulesetLoaded(name)
-    hydrateForm()
+    await ensureRulesetLoaded(name);
+    hydrateForm();
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 watch(selectedContract, () => {
   if (!isDirty.value) {
-    hydrateForm()
+    hydrateForm();
   }
-})
+});
 
 function emptyContract(rulesetName: string): ContractForm {
   return {
@@ -338,7 +323,7 @@ function emptyContract(rulesetName: string): ContractForm {
     input_fields: [],
     output_fields: [],
     notes: '',
-  }
+  };
 }
 
 function cloneField(field: ContractField): ContractField {
@@ -347,7 +332,7 @@ function cloneField(field: ContractField): ContractField {
     data_type: field.data_type,
     required: field.required,
     description: field.description ?? '',
-  }
+  };
 }
 
 function toForm(contract: DecisionContract | ContractForm): ContractForm {
@@ -359,7 +344,7 @@ function toForm(contract: DecisionContract | ContractForm): ContractForm {
     input_fields: contract.input_fields.map(cloneField),
     output_fields: contract.output_fields.map(cloneField),
     notes: contract.notes ?? '',
-  }
+  };
 }
 
 function contractSignature(contract: ContractForm): string {
@@ -371,7 +356,7 @@ function contractSignature(contract: ContractForm): string {
     input_fields: contract.input_fields.map(normalizeFieldForSignature),
     output_fields: contract.output_fields.map(normalizeFieldForSignature),
     notes: (contract.notes ?? '').trim(),
-  })
+  });
 }
 
 function normalizeFieldForSignature(field: ContractField) {
@@ -380,70 +365,70 @@ function normalizeFieldForSignature(field: ContractField) {
     data_type: field.data_type,
     required: field.required,
     description: (field.description ?? '').trim(),
-  }
+  };
 }
 
 function hydrateForm() {
-  const next = baselineContract.value
-  form.value = toForm(next)
-  baselineSignature.value = contractSignature(form.value)
+  const next = baselineContract.value;
+  form.value = toForm(next);
+  baselineSignature.value = contractSignature(form.value);
 }
 
 async function ensureRulesetLoaded(name: string) {
   if (!auth.token || !projectId.value || !orgId.value || rulesetCache.value[name]) {
-    return
+    return;
   }
 
-  loadingRuleset.value = true
+  loadingRuleset.value = true;
   try {
-    const draft = await rulesetDraftApi.get(auth.token, orgId.value, projectId.value, name)
+    const draft = await rulesetDraftApi.get(auth.token, orgId.value, projectId.value, name);
     rulesetCache.value = {
       ...rulesetCache.value,
       [name]: normalizeRuleset(draft.draft, name),
-    }
+    };
   } catch (error: any) {
-    rulesetLoadError.value = error.message || t('contracts.loadRulesetFailed')
+    rulesetLoadError.value = error.message || t('contracts.loadRulesetFailed');
   } finally {
-    loadingRuleset.value = false
+    loadingRuleset.value = false;
   }
 }
 
 function buildDraftContract(rulesetName: string, ruleset: RuleSet | null): ContractForm {
-  const draft = emptyContract(rulesetName)
+  const draft = emptyContract(rulesetName);
 
-  if (!ruleset) return draft
+  if (!ruleset) return draft;
 
-  draft.version_pattern = toVersionPattern(ruleset.config.version)
-  draft.input_fields = inferInputFields(ruleset)
-  draft.output_fields = inferOutputFields(ruleset)
+  draft.version_pattern = toVersionPattern(ruleset.config.version);
+  draft.input_fields = inferInputFields(ruleset);
+  draft.output_fields = inferOutputFields(ruleset);
 
-  return draft
+  return draft;
 }
 
 function toVersionPattern(version?: string): string {
-  if (!version) return '1.x'
-  const major = version.split('.')[0]?.trim()
-  return major ? `${major}.x` : '1.x'
+  if (!version) return '1.x';
+  const major = version.split('.')[0]?.trim();
+  return major ? `${major}.x` : '1.x';
 }
 
 function mapSchemaFieldType(type?: SchemaField['type']): FactDataType {
   switch (type) {
     case 'number':
-      return 'number'
+      return 'number';
     case 'boolean':
-      return 'boolean'
+      return 'boolean';
     case 'object':
     case 'array':
     case 'any':
-      return 'object'
+      return 'object';
     case 'string':
     default:
-      return 'string'
+      return 'string';
   }
 }
 
 function inferInputFields(ruleset: RuleSet): ContractField[] {
-  const fields = new Map<string, ContractField>()
+  const fields = new Map<string, ContractField>();
 
   for (const field of ruleset.config.inputSchema ?? []) {
     fields.set(field.name, {
@@ -451,26 +436,26 @@ function inferInputFields(ruleset: RuleSet): ContractField[] {
       data_type: mapSchemaFieldType(field.type),
       required: field.required ?? false,
       description: field.description ?? '',
-    })
+    });
   }
 
   for (const path of collectReferencedInputs(ruleset)) {
-    const fact = factLookup.value.get(path)
-    if (!fact || fields.has(path)) continue
+    const fact = factLookup.value.get(path);
+    if (!fact || fields.has(path)) continue;
 
     fields.set(path, {
       name: path,
       data_type: fact.type,
       required: fact.required ?? false,
       description: fact.description ?? '',
-    })
+    });
   }
 
-  return Array.from(fields.values())
+  return Array.from(fields.values());
 }
 
 function inferOutputFields(ruleset: RuleSet): ContractField[] {
-  const fields = new Map<string, ContractField>()
+  const fields = new Map<string, ContractField>();
 
   for (const field of ruleset.config.outputSchema ?? []) {
     fields.set(field.name, {
@@ -478,222 +463,222 @@ function inferOutputFields(ruleset: RuleSet): ContractField[] {
       data_type: mapSchemaFieldType(field.type),
       required: field.required ?? false,
       description: field.description ?? '',
-    })
+    });
   }
 
   for (const step of ruleset.steps) {
-    if (step.type !== 'terminal') continue
+    if (step.type !== 'terminal') continue;
 
     for (const output of step.output ?? []) {
-      if (!output.name || fields.has(output.name)) continue
+      if (!output.name || fields.has(output.name)) continue;
 
       fields.set(output.name, {
         name: output.name,
         data_type: inferExprDataType(output.value, ruleset),
         required: true,
         description: '',
-      })
+      });
     }
   }
 
-  return Array.from(fields.values())
+  return Array.from(fields.values());
 }
 
 function collectReferencedInputs(ruleset: RuleSet): string[] {
-  const paths = new Set<string>()
+  const paths = new Set<string>();
 
   for (const step of ruleset.steps) {
     if (step.type === 'decision') {
       for (const branch of step.branches) {
-        collectConditionPaths(branch.condition, paths)
+        collectConditionPaths(branch.condition, paths);
       }
-      continue
+      continue;
     }
 
     if (step.type === 'action') {
       for (const assignment of step.assignments ?? []) {
-        collectExprPaths(assignment.value, paths)
+        collectExprPaths(assignment.value, paths);
       }
       for (const call of step.externalCalls ?? []) {
         for (const param of Object.values(call.params ?? {})) {
-          collectExprPaths(param, paths)
+          collectExprPaths(param, paths);
         }
         if (call.fallbackValue) {
-          collectExprPaths(call.fallbackValue, paths)
+          collectExprPaths(call.fallbackValue, paths);
         }
       }
       if (step.logging?.message) {
-        collectExprPaths(step.logging.message, paths)
+        collectExprPaths(step.logging.message, paths);
       }
-      continue
+      continue;
     }
 
     if (step.type === 'terminal') {
       if (step.message) {
-        collectExprPaths(step.message, paths)
+        collectExprPaths(step.message, paths);
       }
       for (const output of step.output ?? []) {
-        collectExprPaths(output.value, paths)
+        collectExprPaths(output.value, paths);
       }
     }
   }
 
-  return Array.from(paths)
+  return Array.from(paths);
 }
 
 function collectConditionPaths(condition: Condition, paths: Set<string>) {
   switch (condition.type) {
     case 'simple':
-      collectExprPaths(condition.left, paths)
-      collectExprPaths(condition.right, paths)
-      break
+      collectExprPaths(condition.left, paths);
+      collectExprPaths(condition.right, paths);
+      break;
     case 'logical':
       for (const child of condition.conditions) {
-        collectConditionPaths(child, paths)
+        collectConditionPaths(child, paths);
       }
-      break
+      break;
     case 'not':
-      collectConditionPaths(condition.condition, paths)
-      break
+      collectConditionPaths(condition.condition, paths);
+      break;
     case 'expression':
       for (const match of condition.expression.matchAll(/\$\.([A-Za-z0-9_.]+)/g)) {
-        paths.add(match[1])
+        paths.add(match[1]);
       }
-      break
+      break;
     case 'constant':
-      break
+      break;
   }
 }
 
 function collectExprPaths(expr: Expr, paths: Set<string>) {
   switch (expr.type) {
     case 'variable': {
-      const normalized = normalizeVariablePath(expr.path)
+      const normalized = normalizeVariablePath(expr.path);
       if (normalized) {
-        paths.add(normalized)
+        paths.add(normalized);
       }
-      break
+      break;
     }
     case 'binary':
-      collectExprPaths(expr.left, paths)
-      collectExprPaths(expr.right, paths)
-      break
+      collectExprPaths(expr.left, paths);
+      collectExprPaths(expr.right, paths);
+      break;
     case 'unary':
-      collectExprPaths(expr.operand, paths)
-      break
+      collectExprPaths(expr.operand, paths);
+      break;
     case 'function':
       for (const arg of expr.args) {
-        collectExprPaths(arg, paths)
+        collectExprPaths(arg, paths);
       }
-      break
+      break;
     case 'conditional':
-      collectExprPaths(expr.condition, paths)
-      collectExprPaths(expr.thenExpr, paths)
-      collectExprPaths(expr.elseExpr, paths)
-      break
+      collectExprPaths(expr.condition, paths);
+      collectExprPaths(expr.thenExpr, paths);
+      collectExprPaths(expr.elseExpr, paths);
+      break;
     case 'array':
       for (const element of expr.elements) {
-        collectExprPaths(element, paths)
+        collectExprPaths(element, paths);
       }
-      break
+      break;
     case 'object':
       for (const value of Object.values(expr.properties)) {
-        collectExprPaths(value, paths)
+        collectExprPaths(value, paths);
       }
-      break
+      break;
     case 'member':
-      collectExprPaths(expr.object, paths)
+      collectExprPaths(expr.object, paths);
       if (typeof expr.property !== 'string') {
-        collectExprPaths(expr.property, paths)
+        collectExprPaths(expr.property, paths);
       }
-      break
+      break;
     case 'literal':
-      break
+      break;
   }
 }
 
 function normalizeVariablePath(path: string): string | null {
-  if (!path.startsWith('$.')) return null
-  return path.slice(2)
+  if (!path.startsWith('$.')) return null;
+  return path.slice(2);
 }
 
 function inferExprDataType(expr: Expr, ruleset: RuleSet): FactDataType {
   switch (expr.type) {
     case 'literal':
-      if (expr.valueType === 'number') return 'number'
-      if (expr.valueType === 'boolean') return 'boolean'
-      return 'string'
+      if (expr.valueType === 'number') return 'number';
+      if (expr.valueType === 'boolean') return 'boolean';
+      return 'string';
     case 'variable': {
-      const normalized = normalizeVariablePath(expr.path)
-      if (!normalized) return 'string'
+      const normalized = normalizeVariablePath(expr.path);
+      if (!normalized) return 'string';
 
-      const fact = factLookup.value.get(normalized)
-      if (fact) return fact.type
+      const fact = factLookup.value.get(normalized);
+      if (fact) return fact.type;
 
       for (const field of ruleset.config.inputSchema ?? []) {
-        if (field.name === normalized) return mapSchemaFieldType(field.type)
+        if (field.name === normalized) return mapSchemaFieldType(field.type);
       }
       for (const field of ruleset.config.outputSchema ?? []) {
-        if (field.name === normalized) return mapSchemaFieldType(field.type)
+        if (field.name === normalized) return mapSchemaFieldType(field.type);
       }
-      return 'string'
+      return 'string';
     }
     case 'binary':
-      if (['add', 'sub', 'mul', 'div', 'mod'].includes(expr.op)) return 'number'
-      return 'boolean'
+      if (['add', 'sub', 'mul', 'div', 'mod'].includes(expr.op)) return 'number';
+      return 'boolean';
     case 'unary':
-      return expr.op === 'neg' ? 'number' : 'boolean'
+      return expr.op === 'neg' ? 'number' : 'boolean';
     case 'conditional':
-      return inferExprDataType(expr.thenExpr, ruleset)
+      return inferExprDataType(expr.thenExpr, ruleset);
     case 'array':
     case 'object':
     case 'member':
-      return 'object'
+      return 'object';
     case 'function':
-      return 'string'
+      return 'string';
   }
 }
 
 function findDuplicateNames(fields: ContractField[]): string[] {
-  const seen = new Set<string>()
-  const duplicates = new Set<string>()
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
 
   for (const field of fields) {
-    const name = field.name.trim()
-    if (!name) continue
+    const name = field.name.trim();
+    if (!name) continue;
     if (seen.has(name)) {
-      duplicates.add(name)
+      duplicates.add(name);
     } else {
-      seen.add(name)
+      seen.add(name);
     }
   }
 
-  return Array.from(duplicates)
+  return Array.from(duplicates);
 }
 
 function buildExampleObject(fields: ContractField[]) {
-  const payload: Record<string, unknown> = {}
+  const payload: Record<string, unknown> = {};
   for (const field of fields) {
-    const name = field.name.trim()
-    if (!name) continue
-    payload[name] = sampleValueForType(field.data_type)
+    const name = field.name.trim();
+    if (!name) continue;
+    payload[name] = sampleValueForType(field.data_type);
   }
-  return payload
+  return payload;
 }
 
 function sampleValueForType(type: FactDataType): unknown {
   switch (type) {
     case 'number':
-      return 100
+      return 100;
     case 'boolean':
-      return true
+      return true;
     case 'date':
-      return '2026-04-12T00:00:00Z'
+      return '2026-04-12T00:00:00Z';
     case 'object':
-      return {}
+      return {};
     case 'string':
     default:
-      return 'example'
+      return 'example';
   }
 }
 
@@ -703,28 +688,28 @@ function addField(list: ContractField[]) {
     data_type: 'string',
     required: true,
     description: '',
-  })
+  });
 }
 
 function removeField(list: ContractField[], index: number) {
-  list.splice(index, 1)
+  list.splice(index, 1);
 }
 
 function applyInputSuggestions() {
-  form.value.input_fields = inputSuggestions.value.map(cloneField)
+  form.value.input_fields = inputSuggestions.value.map(cloneField);
 }
 
 function applyOutputSuggestions() {
-  form.value.output_fields = outputSuggestions.value.map(cloneField)
+  form.value.output_fields = outputSuggestions.value.map(cloneField);
 }
 
 function refreshFromRuleset() {
-  hydrateForm()
+  hydrateForm();
 }
 
 async function handleSave() {
-  if (!selectedRulesetName.value) return
-  saving.value = true
+  if (!selectedRulesetName.value) return;
+  saving.value = true;
   try {
     const saved = await catalog.upsertContract(selectedRulesetName.value, {
       version_pattern: form.value.version_pattern.trim(),
@@ -743,24 +728,24 @@ async function handleSave() {
         description: field.description?.trim() || undefined,
       })),
       notes: form.value.notes?.trim() || undefined,
-    })
+    });
     if (!saved) {
-      throw new Error(t('contracts.saveFailed'))
+      throw new Error(t('contracts.saveFailed'));
     }
-    form.value = toForm(saved)
-    baselineSignature.value = contractSignature(form.value)
-    MessagePlugin.success(t('contracts.saveSuccess'))
+    form.value = toForm(saved);
+    baselineSignature.value = contractSignature(form.value);
+    MessagePlugin.success(t('contracts.saveSuccess'));
   } catch (error: any) {
-    MessagePlugin.error(error.message || t('contracts.saveFailed'))
+    MessagePlugin.error(error.message || t('contracts.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 function handleDelete() {
-  if (!selectedRulesetName.value) return
+  if (!selectedRulesetName.value) return;
 
-  const name = selectedRulesetName.value
+  const name = selectedRulesetName.value;
   const dialog = DialogPlugin.confirm({
     header: t('contracts.deleteDialog'),
     body: t('contracts.deleteConfirm', { name }),
@@ -768,53 +753,55 @@ function handleDelete() {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await catalog.deleteContract(name)
-        dialog.hide()
-        hydrateForm()
-        MessagePlugin.success(t('contracts.deleteSuccess'))
+        await catalog.deleteContract(name);
+        dialog.hide();
+        hydrateForm();
+        MessagePlugin.success(t('contracts.deleteSuccess'));
       } catch (error: any) {
-        MessagePlugin.error(error.message || t('contracts.saveFailed'))
+        MessagePlugin.error(error.message || t('contracts.saveFailed'));
       }
     },
-  })
+  });
 }
 
 function openRulesetEditor() {
-  if (!selectedRulesetName.value) return
-  void router.push(`/orgs/${orgId.value}/projects/${projectId.value}/editor/${selectedRulesetName.value}`)
+  if (!selectedRulesetName.value) return;
+  void router.push(
+    `/orgs/${orgId.value}/projects/${projectId.value}/editor/${selectedRulesetName.value}`
+  );
 }
 
 function handleValidationAction(issue: ValidationIssue) {
-  if (!issue.action) return
+  if (!issue.action) return;
 
   if (issue.action.kind === 'create-fact') {
     void router.push({
       path: `/orgs/${orgId.value}/projects/${projectId.value}/facts`,
       query: { createFact: issue.action.name },
-    })
+    });
   }
 }
 
 function selectRuleset(name: string) {
-  selectedRulesetName.value = name
+  selectedRulesetName.value = name;
 }
 
 function sectionLabel(section: SectionKey): string {
   switch (section) {
     case 'overview':
-      return t('contracts.overviewTab')
+      return t('contracts.overviewTab');
     case 'inputs':
-      return t('contracts.inputFields')
+      return t('contracts.inputFields');
     case 'outputs':
-      return t('contracts.outputFields')
+      return t('contracts.outputFields');
     case 'notes':
-      return t('contracts.notesLabel')
+      return t('contracts.notesLabel');
   }
 }
 
 function summaryRowForRuleset() {
-  const ruleset = selectedRuleset.value
-  if (!ruleset) return []
+  const ruleset = selectedRuleset.value;
+  if (!ruleset) return [];
 
   return [
     ...ruleset.steps
@@ -825,7 +812,9 @@ function summaryRowForRuleset() {
         title: step.name,
         detail:
           step.type === 'decision'
-            ? step.branches.map((branch) => branch.label || conditionToString(branch.condition)).join(' · ')
+            ? step.branches
+                .map((branch) => branch.label || conditionToString(branch.condition))
+                .join(' · ')
             : '',
       })),
     ...ruleset.steps
@@ -834,17 +823,26 @@ function summaryRowForRuleset() {
       .map((step) => ({
         id: step.id,
         title: step.name,
-        detail: step.type === 'terminal' ? (step.output ?? []).map((field) => `${field.name} = ${exprToString(field.value)}`).join(' · ') : '',
+        detail:
+          step.type === 'terminal'
+            ? (step.output ?? [])
+                .map((field) => `${field.name} = ${exprToString(field.value)}`)
+                .join(' · ')
+            : '',
       })),
-  ]
+  ];
 }
 </script>
 
 <template>
   <div class="contract-view">
     <t-breadcrumb class="asset-breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{ t('breadcrumb.projects') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{
+        t('breadcrumb.projects')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('projectNav.contracts') }}</t-breadcrumb-item>
     </t-breadcrumb>
 
@@ -860,7 +858,7 @@ function summaryRowForRuleset() {
     </div>
 
     <div v-else-if="projectStore.rulesets.length === 0" class="asset-empty">
-      <t-icon name="file-safety" size="40px" style="opacity:0.3" />
+      <t-icon name="file-safety" size="40px" style="opacity: 0.3" />
       <p>{{ t('contracts.noRulesets') }}</p>
     </div>
 
@@ -897,14 +895,20 @@ function summaryRowForRuleset() {
             <div class="contract-main__title-row">
               <h3 class="contract-main__title">{{ selectedRulesetName }}</h3>
               <t-tag size="small" variant="light" :theme="selectedContract ? 'success' : 'warning'">
-                {{ selectedContract ? t('contracts.workspaceSaved') : t('contracts.workspaceDraft') }}
+                {{
+                  selectedContract ? t('contracts.workspaceSaved') : t('contracts.workspaceDraft')
+                }}
               </t-tag>
               <t-tag v-if="selectedRulesetInfo?.version" size="small" variant="light">
                 v{{ selectedRulesetInfo.version }}
               </t-tag>
             </div>
             <p class="contract-main__subtitle">
-              {{ selectedRuleset?.config.description || selectedRulesetInfo?.description || t('project.noDesc') }}
+              {{
+                selectedRuleset?.config.description ||
+                selectedRulesetInfo?.description ||
+                t('project.noDesc')
+              }}
             </p>
           </div>
 
@@ -915,7 +919,14 @@ function summaryRowForRuleset() {
             <t-button size="small" variant="outline" @click="refreshFromRuleset">
               {{ t('contracts.refreshDraft') }}
             </t-button>
-            <t-button v-if="canEdit" size="small" theme="primary" :loading="saving" :disabled="!isDirty" @click="handleSave">
+            <t-button
+              v-if="canEdit"
+              size="small"
+              theme="primary"
+              :loading="saving"
+              :disabled="!isDirty"
+              @click="handleSave"
+            >
               {{ t('contracts.saveBtn') }}
             </t-button>
             <t-button
@@ -993,11 +1004,7 @@ function summaryRowForRuleset() {
 
                   <label class="contract-form-item">
                     <span class="contract-form-item__label">{{ t('contracts.slaLabel') }}</span>
-                    <t-input-number
-                      v-model="form.sla_p99_ms"
-                      :disabled="!canEdit"
-                      :min="0"
-                    />
+                    <t-input-number v-model="form.sla_p99_ms" :disabled="!canEdit" :min="0" />
                   </label>
                 </div>
 
@@ -1028,14 +1035,29 @@ function summaryRowForRuleset() {
               <template v-else-if="activeSection === 'inputs'">
                 <div class="field-toolbar">
                   <div>
-                    <div class="field-toolbar__title">{{ t('contracts.inputCount', { count: form.input_fields.length }) }}</div>
-                    <div class="field-toolbar__hint">{{ t('contracts.detectedInputs') }}: {{ inputSuggestions.length }}</div>
+                    <div class="field-toolbar__title">
+                      {{ t('contracts.inputCount', { count: form.input_fields.length }) }}
+                    </div>
+                    <div class="field-toolbar__hint">
+                      {{ t('contracts.detectedInputs') }}: {{ inputSuggestions.length }}
+                    </div>
                   </div>
                   <div class="field-toolbar__actions">
-                    <t-button size="small" variant="outline" :disabled="!canEdit" @click="applyInputSuggestions">
+                    <t-button
+                      size="small"
+                      variant="outline"
+                      :disabled="!canEdit"
+                      @click="applyInputSuggestions"
+                    >
                       {{ t('contracts.useSuggestedInputs') }}
                     </t-button>
-                    <t-button size="small" theme="primary" variant="outline" :disabled="!canEdit" @click="addField(form.input_fields)">
+                    <t-button
+                      size="small"
+                      theme="primary"
+                      variant="outline"
+                      :disabled="!canEdit"
+                      @click="addField(form.input_fields)"
+                    >
                       <t-icon name="add" />
                       {{ t('contracts.addInput') }}
                     </t-button>
@@ -1047,13 +1069,29 @@ function summaryRowForRuleset() {
                 </div>
 
                 <div v-else class="field-editor">
-                  <div v-for="(field, index) in form.input_fields" :key="index" class="field-editor__row">
-                    <t-input v-model="field.name" :disabled="!canEdit" :placeholder="t('contracts.fieldName')" />
-                    <t-select v-model="field.data_type" :disabled="!canEdit" :options="dataTypeOptions" />
+                  <div
+                    v-for="(field, index) in form.input_fields"
+                    :key="index"
+                    class="field-editor__row"
+                  >
+                    <t-input
+                      v-model="field.name"
+                      :disabled="!canEdit"
+                      :placeholder="t('contracts.fieldName')"
+                    />
+                    <t-select
+                      v-model="field.data_type"
+                      :disabled="!canEdit"
+                      :options="dataTypeOptions"
+                    />
                     <t-checkbox v-model="field.required" :disabled="!canEdit">
                       {{ t('contracts.required') }}
                     </t-checkbox>
-                    <t-input v-model="field.description" :disabled="!canEdit" :placeholder="t('contracts.fieldDesc')" />
+                    <t-input
+                      v-model="field.description"
+                      :disabled="!canEdit"
+                      :placeholder="t('contracts.fieldDesc')"
+                    />
                     <t-button
                       size="small"
                       variant="text"
@@ -1070,14 +1108,29 @@ function summaryRowForRuleset() {
               <template v-else-if="activeSection === 'outputs'">
                 <div class="field-toolbar">
                   <div>
-                    <div class="field-toolbar__title">{{ t('contracts.outputCount', { count: form.output_fields.length }) }}</div>
-                    <div class="field-toolbar__hint">{{ t('contracts.detectedOutputs') }}: {{ outputSuggestions.length }}</div>
+                    <div class="field-toolbar__title">
+                      {{ t('contracts.outputCount', { count: form.output_fields.length }) }}
+                    </div>
+                    <div class="field-toolbar__hint">
+                      {{ t('contracts.detectedOutputs') }}: {{ outputSuggestions.length }}
+                    </div>
                   </div>
                   <div class="field-toolbar__actions">
-                    <t-button size="small" variant="outline" :disabled="!canEdit" @click="applyOutputSuggestions">
+                    <t-button
+                      size="small"
+                      variant="outline"
+                      :disabled="!canEdit"
+                      @click="applyOutputSuggestions"
+                    >
                       {{ t('contracts.useSuggestedOutputs') }}
                     </t-button>
-                    <t-button size="small" theme="primary" variant="outline" :disabled="!canEdit" @click="addField(form.output_fields)">
+                    <t-button
+                      size="small"
+                      theme="primary"
+                      variant="outline"
+                      :disabled="!canEdit"
+                      @click="addField(form.output_fields)"
+                    >
                       <t-icon name="add" />
                       {{ t('contracts.addOutput') }}
                     </t-button>
@@ -1089,13 +1142,29 @@ function summaryRowForRuleset() {
                 </div>
 
                 <div v-else class="field-editor">
-                  <div v-for="(field, index) in form.output_fields" :key="index" class="field-editor__row">
-                    <t-input v-model="field.name" :disabled="!canEdit" :placeholder="t('contracts.fieldName')" />
-                    <t-select v-model="field.data_type" :disabled="!canEdit" :options="dataTypeOptions" />
+                  <div
+                    v-for="(field, index) in form.output_fields"
+                    :key="index"
+                    class="field-editor__row"
+                  >
+                    <t-input
+                      v-model="field.name"
+                      :disabled="!canEdit"
+                      :placeholder="t('contracts.fieldName')"
+                    />
+                    <t-select
+                      v-model="field.data_type"
+                      :disabled="!canEdit"
+                      :options="dataTypeOptions"
+                    />
                     <t-checkbox v-model="field.required" :disabled="!canEdit">
                       {{ t('contracts.required') }}
                     </t-checkbox>
-                    <t-input v-model="field.description" :disabled="!canEdit" :placeholder="t('contracts.fieldDesc')" />
+                    <t-input
+                      v-model="field.description"
+                      :disabled="!canEdit"
+                      :placeholder="t('contracts.fieldDesc')"
+                    />
                     <t-button
                       size="small"
                       variant="text"
@@ -1127,8 +1196,18 @@ function summaryRowForRuleset() {
             <section class="assist-card">
               <div class="assist-card__header">
                 <h4>{{ t('contracts.healthTitle') }}</h4>
-                <t-tag size="small" :theme="validationIssues.some((item) => item.level === 'error') ? 'danger' : 'success'" variant="light">
-                  {{ validationIssues.length === 0 ? t('contracts.healthReady') : t('contracts.healthNeedsWork') }}
+                <t-tag
+                  size="small"
+                  :theme="
+                    validationIssues.some((item) => item.level === 'error') ? 'danger' : 'success'
+                  "
+                  variant="light"
+                >
+                  {{
+                    validationIssues.length === 0
+                      ? t('contracts.healthReady')
+                      : t('contracts.healthNeedsWork')
+                  }}
                 </t-tag>
               </div>
               <div v-if="validationIssues.length === 0" class="assist-empty">
diff --git a/ordo-editor/apps/studio/src/views/project/CreateReleaseRequestView.vue b/ordo-editor/apps/studio/src/views/project/CreateReleaseRequestView.vue
index 061fe342..b6cd6e1b 100644
--- a/ordo-editor/apps/studio/src/views/project/CreateReleaseRequestView.vue
+++ b/ordo-editor/apps/studio/src/views/project/CreateReleaseRequestView.vue
@@ -1,33 +1,33 @@
 <script setup lang="ts">
-import { computed, nextTick, onMounted, ref, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import type { ReleaseTargetPreview } from '@/api/types'
-import { releaseApi } from '@/api/platform-client'
-import { useAuthStore } from '@/stores/auth'
-import { useEnvironmentStore } from '@/stores/environment'
-import { useProjectStore } from '@/stores/project'
-import { useRbacStore } from '@/stores/rbac'
-import { useRolloutStrategyLabel } from '@/constants/release-center'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const labelRolloutStrategy = useRolloutStrategyLabel()
-const auth = useAuthStore()
-const envStore = useEnvironmentStore()
-const projectStore = useProjectStore()
-const rbacStore = useRbacStore()
-
-const orgId = route.params.orgId as string
-const projectId = route.params.projectId as string
-
-const loading = ref(true)
-const submitting = ref(false)
-const policies = ref<any[]>([])
-const previewLoading = ref(false)
-const targetPreview = ref<ReleaseTargetPreview | null>(null)
+import { computed, nextTick, onMounted, ref, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import type { ReleaseTargetPreview } from '@/api/types';
+import { releaseApi } from '@/api/platform-client';
+import { useAuthStore } from '@/stores/auth';
+import { useEnvironmentStore } from '@/stores/environment';
+import { useProjectStore } from '@/stores/project';
+import { useRbacStore } from '@/stores/rbac';
+import { useRolloutStrategyLabel } from '@/constants/release-center';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const labelRolloutStrategy = useRolloutStrategyLabel();
+const auth = useAuthStore();
+const envStore = useEnvironmentStore();
+const projectStore = useProjectStore();
+const rbacStore = useRbacStore();
+
+const orgId = route.params.orgId as string;
+const projectId = route.params.projectId as string;
+
+const loading = ref(true);
+const submitting = ref(false);
+const policies = ref<any[]>([]);
+const previewLoading = ref(false);
+const targetPreview = ref<ReleaseTargetPreview | null>(null);
 
 const form = ref({
   ruleset_name: (route.query.ruleset as string) || '',
@@ -39,79 +39,80 @@ const form = ref({
   release_note: '',
   rollback_version: '',
   affected_instance_count: 0,
-})
+});
 
 // ── Derived options ──────────────────────────────────────────────────────────
 
 const ruleOptions = computed(() =>
-  projectStore.rulesets.map((r) => ({ label: r.name, value: r.name, version: r.version })),
-)
+  projectStore.rulesets.map((r) => ({ label: r.name, value: r.name, version: r.version }))
+);
 const environmentOptions = computed(() =>
-  envStore.environments.map((e) => ({ label: e.name, value: e.id })),
-)
+  envStore.environments.map((e) => ({ label: e.name, value: e.id }))
+);
 const policyOptions = computed(() =>
-  policies.value.map((p) => ({ label: p.name, value: p.id, target_id: p.target_id })),
-)
-
-const selectedRule = computed(() =>
-  projectStore.rulesets.find((r) => r.name === form.value.ruleset_name) ?? null,
-)
-const selectedPublishedVersion = computed(() => selectedRule.value?.published_version ?? '')
-const selectedEnvironment = computed(() =>
-  envStore.environments.find((e) => e.id === form.value.environment_id) ?? null,
-)
-const selectedPolicy = computed(() =>
-  policies.value.find((p) => p.id === form.value.policy_id) ?? null,
-)
-const canManagePolicies = computed(() => rbacStore.can('release:policy.manage'))
-const hasPolicies = computed(() => policies.value.length > 0)
+  policies.value.map((p) => ({ label: p.name, value: p.id, target_id: p.target_id }))
+);
+
+const selectedRule = computed(
+  () => projectStore.rulesets.find((r) => r.name === form.value.ruleset_name) ?? null
+);
+const selectedPublishedVersion = computed(() => selectedRule.value?.published_version ?? '');
+const selectedEnvironment = computed(
+  () => envStore.environments.find((e) => e.id === form.value.environment_id) ?? null
+);
+const selectedPolicy = computed(
+  () => policies.value.find((p) => p.id === form.value.policy_id) ?? null
+);
+const canManagePolicies = computed(() => rbacStore.can('release:policy.manage'));
+const hasPolicies = computed(() => policies.value.length > 0);
 
 // ── Auto-fill logic ──────────────────────────────────────────────────────────
 
 watch(
   () => form.value.ruleset_name,
   (name) => {
-    const match = projectStore.rulesets.find((r) => r.name === name)
+    const match = projectStore.rulesets.find((r) => r.name === name);
     if (!match) {
-      form.value.version = ''
-      form.value.rollback_version = ''
-      return
+      form.value.version = '';
+      form.value.rollback_version = '';
+      return;
     }
-    form.value.version = match.version || '1.0.0'
-    form.value.rollback_version = match.published_version || ''
-    if (!form.value.title) form.value.title = `${match.name} ${t('releaseCenter.requestTitleSuffix')}`
+    form.value.version = match.version || '1.0.0';
+    form.value.rollback_version = match.published_version || '';
+    if (!form.value.title)
+      form.value.title = `${match.name} ${t('releaseCenter.requestTitleSuffix')}`;
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 watch(
   () => [form.value.environment_id, policies.value.length] as const,
   ([envId]) => {
-    if (!envId) return
-    const matched = policies.value.find((p) => p.target_id === envId)
-    if (matched && !form.value.policy_id) form.value.policy_id = matched.id
-  },
-)
+    if (!envId) return;
+    const matched = policies.value.find((p) => p.target_id === envId);
+    if (matched && !form.value.policy_id) form.value.policy_id = matched.id;
+  }
+);
 
 watch(
   () => form.value.environment_id,
   async (environmentId) => {
-    targetPreview.value = null
-    form.value.affected_instance_count = 0
-    if (!environmentId || !auth.token) return
-    previewLoading.value = true
+    targetPreview.value = null;
+    form.value.affected_instance_count = 0;
+    if (!environmentId || !auth.token) return;
+    previewLoading.value = true;
     try {
-      const preview = await releaseApi.previewTarget(auth.token, orgId, projectId, environmentId)
-      targetPreview.value = preview
-      form.value.affected_instance_count = preview.affected_instance_count
+      const preview = await releaseApi.previewTarget(auth.token, orgId, projectId, environmentId);
+      targetPreview.value = preview;
+      form.value.affected_instance_count = preview.affected_instance_count;
     } catch (e: any) {
-      MessagePlugin.error(e.message || t('common.loadFailed'))
+      MessagePlugin.error(e.message || t('common.loadFailed'));
     } finally {
-      previewLoading.value = false
+      previewLoading.value = false;
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 // ── Lifecycle ────────────────────────────────────────────────────────────────
 
@@ -123,39 +124,39 @@ onMounted(async () => {
       rbacStore.fetchRoles(orgId),
       rbacStore.fetchMyRoles(orgId),
       refreshPolicies(),
-    ])
-    await nextTick()
+    ]);
+    await nextTick();
     if (!form.value.ruleset_name && projectStore.rulesets.length > 0) {
-      form.value.ruleset_name = projectStore.rulesets[0].name
+      form.value.ruleset_name = projectStore.rulesets[0].name;
     }
     // Set default environment
     if (!form.value.environment_id) {
-      const def = envStore.environments.find((e) => e.is_default) ?? envStore.environments[0]
-      if (def) form.value.environment_id = def.id
+      const def = envStore.environments.find((e) => e.is_default) ?? envStore.environments[0];
+      if (def) form.value.environment_id = def.id;
     }
     // Set default policy for environment
     if (form.value.environment_id && !form.value.policy_id) {
-      const matched = policies.value.find((p) => p.target_id === form.value.environment_id)
-      if (matched) form.value.policy_id = matched.id
+      const matched = policies.value.find((p) => p.target_id === form.value.environment_id);
+      if (matched) form.value.policy_id = matched.id;
     }
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.loadFailed'))
+    MessagePlugin.error(e.message || t('common.loadFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 async function refreshPolicies() {
-  if (!auth.token) return
-  policies.value = await releaseApi.listPolicies(auth.token, orgId, projectId)
+  if (!auth.token) return;
+  policies.value = await releaseApi.listPolicies(auth.token, orgId, projectId);
 }
 
 // ── Submit ───────────────────────────────────────────────────────────────────
 
 async function handleSubmit() {
   if (!auth.token) {
-    MessagePlugin.error(t('auth.loginFailed'))
-    return
+    MessagePlugin.error(t('auth.loginFailed'));
+    return;
   }
   if (
     !form.value.ruleset_name ||
@@ -164,10 +165,10 @@ async function handleSubmit() {
     !form.value.title ||
     !form.value.change_summary
   ) {
-    MessagePlugin.warning(t('releaseCenter.formRequired'))
-    return
+    MessagePlugin.warning(t('releaseCenter.formRequired'));
+    return;
   }
-  submitting.value = true
+  submitting.value = true;
   try {
     const created = await releaseApi.createRequest(auth.token, orgId, projectId, {
       ruleset_name: form.value.ruleset_name,
@@ -179,21 +180,21 @@ async function handleSubmit() {
       release_note: form.value.release_note || undefined,
       rollback_version: form.value.rollback_version || undefined,
       affected_instance_count: targetPreview.value?.affected_instance_count ?? 0,
-    })
-    MessagePlugin.success(t('releaseCenter.requestCreated'))
+    });
+    MessagePlugin.success(t('releaseCenter.requestCreated'));
     router.replace({
       name: 'project-release-request-detail',
       params: { orgId, projectId, releaseId: created.id },
-    })
+    });
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('releaseCenter.requestCreateFailed'))
+    MessagePlugin.error(e.message || t('releaseCenter.requestCreateFailed'));
   } finally {
-    submitting.value = false
+    submitting.value = false;
   }
 }
 
 function handleCancel() {
-  router.push({ name: 'project-release-requests', params: { orgId, projectId } })
+  router.push({ name: 'project-release-requests', params: { orgId, projectId } });
 }
 
 function goToPolicies() {
@@ -201,7 +202,7 @@ function goToPolicies() {
     name: 'project-release-policies',
     params: { orgId, projectId },
     query: { create: '1' },
-  })
+  });
 }
 </script>
 
@@ -224,7 +225,6 @@ function goToPolicies() {
       <!-- Left: form -->
       <div class="form-col">
         <t-form label-align="top" :colon="false">
-
           <div class="section-label">{{ t('releaseCenter.sectionTarget') }}</div>
           <div class="field-row">
             <t-form-item :label="t('releaseCenter.rulesetField')" required>
@@ -322,20 +322,24 @@ function goToPolicies() {
               <span>
                 {{
                   targetPreview?.bound_servers?.length
-                    ? `${targetPreview.bound_servers.length} ${t('releaseCenter.affectedInstances')} · ${targetPreview.bound_servers.map((server) => server.name).join(', ')}`
-                    : (targetPreview?.message || t('releaseCenter.noBoundServer'))
+                    ? `${targetPreview.bound_servers.length} ${t(
+                        'releaseCenter.affectedInstances'
+                      )} · ${targetPreview.bound_servers.map((server) => server.name).join(', ')}`
+                    : targetPreview?.message || t('releaseCenter.noBoundServer')
                 }}
               </span>
             </div>
             <div v-if="targetPreview?.bound_servers?.length" class="notice-sub">
               {{
                 targetPreview.bound_servers
-                  .map((server) => `${server.name} · ${t(`releaseCenter.serverStatusMap.${server.status}`)}`)
+                  .map(
+                    (server) =>
+                      `${server.name} · ${t(`releaseCenter.serverStatusMap.${server.status}`)}`
+                  )
                   .join(' / ')
               }}
             </div>
           </div>
-
         </t-form>
 
         <!-- Actions -->
@@ -369,7 +373,9 @@ function goToPolicies() {
           <div class="preview-kv">
             <div class="kv-item">
               <span>{{ t('releaseCenter.rolloutStrategy') }}</span>
-              <strong>{{ selectedPolicy ? labelRolloutStrategy(selectedPolicy.rollout_strategy) : '—' }}</strong>
+              <strong>{{
+                selectedPolicy ? labelRolloutStrategy(selectedPolicy.rollout_strategy) : '—'
+              }}</strong>
             </div>
             <div class="kv-item">
               <span>{{ t('releaseCenter.policyField') }}</span>
@@ -385,7 +391,9 @@ function goToPolicies() {
             </div>
             <div class="kv-item">
               <span>{{ t('releaseCenter.executionNode') }}</span>
-              <strong>{{ targetPreview?.bound_servers?.map((server) => server.name).join(', ') || '—' }}</strong>
+              <strong>{{
+                targetPreview?.bound_servers?.map((server) => server.name).join(', ') || '—'
+              }}</strong>
             </div>
             <div class="kv-item">
               <span>{{ t('releaseCenter.requesterLabel') }}</span>
diff --git a/ordo-editor/apps/studio/src/views/project/DeploymentsView.vue b/ordo-editor/apps/studio/src/views/project/DeploymentsView.vue
index 45064e44..041dcb14 100644
--- a/ordo-editor/apps/studio/src/views/project/DeploymentsView.vue
+++ b/ordo-editor/apps/studio/src/views/project/DeploymentsView.vue
@@ -1,64 +1,70 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue'
-import { useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useAuthStore } from '@/stores/auth'
-import { useEnvironmentStore } from '@/stores/environment'
-import { rulesetDraftApi } from '@/api/platform-client'
-import ReleaseNav from '@/components/project/ReleaseNav.vue'
-import { StudioDialogActions, StudioPageHeader } from '@/components/ui'
-import type { RulesetDeployment } from '@/api/types'
-
-const route = useRoute()
-const { t } = useI18n()
-const auth = useAuthStore()
-const envStore = useEnvironmentStore()
-
-const orgId = route.params.orgId as string
-const projectId = route.params.projectId as string
-
-const deployments = ref<RulesetDeployment[]>([])
-const loading = ref(false)
-const redeployingId = ref<string | null>(null)
-const showRedeployDialog = ref(false)
-const selectedDeployment = ref<RulesetDeployment | null>(null)
-const redeployEnvId = ref('')
+import { onMounted, ref } from 'vue';
+import { useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useAuthStore } from '@/stores/auth';
+import { useEnvironmentStore } from '@/stores/environment';
+import { rulesetDraftApi } from '@/api/platform-client';
+import ReleaseNav from '@/components/project/ReleaseNav.vue';
+import { StudioDialogActions, StudioPageHeader } from '@/components/ui';
+import type { RulesetDeployment } from '@/api/types';
+
+const route = useRoute();
+const { t } = useI18n();
+const auth = useAuthStore();
+const envStore = useEnvironmentStore();
+
+const orgId = route.params.orgId as string;
+const projectId = route.params.projectId as string;
+
+const deployments = ref<RulesetDeployment[]>([]);
+const loading = ref(false);
+const redeployingId = ref<string | null>(null);
+const showRedeployDialog = ref(false);
+const selectedDeployment = ref<RulesetDeployment | null>(null);
+const redeployEnvId = ref('');
 
 onMounted(async () => {
-  loading.value = true
+  loading.value = true;
   try {
-    await envStore.fetchEnvironments(orgId, projectId)
-    redeployEnvId.value = envStore.environments.find((env) => env.is_default)?.id ?? ''
-    deployments.value = await rulesetDraftApi.listProjectDeployments(auth.token!, orgId, projectId, 100)
+    await envStore.fetchEnvironments(orgId, projectId);
+    redeployEnvId.value = envStore.environments.find((env) => env.is_default)?.id ?? '';
+    deployments.value = await rulesetDraftApi.listProjectDeployments(
+      auth.token!,
+      orgId,
+      projectId,
+      100
+    );
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 function statusTheme(status: string) {
-  if (status === 'success') return 'success'
-  if (status === 'failed') return 'danger'
-  return 'warning'
+  if (status === 'success') return 'success';
+  if (status === 'failed') return 'danger';
+  return 'warning';
 }
 
 function statusLabel(status: string) {
-  if (status === 'queued') return t('deployments.statusQueued')
-  if (status === 'success') return t('deployments.statusSuccess')
-  return t('deployments.statusFailed')
+  if (status === 'queued') return t('deployments.statusQueued');
+  if (status === 'success') return t('deployments.statusSuccess');
+  return t('deployments.statusFailed');
 }
 
 function openRedeploy(dep: RulesetDeployment) {
-  selectedDeployment.value = dep
-  redeployEnvId.value = envStore.environments.find((env) => env.is_default)?.id ?? dep.environment_id
-  showRedeployDialog.value = true
+  selectedDeployment.value = dep;
+  redeployEnvId.value =
+    envStore.environments.find((env) => env.is_default)?.id ?? dep.environment_id;
+  showRedeployDialog.value = true;
 }
 
 async function confirmRedeploy() {
-  if (!selectedDeployment.value || !redeployEnvId.value) return
-  const dep = selectedDeployment.value
-  redeployingId.value = dep.id
-  showRedeployDialog.value = false
+  if (!selectedDeployment.value || !redeployEnvId.value) return;
+  const dep = selectedDeployment.value;
+  redeployingId.value = dep.id;
+  showRedeployDialog.value = false;
   try {
     const newDep = await rulesetDraftApi.redeploy(
       auth.token!,
@@ -66,26 +72,29 @@ async function confirmRedeploy() {
       projectId,
       dep.ruleset_name,
       dep.id,
-      { environment_id: redeployEnvId.value },
-    )
-    deployments.value.unshift(newDep)
-    MessagePlugin.success(t('deployments.redeploySuccess'))
+      { environment_id: redeployEnvId.value }
+    );
+    deployments.value.unshift(newDep);
+    MessagePlugin.success(t('deployments.redeploySuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    redeployingId.value = null
-    selectedDeployment.value = null
+    redeployingId.value = null;
+    selectedDeployment.value = null;
   }
 }
 
 function formatDate(dt: string) {
-  return new Date(dt).toLocaleString()
+  return new Date(dt).toLocaleString();
 }
 </script>
 
 <template>
   <div class="view-page">
-    <StudioPageHeader :title="t('releaseCenter.historyTitle')" :subtitle="t('releaseCenter.historySubtitle')" />
+    <StudioPageHeader
+      :title="t('releaseCenter.historyTitle')"
+      :subtitle="t('releaseCenter.historySubtitle')"
+    />
     <ReleaseNav />
 
     <div v-if="loading" class="list-skeleton">
@@ -129,7 +138,9 @@ function formatDate(dt: string) {
             :loading="redeployingId === dep.id"
             @click="openRedeploy(dep)"
           >
-            {{ redeployingId === dep.id ? t('deployments.redeploying') : t('deployments.redeploy') }}
+            {{
+              redeployingId === dep.id ? t('deployments.redeploying') : t('deployments.redeploy')
+            }}
           </t-button>
         </div>
       </t-card>
@@ -155,8 +166,12 @@ function formatDate(dt: string) {
         </t-form-item>
       </t-form>
       <StudioDialogActions>
-        <t-button variant="outline" @click="showRedeployDialog = false">{{ t('common.cancel') }}</t-button>
-        <t-button theme="primary" @click="confirmRedeploy">{{ t('deployments.redeploy') }}</t-button>
+        <t-button variant="outline" @click="showRedeployDialog = false">{{
+          t('common.cancel')
+        }}</t-button>
+        <t-button theme="primary" @click="confirmRedeploy">{{
+          t('deployments.redeploy')
+        }}</t-button>
       </StudioDialogActions>
     </t-dialog>
   </div>
diff --git a/ordo-editor/apps/studio/src/views/project/EnvironmentFormView.vue b/ordo-editor/apps/studio/src/views/project/EnvironmentFormView.vue
index 6850c3a1..ca99b31a 100644
--- a/ordo-editor/apps/studio/src/views/project/EnvironmentFormView.vue
+++ b/ordo-editor/apps/studio/src/views/project/EnvironmentFormView.vue
@@ -1,30 +1,30 @@
 <script setup lang="ts">
-import { computed, onMounted, ref, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import type { ProjectEnvironment, ServerInfo } from '@/api/types'
-import { useEnvironmentStore } from '@/stores/environment'
-import { useServerStore } from '@/stores/server'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const envStore = useEnvironmentStore()
-const serverStore = useServerStore()
-
-const orgId = route.params.orgId as string
-const projectId = route.params.projectId as string
-const envId = computed(() => route.params.envId as string | undefined)
-const isEdit = computed(() => !!envId.value)
-
-const loading = ref(true)
-const saving = ref(false)
-const environment = ref<ProjectEnvironment | null>(null)
-const serverKeyword = ref('')
-const serverFilter = ref<'healthy' | 'all'>('healthy')
-const natsPrefixTouched = ref(false)
-const lastSelectedServerId = ref<string | null>(null)
+import { computed, onMounted, ref, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import type { ProjectEnvironment, ServerInfo } from '@/api/types';
+import { useEnvironmentStore } from '@/stores/environment';
+import { useServerStore } from '@/stores/server';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const envStore = useEnvironmentStore();
+const serverStore = useServerStore();
+
+const orgId = route.params.orgId as string;
+const projectId = route.params.projectId as string;
+const envId = computed(() => route.params.envId as string | undefined);
+const isEdit = computed(() => !!envId.value);
+
+const loading = ref(true);
+const saving = ref(false);
+const environment = ref<ProjectEnvironment | null>(null);
+const serverKeyword = ref('');
+const serverFilter = ref<'healthy' | 'all'>('healthy');
+const natsPrefixTouched = ref(false);
+const lastSelectedServerId = ref<string | null>(null);
 
 const form = ref({
   name: '',
@@ -32,25 +32,25 @@ const form = ref({
   nats_subject_prefix: '',
   canary_target_env_id: '',
   canary_percentage: 0,
-})
+});
 
 const availableCanaryTargets = computed(() =>
   envStore.environments
     .filter((env) => env.id !== envId.value)
-    .map((env) => ({ label: env.name, value: env.id })),
-)
+    .map((env) => ({ label: env.name, value: env.id }))
+);
 
 const selectedServers = computed(() =>
   form.value.server_ids
     .map((id) => serverStore.getById(id))
-    .filter((server): server is ServerInfo => !!server),
-)
+    .filter((server): server is ServerInfo => !!server)
+);
 
 const visibleServers = computed(() => {
-  const query = serverKeyword.value.trim().toLowerCase()
+  const query = serverKeyword.value.trim().toLowerCase();
   return serverStore.servers.filter((server) => {
-    if (serverFilter.value === 'healthy' && server.status === 'offline') return false
-    if (!query) return true
+    if (serverFilter.value === 'healthy' && server.status === 'offline') return false;
+    if (!query) return true;
     const haystack = [
       server.name,
       server.url,
@@ -58,76 +58,79 @@ const visibleServers = computed(() => {
       ...Object.entries(server.labels).map(([key, value]) => `${key}=${value}`),
     ]
       .join(' ')
-      .toLowerCase()
-    return haystack.includes(query)
-  })
-})
+      .toLowerCase();
+    return haystack.includes(query);
+  });
+});
 
 const tableServers = computed(() =>
-  visibleServers.value
-    .slice()
-    .sort((left, right) => {
-      const statusOrder = { online: 0, degraded: 1, offline: 2 }
-      const statusDelta = statusOrder[left.status] - statusOrder[right.status]
-      if (statusDelta !== 0) return statusDelta
-      return left.name.localeCompare(right.name)
-    }),
-)
-
-const selectableVisibleCount = computed(() =>
-  tableServers.value.filter((server) => server.status !== 'offline').length,
-)
-
-const selectedVisibleCount = computed(() =>
-  tableServers.value.filter((server) => server.status !== 'offline' && isSelected(server.id)).length,
-)
-
-const allVisibleSelected = computed(() =>
-  selectableVisibleCount.value > 0 && selectedVisibleCount.value === selectableVisibleCount.value,
-)
+  visibleServers.value.slice().sort((left, right) => {
+    const statusOrder = { online: 0, degraded: 1, offline: 2 };
+    const statusDelta = statusOrder[left.status] - statusOrder[right.status];
+    if (statusDelta !== 0) return statusDelta;
+    return left.name.localeCompare(right.name);
+  })
+);
+
+const selectableVisibleCount = computed(
+  () => tableServers.value.filter((server) => server.status !== 'offline').length
+);
+
+const selectedVisibleCount = computed(
+  () =>
+    tableServers.value.filter((server) => server.status !== 'offline' && isSelected(server.id))
+      .length
+);
+
+const allVisibleSelected = computed(
+  () =>
+    selectableVisibleCount.value > 0 && selectedVisibleCount.value === selectableVisibleCount.value
+);
 
 const selectedSummary = computed(() => {
-  if (selectedServers.value.length === 0) return t('environment.selectionEmpty')
-  const names = selectedServers.value.slice(0, 3).map((server) => server.name)
-  const extra = selectedServers.value.length - names.length
-  return extra > 0 ? `${names.join(', ')} +${extra}` : names.join(', ')
-})
+  if (selectedServers.value.length === 0) return t('environment.selectionEmpty');
+  const names = selectedServers.value.slice(0, 3).map((server) => server.name);
+  const extra = selectedServers.value.length - names.length;
+  return extra > 0 ? `${names.join(', ')} +${extra}` : names.join(', ');
+});
 
 const degradedSelectedServers = computed(() =>
-  selectedServers.value.filter((server) => server.status === 'degraded'),
-)
+  selectedServers.value.filter((server) => server.status === 'degraded')
+);
 
 const mismatchedSelectedServers = computed(() => {
-  const targetTier = inferTier(form.value.name)
-  if (!targetTier) return []
+  const targetTier = inferTier(form.value.name);
+  if (!targetTier) return [];
   return selectedServers.value.filter((server) => {
-    const serverTier = inferTier([
-      server.name,
-      server.url,
-      ...Object.entries(server.labels).map(([key, value]) => `${key}=${value}`),
-    ].join(' '))
-    return !!serverTier && serverTier !== targetTier
-  })
-})
+    const serverTier = inferTier(
+      [
+        server.name,
+        server.url,
+        ...Object.entries(server.labels).map(([key, value]) => `${key}=${value}`),
+      ].join(' ')
+    );
+    return !!serverTier && serverTier !== targetTier;
+  });
+});
 
 function fillForm(env: ProjectEnvironment | null) {
-  environment.value = env
-  natsPrefixTouched.value = !!env?.nats_subject_prefix
+  environment.value = env;
+  natsPrefixTouched.value = !!env?.nats_subject_prefix;
   form.value = {
     name: env?.name ?? '',
     server_ids: env?.server_ids ? [...env.server_ids] : [],
     nats_subject_prefix: env?.nats_subject_prefix ?? '',
     canary_target_env_id: env?.canary_target_env_id ?? '',
     canary_percentage: env?.canary_percentage ?? 0,
-  }
+  };
 }
 
 function inferTier(input: string) {
-  const text = input.toLowerCase()
-  if (/(prod|production|生产)/.test(text)) return 'prod'
-  if (/(staging|stage|预发|預發)/.test(text)) return 'staging'
-  if (/(test|testing|dev|develop|测试|測試|开发|開發)/.test(text)) return 'dev'
-  return null
+  const text = input.toLowerCase();
+  if (/(prod|production|生产)/.test(text)) return 'prod';
+  if (/(staging|stage|预发|預發)/.test(text)) return 'staging';
+  if (/(test|testing|dev|develop|测试|測試|开发|開發)/.test(text)) return 'dev';
+  return null;
 }
 
 function slugifyEnvironmentName(input: string) {
@@ -135,171 +138,173 @@ function slugifyEnvironmentName(input: string) {
     .trim()
     .toLowerCase()
     .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-  return normalized || 'environment'
+    .replace(/^-+|-+$/g, '');
+  return normalized || 'environment';
 }
 
 const suggestedNatsPrefix = computed(() => {
-  const base = `ordo.rules.${slugifyEnvironmentName(form.value.name)}`
-  const currentEnvId = envId.value
+  const base = `ordo.rules.${slugifyEnvironmentName(form.value.name)}`;
+  const currentEnvId = envId.value;
   const existing = new Set(
     envStore.environments
       .filter((env) => env.id !== currentEnvId)
       .map((env) => env.nats_subject_prefix)
-      .filter((value): value is string => !!value && value.trim().length > 0),
-  )
+      .filter((value): value is string => !!value && value.trim().length > 0)
+  );
 
-  if (!existing.has(base)) return base
+  if (!existing.has(base)) return base;
 
-  let index = 2
-  let candidate = `${base}-${index}`
+  let index = 2;
+  let candidate = `${base}-${index}`;
   while (existing.has(candidate)) {
-    index += 1
-    candidate = `${base}-${index}`
+    index += 1;
+    candidate = `${base}-${index}`;
   }
-  return candidate
-})
+  return candidate;
+});
 
 function isSelected(serverId: string) {
-  return form.value.server_ids.includes(serverId)
+  return form.value.server_ids.includes(serverId);
 }
 
 function setSelectedServers(serverIds: string[]) {
-  form.value.server_ids = Array.from(new Set(serverIds))
+  form.value.server_ids = Array.from(new Set(serverIds));
 }
 
 function toggleServer(serverId: string, range = false) {
   if (range && lastSelectedServerId.value) {
     const visibleSelectableIds = tableServers.value
       .filter((server) => server.status !== 'offline')
-      .map((server) => server.id)
-    const start = visibleSelectableIds.indexOf(lastSelectedServerId.value)
-    const end = visibleSelectableIds.indexOf(serverId)
+      .map((server) => server.id);
+    const start = visibleSelectableIds.indexOf(lastSelectedServerId.value);
+    const end = visibleSelectableIds.indexOf(serverId);
     if (start !== -1 && end !== -1) {
-      const [from, to] = start < end ? [start, end] : [end, start]
-      const rangeIds = visibleSelectableIds.slice(from, to + 1)
-      setSelectedServers([...form.value.server_ids, ...rangeIds])
-      lastSelectedServerId.value = serverId
-      return
+      const [from, to] = start < end ? [start, end] : [end, start];
+      const rangeIds = visibleSelectableIds.slice(from, to + 1);
+      setSelectedServers([...form.value.server_ids, ...rangeIds]);
+      lastSelectedServerId.value = serverId;
+      return;
     }
   }
 
-  const next = new Set(form.value.server_ids)
+  const next = new Set(form.value.server_ids);
   if (next.has(serverId)) {
-    next.delete(serverId)
+    next.delete(serverId);
   } else {
-    next.add(serverId)
+    next.add(serverId);
   }
-  setSelectedServers(Array.from(next))
-  lastSelectedServerId.value = serverId
+  setSelectedServers(Array.from(next));
+  lastSelectedServerId.value = serverId;
 }
 
 function selectVisibleServers() {
   setSelectedServers([
     ...form.value.server_ids,
-    ...tableServers.value.filter((server) => server.status !== 'offline').map((server) => server.id),
-  ])
+    ...tableServers.value
+      .filter((server) => server.status !== 'offline')
+      .map((server) => server.id),
+  ]);
 }
 
 function clearVisibleServers() {
-  const visibleIds = new Set(tableServers.value.map((server) => server.id))
-  setSelectedServers(form.value.server_ids.filter((serverId) => !visibleIds.has(serverId)))
+  const visibleIds = new Set(tableServers.value.map((server) => server.id));
+  setSelectedServers(form.value.server_ids.filter((serverId) => !visibleIds.has(serverId)));
 }
 
 function toggleVisibleServers(checked: boolean) {
   if (checked) {
-    selectVisibleServers()
+    selectVisibleServers();
   } else {
-    clearVisibleServers()
+    clearVisibleServers();
   }
 }
 
 function markNatsPrefixTouched() {
-  natsPrefixTouched.value = true
+  natsPrefixTouched.value = true;
 }
 
 function statusTheme(status: ServerInfo['status']) {
-  if (status === 'online') return 'success'
-  if (status === 'degraded') return 'warning'
-  return 'danger'
+  if (status === 'online') return 'success';
+  if (status === 'degraded') return 'warning';
+  return 'danger';
 }
 
 function statusLabel(status: ServerInfo['status']) {
-  return t(`releaseCenter.serverStatusMap.${status}`)
+  return t(`releaseCenter.serverStatusMap.${status}`);
 }
 
 function labelsText(server: ServerInfo) {
-  const labels = Object.entries(server.labels)
-  if (labels.length === 0) return t('environment.labelsEmpty')
-  return labels.map(([key, value]) => `${key}=${value}`).join(', ')
+  const labels = Object.entries(server.labels);
+  if (labels.length === 0) return t('environment.labelsEmpty');
+  return labels.map(([key, value]) => `${key}=${value}`).join(', ');
 }
 
 watch(
   () => form.value.name,
   (name) => {
-    if (natsPrefixTouched.value) return
-    form.value.nats_subject_prefix = name.trim() ? suggestedNatsPrefix.value : ''
-  },
-)
+    if (natsPrefixTouched.value) return;
+    form.value.nats_subject_prefix = name.trim() ? suggestedNatsPrefix.value : '';
+  }
+);
 
 onMounted(async () => {
   try {
-    await Promise.all([envStore.fetchEnvironments(orgId, projectId), serverStore.fetchServers()])
+    await Promise.all([envStore.fetchEnvironments(orgId, projectId), serverStore.fetchServers()]);
     const current = isEdit.value
       ? envStore.environments.find((env) => env.id === envId.value) ?? null
-      : null
+      : null;
     if (isEdit.value && !current) {
-      MessagePlugin.error(t('common.loadFailed'))
-      router.replace({ name: 'project-environments', params: { orgId, projectId } })
-      return
+      MessagePlugin.error(t('common.loadFailed'));
+      router.replace({ name: 'project-environments', params: { orgId, projectId } });
+      return;
     }
-    fillForm(current)
+    fillForm(current);
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.loadFailed'))
+    MessagePlugin.error(e.message || t('common.loadFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 async function save() {
-  const name = form.value.name.trim()
+  const name = form.value.name.trim();
   if (!name) {
-    MessagePlugin.warning(t('environment.name'))
-    return
+    MessagePlugin.warning(t('environment.name'));
+    return;
   }
 
-  saving.value = true
+  saving.value = true;
   try {
     const payload = {
       name,
       server_ids: form.value.server_ids,
       nats_subject_prefix: form.value.nats_subject_prefix.trim() || null,
-    }
+    };
 
-    let saved: ProjectEnvironment
+    let saved: ProjectEnvironment;
     if (isEdit.value && environment.value) {
-      saved = await envStore.updateEnvironment(orgId, projectId, environment.value.id, payload)
-      MessagePlugin.success(t('environment.updated'))
+      saved = await envStore.updateEnvironment(orgId, projectId, environment.value.id, payload);
+      MessagePlugin.success(t('environment.updated'));
     } else {
-      saved = await envStore.createEnvironment(orgId, projectId, payload)
-      MessagePlugin.success(t('environment.created'))
+      saved = await envStore.createEnvironment(orgId, projectId, payload);
+      MessagePlugin.success(t('environment.created'));
     }
 
     await envStore.setCanary(orgId, projectId, saved.id, {
       canary_target_env_id: form.value.canary_target_env_id || null,
       canary_percentage: form.value.canary_percentage,
-    })
+    });
 
-    router.replace({ name: 'project-environments', params: { orgId, projectId } })
+    router.replace({ name: 'project-environments', params: { orgId, projectId } });
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.saveFailed'))
+    MessagePlugin.error(e.message || t('common.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 function cancel() {
-  router.push({ name: 'project-environments', params: { orgId, projectId } })
+  router.push({ name: 'project-environments', params: { orgId, projectId } });
 }
 </script>
 
@@ -339,14 +344,20 @@ function cancel() {
                 </div>
                 <div class="server-picker__actions">
                   <t-radio-group v-model="serverFilter" variant="default-filled">
-                    <t-radio-button value="healthy">{{ t('environment.serverFilterHealthy') }}</t-radio-button>
-                    <t-radio-button value="all">{{ t('environment.serverFilterAll') }}</t-radio-button>
+                    <t-radio-button value="healthy">{{
+                      t('environment.serverFilterHealthy')
+                    }}</t-radio-button>
+                    <t-radio-button value="all">{{
+                      t('environment.serverFilterAll')
+                    }}</t-radio-button>
                   </t-radio-group>
                 </div>
               </div>
 
               <div class="server-picker__selection">
-                <span class="server-picker__selection-label">{{ t('environment.selectedNodesTitle') }}</span>
+                <span class="server-picker__selection-label">{{
+                  t('environment.selectedNodesTitle')
+                }}</span>
                 <strong class="server-picker__selection-value">{{ selectedSummary }}</strong>
               </div>
 
@@ -387,7 +398,9 @@ function cancel() {
                         'server-row--selected': isSelected(server.id),
                         'server-row--disabled': server.status === 'offline',
                       }"
-                      @click="server.status !== 'offline' && toggleServer(server.id, $event.shiftKey)"
+                      @click="
+                        server.status !== 'offline' && toggleServer(server.id, $event.shiftKey)
+                      "
                     >
                       <td class="col-check">
                         <t-checkbox
@@ -418,11 +431,22 @@ function cancel() {
           </t-form-item>
 
           <div v-if="degradedSelectedServers.length" class="server-warning">
-            {{ t('environment.degradedWarning', { names: degradedSelectedServers.map((server) => server.name).join(', ') }) }}
+            {{
+              t('environment.degradedWarning', {
+                names: degradedSelectedServers.map((server) => server.name).join(', '),
+              })
+            }}
           </div>
 
-          <div v-if="mismatchedSelectedServers.length" class="server-warning server-warning--danger">
-            {{ t('environment.mismatchWarning', { names: mismatchedSelectedServers.map((server) => server.name).join(', ') }) }}
+          <div
+            v-if="mismatchedSelectedServers.length"
+            class="server-warning server-warning--danger"
+          >
+            {{
+              t('environment.mismatchWarning', {
+                names: mismatchedSelectedServers.map((server) => server.name).join(', '),
+              })
+            }}
           </div>
 
           <t-form-item>
@@ -460,7 +484,9 @@ function cancel() {
 
         <div class="form-actions">
           <t-button variant="outline" @click="cancel">{{ t('common.cancel') }}</t-button>
-          <t-button theme="primary" :loading="saving" @click="save">{{ t('environment.save') }}</t-button>
+          <t-button theme="primary" :loading="saving" @click="save">{{
+            t('environment.save')
+          }}</t-button>
         </div>
       </div>
 
@@ -483,7 +509,10 @@ function cancel() {
             </div>
             <div class="preview-item">
               <span>{{ t('environment.canaryTarget') }}</span>
-              <strong>{{ availableCanaryTargets.find((item) => item.value === form.canary_target_env_id)?.label || '—' }}</strong>
+              <strong>{{
+                availableCanaryTargets.find((item) => item.value === form.canary_target_env_id)
+                  ?.label || '—'
+              }}</strong>
             </div>
             <div class="preview-item">
               <span>{{ t('environment.canaryPct') }}</span>
diff --git a/ordo-editor/apps/studio/src/views/project/EnvironmentsView.vue b/ordo-editor/apps/studio/src/views/project/EnvironmentsView.vue
index dd6f6087..444b0055 100644
--- a/ordo-editor/apps/studio/src/views/project/EnvironmentsView.vue
+++ b/ordo-editor/apps/studio/src/views/project/EnvironmentsView.vue
@@ -1,32 +1,32 @@
 <script setup lang="ts">
-import { onMounted } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { DialogPlugin, MessagePlugin } from 'tdesign-vue-next'
-import type { ProjectEnvironment } from '@/api/types'
-import { StudioPageHeader } from '@/components/ui'
-import { useEnvironmentStore } from '@/stores/environment'
-import { useServerStore } from '@/stores/server'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const envStore = useEnvironmentStore()
-const serverStore = useServerStore()
-
-const orgId = route.params.orgId as string
-const projectId = route.params.projectId as string
+import { onMounted } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { DialogPlugin, MessagePlugin } from 'tdesign-vue-next';
+import type { ProjectEnvironment } from '@/api/types';
+import { StudioPageHeader } from '@/components/ui';
+import { useEnvironmentStore } from '@/stores/environment';
+import { useServerStore } from '@/stores/server';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const envStore = useEnvironmentStore();
+const serverStore = useServerStore();
+
+const orgId = route.params.orgId as string;
+const projectId = route.params.projectId as string;
 
 onMounted(async () => {
-  await Promise.all([envStore.fetchEnvironments(orgId, projectId), serverStore.fetchServers()])
-})
+  await Promise.all([envStore.fetchEnvironments(orgId, projectId), serverStore.fetchServers()]);
+});
 
 function createEnv() {
-  router.push({ name: 'project-environment-create', params: { orgId, projectId } })
+  router.push({ name: 'project-environment-create', params: { orgId, projectId } });
 }
 
 function editEnv(envId: string) {
-  router.push({ name: 'project-environment-edit', params: { orgId, projectId, envId } })
+  router.push({ name: 'project-environment-edit', params: { orgId, projectId, envId } });
 }
 
 function deleteEnv(env: ProjectEnvironment) {
@@ -37,26 +37,24 @@ function deleteEnv(env: ProjectEnvironment) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await envStore.deleteEnvironment(orgId, projectId, env.id)
-        MessagePlugin.success(t('environment.deleted'))
-        dialog.hide()
+        await envStore.deleteEnvironment(orgId, projectId, env.id);
+        MessagePlugin.success(t('environment.deleted'));
+        dialog.hide();
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 function serverNames(serverIds: string[]) {
-  if (serverIds.length === 0) return t('environment.noServer')
-  return serverIds
-    .map((serverId) => serverStore.getById(serverId)?.name ?? serverId)
-    .join(', ')
+  if (serverIds.length === 0) return t('environment.noServer');
+  return serverIds.map((serverId) => serverStore.getById(serverId)?.name ?? serverId).join(', ');
 }
 
 function canaryTargetName(envId: string | null) {
-  if (!envId) return t('environment.noCanary')
-  return envStore.environments.find((env) => env.id === envId)?.name ?? envId
+  if (!envId) return t('environment.noCanary');
+  return envStore.environments.find((env) => env.id === envId)?.name ?? envId;
 }
 </script>
 
@@ -92,13 +90,21 @@ function canaryTargetName(envId: string | null) {
         <div class="env-header">
           <div class="env-name-row">
             <span class="env-name">{{ env.name }}</span>
-            <t-tag v-if="env.is_default" theme="primary" variant="light">{{ t('environment.default') }}</t-tag>
+            <t-tag v-if="env.is_default" theme="primary" variant="light">{{
+              t('environment.default')
+            }}</t-tag>
           </div>
           <div class="env-actions">
             <t-button variant="text" size="small" @click="editEnv(env.id)">
               {{ t('environment.edit') }}
             </t-button>
-            <t-button v-if="!env.is_default" variant="text" theme="danger" size="small" @click="deleteEnv(env)">
+            <t-button
+              v-if="!env.is_default"
+              variant="text"
+              theme="danger"
+              size="small"
+              @click="deleteEnv(env)"
+            >
               {{ t('environment.delete') }}
             </t-button>
           </div>
@@ -114,7 +120,9 @@ function canaryTargetName(envId: string | null) {
         </div>
         <div v-if="env.canary_percentage > 0" class="env-meta">
           <span class="meta-label">{{ t('environment.canary') }}:</span>
-          <span>{{ env.canary_percentage }}% → {{ canaryTargetName(env.canary_target_env_id) }}</span>
+          <span
+            >{{ env.canary_percentage }}% → {{ canaryTargetName(env.canary_target_env_id) }}</span
+          >
         </div>
       </t-card>
     </div>
diff --git a/ordo-editor/apps/studio/src/views/project/FactCatalogView.vue b/ordo-editor/apps/studio/src/views/project/FactCatalogView.vue
index dfbe0ab8..20068782 100644
--- a/ordo-editor/apps/studio/src/views/project/FactCatalogView.vue
+++ b/ordo-editor/apps/studio/src/views/project/FactCatalogView.vue
@@ -1,28 +1,28 @@
 <script setup lang="ts">
-import { ref, computed, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useRouter, useRoute } from 'vue-router'
-import { useCatalogStore } from '@/stores/catalog'
-import { useOrgStore } from '@/stores/org'
-import { useAuthStore } from '@/stores/auth'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import type { FactDataType, FactDefinition, NullPolicy } from '@/api/types'
-
-const catalog = useCatalogStore()
-const orgStore = useOrgStore()
-const auth = useAuthStore()
-const { t } = useI18n()
-const router = useRouter()
-const route = useRoute()
-const orgId = computed(() => route.params.orgId as string)
-
-const canEdit = computed(() => auth.user ? orgStore.canAdmin(auth.user.id) : false)
-
-const selected = ref<FactDefinition | null>(null)
-const saving = ref(false)
-const isNew = ref(false)
-const searchQuery = ref('')
-const prefillHint = ref('')
+import { ref, computed, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter, useRoute } from 'vue-router';
+import { useCatalogStore } from '@/stores/catalog';
+import { useOrgStore } from '@/stores/org';
+import { useAuthStore } from '@/stores/auth';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import type { FactDataType, FactDefinition, NullPolicy } from '@/api/types';
+
+const catalog = useCatalogStore();
+const orgStore = useOrgStore();
+const auth = useAuthStore();
+const { t } = useI18n();
+const router = useRouter();
+const route = useRoute();
+const orgId = computed(() => route.params.orgId as string);
+
+const canEdit = computed(() => (auth.user ? orgStore.canAdmin(auth.user.id) : false));
+
+const selected = ref<FactDefinition | null>(null);
+const saving = ref(false);
+const isNew = ref(false);
+const searchQuery = ref('');
+const prefillHint = ref('');
 
 const emptyForm = (name = ''): Omit<FactDefinition, 'created_at' | 'updated_at'> => ({
   name,
@@ -32,20 +32,21 @@ const emptyForm = (name = ''): Omit<FactDefinition, 'created_at' | 'updated_at'>
   latency_ms: undefined,
   description: '',
   owner: '',
-})
+});
 
-const form = ref(emptyForm())
+const form = ref(emptyForm());
 
 const filteredFacts = computed(() => {
-  const keyword = searchQuery.value.trim().toLowerCase()
-  const facts = [...catalog.facts].sort((a, b) => a.name.localeCompare(b.name))
-  if (!keyword) return facts
+  const keyword = searchQuery.value.trim().toLowerCase();
+  const facts = [...catalog.facts].sort((a, b) => a.name.localeCompare(b.name));
+  if (!keyword) return facts;
 
   return facts.filter((fact) =>
-    [fact.name, fact.source, fact.owner ?? '', fact.description ?? '']
-      .some((value) => value.toLowerCase().includes(keyword)),
-  )
-})
+    [fact.name, fact.source, fact.owner ?? '', fact.description ?? ''].some((value) =>
+      value.toLowerCase().includes(keyword)
+    )
+  );
+});
 
 const dataTypeLabel = computed<Record<FactDataType, string>>(() => ({
   string: t('facts.typeString'),
@@ -53,62 +54,62 @@ const dataTypeLabel = computed<Record<FactDataType, string>>(() => ({
   boolean: t('facts.typeBoolean'),
   date: t('facts.typeDate'),
   object: t('facts.typeObject'),
-}))
+}));
 
 const nullPolicyLabel = computed<Record<NullPolicy, string>>(() => ({
   error: t('facts.policyError'),
   default: t('facts.policyDefault'),
   skip: t('facts.policySkip'),
-}))
+}));
 
 watch(
   () => catalog.facts,
   (facts) => {
-    if (isNew.value) return
+    if (isNew.value) return;
     if (!selected.value && facts.length > 0) {
-      openEdit([...facts].sort((a, b) => a.name.localeCompare(b.name))[0])
-      return
+      openEdit([...facts].sort((a, b) => a.name.localeCompare(b.name))[0]);
+      return;
     }
     if (selected.value) {
-      const next = facts.find((fact) => fact.name === selected.value?.name) ?? null
-      selected.value = next
+      const next = facts.find((fact) => fact.name === selected.value?.name) ?? null;
+      selected.value = next;
     }
   },
-  { immediate: true, deep: true },
-)
+  { immediate: true, deep: true }
+);
 
 watch(
   () => route.query.createFact,
   (value) => {
-    const requestedName = typeof value === 'string' ? value.trim() : ''
-    if (!requestedName) return
+    const requestedName = typeof value === 'string' ? value.trim() : '';
+    if (!requestedName) return;
 
-    const existing = catalog.facts.find((fact) => fact.name === requestedName)
+    const existing = catalog.facts.find((fact) => fact.name === requestedName);
     if (existing) {
-      openEdit(existing)
+      openEdit(existing);
     } else {
-      openNew(requestedName)
-      prefillHint.value = t('facts.prefillHint', { name: requestedName })
+      openNew(requestedName);
+      prefillHint.value = t('facts.prefillHint', { name: requestedName });
     }
 
-    const nextQuery = { ...route.query }
-    delete nextQuery.createFact
-    void router.replace({ query: nextQuery })
+    const nextQuery = { ...route.query };
+    delete nextQuery.createFact;
+    void router.replace({ query: nextQuery });
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 function openNew(prefillName = '') {
-  isNew.value = true
-  selected.value = null
-  form.value = emptyForm(prefillName)
-  prefillHint.value = prefillName ? t('facts.prefillHint', { name: prefillName }) : ''
+  isNew.value = true;
+  selected.value = null;
+  form.value = emptyForm(prefillName);
+  prefillHint.value = prefillName ? t('facts.prefillHint', { name: prefillName }) : '';
 }
 
 function openEdit(fact: FactDefinition) {
-  isNew.value = false
-  selected.value = fact
-  prefillHint.value = ''
+  isNew.value = false;
+  selected.value = fact;
+  prefillHint.value = '';
   form.value = {
     name: fact.name,
     data_type: fact.data_type,
@@ -117,20 +118,20 @@ function openEdit(fact: FactDefinition) {
     latency_ms: fact.latency_ms,
     description: fact.description ?? '',
     owner: fact.owner ?? '',
-  }
+  };
 }
 
 async function handleSave() {
   if (!form.value.name.trim()) {
-    MessagePlugin.warning(t('facts.nameRequired'))
-    return
+    MessagePlugin.warning(t('facts.nameRequired'));
+    return;
   }
   if (!form.value.source.trim()) {
-    MessagePlugin.warning(t('facts.sourceRequired'))
-    return
+    MessagePlugin.warning(t('facts.sourceRequired'));
+    return;
   }
 
-  saving.value = true
+  saving.value = true;
   try {
     const saved = await catalog.upsertFact({
       ...form.value,
@@ -138,17 +139,17 @@ async function handleSave() {
       source: form.value.source.trim(),
       description: form.value.description?.trim() || undefined,
       owner: form.value.owner?.trim() || undefined,
-    })
+    });
     if (!saved) {
-      throw new Error(t('facts.saveFailed'))
+      throw new Error(t('facts.saveFailed'));
     }
 
-    MessagePlugin.success(isNew.value ? t('facts.createSuccess') : t('facts.updateSuccess'))
-    openEdit(saved)
+    MessagePlugin.success(isNew.value ? t('facts.createSuccess') : t('facts.updateSuccess'));
+    openEdit(saved);
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('facts.saveFailed'))
+    MessagePlugin.error(e.message || t('facts.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
@@ -160,35 +161,35 @@ function handleDelete(fact: FactDefinition) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await catalog.deleteFact(fact.name)
+        await catalog.deleteFact(fact.name);
         if (selected.value?.name === fact.name) {
-          selected.value = null
+          selected.value = null;
           const next = [...catalog.facts]
             .filter((item) => item.name !== fact.name)
-            .sort((a, b) => a.name.localeCompare(b.name))[0]
+            .sort((a, b) => a.name.localeCompare(b.name))[0];
           if (next) {
-            openEdit(next)
+            openEdit(next);
           } else {
-            isNew.value = false
-            form.value = emptyForm()
+            isNew.value = false;
+            form.value = emptyForm();
           }
         }
-        dlg.hide()
-        MessagePlugin.success(t('facts.deleteSuccess'))
+        dlg.hide();
+        MessagePlugin.success(t('facts.deleteSuccess'));
       } catch (e: any) {
-        MessagePlugin.error(e.message || t('facts.saveFailed'))
+        MessagePlugin.error(e.message || t('facts.saveFailed'));
       }
     },
-  })
+  });
 }
 
 function cancelEdit() {
-  prefillHint.value = ''
+  prefillHint.value = '';
   if (selected.value) {
-    openEdit(selected.value)
+    openEdit(selected.value);
   } else {
-    isNew.value = false
-    form.value = emptyForm()
+    isNew.value = false;
+    form.value = emptyForm();
   }
 }
 </script>
@@ -196,8 +197,12 @@ function cancelEdit() {
 <template>
   <div class="fact-view">
     <t-breadcrumb class="asset-breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{ t('breadcrumb.projects') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{
+        t('breadcrumb.projects')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('projectNav.facts') }}</t-breadcrumb-item>
     </t-breadcrumb>
 
@@ -227,7 +232,7 @@ function cancelEdit() {
           <t-loading size="small" />
         </div>
         <div v-else-if="catalog.facts.length === 0" class="asset-empty">
-          <t-icon name="data" size="32px" style="opacity:0.3" />
+          <t-icon name="data" size="32px" style="opacity: 0.3" />
           <p>{{ t('facts.empty') }}</p>
         </div>
         <div
@@ -243,15 +248,15 @@ function cancelEdit() {
             <span class="fact-item__policy">{{ nullPolicyLabel[fact.null_policy] }}</span>
           </div>
           <div class="fact-item__source">{{ fact.source }}</div>
-          <button
-            v-if="canEdit"
-            class="fact-item__del"
-            @click.stop="handleDelete(fact)"
-          ><t-icon name="close" size="12px" /></button>
+          <button v-if="canEdit" class="fact-item__del" @click.stop="handleDelete(fact)">
+            <t-icon name="close" size="12px" />
+          </button>
         </div>
 
         <div v-if="isNew" class="fact-item is-active">
-          <div class="fact-item__name" style="opacity:0.5">{{ form.name || t('facts.newPlaceholder') }}</div>
+          <div class="fact-item__name" style="opacity: 0.5">
+            {{ form.name || t('facts.newPlaceholder') }}
+          </div>
           <div class="fact-item__source">{{ prefillHint || t('facts.editorNew') }}</div>
         </div>
       </div>
@@ -286,13 +291,21 @@ function cancelEdit() {
             </t-select>
           </t-form-item>
           <t-form-item :label="t('facts.latencyLabel')">
-            <t-input-number v-model="form.latency_ms" :min="0" :placeholder="t('facts.latencyPlaceholder')" />
+            <t-input-number
+              v-model="form.latency_ms"
+              :min="0"
+              :placeholder="t('facts.latencyPlaceholder')"
+            />
           </t-form-item>
           <t-form-item :label="t('facts.ownerLabel')">
             <t-input v-model="form.owner" :placeholder="t('facts.ownerPlaceholder')" />
           </t-form-item>
           <t-form-item :label="t('facts.descLabel')">
-            <t-textarea v-model="form.description" :rows="4" :placeholder="t('facts.descPlaceholder')" />
+            <t-textarea
+              v-model="form.description"
+              :rows="4"
+              :placeholder="t('facts.descPlaceholder')"
+            />
           </t-form-item>
         </t-form>
 
@@ -305,7 +318,7 @@ function cancelEdit() {
       </div>
 
       <div v-else class="fact-placeholder">
-        <t-icon name="data" size="36px" style="opacity:0.15" />
+        <t-icon name="data" size="36px" style="opacity: 0.15" />
         <p>{{ t('facts.placeholder') }}</p>
       </div>
     </div>
@@ -370,8 +383,12 @@ function cancelEdit() {
   position: relative;
 }
 
-.fact-item:hover { background: var(--ordo-hover-bg); }
-.fact-item.is-active { background: var(--ordo-active-bg); }
+.fact-item:hover {
+  background: var(--ordo-hover-bg);
+}
+.fact-item.is-active {
+  background: var(--ordo-active-bg);
+}
 
 .fact-item__name {
   font-size: 13px;
@@ -413,8 +430,13 @@ function cancelEdit() {
   justify-content: center;
 }
 
-.fact-item:hover .fact-item__del { display: flex; }
-.fact-item__del:hover { background: rgba(255,80,80,0.15); color: #e34d59; }
+.fact-item:hover .fact-item__del {
+  display: flex;
+}
+.fact-item__del:hover {
+  background: rgba(255, 80, 80, 0.15);
+  color: #e34d59;
+}
 
 .fact-editor {
   flex: 1;
@@ -450,7 +472,8 @@ function cancelEdit() {
   font-size: 13px;
 }
 
-.asset-loading, .asset-empty {
+.asset-loading,
+.asset-empty {
   display: flex;
   flex-direction: column;
   align-items: center;
diff --git a/ordo-editor/apps/studio/src/views/project/ProjectInstancesView.vue b/ordo-editor/apps/studio/src/views/project/ProjectInstancesView.vue
index 3efc1159..fd0b7daa 100644
--- a/ordo-editor/apps/studio/src/views/project/ProjectInstancesView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ProjectInstancesView.vue
@@ -1,30 +1,35 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { useProjectStore } from '@/stores/project'
-import { useServerStore } from '@/stores/server'
-import { projectApi } from '@/api/platform-client'
-
-const { t } = useI18n()
-const route = useRoute()
-const router = useRouter()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const projectStore = useProjectStore()
-const serverStore = useServerStore()
-
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
-const project = computed(() => projectStore.currentProject)
-
-const selectedServerId = ref<string>('default')
-const binding = ref(false)
-const healthLoading = ref(false)
-const healthStatus = ref<{ online: boolean; response?: string; error?: string; url: string } | null>(null)
+import { computed, onMounted, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { useProjectStore } from '@/stores/project';
+import { useServerStore } from '@/stores/server';
+import { projectApi } from '@/api/platform-client';
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const projectStore = useProjectStore();
+const serverStore = useServerStore();
+
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
+const project = computed(() => projectStore.currentProject);
+
+const selectedServerId = ref<string>('default');
+const binding = ref(false);
+const healthLoading = ref(false);
+const healthStatus = ref<{
+  online: boolean;
+  response?: string;
+  error?: string;
+  url: string;
+} | null>(null);
 
 const serverOptions = computed(() => [
   { label: t('projectInstances.useDefault'), value: 'default' },
@@ -32,65 +37,68 @@ const serverOptions = computed(() => [
     label: `${s.name}${s.version ? ` (${s.version})` : ''}`,
     value: s.id,
   })),
-])
+]);
 
 const boundServer = computed(() => {
-  if (selectedServerId.value === 'default') return null
-  return serverStore.getById(selectedServerId.value) ?? null
-})
+  if (selectedServerId.value === 'default') return null;
+  return serverStore.getById(selectedServerId.value) ?? null;
+});
 
 const statusTheme = computed(() => {
-  if (!boundServer.value) return 'default'
+  if (!boundServer.value) return 'default';
   switch (boundServer.value.status) {
-    case 'online': return 'success'
-    case 'degraded': return 'warning'
-    default: return 'danger'
+    case 'online':
+      return 'success';
+    case 'degraded':
+      return 'warning';
+    default:
+      return 'danger';
   }
-})
+});
 
 function formatTs(v: string | null | undefined) {
-  if (!v) return t('projectInstances.neverSeen')
-  return new Date(v).toLocaleString()
+  if (!v) return t('projectInstances.neverSeen');
+  return new Date(v).toLocaleString();
 }
 
-const canAdmin = computed(() => !!auth.user && orgStore.canAdmin(auth.user.id))
+const canAdmin = computed(() => !!auth.user && orgStore.canAdmin(auth.user.id));
 
 onMounted(async () => {
-  await serverStore.fetchServers()
+  await serverStore.fetchServers();
   if (project.value) {
-    selectedServerId.value = project.value.server_id ?? 'default'
+    selectedServerId.value = project.value.server_id ?? 'default';
   }
-})
+});
 
 async function saveBinding() {
-  if (!orgStore.currentOrg || !auth.token) return
-  binding.value = true
+  if (!orgStore.currentOrg || !auth.token) return;
+  binding.value = true;
   try {
     await projectApi.bindServer(auth.token, orgStore.currentOrg.id, projectId.value, {
       server_id: selectedServerId.value === 'default' ? null : selectedServerId.value,
-    })
-    const updated = await projectApi.get(auth.token, orgStore.currentOrg.id, projectId.value)
-    await projectStore.fetchProjects(orgStore.currentOrg.id)
-    await projectStore.selectProject(updated)
-    healthStatus.value = null
-    MessagePlugin.success(t('projectInstances.saveSuccess'))
+    });
+    const updated = await projectApi.get(auth.token, orgStore.currentOrg.id, projectId.value);
+    await projectStore.fetchProjects(orgStore.currentOrg.id);
+    await projectStore.selectProject(updated);
+    healthStatus.value = null;
+    MessagePlugin.success(t('projectInstances.saveSuccess'));
   } catch {
-    MessagePlugin.error(t('projectInstances.saveFailed'))
+    MessagePlugin.error(t('projectInstances.saveFailed'));
   } finally {
-    binding.value = false
+    binding.value = false;
   }
 }
 
 async function checkHealth() {
-  if (!auth.token || !boundServer.value) return
-  healthLoading.value = true
+  if (!auth.token || !boundServer.value) return;
+  healthLoading.value = true;
   try {
-    const { serverApi } = await import('@/api/platform-client')
-    healthStatus.value = await serverApi.getHealth(auth.token, boundServer.value.id)
+    const { serverApi } = await import('@/api/platform-client');
+    healthStatus.value = await serverApi.getHealth(auth.token, boundServer.value.id);
   } catch {
-    MessagePlugin.error(t('projectInstances.healthFailed'))
+    MessagePlugin.error(t('projectInstances.healthFailed'));
   } finally {
-    healthLoading.value = false
+    healthLoading.value = false;
   }
 }
 </script>
@@ -98,8 +106,12 @@ async function checkHealth() {
 <template>
   <div class="instances-page">
     <t-breadcrumb class="breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{ t('breadcrumb.projects') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{
+        t('breadcrumb.projects')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ project?.name }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('projectNav.instances') }}</t-breadcrumb-item>
     </t-breadcrumb>
@@ -141,7 +153,9 @@ async function checkHealth() {
           </t-button>
           <div v-if="healthStatus" class="health-result">
             <t-tag :theme="healthStatus.online ? 'success' : 'danger'" variant="light">
-              {{ healthStatus.online ? t('projectInstances.online') : t('projectInstances.offline') }}
+              {{
+                healthStatus.online ? t('projectInstances.online') : t('projectInstances.offline')
+              }}
             </t-tag>
             <pre v-if="healthStatus.response || healthStatus.error" class="health-pre">{{
               healthStatus.response || healthStatus.error
@@ -157,7 +171,12 @@ async function checkHealth() {
             <h2 class="card-title">{{ t('projectInstances.binding') }}</h2>
             <p class="card-desc">{{ t('projectInstances.bindingDesc') }}</p>
           </div>
-          <t-button variant="text" size="small" :loading="serverStore.loading" @click="serverStore.fetchServers()">
+          <t-button
+            variant="text"
+            size="small"
+            :loading="serverStore.loading"
+            @click="serverStore.fetchServers()"
+          >
             {{ t('projectInstances.refresh') }}
           </t-button>
         </div>
diff --git a/ordo-editor/apps/studio/src/views/project/ProjectListView.vue b/ordo-editor/apps/studio/src/views/project/ProjectListView.vue
index a755d37b..3a7fd299 100644
--- a/ordo-editor/apps/studio/src/views/project/ProjectListView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ProjectListView.vue
@@ -1,93 +1,97 @@
 <script setup lang="ts">
-import { ref, computed, onMounted, watch } from 'vue'
-import { useRouter, useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { useProjectStore } from '@/stores/project'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import CreateFromTemplateDialog from '@/components/project/CreateFromTemplateDialog.vue'
-import type { Project } from '@/api/types'
-
-const router = useRouter()
-const route = useRoute()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const projectStore = useProjectStore()
-const { t, locale } = useI18n()
-
-const orgId = computed(() => route.params.orgId as string)
-
-const showCreate = ref(false)
-const showTemplateDialog = ref(false)
-const creating = ref(false)
-const newName = ref('')
-const newDesc = ref('')
+import { ref, computed, onMounted, watch } from 'vue';
+import { useRouter, useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { useProjectStore } from '@/stores/project';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import CreateFromTemplateDialog from '@/components/project/CreateFromTemplateDialog.vue';
+import type { Project } from '@/api/types';
+
+const router = useRouter();
+const route = useRoute();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const projectStore = useProjectStore();
+const { t, locale } = useI18n();
+
+const orgId = computed(() => route.params.orgId as string);
+
+const showCreate = ref(false);
+const showTemplateDialog = ref(false);
+const creating = ref(false);
+const newName = ref('');
+const newDesc = ref('');
 
 async function handleTemplateCreated(p: Project) {
-  projectStore.projects.unshift(p)
-  MessagePlugin.success(t('template.createSuccess'))
-  await openProject(p.id)
+  projectStore.projects.unshift(p);
+  MessagePlugin.success(t('template.createSuccess'));
+  await openProject(p.id);
 }
 
 const isAdmin = computed(() => {
-  if (!auth.user) return false
-  return orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return orgStore.canAdmin(auth.user.id);
+});
 
 onMounted(async () => {
   // On refresh, orgId comes from the URL — ensure the org is selected
   if (orgId.value && orgStore.currentOrg?.id !== orgId.value) {
-    await orgStore.selectOrg(orgId.value)
+    await orgStore.selectOrg(orgId.value);
   }
-  await projectStore.fetchProjects(orgId.value)
-})
+  await projectStore.fetchProjects(orgId.value);
+});
 
 watch(
   () => route.query.openTemplate,
   (value) => {
     if (value === '1' && isAdmin.value) {
-      showTemplateDialog.value = true
+      showTemplateDialog.value = true;
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 async function handleCreate() {
   if (!newName.value.trim()) {
-    MessagePlugin.warning(t('project.nameRequired'))
-    return
+    MessagePlugin.warning(t('project.nameRequired'));
+    return;
   }
-  if (!orgStore.currentOrg) return
-  creating.value = true
+  if (!orgStore.currentOrg) return;
+  creating.value = true;
   try {
-    const p = await projectStore.createProject(orgStore.currentOrg.id, newName.value.trim(), newDesc.value || undefined)
-    showCreate.value = false
-    newName.value = ''
-    newDesc.value = ''
-    MessagePlugin.success(t('project.createSuccess'))
-    await openProject(p.id)
+    const p = await projectStore.createProject(
+      orgStore.currentOrg.id,
+      newName.value.trim(),
+      newDesc.value || undefined
+    );
+    showCreate.value = false;
+    newName.value = '';
+    newDesc.value = '';
+    MessagePlugin.success(t('project.createSuccess'));
+    await openProject(p.id);
   } catch (e: any) {
-    MessagePlugin.error(e.message)
+    MessagePlugin.error(e.message);
   } finally {
-    creating.value = false
+    creating.value = false;
   }
 }
 
 async function openProject(projectId: string) {
-  const p = projectStore.projects.find((p) => p.id === projectId)
-  if (!p) return
-  await projectStore.selectProject(p)
-  router.push(`/orgs/${orgId.value}/projects/${projectId}/editor`)
+  const p = projectStore.projects.find((p) => p.id === projectId);
+  if (!p) return;
+  await projectStore.selectProject(p);
+  router.push(`/orgs/${orgId.value}/projects/${projectId}/editor`);
 }
 
 function goToMarketplace() {
-  router.push('/marketplace')
+  router.push('/marketplace');
 }
 
 function handleDelete(projectId: string, name: string) {
-  if (!orgStore.currentOrg) return
-  const orgId = orgStore.currentOrg.id
+  if (!orgStore.currentOrg) return;
+  const orgId = orgStore.currentOrg.id;
   const dlg = DialogPlugin.confirm({
     header: t('project.deleteDialog'),
     body: t('project.deleteConfirm', { name }),
@@ -95,21 +99,21 @@ function handleDelete(projectId: string, name: string) {
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
       try {
-        await projectStore.deleteProject(orgId, projectId)
-        dlg.hide()
-        MessagePlugin.success(t('project.deleteSuccess'))
+        await projectStore.deleteProject(orgId, projectId);
+        dlg.hide();
+        MessagePlugin.success(t('project.deleteSuccess'));
       } catch (e: any) {
-        MessagePlugin.error(e.message)
+        MessagePlugin.error(e.message);
       }
     },
-  })
+  });
 }
 
 function formatDate(iso: string) {
   return new Date(iso).toLocaleDateString(
     locale.value === 'zh-TW' ? 'zh-TW' : locale.value === 'zh-CN' ? 'zh-CN' : 'en-US',
-    { year: 'numeric', month: 'short', day: 'numeric' },
-  )
+    { year: 'numeric', month: 'short', day: 'numeric' }
+  );
 }
 </script>
 
@@ -140,18 +144,22 @@ function formatDate(iso: string) {
 
     <!-- Loading -->
     <div v-if="projectStore.loading" class="project-skeleton-grid">
-      <t-skeleton v-for="i in 4" :key="i" theme="paragraph" animation="gradient"
-        :row-col="[{ width: '50%' }, { width: '70%' }, { width: '40%' }]" />
+      <t-skeleton
+        v-for="i in 4"
+        :key="i"
+        theme="paragraph"
+        animation="gradient"
+        :row-col="[{ width: '50%' }, { width: '70%' }, { width: '40%' }]"
+      />
     </div>
 
     <!-- Empty -->
     <div v-else-if="projectStore.projects.length === 0" class="state-center">
-      <t-empty
-        :title="t('project.emptyTitle')"
-        :description="t('project.emptyDesc')"
-      >
+      <t-empty :title="t('project.emptyTitle')" :description="t('project.emptyDesc')">
         <template #action>
-          <t-button v-if="isAdmin" theme="primary" @click="showCreate = true">{{ t('project.createBtn') }}</t-button>
+          <t-button v-if="isAdmin" theme="primary" @click="showCreate = true">{{
+            t('project.createBtn')
+          }}</t-button>
         </template>
       </t-empty>
     </div>
@@ -274,7 +282,9 @@ function formatDate(iso: string) {
   border-radius: var(--ordo-radius-lg);
   padding: 20px;
   cursor: pointer;
-  transition: border-color 0.15s, box-shadow 0.15s;
+  transition:
+    border-color 0.15s,
+    box-shadow 0.15s;
   display: flex;
   flex-direction: column;
   gap: 8px;
diff --git a/ordo-editor/apps/studio/src/views/project/ProjectSettingsView.vue b/ordo-editor/apps/studio/src/views/project/ProjectSettingsView.vue
index e97ed8bc..ab06a2d8 100644
--- a/ordo-editor/apps/studio/src/views/project/ProjectSettingsView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ProjectSettingsView.vue
@@ -1,56 +1,61 @@
 <script setup lang="ts">
-import { computed, onMounted, ref, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useAuthStore } from '@/stores/auth'
-import { useOrgStore } from '@/stores/org'
-import { useProjectStore } from '@/stores/project'
-import { projectApi, serverApi } from '@/api/platform-client'
-import type { ServerInfo } from '@/api/types'
-
-const { t } = useI18n()
-const route = useRoute()
-const router = useRouter()
-const auth = useAuthStore()
-const orgStore = useOrgStore()
-const projectStore = useProjectStore()
-
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
-const project = computed(() => projectStore.currentProject)
-
-const nameValue = ref('')
-const descValue = ref('')
-const saving = ref(false)
-
-const servers = ref<ServerInfo[]>([])
-const serversLoading = ref(false)
-const selectedServerId = ref('default')
-const binding = ref(false)
-const healthLoading = ref(false)
-const healthStatus = ref<{ online: boolean; response?: string; error?: string; url: string } | null>(null)
+import { computed, onMounted, ref, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useAuthStore } from '@/stores/auth';
+import { useOrgStore } from '@/stores/org';
+import { useProjectStore } from '@/stores/project';
+import { projectApi, serverApi } from '@/api/platform-client';
+import type { ServerInfo } from '@/api/types';
+
+const { t } = useI18n();
+const route = useRoute();
+const router = useRouter();
+const auth = useAuthStore();
+const orgStore = useOrgStore();
+const projectStore = useProjectStore();
+
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
+const project = computed(() => projectStore.currentProject);
+
+const nameValue = ref('');
+const descValue = ref('');
+const saving = ref(false);
+
+const servers = ref<ServerInfo[]>([]);
+const serversLoading = ref(false);
+const selectedServerId = ref('default');
+const binding = ref(false);
+const healthLoading = ref(false);
+const healthStatus = ref<{
+  online: boolean;
+  response?: string;
+  error?: string;
+  url: string;
+} | null>(null);
 
 watch(
   project,
   (value) => {
-    if (!value) return
-    nameValue.value = value.name
-    descValue.value = value.description ?? ''
-    selectedServerId.value = value.server_id ?? 'default'
+    if (!value) return;
+    nameValue.value = value.name;
+    descValue.value = value.description ?? '';
+    selectedServerId.value = value.server_id ?? 'default';
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 const canEdit = computed(() => {
-  if (!auth.user) return false
-  return orgStore.canEdit(auth.user.id)
-})
+  if (!auth.user) return false;
+  return orgStore.canEdit(auth.user.id);
+});
 
 const canAdmin = computed(() => {
-  if (!auth.user) return false
-  return orgStore.canAdmin(auth.user.id)
-})
+  if (!auth.user) return false;
+  return orgStore.canAdmin(auth.user.id);
+});
 
 const serverOptions = computed(() => [
   { label: t('projectSettings.serverDefault'), value: 'default' },
@@ -58,127 +63,127 @@ const serverOptions = computed(() => [
     label: `${server.name}${server.version ? ` (${server.version})` : ''}`,
     value: server.id,
   })),
-])
+]);
 
 const boundServer = computed(() => {
-  if (selectedServerId.value === 'default') return null
-  return servers.value.find((server) => server.id === selectedServerId.value) ?? null
-})
+  if (selectedServerId.value === 'default') return null;
+  return servers.value.find((server) => server.id === selectedServerId.value) ?? null;
+});
 
 const engineTagTheme = computed(() => {
-  if (!boundServer.value) return 'default'
+  if (!boundServer.value) return 'default';
   switch (boundServer.value.status) {
     case 'online':
-      return 'success'
+      return 'success';
     case 'degraded':
-      return 'warning'
+      return 'warning';
     default:
-      return 'danger'
+      return 'danger';
   }
-})
+});
 
 const engineStatusText = computed(() => {
-  if (!boundServer.value) return t('projectSettings.engineDefault')
+  if (!boundServer.value) return t('projectSettings.engineDefault');
   switch (boundServer.value.status) {
     case 'online':
-      return t('projectSettings.engineConnected')
+      return t('projectSettings.engineConnected');
     case 'degraded':
-      return t('projectSettings.engineDegraded')
+      return t('projectSettings.engineDegraded');
     default:
-      return t('projectSettings.engineDisconnected')
+      return t('projectSettings.engineDisconnected');
   }
-})
+});
 
 function formatTimestamp(value: string | null | undefined) {
-  if (!value) return t('projectSettings.serverNeverSeen')
-  return new Date(value).toLocaleString()
+  if (!value) return t('projectSettings.serverNeverSeen');
+  return new Date(value).toLocaleString();
 }
 
 async function loadServers() {
-  if (!auth.token) return
-  serversLoading.value = true
+  if (!auth.token) return;
+  serversLoading.value = true;
   try {
-    servers.value = await serverApi.list(auth.token)
+    servers.value = await serverApi.list(auth.token);
   } catch {
-    MessagePlugin.error(t('projectSettings.serverLoadFailed'))
+    MessagePlugin.error(t('projectSettings.serverLoadFailed'));
   } finally {
-    serversLoading.value = false
+    serversLoading.value = false;
   }
 }
 
-onMounted(loadServers)
+onMounted(loadServers);
 
 async function saveGeneral() {
   if (!nameValue.value.trim()) {
-    MessagePlugin.warning(t('projectSettings.nameRequired'))
-    return
+    MessagePlugin.warning(t('projectSettings.nameRequired'));
+    return;
   }
-  if (!orgStore.currentOrg || !auth.token) return
+  if (!orgStore.currentOrg || !auth.token) return;
 
-  saving.value = true
+  saving.value = true;
   try {
     const updated = await projectApi.update(auth.token, orgStore.currentOrg.id, projectId.value, {
       name: nameValue.value.trim(),
       description: descValue.value.trim() || undefined,
-    })
-    await projectStore.fetchProjects(orgStore.currentOrg.id)
-    await projectStore.selectProject(updated)
-    MessagePlugin.success(t('projectSettings.saveSuccess'))
+    });
+    await projectStore.fetchProjects(orgStore.currentOrg.id);
+    await projectStore.selectProject(updated);
+    MessagePlugin.success(t('projectSettings.saveSuccess'));
   } catch {
-    MessagePlugin.error(t('projectSettings.saveFailed'))
+    MessagePlugin.error(t('projectSettings.saveFailed'));
   } finally {
-    saving.value = false
+    saving.value = false;
   }
 }
 
 async function saveServerBinding() {
-  if (!orgStore.currentOrg || !auth.token) return
+  if (!orgStore.currentOrg || !auth.token) return;
 
-  binding.value = true
+  binding.value = true;
   try {
     await projectApi.bindServer(auth.token, orgStore.currentOrg.id, projectId.value, {
       server_id: selectedServerId.value === 'default' ? null : selectedServerId.value,
-    })
-    const updated = await projectApi.get(auth.token, orgStore.currentOrg.id, projectId.value)
-    await projectStore.fetchProjects(orgStore.currentOrg.id)
-    await projectStore.selectProject(updated)
-    healthStatus.value = null
-    MessagePlugin.success(t('projectSettings.serverSaveSuccess'))
+    });
+    const updated = await projectApi.get(auth.token, orgStore.currentOrg.id, projectId.value);
+    await projectStore.fetchProjects(orgStore.currentOrg.id);
+    await projectStore.selectProject(updated);
+    healthStatus.value = null;
+    MessagePlugin.success(t('projectSettings.serverSaveSuccess'));
   } catch {
-    MessagePlugin.error(t('projectSettings.serverSaveFailed'))
+    MessagePlugin.error(t('projectSettings.serverSaveFailed'));
   } finally {
-    binding.value = false
+    binding.value = false;
   }
 }
 
 async function checkServerHealth() {
-  if (!auth.token || !boundServer.value) return
+  if (!auth.token || !boundServer.value) return;
 
-  healthLoading.value = true
+  healthLoading.value = true;
   try {
-    healthStatus.value = await serverApi.getHealth(auth.token, boundServer.value.id)
+    healthStatus.value = await serverApi.getHealth(auth.token, boundServer.value.id);
   } catch {
-    MessagePlugin.error(t('projectSettings.serverHealthFailed'))
+    MessagePlugin.error(t('projectSettings.serverHealthFailed'));
   } finally {
-    healthLoading.value = false
+    healthLoading.value = false;
   }
 }
 
-const showDeleteDialog = ref(false)
-const deleting = ref(false)
+const showDeleteDialog = ref(false);
+const deleting = ref(false);
 
 async function confirmDelete() {
-  if (!orgStore.currentOrg) return
-  deleting.value = true
+  if (!orgStore.currentOrg) return;
+  deleting.value = true;
   try {
-    await projectStore.deleteProject(orgStore.currentOrg.id, projectId.value)
-    MessagePlugin.success(t('projectSettings.deleteSuccess'))
-    router.push(`/orgs/${orgId.value}/projects`)
+    await projectStore.deleteProject(orgStore.currentOrg.id, projectId.value);
+    MessagePlugin.success(t('projectSettings.deleteSuccess'));
+    router.push(`/orgs/${orgId.value}/projects`);
   } catch {
-    MessagePlugin.error(t('common.saveFailed'))
+    MessagePlugin.error(t('common.saveFailed'));
   } finally {
-    deleting.value = false
-    showDeleteDialog.value = false
+    deleting.value = false;
+    showDeleteDialog.value = false;
   }
 }
 </script>
@@ -186,8 +191,12 @@ async function confirmDelete() {
 <template>
   <div class="project-settings-page">
     <t-breadcrumb class="breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{ t('breadcrumb.projects') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{
+        t('breadcrumb.projects')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ project?.name }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('breadcrumb.projectSettings') }}</t-breadcrumb-item>
     </t-breadcrumb>
@@ -199,7 +208,11 @@ async function confirmDelete() {
         <h2 class="card-title">{{ t('projectSettings.general') }}</h2>
         <t-form label-align="top" :colon="false" class="settings-form">
           <t-form-item :label="t('projectSettings.nameLabel')">
-            <t-input v-model="nameValue" :disabled="!canEdit" :placeholder="t('project.namePlaceholder')" />
+            <t-input
+              v-model="nameValue"
+              :disabled="!canEdit"
+              :placeholder="t('project.namePlaceholder')"
+            />
           </t-form-item>
           <t-form-item :label="t('projectSettings.descLabel')">
             <t-textarea
@@ -220,7 +233,11 @@ async function confirmDelete() {
       <t-card :bordered="false" class="settings-card">
         <h2 class="card-title">{{ t('projectSettings.members') }}</h2>
         <p class="card-desc">{{ t('projectSettings.membersDesc') }}</p>
-        <t-button variant="outline" size="small" @click="router.push(`/orgs/${orgStore.currentOrg?.id}/members`)">
+        <t-button
+          variant="outline"
+          size="small"
+          @click="router.push(`/orgs/${orgStore.currentOrg?.id}/members`)"
+        >
           <t-icon name="user" />
           {{ t('projectSettings.viewMembers') }}
         </t-button>
@@ -240,7 +257,10 @@ async function confirmDelete() {
         </div>
         <div v-if="boundServer" class="engine-meta">
           <span>{{ boundServer.url }}</span>
-          <span>{{ t('projectSettings.serverLastSeen') }}: {{ formatTimestamp(boundServer.last_seen) }}</span>
+          <span
+            >{{ t('projectSettings.serverLastSeen') }}:
+            {{ formatTimestamp(boundServer.last_seen) }}</span
+          >
         </div>
       </t-card>
 
@@ -284,14 +304,25 @@ async function confirmDelete() {
             <span class="server-detail__label">{{ t('projectSettings.serverLastSeen') }}</span>
             <span>{{ formatTimestamp(boundServer.last_seen) }}</span>
           </div>
-          <t-button variant="outline" size="small" :loading="healthLoading" @click="checkServerHealth">
+          <t-button
+            variant="outline"
+            size="small"
+            :loading="healthLoading"
+            @click="checkServerHealth"
+          >
             {{ t('projectSettings.serverCheckHealth') }}
           </t-button>
           <div v-if="healthStatus" class="health-box">
             <t-tag :theme="healthStatus.online ? 'success' : 'danger'" variant="light">
-              {{ healthStatus.online ? t('projectSettings.serverHealthOnline') : t('projectSettings.serverHealthOffline') }}
+              {{
+                healthStatus.online
+                  ? t('projectSettings.serverHealthOnline')
+                  : t('projectSettings.serverHealthOffline')
+              }}
             </t-tag>
-            <pre class="health-response">{{ healthStatus.response || healthStatus.error || healthStatus.url }}</pre>
+            <pre class="health-response">{{
+              healthStatus.response || healthStatus.error || healthStatus.url
+            }}</pre>
           </div>
         </div>
         <p v-else class="card-desc server-unbound">{{ t('projectSettings.serverUnbound') }}</p>
diff --git a/ordo-editor/apps/studio/src/views/project/ReleaseCenterView.vue b/ordo-editor/apps/studio/src/views/project/ReleaseCenterView.vue
index 87043f50..9d72ca72 100644
--- a/ordo-editor/apps/studio/src/views/project/ReleaseCenterView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ReleaseCenterView.vue
@@ -1,122 +1,161 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { releaseApi } from '@/api/platform-client'
-import type { ReleaseExecution, ReleaseExecutionEvent, ReleasePolicy, ReleaseRequest } from '@/api/types'
-import { StudioPageHeader } from '@/components/ui'
-import ReleaseNav from '@/components/project/ReleaseNav.vue'
-import { useRolloutStrategyLabel } from '@/constants/release-center'
-import { useAuthStore } from '@/stores/auth'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const labelRolloutStrategy = useRolloutStrategyLabel()
-const auth = useAuthStore()
-const requests = ref<ReleaseRequest[]>([])
-const policies = ref<ReleasePolicy[]>([])
-const currentExecution = ref<ReleaseExecution | null>(null)
-const executionEvents = ref<ReleaseExecutionEvent[]>([])
-const showEventLog = ref(false)
-
-const pendingRequests = computed(() => requests.value.filter((item) => item.status === 'pending_approval').length)
-const activeExecutions = computed(() => requests.value.filter((item) => item.status === 'executing').length)
-const policyCount = computed(() => policies.value.length)
-const recentRequests = computed(() => [...requests.value].slice(0, 5))
+import { computed, onMounted, onUnmounted, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { releaseApi } from '@/api/platform-client';
+import type {
+  ReleaseExecution,
+  ReleaseExecutionEvent,
+  ReleasePolicy,
+  ReleaseRequest,
+} from '@/api/types';
+import { StudioPageHeader } from '@/components/ui';
+import ReleaseNav from '@/components/project/ReleaseNav.vue';
+import { useRolloutStrategyLabel } from '@/constants/release-center';
+import { useAuthStore } from '@/stores/auth';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const labelRolloutStrategy = useRolloutStrategyLabel();
+const auth = useAuthStore();
+const requests = ref<ReleaseRequest[]>([]);
+const policies = ref<ReleasePolicy[]>([]);
+const currentExecution = ref<ReleaseExecution | null>(null);
+const executionEvents = ref<ReleaseExecutionEvent[]>([]);
+const showEventLog = ref(false);
+
+const pendingRequests = computed(
+  () => requests.value.filter((item) => item.status === 'pending_approval').length
+);
+const activeExecutions = computed(
+  () => requests.value.filter((item) => item.status === 'executing').length
+);
+const policyCount = computed(() => policies.value.length);
+const recentRequests = computed(() => [...requests.value].slice(0, 5));
 
 const isLiveExecution = computed(() =>
-  ['preparing', 'waiting_start', 'rolling_out', 'paused', 'verifying']
-    .includes(currentExecution.value?.status ?? ''),
-)
+  ['preparing', 'waiting_start', 'rolling_out', 'paused', 'verifying'].includes(
+    currentExecution.value?.status ?? ''
+  )
+);
 
-const failedInstances = computed(() =>
-  currentExecution.value?.instances.filter((i) => i.status === 'failed') ?? [],
-)
+const failedInstances = computed(
+  () => currentExecution.value?.instances.filter((i) => i.status === 'failed') ?? []
+);
 
 function formatDurationMs(ms: number) {
-  if (ms < 1000) return `${ms}ms`
-  return `${(ms / 1000).toFixed(1)}s`
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
 }
 
-let pollTimer: ReturnType<typeof setInterval> | null = null
+let pollTimer: ReturnType<typeof setInterval> | null = null;
 
 async function fetchExecutionEvents() {
-  if (!auth.token || !currentExecution.value) return
-  const exec = currentExecution.value
+  if (!auth.token || !currentExecution.value) return;
+  const exec = currentExecution.value;
   // Find the associated release request
-  const req = requests.value.find((r) => r.id === exec.request_id)
-  if (!req) return
+  const req = requests.value.find((r) => r.id === exec.request_id);
+  if (!req) return;
   try {
     executionEvents.value = await releaseApi.getExecutionEvents(
       auth.token,
       route.params.orgId as string,
       route.params.projectId as string,
       req.id,
-      exec.id,
-    )
-  } catch { /* silent */ }
+      exec.id
+    );
+  } catch {
+    /* silent */
+  }
 }
 
 function startPolling() {
-  if (pollTimer || !isLiveExecution.value) return
-  const interval = isLiveExecution.value ? 2000 : 10000
+  if (pollTimer || !isLiveExecution.value) return;
+  const interval = isLiveExecution.value ? 2000 : 10000;
   pollTimer = setInterval(async () => {
-    if (!auth.token) return
+    if (!auth.token) return;
     try {
       const [requestData, executionData] = await Promise.all([
-        releaseApi.listRequests(auth.token, route.params.orgId as string, route.params.projectId as string),
-        releaseApi.getCurrentExecution(auth.token, route.params.orgId as string, route.params.projectId as string),
-      ])
-      requests.value = requestData
-      currentExecution.value = executionData
+        releaseApi.listRequests(
+          auth.token,
+          route.params.orgId as string,
+          route.params.projectId as string
+        ),
+        releaseApi.getCurrentExecution(
+          auth.token,
+          route.params.orgId as string,
+          route.params.projectId as string
+        ),
+      ]);
+      requests.value = requestData;
+      currentExecution.value = executionData;
       if (!isLiveExecution.value) {
-        clearInterval(pollTimer!)
-        pollTimer = null
-        fetchExecutionEvents()
+        clearInterval(pollTimer!);
+        pollTimer = null;
+        fetchExecutionEvents();
       }
-    } catch { /* silent */ }
-  }, interval)
+    } catch {
+      /* silent */
+    }
+  }, interval);
 }
 
-onUnmounted(() => { if (pollTimer) clearInterval(pollTimer) })
+onUnmounted(() => {
+  if (pollTimer) clearInterval(pollTimer);
+});
 
 function requestStatusTheme(status: string) {
-  if (status === 'completed') return 'success'
-  if (status === 'pending_approval' || status === 'executing') return 'warning'
-  if (status === 'rejected' || status === 'failed') return 'danger'
-  return 'default'
+  if (status === 'completed') return 'success';
+  if (status === 'pending_approval' || status === 'executing') return 'warning';
+  if (status === 'rejected' || status === 'failed') return 'danger';
+  return 'default';
 }
 
 function executionStatusTheme(status: string) {
-  if (status === 'completed') return 'success'
-  if (status === 'failed') return 'danger'
-  if (status === 'paused') return 'default'
-  if (status === 'rollback_in_progress') return 'warning'
-  return 'warning'
+  if (status === 'completed') return 'success';
+  if (status === 'failed') return 'danger';
+  if (status === 'paused') return 'default';
+  if (status === 'rollback_in_progress') return 'warning';
+  return 'warning';
 }
 
 function goToDetail(id: string) {
-  router.push({ name: 'project-release-request-detail', params: { ...route.params, releaseId: id } })
+  router.push({
+    name: 'project-release-request-detail',
+    params: { ...route.params, releaseId: id },
+  });
 }
 
 onMounted(async () => {
-  if (!auth.token) return
+  if (!auth.token) return;
   try {
     const [policyData, requestData, executionData] = await Promise.all([
-      releaseApi.listPolicies(auth.token, route.params.orgId as string, route.params.projectId as string),
-      releaseApi.listRequests(auth.token, route.params.orgId as string, route.params.projectId as string),
-      releaseApi.getCurrentExecution(auth.token, route.params.orgId as string, route.params.projectId as string),
-    ])
-    policies.value = policyData
-    requests.value = requestData
-    currentExecution.value = executionData
-    startPolling()
+      releaseApi.listPolicies(
+        auth.token,
+        route.params.orgId as string,
+        route.params.projectId as string
+      ),
+      releaseApi.listRequests(
+        auth.token,
+        route.params.orgId as string,
+        route.params.projectId as string
+      ),
+      releaseApi.getCurrentExecution(
+        auth.token,
+        route.params.orgId as string,
+        route.params.projectId as string
+      ),
+    ]);
+    policies.value = policyData;
+    requests.value = requestData;
+    currentExecution.value = executionData;
+    startPolling();
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.loadFailed'))
+    MessagePlugin.error(e.message || t('common.loadFailed'));
   }
-})
+});
 </script>
 
 <template>
@@ -149,16 +188,25 @@ onMounted(async () => {
           <div>
             <div class="execution-title">{{ t('releaseCenter.batchProgress') }}</div>
             <div class="execution-subtitle">
-              {{ currentExecution.current_batch }} / {{ currentExecution.total_batches }}
-              · {{ labelRolloutStrategy(currentExecution.strategy) }}
+              {{ currentExecution.current_batch }} / {{ currentExecution.total_batches }} ·
+              {{ labelRolloutStrategy(currentExecution.strategy) }}
             </div>
           </div>
           <t-tag :theme="executionStatusTheme(currentExecution.status)" variant="light">
-            {{ t(`releaseCenter.executionStatusMap.${currentExecution.status}`, t('releaseCenter.statusRollingOut')) }}
+            {{
+              t(
+                `releaseCenter.executionStatusMap.${currentExecution.status}`,
+                t('releaseCenter.statusRollingOut')
+              )
+            }}
           </t-tag>
         </div>
         <template v-if="currentExecution">
-          <t-progress :percentage="Math.round((currentExecution.current_batch / currentExecution.total_batches) * 100)" />
+          <t-progress
+            :percentage="
+              Math.round((currentExecution.current_batch / currentExecution.total_batches) * 100)
+            "
+          />
           <div class="instance-summary">
             <div class="instance-pill success">
               <strong>{{ currentExecution.summary.succeeded_instances }}</strong>
@@ -203,8 +251,19 @@ onMounted(async () => {
       <template #header>
         <div class="table-card-header">
           <span>{{ t('releaseCenter.instancePreview') }}</span>
-          <t-button variant="text" size="small" @click="showEventLog = !showEventLog; if(showEventLog) fetchExecutionEvents()">
-            {{ showEventLog ? t('releaseCenter.monitoring.hideEventLog') : t('releaseCenter.monitoring.showEventLog') }}
+          <t-button
+            variant="text"
+            size="small"
+            @click="
+              showEventLog = !showEventLog;
+              if (showEventLog) fetchExecutionEvents();
+            "
+          >
+            {{
+              showEventLog
+                ? t('releaseCenter.monitoring.hideEventLog')
+                : t('releaseCenter.monitoring.showEventLog')
+            }}
           </t-button>
         </div>
       </template>
@@ -236,7 +295,15 @@ onMounted(async () => {
       >
         <template #status="{ row }">
           <t-tag
-            :theme="row.status === 'success' ? 'success' : row.status === 'failed' ? 'danger' : row.status === 'updating' ? 'warning' : 'default'"
+            :theme="
+              row.status === 'success'
+                ? 'success'
+                : row.status === 'failed'
+                  ? 'danger'
+                  : row.status === 'updating'
+                    ? 'warning'
+                    : 'default'
+            "
             variant="light"
             size="small"
           >
@@ -245,7 +312,9 @@ onMounted(async () => {
         </template>
         <template #batch="{ row }">
           <span v-if="row.metric_summary?.batch_index">
-            {{ row.metric_summary.batch_index }}/{{ row.metric_summary.total_batches ?? currentExecution?.total_batches }}
+            {{ row.metric_summary.batch_index }}/{{
+              row.metric_summary.total_batches ?? currentExecution?.total_batches
+            }}
           </span>
           <span v-else>—</span>
         </template>
@@ -272,7 +341,9 @@ onMounted(async () => {
         <div v-for="ev in executionEvents" :key="ev.id" class="event-log__item">
           <span class="event-log__time">{{ new Date(ev.created_at).toLocaleTimeString() }}</span>
           <span class="event-log__type">{{ ev.event_type }}</span>
-          <span v-if="ev.instance_id" class="event-log__instance">{{ ev.instance_id.slice(0, 8) }}</span>
+          <span v-if="ev.instance_id" class="event-log__instance">{{
+            ev.instance_id.slice(0, 8)
+          }}</span>
         </div>
       </div>
     </t-card>
@@ -349,9 +420,15 @@ onMounted(async () => {
   gap: 3px;
 }
 
-.instance-pill.success { background: rgba(0, 168, 112, 0.08); }
-.instance-pill.warning { background: rgba(237, 108, 2, 0.08); }
-.instance-pill.danger { background: rgba(214, 48, 49, 0.08); }
+.instance-pill.success {
+  background: rgba(0, 168, 112, 0.08);
+}
+.instance-pill.warning {
+  background: rgba(237, 108, 2, 0.08);
+}
+.instance-pill.danger {
+  background: rgba(214, 48, 49, 0.08);
+}
 
 .instance-pill strong {
   font-size: 18px;
diff --git a/ordo-editor/apps/studio/src/views/project/ReleasePoliciesView.vue b/ordo-editor/apps/studio/src/views/project/ReleasePoliciesView.vue
index da0d404e..e37e4729 100644
--- a/ordo-editor/apps/studio/src/views/project/ReleasePoliciesView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ReleasePoliciesView.vue
@@ -1,27 +1,27 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { memberApi, releaseApi } from '@/api/platform-client'
-import type { Member, ReleasePolicy } from '@/api/types'
-import { StudioPageHeader } from '@/components/ui'
-import ReleaseNav from '@/components/project/ReleaseNav.vue'
-import { useRolloutStrategyLabel } from '@/constants/release-center'
-import { useAuthStore } from '@/stores/auth'
-import { useEnvironmentStore } from '@/stores/environment'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const labelRolloutStrategy = useRolloutStrategyLabel()
-const auth = useAuthStore()
-const envStore = useEnvironmentStore()
-const policies = ref<ReleasePolicy[]>([])
-const loading = ref(false)
-const creating = ref(false)
-const showCreateDialog = ref(false)
-const members = ref<Member[]>([])
+import { computed, onMounted, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { memberApi, releaseApi } from '@/api/platform-client';
+import type { Member, ReleasePolicy } from '@/api/types';
+import { StudioPageHeader } from '@/components/ui';
+import ReleaseNav from '@/components/project/ReleaseNav.vue';
+import { useRolloutStrategyLabel } from '@/constants/release-center';
+import { useAuthStore } from '@/stores/auth';
+import { useEnvironmentStore } from '@/stores/environment';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const labelRolloutStrategy = useRolloutStrategyLabel();
+const auth = useAuthStore();
+const envStore = useEnvironmentStore();
+const policies = ref<ReleasePolicy[]>([]);
+const loading = ref(false);
+const creating = ref(false);
+const showCreateDialog = ref(false);
+const members = ref<Member[]>([]);
 const form = ref({
   name: '',
   scope: 'project' as 'org' | 'project',
@@ -36,65 +36,67 @@ const form = ref({
   auto_rollback: true,
   max_failed_instances: 1,
   metric_guard: '',
-})
+});
 const environmentOptions = computed(() =>
   envStore.environments.map((env) => ({
     label: env.name,
     value: env.id,
-  })),
-)
+  }))
+);
 const memberOptions = computed(() =>
   members.value.map((member) => ({
     label: member.display_name || member.email,
     value: member.user_id,
-  })),
-)
+  }))
+);
 
 function envName(id: string) {
-  return envStore.environments.find((e) => e.id === id)?.name || id
+  return envStore.environments.find((e) => e.id === id)?.name || id;
 }
 
 function approverNames(ids: string[]) {
-  return ids.map((id) => {
-    const m = members.value.find((m) => m.user_id === id)
-    return m ? (m.display_name || m.email) : id
-  }).join(', ')
+  return ids
+    .map((id) => {
+      const m = members.value.find((m) => m.user_id === id);
+      return m ? m.display_name || m.email : id;
+    })
+    .join(', ');
 }
 
 onMounted(async () => {
-  if (!auth.token) return
-  loading.value = true
+  if (!auth.token) return;
+  loading.value = true;
   try {
     await Promise.all([
       refreshPolicies(),
       envStore.fetchEnvironments(route.params.orgId as string, route.params.projectId as string),
       loadMembers(),
-    ])
+    ]);
     if (route.query.create === '1') {
-      openCreateDialog()
-      const nextQuery = { ...route.query }
-      delete nextQuery.create
-      router.replace({ query: nextQuery })
+      openCreateDialog();
+      const nextQuery = { ...route.query };
+      delete nextQuery.create;
+      router.replace({ query: nextQuery });
     }
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.loadFailed'))
+    MessagePlugin.error(e.message || t('common.loadFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 async function refreshPolicies() {
-  if (!auth.token) return
+  if (!auth.token) return;
   policies.value = await releaseApi.listPolicies(
     auth.token,
     route.params.orgId as string,
-    route.params.projectId as string,
-  )
+    route.params.projectId as string
+  );
 }
 
 async function loadMembers() {
-  if (!auth.token) return
-  members.value = await memberApi.list(auth.token, route.params.orgId as string)
+  if (!auth.token) return;
+  members.value = await memberApi.list(auth.token, route.params.orgId as string);
 }
 
 function openCreateDialog() {
@@ -112,17 +114,17 @@ function openCreateDialog() {
     auto_rollback: true,
     max_failed_instances: 1,
     metric_guard: '',
-  }
-  showCreateDialog.value = true
+  };
+  showCreateDialog.value = true;
 }
 
 async function submitPolicy() {
-  if (!auth.token) return
+  if (!auth.token) return;
   if (!form.value.name || !form.value.target_id || form.value.approver_ids.length === 0) {
-    MessagePlugin.warning(t('releaseCenter.formRequired'))
-    return
+    MessagePlugin.warning(t('releaseCenter.formRequired'));
+    return;
   }
-  creating.value = true
+  creating.value = true;
   try {
     const created = await releaseApi.createPolicy(
       auth.token,
@@ -149,30 +151,39 @@ async function submitPolicy() {
           max_failed_instances: form.value.max_failed_instances,
           metric_guard: form.value.metric_guard || undefined,
         },
-      },
-    )
-    policies.value.unshift(created)
-    showCreateDialog.value = false
-    MessagePlugin.success(t('releaseCenter.policyCreated'))
+      }
+    );
+    policies.value.unshift(created);
+    showCreateDialog.value = false;
+    MessagePlugin.success(t('releaseCenter.policyCreated'));
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('releaseCenter.policyCreateFailed'))
+    MessagePlugin.error(e.message || t('releaseCenter.policyCreateFailed'));
   } finally {
-    creating.value = false
+    creating.value = false;
   }
 }
 </script>
 
 <template>
   <div class="view-page">
-    <StudioPageHeader :title="$t('releaseCenter.policiesTitle')" :subtitle="$t('releaseCenter.policiesSubtitle')">
+    <StudioPageHeader
+      :title="$t('releaseCenter.policiesTitle')"
+      :subtitle="$t('releaseCenter.policiesSubtitle')"
+    >
       <template #actions>
-        <t-button theme="primary" @click="openCreateDialog">{{ $t('releaseCenter.createPolicy') }}</t-button>
+        <t-button theme="primary" @click="openCreateDialog">{{
+          $t('releaseCenter.createPolicy')
+        }}</t-button>
       </template>
     </StudioPageHeader>
     <ReleaseNav />
 
     <div v-if="loading" class="loading-state">
-      <t-skeleton theme="paragraph" animation="gradient" :row-col="[{ width: '36%' }, { width: '92%' }, { width: '70%' }]" />
+      <t-skeleton
+        theme="paragraph"
+        animation="gradient"
+        :row-col="[{ width: '36%' }, { width: '92%' }, { width: '70%' }]"
+      />
     </div>
 
     <div v-else-if="policies.length" class="policy-list">
@@ -200,13 +211,20 @@ async function submitPolicy() {
           </div>
           <div class="kv">
             <span>{{ $t('releaseCenter.rollbackPolicy') }}</span>
-            <strong>{{ policy.rollback_policy.auto_rollback ? $t('common.enabled') : $t('common.disabled') }}</strong>
+            <strong>{{
+              policy.rollback_policy.auto_rollback ? $t('common.enabled') : $t('common.disabled')
+            }}</strong>
           </div>
         </div>
 
         <div class="policy-foot">
-          <span v-if="policy.rollback_policy.metric_guard">{{ $t('releaseCenter.metricGuard') }}: {{ policy.rollback_policy.metric_guard }}</span>
-          <span>{{ $t('releaseCenter.updatedAt') }}: {{ new Date(policy.updated_at).toLocaleString() }}</span>
+          <span v-if="policy.rollback_policy.metric_guard"
+            >{{ $t('releaseCenter.metricGuard') }}: {{ policy.rollback_policy.metric_guard }}</span
+          >
+          <span
+            >{{ $t('releaseCenter.updatedAt') }}:
+            {{ new Date(policy.updated_at).toLocaleString() }}</span
+          >
         </div>
       </t-card>
     </div>
@@ -214,7 +232,12 @@ async function submitPolicy() {
       <t-empty :title="$t('releaseCenter.policyEmpty')" />
     </div>
 
-    <t-dialog v-model:visible="showCreateDialog" :header="$t('releaseCenter.createPolicy')" :footer="false" width="720px">
+    <t-dialog
+      v-model:visible="showCreateDialog"
+      :header="$t('releaseCenter.createPolicy')"
+      :footer="false"
+      width="720px"
+    >
       <t-form label-align="top" :colon="false" class="dialog-form">
         <div class="dialog-grid">
           <t-form-item required>
@@ -251,7 +274,9 @@ async function submitPolicy() {
               <div class="field-label">
                 <span>{{ $t('releaseCenter.minApprovals') }}</span>
                 <t-popup :content="$t('releaseCenter.minApprovalsHelp')" placement="top">
-                  <button type="button" class="field-help" aria-label="Minimum approvals help">?</button>
+                  <button type="button" class="field-help" aria-label="Minimum approvals help">
+                    ?
+                  </button>
                 </t-popup>
               </div>
             </template>
@@ -287,7 +312,9 @@ async function submitPolicy() {
               <div class="field-label">
                 <span>{{ $t('releaseCenter.batchIntervalField') }}</span>
                 <t-popup :content="$t('releaseCenter.batchIntervalHelp')" placement="top">
-                  <button type="button" class="field-help" aria-label="Batch interval help">?</button>
+                  <button type="button" class="field-help" aria-label="Batch interval help">
+                    ?
+                  </button>
                 </t-popup>
               </div>
             </template>
@@ -301,7 +328,9 @@ async function submitPolicy() {
               <div class="field-label">
                 <span>{{ $t('releaseCenter.maxFailedInstancesField') }}</span>
                 <t-popup :content="$t('releaseCenter.maxFailedInstancesHelp')" placement="top">
-                  <button type="button" class="field-help" aria-label="Max failed instances help">?</button>
+                  <button type="button" class="field-help" aria-label="Max failed instances help">
+                    ?
+                  </button>
                 </t-popup>
               </div>
             </template>
@@ -322,8 +351,12 @@ async function submitPolicy() {
       </t-form>
 
       <div class="dialog-actions">
-        <t-button variant="outline" @click="showCreateDialog = false">{{ $t('common.cancel') }}</t-button>
-        <t-button theme="primary" :loading="creating" @click="submitPolicy">{{ $t('releaseCenter.createPolicy') }}</t-button>
+        <t-button variant="outline" @click="showCreateDialog = false">{{
+          $t('common.cancel')
+        }}</t-button>
+        <t-button theme="primary" :loading="creating" @click="submitPolicy">{{
+          $t('releaseCenter.createPolicy')
+        }}</t-button>
       </div>
     </t-dialog>
   </div>
diff --git a/ordo-editor/apps/studio/src/views/project/ReleaseRequestDetailView.vue b/ordo-editor/apps/studio/src/views/project/ReleaseRequestDetailView.vue
index 2820993d..582cabba 100644
--- a/ordo-editor/apps/studio/src/views/project/ReleaseRequestDetailView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ReleaseRequestDetailView.vue
@@ -1,117 +1,121 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { releaseApi } from '@/api/platform-client'
-import type { ReleaseExecution, ReleaseRequest } from '@/api/types'
-import { StudioPageHeader } from '@/components/ui'
-import ReleaseNav from '@/components/project/ReleaseNav.vue'
-import { useRolloutStrategyLabel } from '@/constants/release-center'
-import { useAuthStore } from '@/stores/auth'
-import { useRbacStore } from '@/stores/rbac'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const labelRolloutStrategy = useRolloutStrategyLabel()
-const auth = useAuthStore()
-const rbacStore = useRbacStore()
-
-const loading = ref(false)
-const reviewLoading = ref(false)
-const executeLoading = ref(false)
-const controlLoading = ref<'pause' | 'resume' | 'rollback' | null>(null)
-const request = ref<ReleaseRequest | null>(null)
-const execution = ref<ReleaseExecution | null>(null)
-const elapsedSeconds = ref(0)
-const activeTab = ref('overview')
-
-let pollTimer: ReturnType<typeof setInterval> | null = null
-let clockTimer: ReturnType<typeof setInterval> | null = null
+import { computed, onMounted, onUnmounted, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { releaseApi } from '@/api/platform-client';
+import type { ReleaseExecution, ReleaseRequest } from '@/api/types';
+import { StudioPageHeader } from '@/components/ui';
+import ReleaseNav from '@/components/project/ReleaseNav.vue';
+import { useRolloutStrategyLabel } from '@/constants/release-center';
+import { useAuthStore } from '@/stores/auth';
+import { useRbacStore } from '@/stores/rbac';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const labelRolloutStrategy = useRolloutStrategyLabel();
+const auth = useAuthStore();
+const rbacStore = useRbacStore();
+
+const loading = ref(false);
+const reviewLoading = ref(false);
+const executeLoading = ref(false);
+const controlLoading = ref<'pause' | 'resume' | 'rollback' | null>(null);
+const request = ref<ReleaseRequest | null>(null);
+const execution = ref<ReleaseExecution | null>(null);
+const elapsedSeconds = ref(0);
+const activeTab = ref('overview');
+
+let pollTimer: ReturnType<typeof setInterval> | null = null;
+let clockTimer: ReturnType<typeof setInterval> | null = null;
 
 const reviewDialog = ref<{ visible: boolean; mode: 'approve' | 'reject'; comment: string }>({
-  visible: false, mode: 'approve', comment: '',
-})
-
-const canApprove = computed(() => rbacStore.can('release:request.approve'))
-const canReject = computed(() => rbacStore.can('release:request.reject'))
-const canExecute = computed(() => rbacStore.can('release:execute'))
-const canPause = computed(() => rbacStore.can('release:pause'))
-const canResume = computed(() => rbacStore.can('release:resume'))
-const canRollback = computed(() => rbacStore.can('release:rollback'))
-const canReview = computed(() =>
-  !!request.value?.approvals.some(
-    (a) => a.reviewer_id === auth.user?.id && a.decision === 'pending',
-  ),
-)
+  visible: false,
+  mode: 'approve',
+  comment: '',
+});
+
+const canApprove = computed(() => rbacStore.can('release:request.approve'));
+const canReject = computed(() => rbacStore.can('release:request.reject'));
+const canExecute = computed(() => rbacStore.can('release:execute'));
+const canPause = computed(() => rbacStore.can('release:pause'));
+const canResume = computed(() => rbacStore.can('release:resume'));
+const canRollback = computed(() => rbacStore.can('release:rollback'));
+const canReview = computed(
+  () =>
+    !!request.value?.approvals.some(
+      (a) => a.reviewer_id === auth.user?.id && a.decision === 'pending'
+    )
+);
 
 const isLiveExecution = computed(() =>
-  ['preparing', 'waiting_start', 'rolling_out', 'paused']
-    .includes(execution.value?.status ?? ''),
-)
+  ['preparing', 'waiting_start', 'rolling_out', 'paused'].includes(execution.value?.status ?? '')
+);
 
 const displayExecutionStatus = computed(() => {
-  if (!execution.value) return null
-  const failedInstances = execution.value.summary?.failed_instances ?? 0
-  const pendingInstances = execution.value.summary?.pending_instances ?? 0
+  if (!execution.value) return null;
+  const failedInstances = execution.value.summary?.failed_instances ?? 0;
+  const pendingInstances = execution.value.summary?.pending_instances ?? 0;
   if (execution.value.status === 'completed' && (failedInstances > 0 || pendingInstances > 0)) {
-    return 'failed'
+    return 'failed';
   }
-  return execution.value.status
-})
+  return execution.value.status;
+});
 
 const requestDisplayStatus = computed(() => {
-  if (!request.value) return null
+  if (!request.value) return null;
   if (
     displayExecutionStatus.value === 'failed' &&
     ['completed', 'executing'].includes(request.value.status)
   ) {
-    return 'failed'
+    return 'failed';
   }
-  return request.value.status
-})
-
-const hasExecution = computed(() => execution.value !== null)
-const canPauseExecution = computed(() =>
-  !!execution.value && ['preparing', 'waiting_start', 'rolling_out', 'verifying'].includes(execution.value.status),
-)
-const canResumeExecution = computed(() =>
-  execution.value?.status === 'paused',
-)
-const canRollbackExecution = computed(() =>
-  !!execution.value && ['completed', 'failed', 'paused'].includes(displayExecutionStatus.value ?? execution.value.status),
-)
-const canRetryExecution = computed(() =>
-  canExecute.value &&
-  requestDisplayStatus.value === 'failed' &&
-  !isLiveExecution.value,
-)
-const showExecuteAction = computed(() =>
-  canExecute.value && (requestDisplayStatus.value === 'approved' || canRetryExecution.value),
-)
+  return request.value.status;
+});
+
+const hasExecution = computed(() => execution.value !== null);
+const canPauseExecution = computed(
+  () =>
+    !!execution.value &&
+    ['preparing', 'waiting_start', 'rolling_out', 'verifying'].includes(execution.value.status)
+);
+const canResumeExecution = computed(() => execution.value?.status === 'paused');
+const canRollbackExecution = computed(
+  () =>
+    !!execution.value &&
+    ['completed', 'failed', 'paused'].includes(
+      displayExecutionStatus.value ?? execution.value.status
+    )
+);
+const canRetryExecution = computed(
+  () => canExecute.value && requestDisplayStatus.value === 'failed' && !isLiveExecution.value
+);
+const showExecuteAction = computed(
+  () => canExecute.value && (requestDisplayStatus.value === 'approved' || canRetryExecution.value)
+);
 
 const executionTabDot = computed(() => {
-  if (!displayExecutionStatus.value) return null
-  if (displayExecutionStatus.value === 'completed') return 'success'
-  if (['failed', 'rollback_in_progress'].includes(displayExecutionStatus.value)) return 'danger'
-  if (isLiveExecution.value) return 'live'
-  return null
-})
+  if (!displayExecutionStatus.value) return null;
+  if (displayExecutionStatus.value === 'completed') return 'success';
+  if (['failed', 'rollback_in_progress'].includes(displayExecutionStatus.value)) return 'danger';
+  if (isLiveExecution.value) return 'live';
+  return null;
+});
 
-const approvedCount = computed(() =>
-  request.value?.approvals.filter((a) => a.decision === 'approved').length ?? 0,
-)
+const approvedCount = computed(
+  () => request.value?.approvals.filter((a) => a.decision === 'approved').length ?? 0
+);
 
 const approvalProgress = computed(() => {
-  const total = request.value?.approvals.length ?? 0
-  const min = request.value?.request_snapshot.min_approvals ?? 0
-  return { approved: approvedCount.value, total, min }
-})
+  const total = request.value?.approvals.length ?? 0;
+  const min = request.value?.request_snapshot.min_approvals ?? 0;
+  return { approved: approvedCount.value, total, min };
+});
 
 const hasDiffChanges = computed(() => {
-  const d = request.value?.content_diff
-  if (!d) return false
+  const d = request.value?.content_diff;
+  if (!d) return false;
   return (
     (d.added_steps?.length ?? 0) > 0 ||
     (d.modified_steps?.length ?? 0) > 0 ||
@@ -123,194 +127,263 @@ const hasDiffChanges = computed(() => {
     d.output_schema_changed ||
     d.tags_changed ||
     d.description_changed
-  )
-})
+  );
+});
 
 function statusTheme(status: string) {
-  if (['approved', 'completed'].includes(status)) return 'success'
-  if (['pending_approval', 'executing'].includes(status)) return 'warning'
-  if (['rejected', 'failed'].includes(status)) return 'danger'
-  return 'default'
+  if (['approved', 'completed'].includes(status)) return 'success';
+  if (['pending_approval', 'executing'].includes(status)) return 'warning';
+  if (['rejected', 'failed'].includes(status)) return 'danger';
+  return 'default';
 }
 
 function instanceTheme(status: string) {
-  if (status === 'success') return 'success'
-  if (['failed', 'rolled_back'].includes(status)) return 'danger'
-  if (['updating', 'dispatching', 'verifying'].includes(status)) return 'warning'
-  return 'default'
+  if (status === 'success') return 'success';
+  if (['failed', 'rolled_back'].includes(status)) return 'danger';
+  if (['updating', 'dispatching', 'verifying'].includes(status)) return 'warning';
+  return 'default';
 }
 
 function approvalDecisionTheme(decision: string) {
-  if (decision === 'approved') return 'success'
-  if (decision === 'rejected') return 'danger'
-  return 'default'
+  if (decision === 'approved') return 'success';
+  if (decision === 'rejected') return 'danger';
+  return 'default';
 }
 
 function formatElapsed(s: number) {
-  const m = Math.floor(s / 60)
-  return m > 0 ? `${m}m ${s % 60}s` : `${s}s`
+  const m = Math.floor(s / 60);
+  return m > 0 ? `${m}m ${s % 60}s` : `${s}s`;
 }
 
 function formatDatetime(iso: string | undefined | null) {
-  if (!iso) return '—'
+  if (!iso) return '—';
   return new Date(iso).toLocaleString(undefined, {
-    month: 'short', day: 'numeric', year: 'numeric',
-    hour: '2-digit', minute: '2-digit',
-  })
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
 }
 
 function startClock() {
-  if (!execution.value?.started_at) return
-  const t0 = new Date(execution.value.started_at).getTime()
-  clockTimer = setInterval(() => { elapsedSeconds.value = Math.floor((Date.now() - t0) / 1000) }, 1000)
+  if (!execution.value?.started_at) return;
+  const t0 = new Date(execution.value.started_at).getTime();
+  clockTimer = setInterval(() => {
+    elapsedSeconds.value = Math.floor((Date.now() - t0) / 1000);
+  }, 1000);
 }
 
 function stopClock() {
-  if (clockTimer) { clearInterval(clockTimer); clockTimer = null }
+  if (clockTimer) {
+    clearInterval(clockTimer);
+    clockTimer = null;
+  }
 }
 
 function startPolling() {
-  if (pollTimer) return
+  if (pollTimer) return;
   pollTimer = setInterval(async () => {
-    if (!auth.token || !request.value) return
+    if (!auth.token || !request.value) return;
     try {
       const ex = await releaseApi.getRequestExecution(
-        auth.token, route.params.orgId as string,
-        route.params.projectId as string, request.value.id,
-      )
-      execution.value = ex
+        auth.token,
+        route.params.orgId as string,
+        route.params.projectId as string,
+        request.value.id
+      );
+      execution.value = ex;
       if (ex && !isLiveExecution.value) {
-        stopPolling(); stopClock()
+        stopPolling();
+        stopClock();
         if (ex.started_at)
-          elapsedSeconds.value = Math.floor((Date.now() - new Date(ex.started_at).getTime()) / 1000)
+          elapsedSeconds.value = Math.floor(
+            (Date.now() - new Date(ex.started_at).getTime()) / 1000
+          );
         request.value = await releaseApi.getRequest(
-          auth.token, route.params.orgId as string,
-          route.params.projectId as string, request.value.id,
-        )
+          auth.token,
+          route.params.orgId as string,
+          route.params.projectId as string,
+          request.value.id
+        );
       }
-    } catch { /* silent */ }
-  }, 2000)
+    } catch {
+      /* silent */
+    }
+  }, 2000);
 }
 
 function stopPolling() {
-  if (pollTimer) { clearInterval(pollTimer); pollTimer = null }
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
 }
 
 onMounted(async () => {
-  if (!auth.token) return
-  loading.value = true
+  if (!auth.token) return;
+  loading.value = true;
   try {
     await Promise.all([
       rbacStore.fetchRoles(route.params.orgId as string),
       rbacStore.fetchMyRoles(route.params.orgId as string),
-    ])
+    ]);
     request.value = await releaseApi.getRequest(
-      auth.token, route.params.orgId as string,
-      route.params.projectId as string, route.params.releaseId as string,
-    )
+      auth.token,
+      route.params.orgId as string,
+      route.params.projectId as string,
+      route.params.releaseId as string
+    );
     const ex = await releaseApi.getRequestExecution(
-      auth.token, route.params.orgId as string,
-      route.params.projectId as string, route.params.releaseId as string,
-    )
-    execution.value = ex
+      auth.token,
+      route.params.orgId as string,
+      route.params.projectId as string,
+      route.params.releaseId as string
+    );
+    execution.value = ex;
     if (ex?.started_at)
-      elapsedSeconds.value = Math.floor((Date.now() - new Date(ex.started_at).getTime()) / 1000)
-    if (ex) { activeTab.value = 'execution' }
-    if (isLiveExecution.value) { startClock(); startPolling() }
+      elapsedSeconds.value = Math.floor((Date.now() - new Date(ex.started_at).getTime()) / 1000);
+    if (ex) {
+      activeTab.value = 'execution';
+    }
+    if (isLiveExecution.value) {
+      startClock();
+      startPolling();
+    }
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.loadFailed'))
+    MessagePlugin.error(e.message || t('common.loadFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
-onUnmounted(() => { stopPolling(); stopClock() })
+onUnmounted(() => {
+  stopPolling();
+  stopClock();
+});
 
 function openReview(mode: 'approve' | 'reject') {
-  reviewDialog.value = { visible: true, mode, comment: '' }
+  reviewDialog.value = { visible: true, mode, comment: '' };
 }
 
 async function submitReview() {
-  if (!auth.token || !request.value) return
-  reviewLoading.value = true
+  if (!auth.token || !request.value) return;
+  reviewLoading.value = true;
   try {
-    request.value = reviewDialog.value.mode === 'approve'
-      ? await releaseApi.approveRequest(auth.token, route.params.orgId as string,
-          route.params.projectId as string, request.value.id,
-          { comment: reviewDialog.value.comment || undefined })
-      : await releaseApi.rejectRequest(auth.token, route.params.orgId as string,
-          route.params.projectId as string, request.value.id,
-          { comment: reviewDialog.value.comment || undefined })
-    reviewDialog.value.visible = false
-    MessagePlugin.success(reviewDialog.value.mode === 'approve'
-      ? t('releaseCenter.requestApproved') : t('releaseCenter.requestRejected'))
+    request.value =
+      reviewDialog.value.mode === 'approve'
+        ? await releaseApi.approveRequest(
+            auth.token,
+            route.params.orgId as string,
+            route.params.projectId as string,
+            request.value.id,
+            { comment: reviewDialog.value.comment || undefined }
+          )
+        : await releaseApi.rejectRequest(
+            auth.token,
+            route.params.orgId as string,
+            route.params.projectId as string,
+            request.value.id,
+            { comment: reviewDialog.value.comment || undefined }
+          );
+    reviewDialog.value.visible = false;
+    MessagePlugin.success(
+      reviewDialog.value.mode === 'approve'
+        ? t('releaseCenter.requestApproved')
+        : t('releaseCenter.requestRejected')
+    );
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.saveFailed'))
+    MessagePlugin.error(e.message || t('common.saveFailed'));
   } finally {
-    reviewLoading.value = false
+    reviewLoading.value = false;
   }
 }
 
 async function executeRelease() {
-  if (!auth.token || !request.value) return
-  const isRetry = canRetryExecution.value
-  executeLoading.value = true
+  if (!auth.token || !request.value) return;
+  const isRetry = canRetryExecution.value;
+  executeLoading.value = true;
   try {
     const ex = await releaseApi.executeRequest(
-      auth.token, route.params.orgId as string,
-      route.params.projectId as string, request.value.id,
-    )
-    execution.value = ex
-    elapsedSeconds.value = 0
-    activeTab.value = 'execution'
+      auth.token,
+      route.params.orgId as string,
+      route.params.projectId as string,
+      request.value.id
+    );
+    execution.value = ex;
+    elapsedSeconds.value = 0;
+    activeTab.value = 'execution';
     request.value = await releaseApi.getRequest(
-      auth.token, route.params.orgId as string,
-      route.params.projectId as string, request.value.id,
-    )
-    startClock(); startPolling()
-    MessagePlugin.success(t(isRetry ? 'releaseCenter.executionRetried' : 'releaseCenter.executionStarted'))
+      auth.token,
+      route.params.orgId as string,
+      route.params.projectId as string,
+      request.value.id
+    );
+    startClock();
+    startPolling();
+    MessagePlugin.success(
+      t(isRetry ? 'releaseCenter.executionRetried' : 'releaseCenter.executionStarted')
+    );
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('releaseCenter.executionStartFailed'))
+    MessagePlugin.error(e.message || t('releaseCenter.executionStartFailed'));
   } finally {
-    executeLoading.value = false
+    executeLoading.value = false;
   }
 }
 
 async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
-  if (!auth.token || !request.value) return
-  controlLoading.value = action
+  if (!auth.token || !request.value) return;
+  controlLoading.value = action;
   try {
-    const ex = action === 'pause'
-      ? await releaseApi.pauseExecution(auth.token, route.params.orgId as string, route.params.projectId as string, request.value.id)
-      : action === 'resume'
-        ? await releaseApi.resumeExecution(auth.token, route.params.orgId as string, route.params.projectId as string, request.value.id)
-        : await releaseApi.rollbackExecution(auth.token, route.params.orgId as string, route.params.projectId as string, request.value.id)
-    execution.value = ex
+    const ex =
+      action === 'pause'
+        ? await releaseApi.pauseExecution(
+            auth.token,
+            route.params.orgId as string,
+            route.params.projectId as string,
+            request.value.id
+          )
+        : action === 'resume'
+          ? await releaseApi.resumeExecution(
+              auth.token,
+              route.params.orgId as string,
+              route.params.projectId as string,
+              request.value.id
+            )
+          : await releaseApi.rollbackExecution(
+              auth.token,
+              route.params.orgId as string,
+              route.params.projectId as string,
+              request.value.id
+            );
+    execution.value = ex;
     request.value = await releaseApi.getRequest(
-      auth.token, route.params.orgId as string,
-      route.params.projectId as string, request.value.id,
-    )
+      auth.token,
+      route.params.orgId as string,
+      route.params.projectId as string,
+      request.value.id
+    );
     if (action === 'pause') {
-      stopClock()
-      stopPolling()
+      stopClock();
+      stopPolling();
     } else if (action === 'resume') {
-      startClock()
-      startPolling()
+      startClock();
+      startPolling();
     } else if (action === 'rollback') {
-      activeTab.value = 'execution'
+      activeTab.value = 'execution';
       if (isLiveExecution.value) {
-        startClock()
-        startPolling()
+        startClock();
+        startPolling();
       } else {
-        stopClock()
-        stopPolling()
+        stopClock();
+        stopPolling();
       }
     }
-    MessagePlugin.success(t(`releaseCenter.${action}ActionSuccess`))
+    MessagePlugin.success(t(`releaseCenter.${action}ActionSuccess`));
   } catch (e: any) {
-    MessagePlugin.error(e.message || t(`releaseCenter.${action}ActionFailed`))
+    MessagePlugin.error(e.message || t(`releaseCenter.${action}ActionFailed`));
   } finally {
-    controlLoading.value = null
+    controlLoading.value = null;
   }
 }
 </script>
@@ -319,10 +392,17 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   <div class="view-page">
     <StudioPageHeader
       :title="request?.title || t('releaseCenter.requestDetailTitle')"
-      :subtitle="request ? `${request.ruleset_name} · ${request.environment_name} · v${request.version}` : t('releaseCenter.requestDetailSubtitle')"
+      :subtitle="
+        request
+          ? `${request.ruleset_name} · ${request.environment_name} · v${request.version}`
+          : t('releaseCenter.requestDetailSubtitle')
+      "
     >
       <template #actions>
-        <t-button variant="outline" @click="router.push({ name: 'project-release-requests', params: route.params })">
+        <t-button
+          variant="outline"
+          @click="router.push({ name: 'project-release-requests', params: route.params })"
+        >
           {{ t('releaseCenter.backToRequests') }}
         </t-button>
         <template v-if="request?.status === 'pending_approval' && canReview">
@@ -373,8 +453,11 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
     <ReleaseNav />
 
     <div v-if="loading" class="skeleton-list">
-      <t-skeleton theme="paragraph" animation="gradient"
-        :row-col="[{ width: '40%' }, { width: '100%' }, { width: '80%' }]" />
+      <t-skeleton
+        theme="paragraph"
+        animation="gradient"
+        :row-col="[{ width: '40%' }, { width: '100%' }, { width: '80%' }]"
+      />
     </div>
 
     <template v-else-if="request">
@@ -397,11 +480,17 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
           <div class="strip-divider" />
           <div class="strip-item">
             <span>{{ t('releaseCenter.rollbackBaseline') }}</span>
-            <strong>{{ request.version_diff.rollback_version || request.rollback_version || '—' }}</strong>
+            <strong>{{
+              request.version_diff.rollback_version || request.rollback_version || '—'
+            }}</strong>
           </div>
           <div class="strip-item">
             <span>{{ t('releaseCenter.rolloutStrategy') }}</span>
-            <strong>{{ labelRolloutStrategy(request.request_snapshot.rollout_strategy || request.rollout_strategy) }}</strong>
+            <strong>{{
+              labelRolloutStrategy(
+                request.request_snapshot.rollout_strategy || request.rollout_strategy
+              )
+            }}</strong>
           </div>
           <div class="strip-divider" />
           <div class="strip-item">
@@ -413,22 +502,26 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
 
       <!-- Tabs -->
       <t-tabs v-model="activeTab" class="detail-tabs">
-
         <!-- ── Overview ─────────────────────────────────────────────────── -->
         <t-tab-panel value="overview" :label="t('releaseCenter.tabOverview')">
           <div class="panel">
-
             <!-- Request info -->
             <t-card :bordered="false">
               <div class="card-section-title">{{ t('releaseCenter.requestInfo') }}</div>
               <div class="kv-grid kv-grid--3">
                 <div class="kv">
                   <span>{{ t('releaseCenter.requesterLabel') }}</span>
-                  <strong>{{ request.created_by_name || request.request_snapshot.requester_name || request.created_by }}</strong>
+                  <strong>{{
+                    request.created_by_name ||
+                    request.request_snapshot.requester_name ||
+                    request.created_by
+                  }}</strong>
                 </div>
                 <div class="kv">
                   <span>{{ t('releaseCenter.requesterEmail') }}</span>
-                  <strong>{{ request.created_by_email || request.request_snapshot.requester_email || '—' }}</strong>
+                  <strong>{{
+                    request.created_by_email || request.request_snapshot.requester_email || '—'
+                  }}</strong>
                 </div>
                 <div class="kv">
                   <span>{{ t('releaseCenter.policyField') }}</span>
@@ -436,11 +529,16 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                 </div>
                 <div class="kv">
                   <span>{{ t('releaseCenter.affectedInstances') }}</span>
-                  <strong>{{ request.request_snapshot.affected_instance_count ?? request.affected_instance_count }}</strong>
+                  <strong>{{
+                    request.request_snapshot.affected_instance_count ??
+                    request.affected_instance_count
+                  }}</strong>
                 </div>
                 <div class="kv">
                   <span>{{ t('releaseCenter.environmentField') }}</span>
-                  <strong>{{ request.request_snapshot.environment_name || request.environment_name || '—' }}</strong>
+                  <strong>{{
+                    request.request_snapshot.environment_name || request.environment_name || '—'
+                  }}</strong>
                 </div>
                 <div class="kv">
                   <span>{{ t('releaseCenter.createdAt') }}</span>
@@ -456,7 +554,11 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="text-block-label">{{ t('releaseCenter.summaryField') }}</div>
                   <div class="text-block-body">{{ request.change_summary }}</div>
                 </div>
-                <div v-if="request.release_note" class="text-block" :class="{ 'text-block--bordered': request.change_summary }">
+                <div
+                  v-if="request.release_note"
+                  class="text-block"
+                  :class="{ 'text-block--bordered': request.change_summary }"
+                >
                   <div class="text-block-label">{{ t('publish.releaseNote') }}</div>
                   <div class="text-block-body">{{ request.release_note }}</div>
                 </div>
@@ -466,23 +568,45 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
             <!-- Rollout + rollback policy -->
             <div class="two-col">
               <t-card :bordered="false">
-                <div class="card-section-title">{{ t('releaseCenter.rolloutStrategyDetails') }}</div>
+                <div class="card-section-title">
+                  {{ t('releaseCenter.rolloutStrategyDetails') }}
+                </div>
                 <div class="kv-grid kv-grid--2">
                   <div class="kv">
                     <span>{{ t('releaseCenter.rolloutStrategy') }}</span>
-                    <strong>{{ labelRolloutStrategy(request.request_snapshot.rollout_strategy || request.rollout_strategy) }}</strong>
+                    <strong>{{
+                      labelRolloutStrategy(
+                        request.request_snapshot.rollout_strategy || request.rollout_strategy
+                      )
+                    }}</strong>
                   </div>
                   <div v-if="request.request_snapshot.rollout_strategy?.batch_size" class="kv">
                     <span>{{ t('releaseCenter.batchSizeField') }}</span>
                     <strong>{{ request.request_snapshot.rollout_strategy.batch_size }}</strong>
                   </div>
-                  <div v-if="request.request_snapshot.rollout_strategy?.batch_interval_seconds" class="kv">
+                  <div
+                    v-if="request.request_snapshot.rollout_strategy?.batch_interval_seconds"
+                    class="kv"
+                  >
                     <span>{{ t('releaseCenter.batchIntervalField') }}</span>
-                    <strong>{{ request.request_snapshot.rollout_strategy.batch_interval_seconds }}s</strong>
+                    <strong
+                      >{{
+                        request.request_snapshot.rollout_strategy.batch_interval_seconds
+                      }}s</strong
+                    >
                   </div>
-                  <div v-if="request.request_snapshot.rollout_strategy?.pause_on_error_rate" class="kv">
+                  <div
+                    v-if="request.request_snapshot.rollout_strategy?.pause_on_error_rate"
+                    class="kv"
+                  >
                     <span>{{ t('releaseCenter.pauseOnErrorRate') }}</span>
-                    <strong>{{ (request.request_snapshot.rollout_strategy.pause_on_error_rate * 100).toFixed(0) }}%</strong>
+                    <strong
+                      >{{
+                        (
+                          request.request_snapshot.rollout_strategy.pause_on_error_rate * 100
+                        ).toFixed(0)
+                      }}%</strong
+                    >
                   </div>
                 </div>
               </t-card>
@@ -492,11 +616,17 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                 <div class="kv-grid kv-grid--2">
                   <div class="kv">
                     <span>{{ t('releaseCenter.autoRollback') }}</span>
-                    <strong>{{ request.request_snapshot.rollback_policy?.auto_rollback ? t('common.enabled') : t('common.disabled') }}</strong>
+                    <strong>{{
+                      request.request_snapshot.rollback_policy?.auto_rollback
+                        ? t('common.enabled')
+                        : t('common.disabled')
+                    }}</strong>
                   </div>
                   <div class="kv">
                     <span>{{ t('releaseCenter.maxFailedInstancesField') }}</span>
-                    <strong>{{ request.request_snapshot.rollback_policy?.max_failed_instances ?? '—' }}</strong>
+                    <strong>{{
+                      request.request_snapshot.rollback_policy?.max_failed_instances ?? '—'
+                    }}</strong>
                   </div>
                   <div v-if="request.request_snapshot.rollback_policy?.metric_guard" class="kv">
                     <span>{{ t('releaseCenter.metricGuard') }}</span>
@@ -509,52 +639,77 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                 </div>
               </t-card>
             </div>
-
           </div>
         </t-tab-panel>
 
         <!-- ── Approval ─────────────────────────────────────────────────── -->
         <t-tab-panel value="approval" :label="t('releaseCenter.tabApproval')">
           <div class="panel">
-
             <!-- Progress summary -->
             <t-card :bordered="false" class="approval-summary-card">
               <div class="approval-summary">
                 <div class="approval-progress-text">
                   <span class="approval-count">{{ approvalProgress.approved }}</span>
                   <span class="approval-sep">/</span>
-                  <span class="approval-total">{{ approvalProgress.min || approvalProgress.total }}</span>
+                  <span class="approval-total">{{
+                    approvalProgress.min || approvalProgress.total
+                  }}</span>
                   <span class="approval-label">{{ t('releaseCenter.approvalsRequired') }}</span>
                 </div>
                 <t-progress
-                  :percentage="approvalProgress.min
-                    ? Math.min(100, Math.round((approvalProgress.approved / approvalProgress.min) * 100))
-                    : (approvalProgress.total > 0 ? Math.round((approvalProgress.approved / approvalProgress.total) * 100) : 0)"
-                  :status="requestDisplayStatus === 'approved' || requestDisplayStatus === 'completed' ? 'success'
-                    : requestDisplayStatus === 'rejected' || requestDisplayStatus === 'failed' ? 'error' : undefined"
+                  :percentage="
+                    approvalProgress.min
+                      ? Math.min(
+                          100,
+                          Math.round((approvalProgress.approved / approvalProgress.min) * 100)
+                        )
+                      : approvalProgress.total > 0
+                        ? Math.round((approvalProgress.approved / approvalProgress.total) * 100)
+                        : 0
+                  "
+                  :status="
+                    requestDisplayStatus === 'approved' || requestDisplayStatus === 'completed'
+                      ? 'success'
+                      : requestDisplayStatus === 'rejected' || requestDisplayStatus === 'failed'
+                        ? 'error'
+                        : undefined
+                  "
                   theme="line"
-                  style="flex:1; min-width: 160px;"
+                  style="flex: 1; min-width: 160px"
                 />
                 <div class="approval-meta-pills">
                   <span class="meta-pill">
-                    {{ t('releaseCenter.minApprovals') }}: <strong>{{ request.request_snapshot.min_approvals ?? approvalProgress.total }}</strong>
+                    {{ t('releaseCenter.minApprovals') }}:
+                    <strong>{{
+                      request.request_snapshot.min_approvals ?? approvalProgress.total
+                    }}</strong>
                   </span>
                   <span class="meta-pill">
-                    {{ t('releaseCenter.policyField') }}: <strong>{{ request.request_snapshot.policy_name || '—' }}</strong>
+                    {{ t('releaseCenter.policyField') }}:
+                    <strong>{{ request.request_snapshot.policy_name || '—' }}</strong>
                   </span>
                 </div>
               </div>
             </t-card>
 
             <!-- My pending action -->
-            <t-card v-if="canReview && request.status === 'pending_approval'" :bordered="false" class="my-action-card">
+            <t-card
+              v-if="canReview && request.status === 'pending_approval'"
+              :bordered="false"
+              class="my-action-card"
+            >
               <div class="my-action">
                 <div class="my-action-text">
                   <div class="my-action-title">{{ t('releaseCenter.awaitingYourReview') }}</div>
                   <div class="my-action-sub">{{ t('releaseCenter.awaitingYourReviewSub') }}</div>
                 </div>
                 <div class="my-action-btns">
-                  <t-button v-if="canReject" variant="outline" theme="danger" @click="openReview('reject')">
+                  <t-button
+                    v-if="canReject"
+                    variant="outline"
+                    theme="danger"
+                    @click="openReview('reject')"
+                  >
                     {{ t('releaseCenter.rejectAction') }}
                   </t-button>
                   <t-button v-if="canApprove" theme="primary" @click="openReview('approve')">
@@ -585,40 +740,53 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                       <div class="approval-who">
                         <strong>{{ approval.reviewer_name }}</strong>
                         <span v-if="approval.reviewer_email">{{ approval.reviewer_email }}</span>
-                        <t-tag v-if="approval.reviewer_id === auth.user?.id" size="small" variant="light" theme="primary">
+                        <t-tag
+                          v-if="approval.reviewer_id === auth.user?.id"
+                          size="small"
+                          variant="light"
+                          theme="primary"
+                        >
                           {{ t('releaseCenter.you') }}
                         </t-tag>
                       </div>
                       <div class="approval-right">
-                        <t-tag size="small" variant="light" :theme="approvalDecisionTheme(approval.decision)">
+                        <t-tag
+                          size="small"
+                          variant="light"
+                          :theme="approvalDecisionTheme(approval.decision)"
+                        >
                           {{ t(`releaseCenter.approvalMap.${approval.decision}`) }}
                         </t-tag>
-                        <span v-if="approval.decided_at" class="approval-time">{{ formatDatetime(approval.decided_at) }}</span>
+                        <span v-if="approval.decided_at" class="approval-time">{{
+                          formatDatetime(approval.decided_at)
+                        }}</span>
                       </div>
                     </div>
                     <div v-if="approval.comment" class="approval-comment">
-                      <t-icon name="chat" size="12px" style="flex-shrink:0; margin-top:1px;" />
+                      <t-icon name="chat" size="12px" style="flex-shrink: 0; margin-top: 1px" />
                       <span>{{ approval.comment }}</span>
                     </div>
                   </div>
                 </div>
               </div>
             </t-card>
-
           </div>
         </t-tab-panel>
 
         <!-- ── Diff ────────────────────────────────────────────────────── -->
         <t-tab-panel value="diff" :label="t('releaseCenter.tabDiff')">
           <div class="panel">
-
             <!-- Diff header: baseline + counts + schema flags -->
             <t-card :bordered="false">
               <div class="diff-header">
                 <div class="diff-stat-row">
                   <div class="diff-stat">
                     <span>{{ t('releaseCenter.diffBaselineVersion') }}</span>
-                    <strong>{{ request.content_diff.baseline_version || request.version_diff.from_version || 'Unreleased' }}</strong>
+                    <strong>{{
+                      request.content_diff.baseline_version ||
+                      request.version_diff.from_version ||
+                      'Unreleased'
+                    }}</strong>
                   </div>
                   <div class="diff-stat-sep" />
                   <div class="diff-stat">
@@ -628,7 +796,13 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="diff-stat-arrow">→</div>
                   <div class="diff-stat">
                     <span>{{ t('releaseCenter.diffStepsAfter') }}</span>
-                    <strong :class="{ 'c-changed': request.content_diff.step_count_after !== request.content_diff.step_count_before }">
+                    <strong
+                      :class="{
+                        'c-changed':
+                          request.content_diff.step_count_after !==
+                          request.content_diff.step_count_before,
+                      }"
+                    >
                       {{ request.content_diff.step_count_after }}
                     </strong>
                   </div>
@@ -640,16 +814,54 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="diff-stat-arrow">→</div>
                   <div class="diff-stat">
                     <span>{{ t('releaseCenter.diffGroupsAfter') }}</span>
-                    <strong :class="{ 'c-changed': request.content_diff.group_count_after !== request.content_diff.group_count_before }">
+                    <strong
+                      :class="{
+                        'c-changed':
+                          request.content_diff.group_count_after !==
+                          request.content_diff.group_count_before,
+                      }"
+                    >
                       {{ request.content_diff.group_count_after }}
                     </strong>
                   </div>
                 </div>
-                <div v-if="request.content_diff.input_schema_changed || request.content_diff.output_schema_changed || request.content_diff.tags_changed || request.content_diff.description_changed" class="diff-flags">
-                  <t-tag v-if="request.content_diff.input_schema_changed" theme="warning" variant="light" size="small">{{ t('releaseCenter.diffInputSchemaChanged') }}</t-tag>
-                  <t-tag v-if="request.content_diff.output_schema_changed" theme="warning" variant="light" size="small">{{ t('releaseCenter.diffOutputSchemaChanged') }}</t-tag>
-                  <t-tag v-if="request.content_diff.tags_changed" theme="primary" variant="light" size="small">{{ t('releaseCenter.diffTagsChanged') }}</t-tag>
-                  <t-tag v-if="request.content_diff.description_changed" theme="primary" variant="light" size="small">{{ t('releaseCenter.diffDescriptionChanged') }}</t-tag>
+                <div
+                  v-if="
+                    request.content_diff.input_schema_changed ||
+                    request.content_diff.output_schema_changed ||
+                    request.content_diff.tags_changed ||
+                    request.content_diff.description_changed
+                  "
+                  class="diff-flags"
+                >
+                  <t-tag
+                    v-if="request.content_diff.input_schema_changed"
+                    theme="warning"
+                    variant="light"
+                    size="small"
+                    >{{ t('releaseCenter.diffInputSchemaChanged') }}</t-tag
+                  >
+                  <t-tag
+                    v-if="request.content_diff.output_schema_changed"
+                    theme="warning"
+                    variant="light"
+                    size="small"
+                    >{{ t('releaseCenter.diffOutputSchemaChanged') }}</t-tag
+                  >
+                  <t-tag
+                    v-if="request.content_diff.tags_changed"
+                    theme="primary"
+                    variant="light"
+                    size="small"
+                    >{{ t('releaseCenter.diffTagsChanged') }}</t-tag
+                  >
+                  <t-tag
+                    v-if="request.content_diff.description_changed"
+                    theme="primary"
+                    variant="light"
+                    size="small"
+                    >{{ t('releaseCenter.diffDescriptionChanged') }}</t-tag
+                  >
                 </div>
               </div>
             </t-card>
@@ -660,16 +872,28 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
             </t-card>
 
             <!-- Step changes -->
-            <template v-if="(request.content_diff.added_steps?.length ?? 0) > 0 || (request.content_diff.modified_steps?.length ?? 0) > 0 || (request.content_diff.removed_steps?.length ?? 0) > 0">
+            <template
+              v-if="
+                (request.content_diff.added_steps?.length ?? 0) > 0 ||
+                (request.content_diff.modified_steps?.length ?? 0) > 0 ||
+                (request.content_diff.removed_steps?.length ?? 0) > 0
+              "
+            >
               <div class="diff-columns">
                 <t-card :bordered="false">
                   <div class="diff-col-head added">
                     <span class="diff-col-sign">+</span>
                     <span>{{ t('releaseCenter.diffAddedSteps') }}</span>
-                    <span class="diff-col-count">{{ request.content_diff.added_steps?.length ?? 0 }}</span>
+                    <span class="diff-col-count">{{
+                      request.content_diff.added_steps?.length ?? 0
+                    }}</span>
                   </div>
                   <div v-if="request.content_diff.added_steps?.length" class="diff-item-list">
-                    <div v-for="item in request.content_diff.added_steps" :key="item.id" class="diff-item diff-item--added">
+                    <div
+                      v-for="item in request.content_diff.added_steps"
+                      :key="item.id"
+                      class="diff-item diff-item--added"
+                    >
                       <strong>{{ item.name }}</strong>
                       <span v-if="item.step_type">{{ item.step_type }}</span>
                     </div>
@@ -681,10 +905,16 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="diff-col-head modified">
                     <span class="diff-col-sign">~</span>
                     <span>{{ t('releaseCenter.diffModifiedSteps') }}</span>
-                    <span class="diff-col-count">{{ request.content_diff.modified_steps?.length ?? 0 }}</span>
+                    <span class="diff-col-count">{{
+                      request.content_diff.modified_steps?.length ?? 0
+                    }}</span>
                   </div>
                   <div v-if="request.content_diff.modified_steps?.length" class="diff-item-list">
-                    <div v-for="item in request.content_diff.modified_steps" :key="item.id" class="diff-item diff-item--modified">
+                    <div
+                      v-for="item in request.content_diff.modified_steps"
+                      :key="item.id"
+                      class="diff-item diff-item--modified"
+                    >
                       <strong>{{ item.name }}</strong>
                       <span v-if="item.step_type">{{ item.step_type }}</span>
                     </div>
@@ -696,10 +926,16 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="diff-col-head removed">
                     <span class="diff-col-sign">-</span>
                     <span>{{ t('releaseCenter.diffRemovedSteps') }}</span>
-                    <span class="diff-col-count">{{ request.content_diff.removed_steps?.length ?? 0 }}</span>
+                    <span class="diff-col-count">{{
+                      request.content_diff.removed_steps?.length ?? 0
+                    }}</span>
                   </div>
                   <div v-if="request.content_diff.removed_steps?.length" class="diff-item-list">
-                    <div v-for="item in request.content_diff.removed_steps" :key="item.id" class="diff-item diff-item--removed">
+                    <div
+                      v-for="item in request.content_diff.removed_steps"
+                      :key="item.id"
+                      class="diff-item diff-item--removed"
+                    >
                       <strong>{{ item.name }}</strong>
                       <span v-if="item.step_type">{{ item.step_type }}</span>
                     </div>
@@ -710,16 +946,28 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
             </template>
 
             <!-- Group changes -->
-            <template v-if="(request.content_diff.added_groups?.length ?? 0) > 0 || (request.content_diff.modified_groups?.length ?? 0) > 0 || (request.content_diff.removed_groups?.length ?? 0) > 0">
+            <template
+              v-if="
+                (request.content_diff.added_groups?.length ?? 0) > 0 ||
+                (request.content_diff.modified_groups?.length ?? 0) > 0 ||
+                (request.content_diff.removed_groups?.length ?? 0) > 0
+              "
+            >
               <div class="diff-columns">
                 <t-card :bordered="false">
                   <div class="diff-col-head added">
                     <span class="diff-col-sign">+</span>
                     <span>{{ t('releaseCenter.diffAddedGroups') }}</span>
-                    <span class="diff-col-count">{{ request.content_diff.added_groups?.length ?? 0 }}</span>
+                    <span class="diff-col-count">{{
+                      request.content_diff.added_groups?.length ?? 0
+                    }}</span>
                   </div>
                   <div v-if="request.content_diff.added_groups?.length" class="diff-item-list">
-                    <div v-for="name in request.content_diff.added_groups" :key="name" class="diff-item diff-item--added">
+                    <div
+                      v-for="name in request.content_diff.added_groups"
+                      :key="name"
+                      class="diff-item diff-item--added"
+                    >
                       <strong>{{ name }}</strong>
                     </div>
                   </div>
@@ -730,10 +978,16 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="diff-col-head modified">
                     <span class="diff-col-sign">~</span>
                     <span>{{ t('releaseCenter.diffModifiedGroups') }}</span>
-                    <span class="diff-col-count">{{ request.content_diff.modified_groups?.length ?? 0 }}</span>
+                    <span class="diff-col-count">{{
+                      request.content_diff.modified_groups?.length ?? 0
+                    }}</span>
                   </div>
                   <div v-if="request.content_diff.modified_groups?.length" class="diff-item-list">
-                    <div v-for="name in request.content_diff.modified_groups" :key="name" class="diff-item diff-item--modified">
+                    <div
+                      v-for="name in request.content_diff.modified_groups"
+                      :key="name"
+                      class="diff-item diff-item--modified"
+                    >
                       <strong>{{ name }}</strong>
                     </div>
                   </div>
@@ -744,10 +998,16 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   <div class="diff-col-head removed">
                     <span class="diff-col-sign">-</span>
                     <span>{{ t('releaseCenter.diffRemovedGroups') }}</span>
-                    <span class="diff-col-count">{{ request.content_diff.removed_groups?.length ?? 0 }}</span>
+                    <span class="diff-col-count">{{
+                      request.content_diff.removed_groups?.length ?? 0
+                    }}</span>
                   </div>
                   <div v-if="request.content_diff.removed_groups?.length" class="diff-item-list">
-                    <div v-for="name in request.content_diff.removed_groups" :key="name" class="diff-item diff-item--removed">
+                    <div
+                      v-for="name in request.content_diff.removed_groups"
+                      :key="name"
+                      class="diff-item diff-item--removed"
+                    >
                       <strong>{{ name }}</strong>
                     </div>
                   </div>
@@ -755,7 +1015,6 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                 </t-card>
               </div>
             </template>
-
           </div>
         </t-tab-panel>
 
@@ -764,19 +1023,35 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
           <template #label>
             <span class="exec-tab-label">
               {{ t('releaseCenter.tabExecution') }}
-              <span v-if="executionTabDot" class="exec-dot" :class="`exec-dot--${executionTabDot}`" />
+              <span
+                v-if="executionTabDot"
+                class="exec-dot"
+                :class="`exec-dot--${executionTabDot}`"
+              />
             </span>
           </template>
 
           <div class="panel">
             <template v-if="execution">
-              <t-card v-if="displayExecutionStatus === 'completed'" :bordered="false" class="banner-card banner-card--success">
+              <t-card
+                v-if="displayExecutionStatus === 'completed'"
+                :bordered="false"
+                class="banner-card banner-card--success"
+              >
                 ✓ {{ t('releaseCenter.executionCompleted') }}
               </t-card>
-              <t-card v-else-if="displayExecutionStatus === 'failed'" :bordered="false" class="banner-card banner-card--danger">
+              <t-card
+                v-else-if="displayExecutionStatus === 'failed'"
+                :bordered="false"
+                class="banner-card banner-card--danger"
+              >
                 ✗ {{ t('releaseCenter.executionFailed') }}
               </t-card>
-              <t-card v-else-if="displayExecutionStatus === 'rollback_in_progress'" :bordered="false" class="banner-card banner-card--warning">
+              <t-card
+                v-else-if="displayExecutionStatus === 'rollback_in_progress'"
+                :bordered="false"
+                class="banner-card banner-card--warning"
+              >
                 ↩ {{ t('releaseCenter.executionRolledBack') }}
               </t-card>
 
@@ -784,8 +1059,18 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                 <div class="exec-stats">
                   <div class="exec-stat">
                     <span>{{ t('releaseCenter.status') }}</span>
-                    <t-tag :theme="instanceTheme(displayExecutionStatus || execution.status)" variant="light" size="small">
-                      {{ t(`releaseCenter.executionStatusMap.${displayExecutionStatus || execution.status}`) }}
+                    <t-tag
+                      :theme="instanceTheme(displayExecutionStatus || execution.status)"
+                      variant="light"
+                      size="small"
+                    >
+                      {{
+                        t(
+                          `releaseCenter.executionStatusMap.${
+                            displayExecutionStatus || execution.status
+                          }`
+                        )
+                      }}
                       <span v-if="isLiveExecution" class="live-dot" />
                     </t-tag>
                   </div>
@@ -799,7 +1084,9 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                   </div>
                   <div class="exec-stat">
                     <span>{{ t('releaseCenter.succeeded') }}</span>
-                    <strong class="c-success">{{ execution.summary?.succeeded_instances ?? 0 }}</strong>
+                    <strong class="c-success">{{
+                      execution.summary?.succeeded_instances ?? 0
+                    }}</strong>
                   </div>
                   <div class="exec-stat">
                     <span>{{ t('releaseCenter.pending') }}</span>
@@ -816,9 +1103,17 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
                 </div>
                 <t-progress
                   v-if="execution.total_batches > 0"
-                  :percentage="Math.round((execution.current_batch / execution.total_batches) * 100)"
-                  :status="displayExecutionStatus === 'completed' ? 'success' : displayExecutionStatus === 'failed' ? 'error' : 'active'"
-                  style="margin-top: 16px;"
+                  :percentage="
+                    Math.round((execution.current_batch / execution.total_batches) * 100)
+                  "
+                  :status="
+                    displayExecutionStatus === 'completed'
+                      ? 'success'
+                      : displayExecutionStatus === 'failed'
+                        ? 'error'
+                        : 'active'
+                  "
+                  style="margin-top: 16px"
                 />
               </t-card>
 
@@ -854,7 +1149,6 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
             <t-empty v-else :title="t('releaseCenter.executionEmpty')" />
           </div>
         </t-tab-panel>
-
       </t-tabs>
     </template>
 
@@ -862,7 +1156,11 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
 
     <t-dialog
       v-model:visible="reviewDialog.visible"
-      :header="reviewDialog.mode === 'approve' ? t('releaseCenter.approveAction') : t('releaseCenter.rejectAction')"
+      :header="
+        reviewDialog.mode === 'approve'
+          ? t('releaseCenter.approveAction')
+          : t('releaseCenter.rejectAction')
+      "
       :footer="false"
       width="520px"
     >
@@ -872,17 +1170,25 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
         </t-form-item>
         <div v-if="request" class="review-preview">
           <div class="review-preview__title">{{ request.title }}</div>
-          <div class="review-preview__meta">{{ request.ruleset_name }} · {{ request.environment_name }} · v{{ request.version }}</div>
+          <div class="review-preview__meta">
+            {{ request.ruleset_name }} · {{ request.environment_name }} · v{{ request.version }}
+          </div>
         </div>
       </t-form>
       <div class="dialog-actions">
-        <t-button variant="outline" @click="reviewDialog.visible = false">{{ t('common.cancel') }}</t-button>
+        <t-button variant="outline" @click="reviewDialog.visible = false">{{
+          t('common.cancel')
+        }}</t-button>
         <t-button
           :theme="reviewDialog.mode === 'approve' ? 'primary' : 'danger'"
           :loading="reviewLoading"
           @click="submitReview"
         >
-          {{ reviewDialog.mode === 'approve' ? t('releaseCenter.approveAction') : t('releaseCenter.rejectAction') }}
+          {{
+            reviewDialog.mode === 'approve'
+              ? t('releaseCenter.approveAction')
+              : t('releaseCenter.rejectAction')
+          }}
         </t-button>
       </div>
     </t-dialog>
@@ -896,21 +1202,60 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   overflow-y: auto;
 }
 
-.skeleton-list { display: grid; gap: 12px; }
+.skeleton-list {
+  display: grid;
+  gap: 12px;
+}
 
 /* ── strip ─────────────────────────────────────────────────────────────── */
-.strip-card :deep(.t-card__body) { padding: 12px 16px; }
-.strip-card { margin-bottom: 4px; }
-.strip { display: flex; align-items: center; gap: 16px; flex-wrap: wrap; }
-.strip-divider { width: 1px; height: 28px; background: var(--ordo-border-color); flex-shrink: 0; }
-.strip-item { display: flex; flex-direction: column; gap: 2px; }
-.strip-item span { font-size: 11px; color: var(--ordo-text-secondary); }
-.strip-item strong { font-size: 13px; color: var(--ordo-text-primary); font-family: monospace; font-weight: 500; }
-.strip-arrow { color: var(--ordo-text-tertiary); font-weight: 700; }
+.strip-card :deep(.t-card__body) {
+  padding: 12px 16px;
+}
+.strip-card {
+  margin-bottom: 4px;
+}
+.strip {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  flex-wrap: wrap;
+}
+.strip-divider {
+  width: 1px;
+  height: 28px;
+  background: var(--ordo-border-color);
+  flex-shrink: 0;
+}
+.strip-item {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+.strip-item span {
+  font-size: 11px;
+  color: var(--ordo-text-secondary);
+}
+.strip-item strong {
+  font-size: 13px;
+  color: var(--ordo-text-primary);
+  font-family: monospace;
+  font-weight: 500;
+}
+.strip-arrow {
+  color: var(--ordo-text-tertiary);
+  font-weight: 700;
+}
 
 /* ── tabs ──────────────────────────────────────────────────────────────── */
-.detail-tabs { margin-top: 16px; }
-.panel { display: flex; flex-direction: column; gap: 12px; padding-top: 16px; }
+.detail-tabs {
+  margin-top: 16px;
+}
+.panel {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding-top: 16px;
+}
 
 /* ── shared ────────────────────────────────────────────────────────────── */
 .card-section-title {
@@ -922,24 +1267,67 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   margin-bottom: 14px;
 }
 
-.kv-grid { display: grid; gap: 16px; }
-.kv-grid--2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-.kv-grid--3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
-.kv { display: flex; flex-direction: column; gap: 4px; }
-.kv span { font-size: 12px; color: var(--ordo-text-secondary); }
-.kv strong { font-size: 14px; color: var(--ordo-text-primary); font-weight: 500; }
+.kv-grid {
+  display: grid;
+  gap: 16px;
+}
+.kv-grid--2 {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+.kv-grid--3 {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+.kv {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.kv span {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+}
+.kv strong {
+  font-size: 14px;
+  color: var(--ordo-text-primary);
+  font-weight: 500;
+}
 
-.two-col { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
+.two-col {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+}
 
 /* ── text blocks ───────────────────────────────────────────────────────── */
-.text-sections { display: flex; flex-direction: column; gap: 16px; }
-.text-block { display: flex; flex-direction: column; gap: 8px; }
-.text-block--bordered { padding-top: 16px; border-top: 1px solid var(--ordo-border-color); }
-.text-block-label { font-size: 12px; color: var(--ordo-text-secondary); font-weight: 500; }
-.text-block-body { font-size: 14px; color: var(--ordo-text-primary); line-height: 1.75; }
+.text-sections {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.text-block {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.text-block--bordered {
+  padding-top: 16px;
+  border-top: 1px solid var(--ordo-border-color);
+}
+.text-block-label {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+  font-weight: 500;
+}
+.text-block-body {
+  font-size: 14px;
+  color: var(--ordo-text-primary);
+  line-height: 1.75;
+}
 
 /* ── approval ──────────────────────────────────────────────────────────── */
-.approval-summary-card :deep(.t-card__body) { padding: 16px 20px; }
+.approval-summary-card :deep(.t-card__body) {
+  padding: 16px 20px;
+}
 .approval-summary {
   display: flex;
   align-items: center;
@@ -952,11 +1340,30 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   gap: 4px;
   flex-shrink: 0;
 }
-.approval-count { font-size: 28px; font-weight: 700; color: var(--ordo-text-primary); font-variant-numeric: tabular-nums; }
-.approval-sep { font-size: 20px; color: var(--ordo-text-tertiary); }
-.approval-total { font-size: 20px; color: var(--ordo-text-secondary); }
-.approval-label { font-size: 12px; color: var(--ordo-text-secondary); margin-left: 6px; }
-.approval-meta-pills { display: flex; flex-wrap: wrap; gap: 8px; }
+.approval-count {
+  font-size: 28px;
+  font-weight: 700;
+  color: var(--ordo-text-primary);
+  font-variant-numeric: tabular-nums;
+}
+.approval-sep {
+  font-size: 20px;
+  color: var(--ordo-text-tertiary);
+}
+.approval-total {
+  font-size: 20px;
+  color: var(--ordo-text-secondary);
+}
+.approval-label {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+  margin-left: 6px;
+}
+.approval-meta-pills {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
 .meta-pill {
   font-size: 12px;
   color: var(--ordo-text-secondary);
@@ -964,9 +1371,15 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   padding: 4px 10px;
   border-radius: 999px;
 }
-.meta-pill strong { color: var(--ordo-text-primary); font-weight: 500; }
+.meta-pill strong {
+  color: var(--ordo-text-primary);
+  font-weight: 500;
+}
 
-.my-action-card :deep(.t-card__body) { background: rgba(0, 105, 219, 0.04); padding: 14px 16px; }
+.my-action-card :deep(.t-card__body) {
+  background: rgba(0, 105, 219, 0.04);
+  padding: 14px 16px;
+}
 .my-action {
   display: flex;
   align-items: center;
@@ -974,11 +1387,27 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   gap: 16px;
   flex-wrap: wrap;
 }
-.my-action-title { font-size: 14px; font-weight: 600; color: var(--ordo-text-primary); }
-.my-action-sub { font-size: 12px; color: var(--ordo-text-secondary); margin-top: 2px; }
-.my-action-btns { display: flex; gap: 8px; flex-shrink: 0; }
+.my-action-title {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--ordo-text-primary);
+}
+.my-action-sub {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+  margin-top: 2px;
+}
+.my-action-btns {
+  display: flex;
+  gap: 8px;
+  flex-shrink: 0;
+}
 
-.approval-chain { display: flex; flex-direction: column; gap: 0; }
+.approval-chain {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+}
 .approval-row {
   display: flex;
   align-items: flex-start;
@@ -986,8 +1415,16 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   padding: 14px 0;
   border-bottom: 1px solid var(--ordo-border-color);
 }
-.approval-row:last-child { border-bottom: none; padding-bottom: 0; }
-.approval-row--mine { background: rgba(0, 105, 219, 0.03); margin: 0 -16px; padding: 14px 16px; border-radius: 8px; }
+.approval-row:last-child {
+  border-bottom: none;
+  padding-bottom: 0;
+}
+.approval-row--mine {
+  background: rgba(0, 105, 219, 0.03);
+  margin: 0 -16px;
+  padding: 14px 16px;
+  border-radius: 8px;
+}
 
 .approval-stage-badge {
   width: 28px;
@@ -1004,13 +1441,45 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   margin-top: 2px;
 }
 
-.approval-body { flex: 1; display: flex; flex-direction: column; gap: 6px; min-width: 0; }
-.approval-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
-.approval-who { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
-.approval-who strong { font-size: 13px; color: var(--ordo-text-primary); }
-.approval-who span { font-size: 12px; color: var(--ordo-text-secondary); }
-.approval-right { display: flex; align-items: center; gap: 10px; flex-shrink: 0; }
-.approval-time { font-size: 12px; color: var(--ordo-text-tertiary); white-space: nowrap; }
+.approval-body {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  min-width: 0;
+}
+.approval-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+.approval-who {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+.approval-who strong {
+  font-size: 13px;
+  color: var(--ordo-text-primary);
+}
+.approval-who span {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+}
+.approval-right {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-shrink: 0;
+}
+.approval-time {
+  font-size: 12px;
+  color: var(--ordo-text-tertiary);
+  white-space: nowrap;
+}
 .approval-comment {
   display: flex;
   align-items: flex-start;
@@ -1024,20 +1493,65 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
 }
 
 /* ── diff ──────────────────────────────────────────────────────────────── */
-.diff-header { display: flex; flex-direction: column; gap: 12px; }
-.diff-stat-row { display: flex; align-items: center; gap: 14px; flex-wrap: wrap; }
-.diff-stat { display: flex; flex-direction: column; gap: 3px; }
-.diff-stat span { font-size: 11px; color: var(--ordo-text-secondary); }
-.diff-stat strong { font-size: 14px; color: var(--ordo-text-primary); font-weight: 500; font-family: monospace; }
-.diff-stat-sep { width: 1px; height: 28px; background: var(--ordo-border-color); flex-shrink: 0; }
-.diff-stat-arrow { color: var(--ordo-text-tertiary); font-weight: 600; font-size: 14px; }
-.c-changed { color: #0069DB; }
+.diff-header {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+.diff-stat-row {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  flex-wrap: wrap;
+}
+.diff-stat {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+.diff-stat span {
+  font-size: 11px;
+  color: var(--ordo-text-secondary);
+}
+.diff-stat strong {
+  font-size: 14px;
+  color: var(--ordo-text-primary);
+  font-weight: 500;
+  font-family: monospace;
+}
+.diff-stat-sep {
+  width: 1px;
+  height: 28px;
+  background: var(--ordo-border-color);
+  flex-shrink: 0;
+}
+.diff-stat-arrow {
+  color: var(--ordo-text-tertiary);
+  font-weight: 600;
+  font-size: 14px;
+}
+.c-changed {
+  color: #0069db;
+}
 
-.diff-flags { display: flex; gap: 6px; flex-wrap: wrap; }
+.diff-flags {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
 
-.diff-empty-center { text-align: center; font-size: 13px; color: var(--ordo-text-tertiary); margin: 8px 0; }
+.diff-empty-center {
+  text-align: center;
+  font-size: 13px;
+  color: var(--ordo-text-tertiary);
+  margin: 8px 0;
+}
 
-.diff-columns { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 12px; }
+.diff-columns {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
+}
 
 .diff-col-head {
   display: flex;
@@ -1047,10 +1561,19 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   font-size: 12px;
   font-weight: 600;
 }
-.diff-col-head.added   { color: #00A870; }
-.diff-col-head.modified { color: #9E7400; }
-.diff-col-head.removed { color: #DC503C; }
-.diff-col-sign { font-size: 14px; font-weight: 700; }
+.diff-col-head.added {
+  color: #00a870;
+}
+.diff-col-head.modified {
+  color: #9e7400;
+}
+.diff-col-head.removed {
+  color: #dc503c;
+}
+.diff-col-sign {
+  font-size: 14px;
+  font-weight: 700;
+}
 .diff-col-count {
   margin-left: auto;
   font-size: 11px;
@@ -1061,62 +1584,186 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   font-weight: 500;
 }
 
-.diff-item-list { display: flex; flex-direction: column; gap: 5px; }
+.diff-item-list {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+}
 .diff-item {
-  display: flex; flex-direction: column; gap: 2px;
-  padding: 8px 10px; border-radius: 8px;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 8px 10px;
+  border-radius: 8px;
   border-left: 3px solid transparent;
 }
-.diff-item--added   { background: rgba(0, 168, 112, 0.06); border-left-color: #00A870; }
-.diff-item--modified { background: rgba(158, 116, 0, 0.06); border-left-color: #9E7400; }
-.diff-item--removed { background: rgba(220, 80, 60, 0.06); border-left-color: #DC503C; }
-.diff-item strong { font-size: 13px; color: var(--ordo-text-primary); font-weight: 500; }
-.diff-item span { font-size: 11px; color: var(--ordo-text-secondary); font-family: monospace; }
-.diff-empty { font-size: 12px; color: var(--ordo-text-tertiary); margin: 0; }
+.diff-item--added {
+  background: rgba(0, 168, 112, 0.06);
+  border-left-color: #00a870;
+}
+.diff-item--modified {
+  background: rgba(158, 116, 0, 0.06);
+  border-left-color: #9e7400;
+}
+.diff-item--removed {
+  background: rgba(220, 80, 60, 0.06);
+  border-left-color: #dc503c;
+}
+.diff-item strong {
+  font-size: 13px;
+  color: var(--ordo-text-primary);
+  font-weight: 500;
+}
+.diff-item span {
+  font-size: 11px;
+  color: var(--ordo-text-secondary);
+  font-family: monospace;
+}
+.diff-empty {
+  font-size: 12px;
+  color: var(--ordo-text-tertiary);
+  margin: 0;
+}
 
 /* ── exec tab label ─────────────────────────────────────────────────────── */
-.exec-tab-label { display: flex; align-items: center; gap: 6px; }
-.exec-dot { width: 7px; height: 7px; border-radius: 50%; display: inline-block; }
-.exec-dot--success { background: #00A870; }
-.exec-dot--danger  { background: #DC503C; }
-.exec-dot--live    { background: #EBA700; animation: blink 1.4s ease-in-out infinite; }
-@keyframes blink { 0%, 100% { opacity: 1; } 50% { opacity: 0.25; } }
+.exec-tab-label {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+.exec-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  display: inline-block;
+}
+.exec-dot--success {
+  background: #00a870;
+}
+.exec-dot--danger {
+  background: #dc503c;
+}
+.exec-dot--live {
+  background: #eba700;
+  animation: blink 1.4s ease-in-out infinite;
+}
+@keyframes blink {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.25;
+  }
+}
 
 /* ── banner cards ───────────────────────────────────────────────────────── */
-.banner-card :deep(.t-card__body) { padding: 12px 16px; font-size: 13px; font-weight: 500; }
-.banner-card--success :deep(.t-card__body) { color: #00A870; background: rgba(0,168,112,0.08); }
-.banner-card--danger  :deep(.t-card__body) { color: #DC503C; background: rgba(220,80,60,0.08); }
-.banner-card--warning :deep(.t-card__body) { color: #9E7400; background: rgba(235,167,0,0.08); }
+.banner-card :deep(.t-card__body) {
+  padding: 12px 16px;
+  font-size: 13px;
+  font-weight: 500;
+}
+.banner-card--success :deep(.t-card__body) {
+  color: #00a870;
+  background: rgba(0, 168, 112, 0.08);
+}
+.banner-card--danger :deep(.t-card__body) {
+  color: #dc503c;
+  background: rgba(220, 80, 60, 0.08);
+}
+.banner-card--warning :deep(.t-card__body) {
+  color: #9e7400;
+  background: rgba(235, 167, 0, 0.08);
+}
 
 /* ── exec stats ─────────────────────────────────────────────────────────── */
-.exec-stats { display: flex; gap: 28px; flex-wrap: wrap; }
-.exec-stat { display: flex; flex-direction: column; gap: 4px; }
-.exec-stat span { font-size: 12px; color: var(--ordo-text-secondary); }
-.exec-stat strong { font-size: 20px; font-weight: 600; color: var(--ordo-text-primary); font-variant-numeric: tabular-nums; }
-.c-success { color: #00A870; }
-.c-danger  { color: #DC503C; }
+.exec-stats {
+  display: flex;
+  gap: 28px;
+  flex-wrap: wrap;
+}
+.exec-stat {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.exec-stat span {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+}
+.exec-stat strong {
+  font-size: 20px;
+  font-weight: 600;
+  color: var(--ordo-text-primary);
+  font-variant-numeric: tabular-nums;
+}
+.c-success {
+  color: #00a870;
+}
+.c-danger {
+  color: #dc503c;
+}
 .live-dot {
-  display: inline-block; width: 6px; height: 6px; border-radius: 50%;
-  background: currentColor; margin-left: 4px; vertical-align: middle;
+  display: inline-block;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: currentColor;
+  margin-left: 4px;
+  vertical-align: middle;
   animation: blink 1.4s ease-in-out infinite;
 }
 
 /* ── instance table ─────────────────────────────────────────────────────── */
-.instance-table { width: 100%; border-collapse: collapse; font-size: 13px; }
+.instance-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 13px;
+}
 .instance-table th {
-  text-align: left; font-size: 11px; font-weight: 600; text-transform: uppercase;
-  letter-spacing: 0.04em; color: var(--ordo-text-secondary);
-  padding: 0 12px 10px; border-bottom: 1px solid var(--ordo-border-color);
+  text-align: left;
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--ordo-text-secondary);
+  padding: 0 12px 10px;
+  border-bottom: 1px solid var(--ordo-border-color);
+}
+.instance-table td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--ordo-border-color);
+  vertical-align: middle;
+}
+.instance-table tbody tr:last-child td {
+  border-bottom: none;
+}
+.td-name {
+  font-weight: 500;
+  color: var(--ordo-text-primary);
+}
+.td-secondary {
+  color: var(--ordo-text-secondary);
+}
+.td-mono {
+  font-family: monospace;
+  font-size: 12px;
+  color: var(--ordo-text-primary);
+}
+.td-msg {
+  max-width: 200px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
 }
-.instance-table td { padding: 10px 12px; border-bottom: 1px solid var(--ordo-border-color); vertical-align: middle; }
-.instance-table tbody tr:last-child td { border-bottom: none; }
-.td-name { font-weight: 500; color: var(--ordo-text-primary); }
-.td-secondary { color: var(--ordo-text-secondary); }
-.td-mono { font-family: monospace; font-size: 12px; color: var(--ordo-text-primary); }
-.td-msg { max-width: 200px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 
 /* ── dialog ─────────────────────────────────────────────────────────────── */
-.dialog-actions { display: flex; justify-content: flex-end; gap: 10px; padding-top: 12px; }
+.dialog-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 10px;
+  padding-top: 12px;
+}
 .review-preview {
   margin-top: 10px;
   padding: 10px 14px;
@@ -1126,15 +1773,35 @@ async function controlExecution(action: 'pause' | 'resume' | 'rollback') {
   flex-direction: column;
   gap: 4px;
 }
-.review-preview__title { font-size: 13px; font-weight: 600; color: var(--ordo-text-primary); }
-.review-preview__meta { font-size: 12px; color: var(--ordo-text-secondary); }
+.review-preview__title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--ordo-text-primary);
+}
+.review-preview__meta {
+  font-size: 12px;
+  color: var(--ordo-text-secondary);
+}
 
 @media (max-width: 980px) {
-  .view-page { padding: 16px 20px 32px; }
-  .kv-grid--3 { grid-template-columns: repeat(2, 1fr); }
-  .diff-columns { grid-template-columns: 1fr; }
-  .two-col { grid-template-columns: 1fr; }
-  .strip { gap: 12px; }
-  .approval-summary { flex-direction: column; align-items: flex-start; }
+  .view-page {
+    padding: 16px 20px 32px;
+  }
+  .kv-grid--3 {
+    grid-template-columns: repeat(2, 1fr);
+  }
+  .diff-columns {
+    grid-template-columns: 1fr;
+  }
+  .two-col {
+    grid-template-columns: 1fr;
+  }
+  .strip {
+    gap: 12px;
+  }
+  .approval-summary {
+    flex-direction: column;
+    align-items: flex-start;
+  }
 }
 </style>
diff --git a/ordo-editor/apps/studio/src/views/project/ReleaseRequestsView.vue b/ordo-editor/apps/studio/src/views/project/ReleaseRequestsView.vue
index 6c702d21..7d62be3e 100644
--- a/ordo-editor/apps/studio/src/views/project/ReleaseRequestsView.vue
+++ b/ordo-editor/apps/studio/src/views/project/ReleaseRequestsView.vue
@@ -1,74 +1,83 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { releaseApi } from '@/api/platform-client'
-import type { ReleaseRequest } from '@/api/types'
-import { StudioPageHeader } from '@/components/ui'
-import ReleaseNav from '@/components/project/ReleaseNav.vue'
-import { useAuthStore } from '@/stores/auth'
-import { useRbacStore } from '@/stores/rbac'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const auth = useAuthStore()
-const rbacStore = useRbacStore()
-const statusFilter = ref<'all' | 'pending_approval' | 'executing' | 'approved' | 'rejected'>('all')
-const requests = ref<ReleaseRequest[]>([])
-const loading = ref(false)
-const reviewLoading = ref(false)
-const reviewDialog = ref<{ visible: boolean; mode: 'approve' | 'reject'; request: ReleaseRequest | null; comment: string }>({
+import { computed, onMounted, ref } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { releaseApi } from '@/api/platform-client';
+import type { ReleaseRequest } from '@/api/types';
+import { StudioPageHeader } from '@/components/ui';
+import ReleaseNav from '@/components/project/ReleaseNav.vue';
+import { useAuthStore } from '@/stores/auth';
+import { useRbacStore } from '@/stores/rbac';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const auth = useAuthStore();
+const rbacStore = useRbacStore();
+const statusFilter = ref<'all' | 'pending_approval' | 'executing' | 'approved' | 'rejected'>('all');
+const requests = ref<ReleaseRequest[]>([]);
+const loading = ref(false);
+const reviewLoading = ref(false);
+const reviewDialog = ref<{
+  visible: boolean;
+  mode: 'approve' | 'reject';
+  request: ReleaseRequest | null;
+  comment: string;
+}>({
   visible: false,
   mode: 'approve',
   request: null,
   comment: '',
-})
+});
 
 const filteredRequests = computed(() =>
   statusFilter.value === 'all'
     ? requests.value
-    : requests.value.filter((item) => item.status === statusFilter.value),
-)
+    : requests.value.filter((item) => item.status === statusFilter.value)
+);
 
-const canApprove = computed(() => rbacStore.can('release:request.approve'))
-const canReject = computed(() => rbacStore.can('release:request.reject'))
+const canApprove = computed(() => rbacStore.can('release:request.approve'));
+const canReject = computed(() => rbacStore.can('release:request.reject'));
 
 function formatDate(iso: string) {
-  return new Date(iso).toLocaleDateString(undefined, { month: 'short', day: 'numeric', year: 'numeric' })
+  return new Date(iso).toLocaleDateString(undefined, {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  });
 }
 
 onMounted(async () => {
-  if (!auth.token) return
-  loading.value = true
+  if (!auth.token) return;
+  loading.value = true;
   try {
     await Promise.all([
       rbacStore.fetchRoles(route.params.orgId as string),
       rbacStore.fetchMyRoles(route.params.orgId as string),
       refreshRequests(),
-    ])
+    ]);
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.loadFailed'))
+    MessagePlugin.error(e.message || t('common.loadFailed'));
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 
 async function refreshRequests() {
-  if (!auth.token) return
+  if (!auth.token) return;
   requests.value = await releaseApi.listRequests(
     auth.token,
     route.params.orgId as string,
-    route.params.projectId as string,
-  )
+    route.params.projectId as string
+  );
 }
 
 function tagTheme(status: string) {
-  if (status === 'approved' || status === 'completed') return 'success'
-  if (status === 'pending_approval' || status === 'executing') return 'warning'
-  if (status === 'rejected') return 'danger'
-  return 'default'
+  if (status === 'approved' || status === 'completed') return 'success';
+  if (status === 'pending_approval' || status === 'executing') return 'warning';
+  if (status === 'rejected') return 'danger';
+  return 'default';
 }
 
 function openCreatePage() {
@@ -78,51 +87,52 @@ function openCreatePage() {
       orgId: route.params.orgId,
       projectId: route.params.projectId,
     },
-  })
+  });
 }
 
 function openReview(mode: 'approve' | 'reject', request: ReleaseRequest) {
-  reviewDialog.value = { visible: true, mode, request, comment: '' }
+  reviewDialog.value = { visible: true, mode, request, comment: '' };
 }
 
 async function submitReview() {
-  if (!auth.token || !reviewDialog.value.request) return
-  reviewLoading.value = true
+  if (!auth.token || !reviewDialog.value.request) return;
+  reviewLoading.value = true;
   try {
-    const req = reviewDialog.value.mode === 'approve'
-      ? await releaseApi.approveRequest(
-          auth.token,
-          route.params.orgId as string,
-          route.params.projectId as string,
-          reviewDialog.value.request.id,
-          { comment: reviewDialog.value.comment || undefined },
-        )
-      : await releaseApi.rejectRequest(
-          auth.token,
-          route.params.orgId as string,
-          route.params.projectId as string,
-          reviewDialog.value.request.id,
-          { comment: reviewDialog.value.comment || undefined },
-        )
-    const idx = requests.value.findIndex((item) => item.id === req.id)
-    if (idx !== -1) requests.value[idx] = req
-    reviewDialog.value.visible = false
+    const req =
+      reviewDialog.value.mode === 'approve'
+        ? await releaseApi.approveRequest(
+            auth.token,
+            route.params.orgId as string,
+            route.params.projectId as string,
+            reviewDialog.value.request.id,
+            { comment: reviewDialog.value.comment || undefined }
+          )
+        : await releaseApi.rejectRequest(
+            auth.token,
+            route.params.orgId as string,
+            route.params.projectId as string,
+            reviewDialog.value.request.id,
+            { comment: reviewDialog.value.comment || undefined }
+          );
+    const idx = requests.value.findIndex((item) => item.id === req.id);
+    if (idx !== -1) requests.value[idx] = req;
+    reviewDialog.value.visible = false;
     MessagePlugin.success(
       reviewDialog.value.mode === 'approve'
         ? t('releaseCenter.requestApproved')
-        : t('releaseCenter.requestRejected'),
-    )
+        : t('releaseCenter.requestRejected')
+    );
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('common.saveFailed'))
+    MessagePlugin.error(e.message || t('common.saveFailed'));
   } finally {
-    reviewLoading.value = false
+    reviewLoading.value = false;
   }
 }
 
 function canReviewRequest(request: ReleaseRequest) {
   return request.approvals.some(
-    (approval) => approval.reviewer_id === auth.user?.id && approval.decision === 'pending',
-  )
+    (approval) => approval.reviewer_id === auth.user?.id && approval.decision === 'pending'
+  );
 }
 
 function openRequestDetail(request: ReleaseRequest) {
@@ -133,14 +143,16 @@ function openRequestDetail(request: ReleaseRequest) {
       projectId: route.params.projectId,
       releaseId: request.id,
     },
-  })
+  });
 }
-
 </script>
 
 <template>
   <div class="view-page">
-    <StudioPageHeader :title="t('releaseCenter.requestsTitle')" :subtitle="t('releaseCenter.requestsSubtitle')">
+    <StudioPageHeader
+      :title="t('releaseCenter.requestsTitle')"
+      :subtitle="t('releaseCenter.requestsSubtitle')"
+    >
       <template #actions>
         <t-button theme="primary" @click="openCreatePage">
           {{ t('releaseCenter.createRequest') }}
@@ -152,7 +164,9 @@ function openRequestDetail(request: ReleaseRequest) {
     <div class="toolbar">
       <t-radio-group v-model="statusFilter" variant="default-filled">
         <t-radio-button value="all">{{ t('common.all') }}</t-radio-button>
-        <t-radio-button value="pending_approval">{{ t('releaseCenter.statusPendingApproval') }}</t-radio-button>
+        <t-radio-button value="pending_approval">{{
+          t('releaseCenter.statusPendingApproval')
+        }}</t-radio-button>
         <t-radio-button value="executing">{{ t('releaseCenter.statusExecuting') }}</t-radio-button>
         <t-radio-button value="approved">{{ t('releaseCenter.statusApproved') }}</t-radio-button>
         <t-radio-button value="rejected">{{ t('releaseCenter.statusRejected') }}</t-radio-button>
@@ -160,7 +174,11 @@ function openRequestDetail(request: ReleaseRequest) {
     </div>
 
     <div v-if="loading" class="loading-state">
-      <t-skeleton theme="paragraph" animation="gradient" :row-col="[{ width: '30%' }, { width: '96%' }, { width: '80%' }]" />
+      <t-skeleton
+        theme="paragraph"
+        animation="gradient"
+        :row-col="[{ width: '30%' }, { width: '96%' }, { width: '80%' }]"
+      />
     </div>
 
     <div v-else-if="filteredRequests.length" class="request-list">
@@ -183,21 +201,38 @@ function openRequestDetail(request: ReleaseRequest) {
               <span class="sep">·</span>
               <span>{{ request.environment_name }}</span>
               <span class="sep">·</span>
-              <span>{{ request.version_diff?.from_version || 'Unreleased' }} → v{{ request.version }}</span>
+              <span
+                >{{ request.version_diff?.from_version || 'Unreleased' }} → v{{
+                  request.version
+                }}</span
+              >
               <span class="sep">·</span>
               <span>{{ request.created_by_name || request.created_by }}</span>
               <span class="sep">·</span>
               <span>{{ formatDate(request.created_at) }}</span>
             </div>
-            <div v-if="request.change_summary" class="req-summary">{{ request.change_summary }}</div>
+            <div v-if="request.change_summary" class="req-summary">
+              {{ request.change_summary }}
+            </div>
           </div>
 
           <div class="req-actions" @click.stop>
             <template v-if="request.status === 'pending_approval' && canReviewRequest(request)">
-              <t-button v-if="canReject" variant="outline" theme="danger" size="small" @click="openReview('reject', request)">
+              <t-button
+                v-if="canReject"
+                variant="outline"
+                theme="danger"
+                size="small"
+                @click="openReview('reject', request)"
+              >
                 {{ t('releaseCenter.rejectAction') }}
               </t-button>
-              <t-button v-if="canApprove" theme="primary" size="small" @click="openReview('approve', request)">
+              <t-button
+                v-if="canApprove"
+                theme="primary"
+                size="small"
+                @click="openReview('approve', request)"
+              >
                 {{ t('releaseCenter.approveAction') }}
               </t-button>
             </template>
@@ -212,7 +247,11 @@ function openRequestDetail(request: ReleaseRequest) {
     <!-- Review dialog -->
     <t-dialog
       v-model:visible="reviewDialog.visible"
-      :header="reviewDialog.mode === 'approve' ? t('releaseCenter.approveAction') : t('releaseCenter.rejectAction')"
+      :header="
+        reviewDialog.mode === 'approve'
+          ? t('releaseCenter.approveAction')
+          : t('releaseCenter.rejectAction')
+      "
       :footer="false"
       width="520px"
     >
@@ -229,7 +268,9 @@ function openRequestDetail(request: ReleaseRequest) {
             <span>{{ reviewDialog.request.environment_name }}</span>
             <span>·</span>
             <span>
-              {{ reviewDialog.request.version_diff?.from_version || 'Unreleased' }} → v{{ reviewDialog.request.version_diff?.to_version || reviewDialog.request.version }}
+              {{ reviewDialog.request.version_diff?.from_version || 'Unreleased' }} → v{{
+                reviewDialog.request.version_diff?.to_version || reviewDialog.request.version
+              }}
             </span>
           </div>
           <div class="review-context__summary">{{ reviewDialog.request.change_summary }}</div>
@@ -238,9 +279,9 @@ function openRequestDetail(request: ReleaseRequest) {
               <span>{{ t('releaseCenter.requesterLabel') }}</span>
               <strong>
                 {{
-                  reviewDialog.request.created_by_name
-                  || reviewDialog.request.request_snapshot?.requester_name
-                  || reviewDialog.request.created_by
+                  reviewDialog.request.created_by_name ||
+                  reviewDialog.request.request_snapshot?.requester_name ||
+                  reviewDialog.request.created_by
                 }}
               </strong>
             </div>
@@ -250,22 +291,34 @@ function openRequestDetail(request: ReleaseRequest) {
             </div>
             <div class="kv-item">
               <span>{{ t('releaseCenter.affectedInstances') }}</span>
-              <strong>{{ reviewDialog.request.request_snapshot?.affected_instance_count ?? reviewDialog.request.affected_instance_count }}</strong>
+              <strong>{{
+                reviewDialog.request.request_snapshot?.affected_instance_count ??
+                reviewDialog.request.affected_instance_count
+              }}</strong>
             </div>
           </div>
-          <div v-if="reviewDialog.request.release_note" class="review-context__summary review-context__note">
+          <div
+            v-if="reviewDialog.request.release_note"
+            class="review-context__summary review-context__note"
+          >
             {{ reviewDialog.request.release_note }}
           </div>
         </div>
       </t-form>
       <div class="dialog-actions">
-        <t-button variant="outline" @click="reviewDialog.visible = false">{{ t('common.cancel') }}</t-button>
+        <t-button variant="outline" @click="reviewDialog.visible = false">{{
+          t('common.cancel')
+        }}</t-button>
         <t-button
           :theme="reviewDialog.mode === 'approve' ? 'primary' : 'danger'"
           :loading="reviewLoading"
           @click="submitReview"
         >
-          {{ reviewDialog.mode === 'approve' ? t('releaseCenter.approveAction') : t('releaseCenter.rejectAction') }}
+          {{
+            reviewDialog.mode === 'approve'
+              ? t('releaseCenter.approveAction')
+              : t('releaseCenter.rejectAction')
+          }}
         </t-button>
       </div>
     </t-dialog>
diff --git a/ordo-editor/apps/studio/src/views/project/RuleTraceView.vue b/ordo-editor/apps/studio/src/views/project/RuleTraceView.vue
index 6177f9e1..b28ad23d 100644
--- a/ordo-editor/apps/studio/src/views/project/RuleTraceView.vue
+++ b/ordo-editor/apps/studio/src/views/project/RuleTraceView.vue
@@ -1,34 +1,34 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useRoute } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { useAuthStore } from '@/stores/auth'
-import { rulesetDraftApi } from '@/api/platform-client'
-import RuleTraceRunner from '@/components/trace/RuleTraceRunner.vue'
-import type { ProjectRulesetMeta } from '@/api/types'
+import { computed, onMounted, ref } from 'vue';
+import { useRoute } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { useAuthStore } from '@/stores/auth';
+import { rulesetDraftApi } from '@/api/platform-client';
+import RuleTraceRunner from '@/components/trace/RuleTraceRunner.vue';
+import type { ProjectRulesetMeta } from '@/api/types';
 
-const route = useRoute()
-const { t } = useI18n()
-const auth = useAuthStore()
+const route = useRoute();
+const { t } = useI18n();
+const auth = useAuthStore();
 
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
 
-const rulesets = ref<ProjectRulesetMeta[]>([])
-const loading = ref(false)
+const rulesets = ref<ProjectRulesetMeta[]>([]);
+const loading = ref(false);
 
 onMounted(async () => {
-  if (!auth.token) return
-  loading.value = true
+  if (!auth.token) return;
+  loading.value = true;
   try {
-    const result = await rulesetDraftApi.list(auth.token, orgId.value, projectId.value)
-    rulesets.value = result
+    const result = await rulesetDraftApi.list(auth.token, orgId.value, projectId.value);
+    rulesets.value = result;
   } catch {
     // ignore
   } finally {
-    loading.value = false
+    loading.value = false;
   }
-})
+});
 </script>
 
 <template>
@@ -36,12 +36,7 @@ onMounted(async () => {
     <div v-if="loading" class="trace-view__loading">
       <t-loading />
     </div>
-    <RuleTraceRunner
-      v-else
-      :org-id="orgId"
-      :project-id="projectId"
-      :rulesets="rulesets"
-    />
+    <RuleTraceRunner v-else :org-id="orgId" :project-id="projectId" :rulesets="rulesets" />
   </div>
 </template>
 
diff --git a/ordo-editor/apps/studio/src/views/project/TestView.vue b/ordo-editor/apps/studio/src/views/project/TestView.vue
index e7e47e6b..7962165d 100644
--- a/ordo-editor/apps/studio/src/views/project/TestView.vue
+++ b/ordo-editor/apps/studio/src/views/project/TestView.vue
@@ -1,8 +1,8 @@
 <script setup lang="ts">
-import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
-import { useRoute, useRouter } from 'vue-router'
-import { useI18n } from 'vue-i18n'
-import { MessagePlugin } from 'tdesign-vue-next'
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
+import { useI18n } from 'vue-i18n';
+import { MessagePlugin } from 'tdesign-vue-next';
 import {
   OrdoDecisionTable,
   OrdoFlowEditor,
@@ -10,58 +10,59 @@ import {
   type DecisionTable,
   type ExecutionTraceData,
   type RuleSet,
-} from '@ordo-engine/editor-vue'
-import { rulesetDraftApi } from '@/api/platform-client'
-import { normalizeRuleset } from '@/utils/ruleset'
-import { useAuthStore } from '@/stores/auth'
-import { useProjectStore } from '@/stores/project'
-import { useTestStore } from '@/stores/test'
+} from '@ordo-engine/editor-vue';
+import { rulesetDraftApi } from '@/api/platform-client';
+import { normalizeRuleset } from '@/utils/ruleset';
+import { useAuthStore } from '@/stores/auth';
+import { useProjectStore } from '@/stores/project';
+import { useTestStore } from '@/stores/test';
 import type {
   RulesetTestSummary,
   TestCase,
   TestExecutionTraceStep,
   TestRunResult,
-} from '@/api/types'
-
-const route = useRoute()
-const router = useRouter()
-const { t } = useI18n()
-const auth = useAuthStore()
-const projectStore = useProjectStore()
-const testStore = useTestStore()
-
-const orgId = computed(() => route.params.orgId as string)
-const projectId = computed(() => route.params.projectId as string)
-
-const selectedRuleset = ref<string | null>(null)
-const selectedTestId = ref<string | null>(null)
-const selectedDetailTab = ref<'diff' | 'trace' | 'flow' | 'table'>('diff')
-const selectedDraft = ref<RuleSet | null>(null)
-const draftLoading = ref(false)
-const contentContainer = ref<HTMLElement | null>(null)
-const resultsPaneWidth = ref(520)
-const isResizingResultsPane = ref(false)
-const viewportWidth = ref(typeof window !== 'undefined' ? window.innerWidth : 1440)
-
-const projectResult = computed(() => testStore.projectRunResult)
-const running = computed(() => testStore.projectRunning)
+} from '@/api/types';
+
+const route = useRoute();
+const router = useRouter();
+const { t } = useI18n();
+const auth = useAuthStore();
+const projectStore = useProjectStore();
+const testStore = useTestStore();
+
+const orgId = computed(() => route.params.orgId as string);
+const projectId = computed(() => route.params.projectId as string);
+
+const selectedRuleset = ref<string | null>(null);
+const selectedTestId = ref<string | null>(null);
+const selectedDetailTab = ref<'diff' | 'trace' | 'flow' | 'table'>('diff');
+const selectedDraft = ref<RuleSet | null>(null);
+const draftLoading = ref(false);
+const contentContainer = ref<HTMLElement | null>(null);
+const resultsPaneWidth = ref(520);
+const isResizingResultsPane = ref(false);
+const viewportWidth = ref(typeof window !== 'undefined' ? window.innerWidth : 1440);
+
+const projectResult = computed(() => testStore.projectRunResult);
+const running = computed(() => testStore.projectRunning);
 const summaryMap = computed(
-  () => new Map(projectResult.value?.rulesets.map((ruleset) => [ruleset.ruleset_name, ruleset]) ?? []),
-)
+  () =>
+    new Map(projectResult.value?.rulesets.map((ruleset) => [ruleset.ruleset_name, ruleset]) ?? [])
+);
 const rulesetRows = computed(() =>
   projectStore.rulesets.map((ruleset) => ({
     name: ruleset.name,
     version: ruleset.version,
     summary: summaryMap.value.get(ruleset.name) ?? null,
-  })),
-)
+  }))
+);
 
 const selectedSummary = computed<RulesetTestSummary | null>(
-  () => summaryMap.value.get(selectedRuleset.value ?? '') ?? null,
-)
+  () => summaryMap.value.get(selectedRuleset.value ?? '') ?? null
+);
 const selectedTests = computed<TestCase[]>(
-  () => testStore.testsByRuleset.get(selectedRuleset.value ?? '') ?? [],
-)
+  () => testStore.testsByRuleset.get(selectedRuleset.value ?? '') ?? []
+);
 const selectedResultsOrPending = computed(() => {
   if (selectedSummary.value?.results.length) {
     return selectedSummary.value.results.map((result) => ({
@@ -73,7 +74,7 @@ const selectedResultsOrPending = computed(() => {
       passed: result.passed,
       failures: result.failures,
       result,
-    }))
+    }));
   }
 
   return selectedTests.value.map((test) => ({
@@ -85,261 +86,264 @@ const selectedResultsOrPending = computed(() => {
     passed: false,
     failures: [],
     result: null,
-  }))
-})
+  }));
+});
 const selectedResult = computed<TestRunResult | null>(() => {
-  const summary = selectedSummary.value
-  if (!summary) return null
-  if (!summary.results.length) return null
-  return summary.results.find((result) => result.test_id === selectedTestId.value) ?? summary.results[0]
-})
+  const summary = selectedSummary.value;
+  if (!summary) return null;
+  if (!summary.results.length) return null;
+  return (
+    summary.results.find((result) => result.test_id === selectedTestId.value) ?? summary.results[0]
+  );
+});
 const selectedTestCase = computed<TestCase | null>(
-  () => selectedTests.value.find((test) => test.id === selectedResult.value?.test_id) ?? null,
-)
-
-const expectedCode = computed(() => selectedTestCase.value?.expect.code ?? null)
-const expectedMessage = computed(() => selectedTestCase.value?.expect.message ?? null)
-const expectedOutput = computed(() => selectedTestCase.value?.expect.output ?? null)
-const actualCode = computed(() => selectedResult.value?.actual_code ?? null)
-const actualMessage = computed(() => selectedResult.value?.actual_message ?? null)
-const actualOutput = computed(() => selectedResult.value?.actual_output ?? null)
+  () => selectedTests.value.find((test) => test.id === selectedResult.value?.test_id) ?? null
+);
+
+const expectedCode = computed(() => selectedTestCase.value?.expect.code ?? null);
+const expectedMessage = computed(() => selectedTestCase.value?.expect.message ?? null);
+const expectedOutput = computed(() => selectedTestCase.value?.expect.output ?? null);
+const actualCode = computed(() => selectedResult.value?.actual_code ?? null);
+const actualMessage = computed(() => selectedResult.value?.actual_message ?? null);
+const actualOutput = computed(() => selectedResult.value?.actual_output ?? null);
 const rawExpected = computed(() => ({
   code: expectedCode.value,
   message: expectedMessage.value,
   output: expectedOutput.value ?? null,
-}))
+}));
 const rawActual = computed(() => ({
   code: actualCode.value,
   message: actualMessage.value,
   output: actualOutput.value ?? null,
-}))
+}));
 
 const outputDiffs = computed(() => {
-  const expected = expectedOutput.value ?? {}
-  const actual = actualOutput.value ?? {}
-  const keys = Array.from(new Set([...Object.keys(expected), ...Object.keys(actual)])).sort()
+  const expected = expectedOutput.value ?? {};
+  const actual = actualOutput.value ?? {};
+  const keys = Array.from(new Set([...Object.keys(expected), ...Object.keys(actual)])).sort();
   return keys.map((key) => {
-    const expectedValue = key in expected ? expected[key] : undefined
-    const actualValue = key in actual ? actual[key] : undefined
+    const expectedValue = key in expected ? expected[key] : undefined;
+    const actualValue = key in actual ? actual[key] : undefined;
     return {
       key,
       expected: expectedValue,
       actual: actualValue,
       matches: isEqual(expectedValue, actualValue),
-    }
-  })
-})
+    };
+  });
+});
 
-const traceSummary = computed(() => selectedResult.value?.trace ?? null)
+const traceSummary = computed(() => selectedResult.value?.trace ?? null);
 const flowTrace = computed<ExecutionTraceData | null>(() => {
-  const trace = traceSummary.value
-  const result = selectedResult.value
-  if (!trace || !result) return null
+  const trace = traceSummary.value;
+  const result = selectedResult.value;
+  if (!trace || !result) return null;
   return {
     path: trace.path,
     steps: trace.steps.map((step) => ({
       id: step.id,
       name: step.name,
       duration_us: step.duration_us,
-      result: step.is_terminal ? (result.actual_code ?? trace.result_code) : null,
+      result: step.is_terminal ? result.actual_code ?? trace.result_code : null,
     })),
     resultCode: result.actual_code ?? trace.result_code,
     resultMessage: result.actual_message ?? '',
     output: result.actual_output ?? {},
-  }
-})
+  };
+});
 const selectedDecisionTable = computed<DecisionTable | null>(() => {
-  const draft = selectedDraft.value
-  if (!draft) return null
-  return decompileStepsToTable(draft.steps, draft.startStepId) ?? null
-})
+  const draft = selectedDraft.value;
+  if (!draft) return null;
+  return decompileStepsToTable(draft.steps, draft.startStepId) ?? null;
+});
 const contentGridStyle = computed(() => {
-  if (viewportWidth.value <= 1200) return {}
+  if (viewportWidth.value <= 1200) return {};
   return {
     gridTemplateColumns: `240px minmax(320px, ${resultsPaneWidth.value}px) 10px minmax(420px, 1fr)`,
-  }
-})
+  };
+});
 
 watch(selectedDecisionTable, (table) => {
   if (!table && selectedDetailTab.value === 'table') {
-    selectedDetailTab.value = 'diff'
+    selectedDetailTab.value = 'diff';
   }
-})
+});
 
 watch(
   rulesetRows,
   (rows) => {
     if (rows.length === 0) {
-      selectedRuleset.value = null
-      return
+      selectedRuleset.value = null;
+      return;
     }
     if (!selectedRuleset.value || !rows.some((row) => row.name === selectedRuleset.value)) {
-      selectedRuleset.value = rows[0].name
+      selectedRuleset.value = rows[0].name;
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 watch(
   selectedSummary,
   (summary) => {
     if (!summary || summary.results.length === 0) {
-      selectedTestId.value = null
-      return
+      selectedTestId.value = null;
+      return;
     }
-    if (!selectedTestId.value || !summary.results.some((result) => result.test_id === selectedTestId.value)) {
-      selectedTestId.value = summary.results[0].test_id
+    if (
+      !selectedTestId.value ||
+      !summary.results.some((result) => result.test_id === selectedTestId.value)
+    ) {
+      selectedTestId.value = summary.results[0].test_id;
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 watch(
   selectedRuleset,
   async (name) => {
-    selectedDraft.value = null
-    if (!name || !auth.token) return
+    selectedDraft.value = null;
+    if (!name || !auth.token) return;
 
     try {
-      await testStore.fetchTests(projectId.value, name)
+      await testStore.fetchTests(projectId.value, name);
     } catch {
       // Test cases are optional for diagnostics.
     }
 
-    draftLoading.value = true
+    draftLoading.value = true;
     try {
-      const draft = await rulesetDraftApi.get(auth.token, orgId.value, projectId.value, name)
-      selectedDraft.value = normalizeRuleset(draft.draft, name)
+      const draft = await rulesetDraftApi.get(auth.token, orgId.value, projectId.value, name);
+      selectedDraft.value = normalizeRuleset(draft.draft, name);
     } catch {
-      selectedDraft.value = null
+      selectedDraft.value = null;
     } finally {
-      draftLoading.value = false
+      draftLoading.value = false;
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 async function runAll() {
   if (rulesetRows.value.length === 0) {
-    MessagePlugin.warning(t('test.project.noRulesets'))
-    return
+    MessagePlugin.warning(t('test.project.noRulesets'));
+    return;
   }
   try {
     await testStore.runProjectTests(
       orgId.value,
       projectId.value,
-      rulesetRows.value.map((ruleset) => ruleset.name),
-    )
+      rulesetRows.value.map((ruleset) => ruleset.name)
+    );
     if (!selectedRuleset.value && rulesetRows.value.length > 0) {
-      selectedRuleset.value = rulesetRows.value[0].name
+      selectedRuleset.value = rulesetRows.value[0].name;
     }
-    MessagePlugin.success(t('test.runSuccess'))
+    MessagePlugin.success(t('test.runSuccess'));
   } catch (e: any) {
-    MessagePlugin.error(e?.message ?? t('test.saveFailed'))
+    MessagePlugin.error(e?.message ?? t('test.saveFailed'));
   }
 }
 
 function selectRuleset(name: string) {
-  selectedRuleset.value = name
+  selectedRuleset.value = name;
 }
 
 function selectResult(result: TestRunResult) {
-  selectedTestId.value = result.test_id
+  selectedTestId.value = result.test_id;
 }
 
 function goToEditor(rulesetName: string) {
-  router.push(`/orgs/${orgId.value}/projects/${projectId.value}/editor/${rulesetName}`)
+  router.push(`/orgs/${orgId.value}/projects/${projectId.value}/editor/${rulesetName}`);
 }
 
 function displayTestName(name: string): string {
-  if (!name.startsWith('i18n:')) return name
-  const key = name.slice(5)
-  const fallback = key.split('.').pop() ?? key
-  return fallback
-    .replace(/[-_]+/g, ' ')
-    .replace(/\b\w/g, (char) => char.toUpperCase())
+  if (!name.startsWith('i18n:')) return name;
+  const key = name.slice(5);
+  const fallback = key.split('.').pop() ?? key;
+  return fallback.replace(/[-_]+/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase());
 }
 
 function durationMs(us: number): string {
-  return `${(us / 1000).toFixed(1)}ms`
+  return `${(us / 1000).toFixed(1)}ms`;
 }
 
 function formatJson(value: unknown): string {
-  if (value === undefined) return '—'
-  if (value === null) return 'null'
-  return JSON.stringify(value, null, 2)
+  if (value === undefined) return '—';
+  if (value === null) return 'null';
+  return JSON.stringify(value, null, 2);
 }
 
 function isEqual(a: unknown, b: unknown): boolean {
-  return JSON.stringify(a) === JSON.stringify(b)
+  return JSON.stringify(a) === JSON.stringify(b);
 }
 
 function resultClass(result: TestRunResult): string {
-  return result.passed ? 'is-pass' : 'is-fail'
+  return result.passed ? 'is-pass' : 'is-fail';
 }
 
 function summaryBadgeClass(summary: RulesetTestSummary | null): string {
-  if (!summary) return 'badge--idle'
-  if (summary.total === 0) return 'badge--idle'
-  if (summary.failed === 0) return 'badge--pass'
-  return 'badge--fail'
+  if (!summary) return 'badge--idle';
+  if (summary.total === 0) return 'badge--idle';
+  if (summary.failed === 0) return 'badge--pass';
+  return 'badge--fail';
 }
 
 function stepLabel(step: TestExecutionTraceStep, index: number): string {
-  return step.name || step.id || `${index + 1}`
+  return step.name || step.id || `${index + 1}`;
 }
 
 function stopResultsResize() {
-  if (!isResizingResultsPane.value) return
-  isResizingResultsPane.value = false
-  document.body.style.cursor = ''
-  document.body.style.userSelect = ''
+  if (!isResizingResultsPane.value) return;
+  isResizingResultsPane.value = false;
+  document.body.style.cursor = '';
+  document.body.style.userSelect = '';
 }
 
 function resizeResultsPane(event: MouseEvent) {
-  if (!isResizingResultsPane.value || !contentContainer.value) return
-
-  const bounds = contentContainer.value.getBoundingClientRect()
-  const leftPaneWidth = 240
-  const splitterWidth = 10
-  const leftOffset = event.clientX - bounds.left
-  const nextWidth = leftOffset - leftPaneWidth
-  const minWidth = 320
-  const minDiagnosticsWidth = 420
+  if (!isResizingResultsPane.value || !contentContainer.value) return;
+
+  const bounds = contentContainer.value.getBoundingClientRect();
+  const leftPaneWidth = 240;
+  const splitterWidth = 10;
+  const leftOffset = event.clientX - bounds.left;
+  const nextWidth = leftOffset - leftPaneWidth;
+  const minWidth = 320;
+  const minDiagnosticsWidth = 420;
   const maxWidth = Math.max(
     minWidth,
-    bounds.width - leftPaneWidth - splitterWidth - minDiagnosticsWidth,
-  )
+    bounds.width - leftPaneWidth - splitterWidth - minDiagnosticsWidth
+  );
 
-  resultsPaneWidth.value = Math.max(minWidth, Math.min(maxWidth, nextWidth))
+  resultsPaneWidth.value = Math.max(minWidth, Math.min(maxWidth, nextWidth));
 }
 
 function startResultsResize(event: MouseEvent) {
-  isResizingResultsPane.value = true
-  document.body.style.cursor = 'col-resize'
-  document.body.style.userSelect = 'none'
-  resizeResultsPane(event)
+  isResizingResultsPane.value = true;
+  document.body.style.cursor = 'col-resize';
+  document.body.style.userSelect = 'none';
+  resizeResultsPane(event);
 }
 
 function syncViewportWidth() {
-  viewportWidth.value = window.innerWidth
+  viewportWidth.value = window.innerWidth;
 }
 
 onMounted(() => {
   if (projectStore.currentProject?.id === projectId.value) {
-    void projectStore.fetchRulesets()
+    void projectStore.fetchRulesets();
   }
-  window.addEventListener('resize', syncViewportWidth)
-  window.addEventListener('mousemove', resizeResultsPane)
-  window.addEventListener('mouseup', stopResultsResize)
-})
+  window.addEventListener('resize', syncViewportWidth);
+  window.addEventListener('mousemove', resizeResultsPane);
+  window.addEventListener('mouseup', stopResultsResize);
+});
 
 onUnmounted(() => {
-  window.removeEventListener('resize', syncViewportWidth)
-  window.removeEventListener('mousemove', resizeResultsPane)
-  window.removeEventListener('mouseup', stopResultsResize)
-  stopResultsResize()
-})
+  window.removeEventListener('resize', syncViewportWidth);
+  window.removeEventListener('mousemove', resizeResultsPane);
+  window.removeEventListener('mouseup', stopResultsResize);
+  stopResultsResize();
+});
 </script>
 
 <template>
@@ -352,7 +356,9 @@ onUnmounted(() => {
       <div class="test-view__header-actions">
         <span class="mode-chip">{{ t('test.project.localDraftMode') }}</span>
         <div v-if="projectResult" class="summary-chip">
-          {{ t('test.project.summary', { passed: projectResult.passed, total: projectResult.total }) }}
+          {{
+            t('test.project.summary', { passed: projectResult.passed, total: projectResult.total })
+          }}
         </div>
         <t-button theme="primary" :loading="running" @click="runAll">
           <t-icon name="play-circle" size="14px" />
@@ -362,7 +368,10 @@ onUnmounted(() => {
     </div>
 
     <div v-if="rulesetRows.length === 0" class="test-view__empty">
-      <t-empty :title="t('test.project.noRulesets')" :description="t('test.project.noRulesetsHint')" />
+      <t-empty
+        :title="t('test.project.noRulesets')"
+        :description="t('test.project.noRulesetsHint')"
+      />
     </div>
 
     <div v-else-if="running" class="test-view__loading">
@@ -384,7 +393,9 @@ onUnmounted(() => {
             <span class="ruleset-row__version">{{ ruleset.version }}</span>
           </div>
           <span class="ruleset-row__badge" :class="summaryBadgeClass(ruleset.summary)">
-            <template v-if="ruleset.summary">{{ ruleset.summary.passed }}/{{ ruleset.summary.total }}</template>
+            <template v-if="ruleset.summary"
+              >{{ ruleset.summary.passed }}/{{ ruleset.summary.total }}</template
+            >
             <template v-else>{{ t('test.statusPending') }}</template>
           </span>
         </button>
@@ -419,17 +430,28 @@ onUnmounted(() => {
         <template v-else>
           <div class="results-header">
             <div>
-              <div class="results-header__name">{{ selectedSummary?.ruleset_name ?? selectedRuleset }}</div>
+              <div class="results-header__name">
+                {{ selectedSummary?.ruleset_name ?? selectedRuleset }}
+              </div>
               <div class="results-header__hint">
                 <template v-if="selectedSummary">
-                  {{ t('test.project.summary', { passed: selectedSummary.passed, total: selectedSummary.total }) }}
+                  {{
+                    t('test.project.summary', {
+                      passed: selectedSummary.passed,
+                      total: selectedSummary.total,
+                    })
+                  }}
                 </template>
                 <template v-else>
                   {{ t('test.project.testCount', { total: selectedTests.length }) }}
                 </template>
               </div>
             </div>
-            <t-button size="small" variant="text" @click="goToEditor(selectedSummary?.ruleset_name ?? selectedRuleset!)">
+            <t-button
+              size="small"
+              variant="text"
+              @click="goToEditor(selectedSummary?.ruleset_name ?? selectedRuleset!)"
+            >
               <t-icon name="edit" size="12px" />
               {{ t('contracts.openEditor') }}
             </t-button>
@@ -454,14 +476,20 @@ onUnmounted(() => {
                 <div>
                   <div class="result-card__name">{{ displayTestName(resultItem.name) }}</div>
                   <div class="result-card__meta">
-                    <span>{{ resultItem.kind === 'result' ? durationMs(resultItem.duration_us) : t('test.statusPending') }}</span>
+                    <span>{{
+                      resultItem.kind === 'result'
+                        ? durationMs(resultItem.duration_us)
+                        : t('test.statusPending')
+                    }}</span>
                     <span v-if="resultItem.actual_code">{{ resultItem.actual_code }}</span>
                   </div>
                 </div>
                 <span class="result-card__status">
                   {{
                     resultItem.kind === 'result'
-                      ? (resultItem.passed ? t('test.statusPassed') : t('test.statusFailed'))
+                      ? resultItem.passed
+                        ? t('test.statusPassed')
+                        : t('test.statusFailed')
                       : t('test.statusPending')
                   }}
                 </span>
@@ -496,7 +524,9 @@ onUnmounted(() => {
         <template v-else>
           <div class="diagnostics-header">
             <div>
-              <div class="diagnostics-header__title">{{ displayTestName(selectedResult.test_name) }}</div>
+              <div class="diagnostics-header__title">
+                {{ displayTestName(selectedResult.test_name) }}
+              </div>
               <div class="diagnostics-header__meta">
                 <span>{{ durationMs(selectedResult.duration_us) }}</span>
                 <span v-if="traceSummary">{{ traceSummary.path_string }}</span>
@@ -556,11 +586,17 @@ onUnmounted(() => {
             <div class="section-card">
               <div class="section-card__title">{{ t('test.project.code') }}</div>
               <div class="compare-grid">
-                <div class="compare-block" :class="{ mismatch: !isEqual(expectedCode, actualCode) }">
+                <div
+                  class="compare-block"
+                  :class="{ mismatch: !isEqual(expectedCode, actualCode) }"
+                >
                   <div class="compare-block__label">{{ t('test.result.expected') }}</div>
                   <pre>{{ formatJson(expectedCode) }}</pre>
                 </div>
-                <div class="compare-block" :class="{ mismatch: !isEqual(expectedCode, actualCode) }">
+                <div
+                  class="compare-block"
+                  :class="{ mismatch: !isEqual(expectedCode, actualCode) }"
+                >
                   <div class="compare-block__label">{{ t('test.result.actual') }}</div>
                   <pre>{{ formatJson(actualCode) }}</pre>
                 </div>
@@ -570,11 +606,17 @@ onUnmounted(() => {
             <div class="section-card">
               <div class="section-card__title">{{ t('test.project.message') }}</div>
               <div class="compare-grid">
-                <div class="compare-block" :class="{ mismatch: !isEqual(expectedMessage, actualMessage) }">
+                <div
+                  class="compare-block"
+                  :class="{ mismatch: !isEqual(expectedMessage, actualMessage) }"
+                >
                   <div class="compare-block__label">{{ t('test.result.expected') }}</div>
                   <pre>{{ formatJson(expectedMessage) }}</pre>
                 </div>
-                <div class="compare-block" :class="{ mismatch: !isEqual(expectedMessage, actualMessage) }">
+                <div
+                  class="compare-block"
+                  :class="{ mismatch: !isEqual(expectedMessage, actualMessage) }"
+                >
                   <div class="compare-block__label">{{ t('test.result.actual') }}</div>
                   <pre>{{ formatJson(actualMessage) }}</pre>
                 </div>
@@ -665,7 +707,9 @@ onUnmounted(() => {
                       <pre>{{ formatJson(step.input_snapshot ?? null) }}</pre>
                     </div>
                     <div class="snapshot-block">
-                      <div class="snapshot-block__label">{{ t('test.project.variablesSnapshot') }}</div>
+                      <div class="snapshot-block__label">
+                        {{ t('test.project.variablesSnapshot') }}
+                      </div>
                       <pre>{{ formatJson(step.variables_snapshot ?? null) }}</pre>
                     </div>
                   </div>
@@ -674,7 +718,10 @@ onUnmounted(() => {
             </template>
           </div>
 
-          <div v-else-if="selectedDetailTab === 'flow'" class="diagnostics-body diagnostics-body--flow">
+          <div
+            v-else-if="selectedDetailTab === 'flow'"
+            class="diagnostics-body diagnostics-body--flow"
+          >
             <div v-if="draftLoading" class="placeholder-block">
               <t-loading size="medium" :text="t('common.loading')" />
             </div>
diff --git a/ordo-editor/apps/studio/src/views/project/VersionHistoryView.vue b/ordo-editor/apps/studio/src/views/project/VersionHistoryView.vue
index 6e3cabc7..39a1ff8f 100644
--- a/ordo-editor/apps/studio/src/views/project/VersionHistoryView.vue
+++ b/ordo-editor/apps/studio/src/views/project/VersionHistoryView.vue
@@ -1,52 +1,55 @@
 <script setup lang="ts">
-import { ref, computed, watch } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useRouter, useRoute } from 'vue-router'
-import { useProjectStore } from '@/stores/project'
-import { useOrgStore } from '@/stores/org'
-import { useAuthStore } from '@/stores/auth'
-import { rulesetDraftApi, rulesetHistoryApi } from '@/api/platform-client'
-import { buildCheckpointVersionEntries, extractRulesetVersion } from '@/utils/ruleset-version'
-import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next'
-import type { RulesetHistoryEntry } from '@/api/types'
-
-const projectStore = useProjectStore()
-const orgStore = useOrgStore()
-const auth = useAuthStore()
-const { t, locale } = useI18n()
-const router = useRouter()
-const route = useRoute()
-const orgId = computed(() => route.params.orgId as string)
-
-const canAdmin = computed(() => auth.user ? orgStore.canAdmin(auth.user.id) : false)
-
-const selectedRuleset = ref<string | null>(null)
+import { ref, computed, watch } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter, useRoute } from 'vue-router';
+import { useProjectStore } from '@/stores/project';
+import { useOrgStore } from '@/stores/org';
+import { useAuthStore } from '@/stores/auth';
+import { rulesetDraftApi, rulesetHistoryApi } from '@/api/platform-client';
+import { buildCheckpointVersionEntries, extractRulesetVersion } from '@/utils/ruleset-version';
+import { MessagePlugin, DialogPlugin } from 'tdesign-vue-next';
+import type { RulesetHistoryEntry } from '@/api/types';
+
+const projectStore = useProjectStore();
+const orgStore = useOrgStore();
+const auth = useAuthStore();
+const { t, locale } = useI18n();
+const router = useRouter();
+const route = useRoute();
+const orgId = computed(() => route.params.orgId as string);
+
+const canAdmin = computed(() => (auth.user ? orgStore.canAdmin(auth.user.id) : false));
+
+const selectedRuleset = ref<string | null>(null);
 const versionData = ref<{
-  name: string
-  current_version: string
-  current_display_version: string
+  name: string;
+  current_version: string;
+  current_display_version: string;
   versions: Array<{
-    seq: number
-    version: string
-    display_version: string
-    created_at: string
-    entry: RulesetHistoryEntry
-  }>
-} | null>(null)
-const historyEntries = ref<RulesetHistoryEntry[]>([])
-const loading = ref(false)
-const rollingBack = ref<number | null>(null)
+    seq: number;
+    version: string;
+    display_version: string;
+    created_at: string;
+    entry: RulesetHistoryEntry;
+  }>;
+} | null>(null);
+const historyEntries = ref<RulesetHistoryEntry[]>([]);
+const loading = ref(false);
+const rollingBack = ref<number | null>(null);
 
 async function loadVersions(name: string) {
-  if (!auth.token || !projectStore.currentProject) return
-  loading.value = true
+  if (!auth.token || !projectStore.currentProject) return;
+  loading.value = true;
   try {
-    const history = await rulesetHistoryApi.list(auth.token, projectStore.currentProject.id, name)
-    historyEntries.value = history.entries
-    const checkpoints = buildCheckpointVersionEntries(history.entries)
-    const meta = projectStore.draftMetas.find((entry) => entry.name === name) ?? null
-    const currentVersion = meta?.draft_version ?? extractRulesetVersion(history.entries[0]?.snapshot)
-    const currentDisplayVersion = checkpoints.find((item) => item.version === currentVersion)?.display_version ?? currentVersion
+    const history = await rulesetHistoryApi.list(auth.token, projectStore.currentProject.id, name);
+    historyEntries.value = history.entries;
+    const checkpoints = buildCheckpointVersionEntries(history.entries);
+    const meta = projectStore.draftMetas.find((entry) => entry.name === name) ?? null;
+    const currentVersion =
+      meta?.draft_version ?? extractRulesetVersion(history.entries[0]?.snapshot);
+    const currentDisplayVersion =
+      checkpoints.find((item) => item.version === currentVersion)?.display_version ??
+      currentVersion;
     versionData.value = {
       name,
       current_version: currentVersion,
@@ -58,55 +61,66 @@ async function loadVersions(name: string) {
         created_at: item.entry.created_at,
         entry: item.entry,
       })),
-    }
+    };
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('versions.loadFailed'))
-    versionData.value = null
-    historyEntries.value = []
+    MessagePlugin.error(e.message || t('versions.loadFailed'));
+    versionData.value = null;
+    historyEntries.value = [];
   } finally {
-    loading.value = false
+    loading.value = false;
   }
 }
 
 watch(selectedRuleset, (name) => {
-  if (name) loadVersions(name)
-  else versionData.value = null
-})
+  if (name) loadVersions(name);
+  else versionData.value = null;
+});
 
 // Auto-select first ruleset
 watch(
   () => projectStore.rulesets,
   (list) => {
     if (list.length > 0 && !selectedRuleset.value) {
-      selectedRuleset.value = list[0].name
+      selectedRuleset.value = list[0].name;
     }
   },
-  { immediate: true },
-)
+  { immediate: true }
+);
 
 function handleRollback(seq: number) {
-  if (!selectedRuleset.value) return
-  const name = selectedRuleset.value
+  if (!selectedRuleset.value) return;
+  const name = selectedRuleset.value;
   const dlg = DialogPlugin.confirm({
     header: t('versions.rollbackDialog'),
     body: t('versions.rollbackConfirm', { name, seq }),
     confirmBtn: { content: t('versions.rollbackConfirmBtn'), theme: 'warning' },
     cancelBtn: t('versions.rollbackCancel'),
     onConfirm: async () => {
-        if (!auth.token || !projectStore.currentProject) return
-      rollingBack.value = seq
+      if (!auth.token || !projectStore.currentProject) return;
+      rollingBack.value = seq;
       try {
-        const org = orgStore.currentOrg
-        if (!org) throw new Error('No active org')
-        const target = versionData.value?.versions.find((item) => item.seq === seq)?.entry
-        if (!target) throw new Error('Version not found')
-        const currentDraft = await rulesetDraftApi.get(auth.token, org.id, projectStore.currentProject.id, name)
-        const restored = await rulesetDraftApi.save(auth.token, org.id, projectStore.currentProject.id, name, {
-          ruleset: target.snapshot,
-          expected_seq: currentDraft.draft_seq,
-        })
+        const org = orgStore.currentOrg;
+        if (!org) throw new Error('No active org');
+        const target = versionData.value?.versions.find((item) => item.seq === seq)?.entry;
+        if (!target) throw new Error('Version not found');
+        const currentDraft = await rulesetDraftApi.get(
+          auth.token,
+          org.id,
+          projectStore.currentProject.id,
+          name
+        );
+        const restored = await rulesetDraftApi.save(
+          auth.token,
+          org.id,
+          projectStore.currentProject.id,
+          name,
+          {
+            ruleset: target.snapshot,
+            expected_seq: currentDraft.draft_seq,
+          }
+        );
         if ('conflict' in restored) {
-          throw new Error(t('versions.rollbackFailed'))
+          throw new Error(t('versions.rollbackFailed'));
         }
         await rulesetHistoryApi.append(auth.token, projectStore.currentProject.id, name, [
           {
@@ -115,37 +129,44 @@ function handleRollback(seq: number) {
             source: 'restore',
             snapshot: target.snapshot,
           },
-        ])
-        dlg.hide()
-        MessagePlugin.success(t('versions.rollbackSuccess', { seq }))
-        await projectStore.fetchRulesets()
-        await loadVersions(name)
+        ]);
+        dlg.hide();
+        MessagePlugin.success(t('versions.rollbackSuccess', { seq }));
+        await projectStore.fetchRulesets();
+        await loadVersions(name);
       } catch (e: any) {
-        MessagePlugin.error(e.message || t('versions.rollbackFailed'))
+        MessagePlugin.error(e.message || t('versions.rollbackFailed'));
       } finally {
-        rollingBack.value = null
+        rollingBack.value = null;
       }
     },
-  })
+  });
 }
 
 function formatDate(dateStr: string) {
   return new Date(dateStr).toLocaleString(
     locale.value === 'zh-TW' ? 'zh-TW' : locale.value === 'zh-CN' ? 'zh-CN' : 'en-US',
     {
-      year: 'numeric', month: '2-digit', day: '2-digit',
-      hour: '2-digit', minute: '2-digit', second: '2-digit',
-    },
-  )
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+    }
+  );
 }
-
 </script>
 
 <template>
   <div class="version-view">
     <t-breadcrumb class="asset-breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
-      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{ t('breadcrumb.projects') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push(`/orgs/${orgId}/projects`)">{{
+        t('breadcrumb.projects')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('projectNav.versions') }}</t-breadcrumb-item>
     </t-breadcrumb>
     <div class="asset-header">
@@ -169,7 +190,7 @@ function formatDate(dateStr: string) {
           :class="{ 'is-active': rs.name === selectedRuleset }"
           @click="selectedRuleset = rs.name"
         >
-          <t-icon name="file-code" size="13px" style="opacity:0.6; flex-shrink:0" />
+          <t-icon name="file-code" size="13px" style="opacity: 0.6; flex-shrink: 0" />
           <span class="ruleset-item__name">{{ rs.name }}</span>
           <span class="ruleset-item__version">v{{ rs.version }}</span>
         </div>
@@ -178,7 +199,7 @@ function formatDate(dateStr: string) {
       <!-- Right: version timeline -->
       <div class="version-timeline">
         <div v-if="!selectedRuleset" class="version-placeholder">
-          <t-icon name="history" size="36px" style="opacity:0.15" />
+          <t-icon name="history" size="36px" style="opacity: 0.15" />
           <p>{{ t('versions.placeholder') }}</p>
         </div>
 
@@ -219,7 +240,8 @@ function formatDate(dateStr: string) {
                   size="small"
                   theme="success"
                   variant="light"
-                >{{ t('versions.currentTag') }}</t-tag>
+                  >{{ t('versions.currentTag') }}</t-tag
+                >
                 <t-button
                   v-else-if="canAdmin"
                   size="small"
@@ -304,8 +326,12 @@ function formatDate(dateStr: string) {
   border-bottom: 1px solid var(--ordo-border-light);
 }
 
-.ruleset-item:hover { background: var(--ordo-hover-bg); }
-.ruleset-item.is-active { background: var(--ordo-active-bg); }
+.ruleset-item:hover {
+  background: var(--ordo-hover-bg);
+}
+.ruleset-item.is-active {
+  background: var(--ordo-active-bg);
+}
 
 .ruleset-item__name {
   flex: 1;
@@ -405,7 +431,8 @@ function formatDate(dateStr: string) {
   font-size: 13px;
 }
 
-.asset-loading, .asset-empty {
+.asset-loading,
+.asset-empty {
   display: flex;
   flex-direction: column;
   align-items: center;
diff --git a/ordo-editor/apps/studio/src/views/server/ServerRegistryView.vue b/ordo-editor/apps/studio/src/views/server/ServerRegistryView.vue
index 5e9f8989..2e179e51 100644
--- a/ordo-editor/apps/studio/src/views/server/ServerRegistryView.vue
+++ b/ordo-editor/apps/studio/src/views/server/ServerRegistryView.vue
@@ -1,80 +1,90 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useRouter } from 'vue-router'
-import { DialogPlugin, MessagePlugin } from 'tdesign-vue-next'
-import { serverApi } from '@/api/platform-client'
-import type { ServerInfo } from '@/api/types'
-import { useAuthStore } from '@/stores/auth'
+import { computed, onMounted, ref } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter } from 'vue-router';
+import { DialogPlugin, MessagePlugin } from 'tdesign-vue-next';
+import { serverApi } from '@/api/platform-client';
+import type { ServerInfo } from '@/api/types';
+import { useAuthStore } from '@/stores/auth';
 
 interface HealthPayload {
-  online: boolean
-  response?: string
-  error?: string
-  url: string
+  online: boolean;
+  response?: string;
+  error?: string;
+  url: string;
 }
 
 interface MetricSample {
-  name: string
-  value: string
-  labels: string[]
+  name: string;
+  value: string;
+  labels: string[];
 }
 
-type ServerFilter = 'active' | 'offline' | 'all'
+type ServerFilter = 'active' | 'offline' | 'all';
 
-const { t } = useI18n()
-const router = useRouter()
-const auth = useAuthStore()
+const { t } = useI18n();
+const router = useRouter();
+const auth = useAuthStore();
 
-const loadingServers = ref(false)
-const removingServerId = ref<string | null>(null)
-const servers = ref<ServerInfo[]>([])
-const serverFilter = ref<ServerFilter>('active')
-const keyword = ref('')
+const loadingServers = ref(false);
+const removingServerId = ref<string | null>(null);
+const servers = ref<ServerInfo[]>([]);
+const serverFilter = ref<ServerFilter>('active');
+const keyword = ref('');
 
-const healthDialogVisible = ref(false)
-const healthDialogServer = ref<ServerInfo | null>(null)
-const healthLoading = ref(false)
-const healthRawOpen = ref(false)
-const healthContent = ref<HealthPayload | null>(null)
+const healthDialogVisible = ref(false);
+const healthDialogServer = ref<ServerInfo | null>(null);
+const healthLoading = ref(false);
+const healthRawOpen = ref(false);
+const healthContent = ref<HealthPayload | null>(null);
 
-const metricsDialogVisible = ref(false)
-const metricsDialogServer = ref<ServerInfo | null>(null)
-const metricsLoading = ref(false)
-const metricsRawOpen = ref(false)
-const metricsRaw = ref('')
-const metricsParsed = ref<MetricSample[]>([])
+const metricsDialogVisible = ref(false);
+const metricsDialogServer = ref<ServerInfo | null>(null);
+const metricsLoading = ref(false);
+const metricsRawOpen = ref(false);
+const metricsRaw = ref('');
+const metricsParsed = ref<MetricSample[]>([]);
 
 const filterOptions = computed(() => [
   { label: t('settings.serverRegistry.filterActive'), value: 'active' },
   { label: t('settings.serverRegistry.filterOffline'), value: 'offline' },
   { label: t('settings.serverRegistry.filterAll'), value: 'all' },
-])
+]);
 
 const columns = computed(() => [
   { colKey: 'name', title: t('settings.serverRegistry.serverName'), width: 240 },
   { colKey: 'url', title: t('settings.serverRegistry.endpoint'), minWidth: 240 },
-  { colKey: 'status', title: t('settings.serverRegistry.status'), width: 120, align: 'center' as const },
+  {
+    colKey: 'status',
+    title: t('settings.serverRegistry.status'),
+    width: 120,
+    align: 'center' as const,
+  },
   { colKey: 'version', title: t('settings.serverRegistry.version'), width: 120 },
   { colKey: 'last_seen', title: t('settings.serverRegistry.lastSeen'), width: 190 },
   { colKey: 'registered_at', title: t('settings.serverRegistry.registeredAt'), width: 190 },
   { colKey: 'labels', title: t('settings.serverRegistry.labels'), minWidth: 180 },
-  { colKey: 'actions', title: t('settings.serverRegistry.actions'), width: 220, align: 'right' as const },
-])
+  {
+    colKey: 'actions',
+    title: t('settings.serverRegistry.actions'),
+    width: 220,
+    align: 'right' as const,
+  },
+]);
 
 const filteredServers = computed(() => {
-  const query = keyword.value.trim().toLowerCase()
+  const query = keyword.value.trim().toLowerCase();
   const statusWeight: Record<ServerInfo['status'], number> = {
     online: 0,
     degraded: 1,
     offline: 2,
-  }
+  };
 
   return servers.value
     .filter((server) => {
-      if (serverFilter.value === 'active' && server.status === 'offline') return false
-      if (serverFilter.value === 'offline' && server.status !== 'offline') return false
-      if (!query) return true
+      if (serverFilter.value === 'active' && server.status === 'offline') return false;
+      if (serverFilter.value === 'offline' && server.status !== 'offline') return false;
+      if (!query) return true;
       return [
         server.name,
         server.url,
@@ -83,36 +93,36 @@ const filteredServers = computed(() => {
       ]
         .join(' ')
         .toLowerCase()
-        .includes(query)
+        .includes(query);
     })
     .slice()
     .sort((left, right) => {
-      const statusDelta = statusWeight[left.status] - statusWeight[right.status]
-      if (statusDelta !== 0) return statusDelta
-      const leftSeen = left.last_seen ? new Date(left.last_seen).getTime() : 0
-      const rightSeen = right.last_seen ? new Date(right.last_seen).getTime() : 0
-      if (leftSeen !== rightSeen) return rightSeen - leftSeen
-      return new Date(right.registered_at).getTime() - new Date(left.registered_at).getTime()
-    })
-})
+      const statusDelta = statusWeight[left.status] - statusWeight[right.status];
+      if (statusDelta !== 0) return statusDelta;
+      const leftSeen = left.last_seen ? new Date(left.last_seen).getTime() : 0;
+      const rightSeen = right.last_seen ? new Date(right.last_seen).getTime() : 0;
+      if (leftSeen !== rightSeen) return rightSeen - leftSeen;
+      return new Date(right.registered_at).getTime() - new Date(left.registered_at).getTime();
+    });
+});
 
 function formatTimestamp(value: string | null | undefined) {
-  if (!value) return t('settings.serverRegistry.neverSeen')
-  return new Date(value).toLocaleString()
+  if (!value) return t('settings.serverRegistry.neverSeen');
+  return new Date(value).toLocaleString();
 }
 
 function statusLabel(status: ServerInfo['status']) {
-  return t(`settings.serverRegistry.statusMap.${status}`)
+  return t(`settings.serverRegistry.statusMap.${status}`);
 }
 
 function serverTheme(status: ServerInfo['status']) {
   switch (status) {
     case 'online':
-      return 'success'
+      return 'success';
     case 'degraded':
-      return 'warning'
+      return 'warning';
     default:
-      return 'danger'
+      return 'danger';
   }
 }
 
@@ -122,70 +132,70 @@ function parseMetrics(raw: string): MetricSample[] {
     .map((line) => line.trim())
     .filter((line) => line.length > 0 && !line.startsWith('#'))
     .map((line) => {
-      const match = line.match(/^([^\s{]+)(?:\{([^}]*)\})?\s+(.+)$/)
-      if (!match) return { name: line, value: '', labels: [] }
-      const [, name, labelsPart, value] = match
+      const match = line.match(/^([^\s{]+)(?:\{([^}]*)\})?\s+(.+)$/);
+      if (!match) return { name: line, value: '', labels: [] };
+      const [, name, labelsPart, value] = match;
       const labels = labelsPart
         ? labelsPart
             .split(/,(?=[a-zA-Z_][a-zA-Z0-9_]*=)/)
             .map((label) => label.trim())
             .filter(Boolean)
-        : []
-      return { name, value: value.trim(), labels }
-    })
+        : [];
+      return { name, value: value.trim(), labels };
+    });
 }
 
 async function loadServers() {
-  if (!auth.token) return
-  loadingServers.value = true
+  if (!auth.token) return;
+  loadingServers.value = true;
   try {
-    servers.value = await serverApi.list(auth.token)
+    servers.value = await serverApi.list(auth.token);
   } catch {
-    MessagePlugin.error(t('settings.serverRegistry.loadFailed'))
+    MessagePlugin.error(t('settings.serverRegistry.loadFailed'));
   } finally {
-    loadingServers.value = false
+    loadingServers.value = false;
   }
 }
 
 async function openHealth(server: ServerInfo) {
-  if (!auth.token) return
-  healthDialogServer.value = server
-  healthDialogVisible.value = true
-  healthRawOpen.value = false
-  healthLoading.value = true
+  if (!auth.token) return;
+  healthDialogServer.value = server;
+  healthDialogVisible.value = true;
+  healthRawOpen.value = false;
+  healthLoading.value = true;
   try {
-    healthContent.value = await serverApi.getHealth(auth.token, server.id)
+    healthContent.value = await serverApi.getHealth(auth.token, server.id);
   } catch (error: any) {
     healthContent.value = {
       online: false,
       error: error.message || t('settings.serverRegistry.healthFailed'),
       url: server.url,
-    }
+    };
   } finally {
-    healthLoading.value = false
+    healthLoading.value = false;
   }
 }
 
 async function openMetrics(server: ServerInfo) {
-  if (!auth.token) return
-  metricsDialogServer.value = server
-  metricsDialogVisible.value = true
-  metricsRawOpen.value = false
-  metricsLoading.value = true
+  if (!auth.token) return;
+  metricsDialogServer.value = server;
+  metricsDialogVisible.value = true;
+  metricsRawOpen.value = false;
+  metricsLoading.value = true;
   try {
-    const raw = await serverApi.getMetrics(auth.token, server.id)
-    metricsRaw.value = raw
-    metricsParsed.value = parseMetrics(raw)
+    const raw = await serverApi.getMetrics(auth.token, server.id);
+    metricsRaw.value = raw;
+    metricsParsed.value = parseMetrics(raw);
   } catch (error: any) {
-    metricsRaw.value = error.message || t('settings.serverRegistry.metricsFailed')
-    metricsParsed.value = []
+    metricsRaw.value = error.message || t('settings.serverRegistry.metricsFailed');
+    metricsParsed.value = [];
   } finally {
-    metricsLoading.value = false
+    metricsLoading.value = false;
   }
 }
 
 async function removeServer(server: ServerInfo) {
-  if (!auth.token) return
+  if (!auth.token) return;
 
   const dialog = DialogPlugin.confirm({
     header: t('settings.serverRegistry.removeDialog'),
@@ -193,28 +203,30 @@ async function removeServer(server: ServerInfo) {
     confirmBtn: { content: t('common.confirm'), theme: 'danger' },
     cancelBtn: t('common.cancel'),
     onConfirm: async () => {
-      removingServerId.value = server.id
+      removingServerId.value = server.id;
       try {
-        await serverApi.delete(auth.token!, server.id)
-        servers.value = servers.value.filter((item) => item.id !== server.id)
-        dialog.hide()
-        MessagePlugin.success(t('settings.serverRegistry.removeSuccess'))
+        await serverApi.delete(auth.token!, server.id);
+        servers.value = servers.value.filter((item) => item.id !== server.id);
+        dialog.hide();
+        MessagePlugin.success(t('settings.serverRegistry.removeSuccess'));
       } catch {
-        MessagePlugin.error(t('settings.serverRegistry.removeFailed'))
+        MessagePlugin.error(t('settings.serverRegistry.removeFailed'));
       } finally {
-        removingServerId.value = null
+        removingServerId.value = null;
       }
     },
-  })
+  });
 }
 
-onMounted(loadServers)
+onMounted(loadServers);
 </script>
 
 <template>
   <div class="registry-page">
     <t-breadcrumb class="breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('settings.serverRegistry.title') }}</t-breadcrumb-item>
     </t-breadcrumb>
 
@@ -284,7 +296,9 @@ onMounted(loadServers)
 
         <template #labels="{ row }">
           <div v-if="Object.keys(row.labels).length" class="label-list">
-            <span v-for="(value, key) in row.labels" :key="key" class="label-chip">{{ key }}={{ value }}</span>
+            <span v-for="(value, key) in row.labels" :key="key" class="label-chip"
+              >{{ key }}={{ value }}</span
+            >
           </div>
           <span v-else class="text-muted">{{ t('settings.serverRegistry.noLabels') }}</span>
         </template>
@@ -314,7 +328,11 @@ onMounted(loadServers)
 
     <t-dialog
       v-model:visible="healthDialogVisible"
-      :header="healthDialogServer ? `${t('settings.serverRegistry.healthDialog')} · ${healthDialogServer.name}` : t('settings.serverRegistry.healthDialog')"
+      :header="
+        healthDialogServer
+          ? `${t('settings.serverRegistry.healthDialog')} · ${healthDialogServer.name}`
+          : t('settings.serverRegistry.healthDialog')
+      "
       width="720px"
       destroy-on-close
     >
@@ -326,7 +344,11 @@ onMounted(loadServers)
       <template v-else-if="healthDialogServer && healthContent">
         <div class="dialog-summary">
           <t-tag :theme="healthContent.online ? 'success' : 'danger'" variant="light">
-            {{ healthContent.online ? t('settings.serverRegistry.healthOnline') : t('settings.serverRegistry.healthOffline') }}
+            {{
+              healthContent.online
+                ? t('settings.serverRegistry.healthOnline')
+                : t('settings.serverRegistry.healthOffline')
+            }}
           </t-tag>
         </div>
         <div class="detail-grid">
@@ -349,16 +371,26 @@ onMounted(loadServers)
         </div>
         <div class="raw-toggle">
           <t-button size="small" variant="text" @click="healthRawOpen = !healthRawOpen">
-            {{ healthRawOpen ? t('settings.serverRegistry.hideRaw') : t('settings.serverRegistry.showRaw') }}
+            {{
+              healthRawOpen
+                ? t('settings.serverRegistry.hideRaw')
+                : t('settings.serverRegistry.showRaw')
+            }}
           </t-button>
         </div>
-        <pre v-if="healthRawOpen" class="detail-pre">{{ JSON.stringify(healthContent, null, 2) }}</pre>
+        <pre v-if="healthRawOpen" class="detail-pre">{{
+          JSON.stringify(healthContent, null, 2)
+        }}</pre>
       </template>
     </t-dialog>
 
     <t-dialog
       v-model:visible="metricsDialogVisible"
-      :header="metricsDialogServer ? `${t('settings.serverRegistry.metricsDialog')} · ${metricsDialogServer.name}` : t('settings.serverRegistry.metricsDialog')"
+      :header="
+        metricsDialogServer
+          ? `${t('settings.serverRegistry.metricsDialog')} · ${metricsDialogServer.name}`
+          : t('settings.serverRegistry.metricsDialog')
+      "
       width="920px"
       destroy-on-close
     >
@@ -374,11 +406,19 @@ onMounted(loadServers)
             <span>{{ t('settings.serverRegistry.metricValue') }}</span>
             <span>{{ t('settings.serverRegistry.labels') }}</span>
           </div>
-          <div v-for="sample in metricsParsed" :key="`${sample.name}-${sample.value}-${sample.labels.join('|')}`" class="metrics-table__row">
+          <div
+            v-for="sample in metricsParsed"
+            :key="`${sample.name}-${sample.value}-${sample.labels.join('|')}`"
+            class="metrics-table__row"
+          >
             <span class="metrics-table__name">{{ sample.name }}</span>
             <strong class="metrics-table__value">{{ sample.value }}</strong>
             <span class="metrics-table__labels">
-              {{ sample.labels.length ? sample.labels.join(', ') : t('settings.serverRegistry.noLabels') }}
+              {{
+                sample.labels.length
+                  ? sample.labels.join(', ')
+                  : t('settings.serverRegistry.noLabels')
+              }}
             </span>
           </div>
         </div>
@@ -386,7 +426,11 @@ onMounted(loadServers)
 
         <div class="raw-toggle">
           <t-button size="small" variant="text" @click="metricsRawOpen = !metricsRawOpen">
-            {{ metricsRawOpen ? t('settings.serverRegistry.hideRaw') : t('settings.serverRegistry.showRaw') }}
+            {{
+              metricsRawOpen
+                ? t('settings.serverRegistry.hideRaw')
+                : t('settings.serverRegistry.showRaw')
+            }}
           </t-button>
         </div>
         <pre v-if="metricsRawOpen" class="detail-pre">{{ metricsRaw }}</pre>
diff --git a/ordo-editor/apps/studio/src/views/settings/SettingsView.vue b/ordo-editor/apps/studio/src/views/settings/SettingsView.vue
index 97e1b5ed..f18c645b 100644
--- a/ordo-editor/apps/studio/src/views/settings/SettingsView.vue
+++ b/ordo-editor/apps/studio/src/views/settings/SettingsView.vue
@@ -1,102 +1,104 @@
 <script setup lang="ts">
-import { ref, onMounted } from 'vue'
-import { useI18n } from 'vue-i18n'
-import { useRouter } from 'vue-router'
-import { MessagePlugin } from 'tdesign-vue-next'
-import { useAuthStore } from '@/stores/auth'
-import { usePreferencesStore } from '@/stores/preferences'
-import { useGithubStore } from '@/stores/github'
-import { setLocale, LOCALE_OPTIONS, i18n, type Locale } from '@/i18n'
-
-const { t } = useI18n()
-const router = useRouter()
-const auth = useAuthStore()
-const prefs = usePreferencesStore()
-
-const displayName = ref(auth.user?.display_name ?? '')
-const savingProfile = ref(false)
+import { ref, onMounted } from 'vue';
+import { useI18n } from 'vue-i18n';
+import { useRouter } from 'vue-router';
+import { MessagePlugin } from 'tdesign-vue-next';
+import { useAuthStore } from '@/stores/auth';
+import { usePreferencesStore } from '@/stores/preferences';
+import { useGithubStore } from '@/stores/github';
+import { setLocale, LOCALE_OPTIONS, i18n, type Locale } from '@/i18n';
+
+const { t } = useI18n();
+const router = useRouter();
+const auth = useAuthStore();
+const prefs = usePreferencesStore();
+
+const displayName = ref(auth.user?.display_name ?? '');
+const savingProfile = ref(false);
 
 async function saveProfile() {
-  if (!displayName.value.trim()) return
-  savingProfile.value = true
+  if (!displayName.value.trim()) return;
+  savingProfile.value = true;
   try {
-    await auth.updateProfile({ display_name: displayName.value.trim() })
-    MessagePlugin.success(t('settings.profileSaved'))
+    await auth.updateProfile({ display_name: displayName.value.trim() });
+    MessagePlugin.success(t('settings.profileSaved'));
   } catch {
-    MessagePlugin.error(t('settings.profileSaveFailed'))
+    MessagePlugin.error(t('settings.profileSaveFailed'));
   } finally {
-    savingProfile.value = false
+    savingProfile.value = false;
   }
 }
 
-const currentPassword = ref('')
-const newPassword = ref('')
-const confirmNewPassword = ref('')
-const changingPassword = ref(false)
+const currentPassword = ref('');
+const newPassword = ref('');
+const confirmNewPassword = ref('');
+const changingPassword = ref(false);
 
 async function changePassword() {
   if (newPassword.value !== confirmNewPassword.value) {
-    MessagePlugin.warning(t('settings.passwordMismatch'))
-    return
+    MessagePlugin.warning(t('settings.passwordMismatch'));
+    return;
   }
-  changingPassword.value = true
+  changingPassword.value = true;
   try {
-    await auth.changePassword(currentPassword.value, newPassword.value)
-    MessagePlugin.success(t('settings.passwordChanged'))
-    currentPassword.value = ''
-    newPassword.value = ''
-    confirmNewPassword.value = ''
+    await auth.changePassword(currentPassword.value, newPassword.value);
+    MessagePlugin.success(t('settings.passwordChanged'));
+    currentPassword.value = '';
+    newPassword.value = '';
+    confirmNewPassword.value = '';
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('settings.passwordChangeFailed'))
+    MessagePlugin.error(e.message || t('settings.passwordChangeFailed'));
   } finally {
-    changingPassword.value = false
+    changingPassword.value = false;
   }
 }
 
-const currentLocale = ref((i18n.global.locale as any).value as Locale)
+const currentLocale = ref((i18n.global.locale as any).value as Locale);
 
 function onLocaleChange(val: Locale) {
-  currentLocale.value = val
-  setLocale(val)
+  currentLocale.value = val;
+  setLocale(val);
 }
 
 // ── GitHub Integration ────────────────────────────────────────────────────────
 
-const githubStore = useGithubStore()
-const connectingGithub = ref(false)
-const disconnectingGithub = ref(false)
+const githubStore = useGithubStore();
+const connectingGithub = ref(false);
+const disconnectingGithub = ref(false);
 
 async function connectGithub() {
-  connectingGithub.value = true
+  connectingGithub.value = true;
   try {
-    await githubStore.connect()
-    MessagePlugin.success(t('settings.github.connected'))
+    await githubStore.connect();
+    MessagePlugin.success(t('settings.github.connected'));
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('settings.github.connectFailed'))
+    MessagePlugin.error(e.message || t('settings.github.connectFailed'));
   } finally {
-    connectingGithub.value = false
+    connectingGithub.value = false;
   }
 }
 
 async function disconnectGithub() {
-  disconnectingGithub.value = true
+  disconnectingGithub.value = true;
   try {
-    await githubStore.disconnect()
-    MessagePlugin.success(t('settings.github.disconnected'))
+    await githubStore.disconnect();
+    MessagePlugin.success(t('settings.github.disconnected'));
   } catch (e: any) {
-    MessagePlugin.error(e.message || t('settings.github.disconnectFailed'))
+    MessagePlugin.error(e.message || t('settings.github.disconnectFailed'));
   } finally {
-    disconnectingGithub.value = false
+    disconnectingGithub.value = false;
   }
 }
 
-onMounted(() => githubStore.fetchStatus())
+onMounted(() => githubStore.fetchStatus());
 </script>
 
 <template>
   <div class="settings-page">
     <t-breadcrumb class="breadcrumb">
-      <t-breadcrumb-item @click="router.push('/dashboard')">{{ t('breadcrumb.home') }}</t-breadcrumb-item>
+      <t-breadcrumb-item @click="router.push('/dashboard')">{{
+        t('breadcrumb.home')
+      }}</t-breadcrumb-item>
       <t-breadcrumb-item>{{ t('settings.title') }}</t-breadcrumb-item>
     </t-breadcrumb>
 
@@ -131,7 +133,11 @@ onMounted(() => githubStore.fetchStatus())
             />
           </t-form-item>
           <t-form-item :label="t('settings.newPassword')">
-            <t-input v-model="newPassword" type="password" :placeholder="t('settings.newPasswordPlaceholder')" />
+            <t-input
+              v-model="newPassword"
+              type="password"
+              :placeholder="t('settings.newPasswordPlaceholder')"
+            />
           </t-form-item>
           <t-form-item :label="t('settings.confirmNewPassword')">
             <t-input
@@ -173,7 +179,11 @@ onMounted(() => githubStore.fetchStatus())
                 <strong>{{ githubStore.status.name || githubStore.status.login }}</strong>
                 <span class="github-login">@{{ githubStore.status.login }}</span>
                 <span v-if="githubStore.status.connected_at" class="github-since">
-                  {{ t('settings.github.since', { date: new Date(githubStore.status.connected_at).toLocaleDateString() }) }}
+                  {{
+                    t('settings.github.since', {
+                      date: new Date(githubStore.status.connected_at).toLocaleDateString(),
+                    })
+                  }}
                 </span>
               </div>
             </div>
@@ -208,8 +218,17 @@ onMounted(() => githubStore.fetchStatus())
             </t-radio-group>
           </t-form-item>
           <t-form-item :label="t('settings.languageLabel')">
-            <t-select :value="currentLocale" style="width: 200px" @change="(v: any) => onLocaleChange(v)">
-              <t-option v-for="opt in LOCALE_OPTIONS" :key="opt.value" :value="opt.value" :label="opt.label" />
+            <t-select
+              :value="currentLocale"
+              style="width: 200px"
+              @change="(v: any) => onLocaleChange(v)"
+            >
+              <t-option
+                v-for="opt in LOCALE_OPTIONS"
+                :key="opt.value"
+                :value="opt.value"
+                :label="opt.label"
+              />
             </t-select>
           </t-form-item>
         </t-form>
diff --git a/ordo-editor/apps/studio/vite.config.ts b/ordo-editor/apps/studio/vite.config.ts
index f604166e..5e6d2873 100644
--- a/ordo-editor/apps/studio/vite.config.ts
+++ b/ordo-editor/apps/studio/vite.config.ts
@@ -1,11 +1,10 @@
-import { defineConfig } from 'vite'
-import vue from '@vitejs/plugin-vue'
-import { resolve } from 'path'
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import { resolve } from 'path';
 
-const packagesPath = resolve(__dirname, '../../packages')
-const platformProxyTarget =
-  process.env.ORDO_PLATFORM_PROXY_TARGET || 'http://localhost:3001'
-const cacheDir = resolve(__dirname, process.env.VITE_CACHE_DIR || 'node_modules/.vite')
+const packagesPath = resolve(__dirname, '../../packages');
+const platformProxyTarget = process.env.ORDO_PLATFORM_PROXY_TARGET || 'http://localhost:3001';
+const cacheDir = resolve(__dirname, process.env.VITE_CACHE_DIR || 'node_modules/.vite');
 
 export default defineConfig({
   plugins: [vue()],
@@ -31,11 +30,7 @@ export default defineConfig({
       },
     },
     fs: {
-      allow: [
-        resolve(__dirname, '..'),
-        packagesPath,
-        resolve(__dirname, '../../node_modules'),
-      ],
+      allow: [resolve(__dirname, '..'), packagesPath, resolve(__dirname, '../../node_modules')],
     },
   },
   optimizeDeps: {
@@ -49,4 +44,4 @@ export default defineConfig({
       'tdesign-vue-next',
     ],
   },
-})
+});
diff --git a/ordo-editor/packages/core/src/engine/__tests__/adapter.test.ts b/ordo-editor/packages/core/src/engine/__tests__/adapter.test.ts
index 843c9e4f..b574671a 100644
--- a/ordo-editor/packages/core/src/engine/__tests__/adapter.test.ts
+++ b/ordo-editor/packages/core/src/engine/__tests__/adapter.test.ts
@@ -1,15 +1,17 @@
-/**
- * Adapter tests
- * 格式转换器测试
- */
-
-import { describe, it, expect } from 'vitest';
-import { convertToEngineFormat, validateEngineCompatibility, isEngineCompatible } from '../adapter';
-import type { RuleSet, DecisionStep, ActionStep, TerminalStep } from '../../model';
+import { describe, expect, it } from 'vitest';
+import { convertToEngineFormat, isEngineCompatible, validateEngineCompatibility } from '../adapter';
+import { convertFromEngineFormat } from '../reverse-adapter';
+import {
+  Expr,
+  type ActionStep,
+  type DecisionStep,
+  type RuleSet,
+  type TerminalStep,
+} from '../../model';
 
 describe('Format Adapter', () => {
   describe('convertToEngineFormat', () => {
-    it('should convert a simple ruleset', () => {
+    it('converts terminal steps into flattened engine format', () => {
       const editorRuleset: RuleSet = {
         config: {
           name: 'test-rule',
@@ -31,11 +33,20 @@ describe('Format Adapter', () => {
 
       expect(engineRuleset.config.name).toBe('test-rule');
       expect(engineRuleset.config.entry_step).toBe('start');
-      expect(engineRuleset.steps['start']).toBeDefined();
-      expect(engineRuleset.steps['start'].kind).toHaveProperty('Terminal');
+      expect(engineRuleset.steps['start']).toMatchObject({
+        id: 'start',
+        name: 'Start Step',
+        type: 'terminal',
+        result: {
+          code: 'SUCCESS',
+          message: '',
+          output: [],
+          data: null,
+        },
+      });
     });
 
-    it('should convert decision step with branches', () => {
+    it('converts decision steps with branches', () => {
       const editorRuleset: RuleSet = {
         config: { name: 'decision-test' },
         startStepId: 'decide',
@@ -47,7 +58,12 @@ describe('Format Adapter', () => {
             branches: [
               {
                 id: 'branch1',
-                condition: { type: 'simple', field: 'age', operator: '>', value: 18 },
+                condition: {
+                  type: 'simple',
+                  left: Expr.variable('$.age'),
+                  operator: 'gt',
+                  right: Expr.number(18),
+                },
                 nextStepId: 'adult',
               },
             ],
@@ -68,17 +84,23 @@ describe('Format Adapter', () => {
         ],
       };
 
-      const engineRuleset = convertToEngineFormat(editorRuleset);
-      const decisionStep = engineRuleset.steps['decide'];
+      const decisionStep = convertToEngineFormat(editorRuleset).steps['decide'];
 
-      expect(decisionStep.kind).toHaveProperty('Decision');
-      if ('Decision' in decisionStep.kind) {
-        expect(decisionStep.kind.Decision.branches).toHaveLength(1);
-        expect(decisionStep.kind.Decision.default_next).toBe('minor');
-      }
+      expect(decisionStep).toMatchObject({
+        id: 'decide',
+        type: 'decision',
+        default_next: 'minor',
+      });
+      expect(decisionStep.branches).toEqual([
+        {
+          condition: 'age > 18',
+          next_step: 'adult',
+          actions: [],
+        },
+      ]);
     });
 
-    it('should convert action step with assignments', () => {
+    it('converts action steps with assignments and external calls', () => {
       const editorRuleset: RuleSet = {
         config: { name: 'action-test' },
         startStepId: 'action',
@@ -87,7 +109,30 @@ describe('Format Adapter', () => {
             id: 'action',
             name: 'Action',
             type: 'action',
-            assignments: [{ name: 'result', value: { type: 'literal', value: 'done' } }],
+            assignments: [{ name: 'result', value: Expr.string('done') }],
+            externalCalls: [
+              {
+                type: 'http',
+                target: 'PATCH https://api.example.com/score',
+                params: {
+                  applicantId: Expr.variable('$.applicant.id'),
+                  score: Expr.number(720),
+                },
+                resultVariable: 'http_result',
+                timeout: 1500,
+              },
+              {
+                type: 'function',
+                target: 'demo.echo#echo',
+                params: {
+                  payload: Expr.object({
+                    amount: Expr.variable('$.amount'),
+                    approved: Expr.boolean(true),
+                  }),
+                },
+                resultVariable: 'echo_result',
+              },
+            ],
             nextStepId: 'end',
           } as ActionStep,
           {
@@ -99,19 +144,134 @@ describe('Format Adapter', () => {
         ],
       };
 
-      const engineRuleset = convertToEngineFormat(editorRuleset);
-      const actionStep = engineRuleset.steps['action'];
+      const actionStep = convertToEngineFormat(editorRuleset).steps['action'];
+
+      expect(actionStep).toMatchObject({
+        id: 'action',
+        type: 'action',
+        next_step: 'end',
+      });
+      expect(actionStep.actions).toEqual([
+        {
+          action: 'set_variable',
+          name: 'result',
+          value: { Literal: 'done' },
+          description: '',
+        },
+        {
+          action: 'external_call',
+          service: 'network.http',
+          method: 'patch',
+          params: [
+            ['url', { Literal: 'https://api.example.com/score' }],
+            [
+              'json_body',
+              {
+                Object: [
+                  ['applicantId', { Field: 'applicant.id' }],
+                  ['score', { Literal: 720 }],
+                ],
+              },
+            ],
+          ],
+          result_variable: 'http_result',
+          timeout_ms: 1500,
+          description: '',
+        },
+        {
+          action: 'external_call',
+          service: 'demo.echo',
+          method: 'echo',
+          params: [
+            [
+              'payload',
+              {
+                Object: [
+                  ['amount', { Field: 'amount' }],
+                  ['approved', { Literal: true }],
+                ],
+              },
+            ],
+          ],
+          result_variable: 'echo_result',
+          timeout_ms: 0,
+          description: '',
+        },
+      ]);
+    });
+  });
 
-      expect(actionStep.kind).toHaveProperty('Action');
-      if ('Action' in actionStep.kind) {
-        expect(actionStep.kind.Action.actions).toHaveLength(1);
-        expect(actionStep.kind.Action.next_step).toBe('end');
-      }
+  describe('convertFromEngineFormat', () => {
+    it('reconstructs external calls from engine action steps', () => {
+      const editorRuleset = convertFromEngineFormat({
+        config: {
+          name: 'reverse-test',
+          version: '1.0.0',
+          description: '',
+          entry_step: 'start',
+        },
+        steps: {
+          start: {
+            id: 'start',
+            name: 'Start',
+            type: 'action',
+            next_step: 'done',
+            actions: [
+              {
+                action: 'external_call',
+                service: 'network.http',
+                method: 'get',
+                params: [['url', { Literal: 'https://api.example.com/users' }]],
+                result_variable: 'users',
+                timeout_ms: 2000,
+              },
+              {
+                action: 'external_call',
+                service: 'demo.echo',
+                method: 'echo',
+                params: [['payload', { Field: 'input.payload' }]],
+                result_variable: 'echo',
+              },
+            ],
+          },
+          done: {
+            id: 'done',
+            name: 'Done',
+            type: 'terminal',
+            result: {
+              code: 'OK',
+              message: '',
+              output: [],
+              data: null,
+            },
+          },
+        },
+      });
+
+      const actionStep = editorRuleset.steps[0] as ActionStep;
+      expect(actionStep.externalCalls).toEqual([
+        {
+          type: 'http',
+          target: 'GET https://api.example.com/users',
+          params: undefined,
+          resultVariable: 'users',
+          timeout: 2000,
+        },
+        {
+          type: 'function',
+          target: 'demo.echo#echo',
+          params: {
+            payload: { type: 'variable', path: 'input.payload' },
+          },
+          resultVariable: 'echo',
+          timeout: undefined,
+        },
+      ]);
     });
   });
 
   describe('validateEngineCompatibility', () => {
-    it('should pass validation for valid ruleset', () => {
+    it('passes validation for a valid ruleset', () => {
       const ruleset: RuleSet = {
         config: { name: 'valid' },
         startStepId: 'start',
@@ -130,7 +290,7 @@ describe('Format Adapter', () => {
       expect(isEngineCompatible(ruleset)).toBe(true);
     });
 
-    it('should detect missing startStepId', () => {
+    it('detects missing startStepId', () => {
       const ruleset: RuleSet = {
         config: { name: 'invalid' },
         startStepId: '',
@@ -142,7 +302,7 @@ describe('Format Adapter', () => {
       expect(errors[0]).toContain('startStepId');
     });
 
-    it('should detect missing step IDs', () => {
+    it('detects missing step IDs', () => {
       const ruleset: RuleSet = {
         config: { name: 'invalid' },
         startStepId: 'start',
@@ -161,7 +321,7 @@ describe('Format Adapter', () => {
       expect(errors.some((e) => e.includes('missing id'))).toBe(true);
     });
 
-    it('should detect non-existent step references', () => {
+    it('detects non-existent step references', () => {
       const ruleset: RuleSet = {
         config: { name: 'invalid' },
         startStepId: 'start',
@@ -173,7 +333,12 @@ describe('Format Adapter', () => {
             branches: [
               {
                 id: 'branch1',
-                condition: { type: 'simple', field: 'x', operator: '==', value: 1 },
+                condition: {
+                  type: 'simple',
+                  left: Expr.variable('$.x'),
+                  operator: 'eq',
+                  right: Expr.number(1),
+                },
                 nextStepId: 'nonexistent',
               },
             ],
diff --git a/ordo-editor/packages/core/src/engine/adapter.ts b/ordo-editor/packages/core/src/engine/adapter.ts
index a1816099..96fde2f9 100644
--- a/ordo-editor/packages/core/src/engine/adapter.ts
+++ b/ordo-editor/packages/core/src/engine/adapter.ts
@@ -61,13 +61,19 @@ interface EngineBranch {
 }
 
 interface EngineAction {
-  action: 'set_variable' | 'log' | 'metric';
+  action: 'set_variable' | 'log' | 'metric' | 'external_call';
   // set_variable fields
   name?: string;
   value?: any; // Expr
   // log fields
   message?: string;
   level?: 'debug' | 'info' | 'warn' | 'error';
+  // external_call fields
+  service?: string;
+  method?: string;
+  params?: Array<[string, any]>;
+  result_variable?: string;
+  timeout_ms?: number;
   description?: string;
 }
 
@@ -288,6 +294,13 @@ function convertActionStep(step: ActionStep): EngineStep {
     }
   }
 
+  // Convert external calls
+  if (step.externalCalls) {
+    for (const externalCall of step.externalCalls) {
+      actions.push(convertExternalCall(externalCall));
+    }
+  }
+
   // Convert logging
   if (step.logging) {
     // Extract message string from logging object
@@ -320,6 +333,94 @@ function convertActionStep(step: ActionStep): EngineStep {
   };
 }
 
+function convertExternalCall(call: NonNullable<ActionStep['externalCalls']>[number]): EngineAction {
+  const timeoutMs = call.timeout && call.timeout > 0 ? call.timeout : 0;
+
+  if (call.type === 'http') {
+    const { method, url } = parseHttpTarget(call.target);
+    const params: Array<[string, any]> = [['url', { Literal: url }]];
+
+    if (call.params && Object.keys(call.params).length > 0) {
+      params.push([
+        'json_body',
+        {
+          Object: Object.entries(call.params).map(([name, value]) => [
+            name,
+            convertToEngineExpr(value),
+          ]),
+        },
+      ]);
+    }
+
+    return {
+      action: 'external_call',
+      service: 'network.http',
+      method,
+      params,
+      result_variable: call.resultVariable,
+      timeout_ms: timeoutMs,
+      description: '',
+    };
+  }
+
+  const { service, method } = parseCapabilityTarget(call.target, call.type);
+
+  return {
+    action: 'external_call',
+    service,
+    method,
+    params: Object.entries(call.params || {}).map(([name, value]) => [
+      name,
+      convertToEngineExpr(value),
+    ]),
+    result_variable: call.resultVariable,
+    timeout_ms: timeoutMs,
+    description: '',
+  };
+}
+
+function parseHttpTarget(target: string): { method: string; url: string } {
+  const trimmed = target.trim();
+  const match = trimmed.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(.+)$/i);
+  if (match) {
+    return {
+      method: match[1].toLowerCase(),
+      url: match[2].trim(),
+    };
+  }
+
+  return {
+    method: 'post',
+    url: trimmed,
+  };
+}
+
+function parseCapabilityTarget(
+  target: string,
+  type: 'grpc' | 'function'
+): { service: string; method: string } {
+  const trimmed = target.trim();
+
+  for (const separator of ['#', '::']) {
+    const index = trimmed.indexOf(separator);
+    if (index > 0) {
+      return {
+        service: trimmed.slice(0, index).trim(),
+        method: trimmed.slice(index + separator.length).trim() || defaultCapabilityMethod(type),
+      };
+    }
+  }
+
+  return {
+    service: trimmed,
+    method: defaultCapabilityMethod(type),
+  };
+}
+
+function defaultCapabilityMethod(type: 'grpc' | 'function'): string {
+  return type === 'grpc' ? 'call' : 'invoke';
+}
+
 /**
  * Convert terminal step
  */
@@ -415,6 +516,66 @@ function convertToEngineExpr(value: any): any {
       return { Literal: value.expression };
     }
 
+    if (value.type === 'binary') {
+      return {
+        Binary: {
+          op: convertBinaryOp(value.op),
+          left: convertToEngineExpr(value.left),
+          right: convertToEngineExpr(value.right),
+        },
+      };
+    }
+
+    if (value.type === 'unary') {
+      return {
+        Unary: {
+          op: convertUnaryOp(value.op),
+          operand: convertToEngineExpr(value.operand),
+        },
+      };
+    }
+
+    if (value.type === 'function') {
+      return {
+        Call: {
+          name: value.name,
+          args: (value.args || []).map(convertToEngineExpr),
+        },
+      };
+    }
+
+    if (value.type === 'conditional') {
+      return {
+        Conditional: {
+          condition: convertToEngineExpr(value.condition),
+          then_branch: convertToEngineExpr(value.thenExpr),
+          else_branch: convertToEngineExpr(value.elseExpr),
+        },
+      };
+    }
+
+    if (value.type === 'array') {
+      return {
+        Array: (value.elements || []).map(convertToEngineExpr),
+      };
+    }
+
+    if (value.type === 'object') {
+      return {
+        Object: Object.entries(value.properties || {}).map(([name, expr]) => [
+          name,
+          convertToEngineExpr(expr),
+        ]),
+      };
+    }
+
+    if (value.type === 'member') {
+      const path = toEngineFieldPath(value);
+      if (path) {
+        return { Field: path };
+      }
+    }
+
     // Check if it's already in Expr format (but with wrong nesting)
     if ('Literal' in value) {
       // Check if nested value also needs conversion
@@ -447,6 +608,72 @@ function convertToEngineExpr(value: any): any {
   return { Literal: value };
 }
 
+function toEngineFieldPath(value: any): string | null {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  if (value.type === 'variable' || value.type === 'field') {
+    return normalizeFieldPath(value.path || value.name || '');
+  }
+
+  if (value.type === 'member' && !value.computed && typeof value.property === 'string') {
+    const base = toEngineFieldPath(value.object);
+    if (!base) {
+      return null;
+    }
+    return `${base}.${value.property}`;
+  }
+
+  return null;
+}
+
+function normalizeFieldPath(path: string): string {
+  if (path.startsWith('$.')) {
+    return path.slice(2);
+  }
+  if (path.startsWith('input.')) {
+    return path.slice(6);
+  }
+  if (path.startsWith('$')) {
+    return path.slice(1);
+  }
+  return path;
+}
+
+function convertBinaryOp(op: string): string {
+  const operatorMap: Record<string, string> = {
+    eq: 'Eq',
+    ne: 'Ne',
+    gt: 'Gt',
+    gte: 'Ge',
+    ge: 'Ge',
+    lt: 'Lt',
+    lte: 'Le',
+    le: 'Le',
+    and: 'And',
+    or: 'Or',
+    add: 'Add',
+    sub: 'Sub',
+    mul: 'Mul',
+    div: 'Div',
+    mod: 'Mod',
+    in: 'In',
+    contains: 'Contains',
+  };
+
+  return operatorMap[op] || op;
+}
+
+function convertUnaryOp(op: string): string {
+  const operatorMap: Record<string, string> = {
+    not: 'Not',
+    neg: 'Neg',
+  };
+
+  return operatorMap[op] || op;
+}
+
 /**
  * Validate Engine compatibility
  * 验证引擎兼容性
diff --git a/ordo-editor/packages/core/src/engine/reverse-adapter.ts b/ordo-editor/packages/core/src/engine/reverse-adapter.ts
index 8afffa5a..c3208999 100644
--- a/ordo-editor/packages/core/src/engine/reverse-adapter.ts
+++ b/ordo-editor/packages/core/src/engine/reverse-adapter.ts
@@ -7,68 +7,73 @@
  * This is the inverse of convertToEngineFormat() in adapter.ts.
  */
 
-import type { RuleSet, Step, DecisionStep, ActionStep, TerminalStep, Branch } from '../model'
-import { Expr } from '../model'
+import type { RuleSet, Step, DecisionStep, ActionStep, TerminalStep, Branch } from '../model';
+import { Expr } from '../model';
 
 /**
  * Engine RuleSet format (matches Rust ordo-core::RuleSet serialisation)
  */
 interface EngineRuleSet {
   config: {
-    name: string
-    version: string
-    description: string
-    entry_step: string
-    field_missing?: 'lenient' | 'strict' | 'default'
-    max_depth?: number
-    timeout_ms?: number
-    enable_trace?: boolean
-    metadata?: Record<string, string>
-  }
-  steps: Record<string, EngineStep>
+    name: string;
+    version: string;
+    description: string;
+    entry_step: string;
+    field_missing?: 'lenient' | 'strict' | 'default';
+    max_depth?: number;
+    timeout_ms?: number;
+    enable_trace?: boolean;
+    metadata?: Record<string, string>;
+  };
+  steps: Record<string, EngineStep>;
 }
 
 interface EngineStep {
-  id: string
-  name: string
-  type: 'decision' | 'action' | 'terminal'
+  id: string;
+  name: string;
+  type: 'decision' | 'action' | 'terminal';
   // Decision
-  branches?: EngineBranch[]
-  default_next?: string | null
+  branches?: EngineBranch[];
+  default_next?: string | null;
   // Action
-  actions?: EngineAction[]
-  next_step?: string
+  actions?: EngineAction[];
+  next_step?: string;
   // Terminal
-  result?: EngineTerminalResult
+  result?: EngineTerminalResult;
 }
 
 interface EngineBranch {
-  condition: string | any  // Server returns parsed AST, not a raw string
-  next_step: string
-  actions?: EngineAction[]
+  condition: string | any; // Server returns parsed AST, not a raw string
+  next_step: string;
+  actions?: EngineAction[];
 }
 
 interface EngineAction {
-  action: 'set_variable' | 'log' | 'metric'
-  name?: string
-  value?: any
-  message?: string
-  level?: string
-  description?: string
+  action: 'set_variable' | 'log' | 'metric' | 'external_call';
+  name?: string;
+  value?: any;
+  message?: string;
+  level?: string;
+  service?: string;
+  method?: string;
+  params?: Array<[string, any]>;
+  result_variable?: string;
+  timeout_ms?: number;
+  description?: string;
 }
 
 interface EngineTerminalResult {
-  code: string
-  message: string
-  output: Array<[string, any]>
-  data?: any
+  code: string;
+  message: string;
+  output: Array<[string, any]>;
+  data?: any;
 }
 
 /**
  * Convert Engine RuleSet → Editor RuleSet
  */
 export function convertFromEngineFormat(engine: EngineRuleSet): RuleSet {
-  const steps: Step[] = Object.values(engine.steps).map(convertEngineStep)
+  const steps: Step[] = Object.values(engine.steps).map(convertEngineStep);
 
   return {
     config: {
@@ -81,17 +86,17 @@ export function convertFromEngineFormat(engine: EngineRuleSet): RuleSet {
     },
     startStepId: engine.config.entry_step,
     steps,
-  }
+  };
 }
 
 function convertEngineStep(step: EngineStep): Step {
   switch (step.type) {
     case 'decision':
-      return convertEngineDecisionStep(step)
+      return convertEngineDecisionStep(step);
     case 'action':
-      return convertEngineActionStep(step)
+      return convertEngineActionStep(step);
     case 'terminal':
-      return convertEngineTerminalStep(step)
+      return convertEngineTerminalStep(step);
     default:
       // Unknown type — treat as terminal with error
       return {
@@ -101,7 +106,7 @@ function convertEngineStep(step: EngineStep): Step {
         code: 'ERROR',
         message: Expr.string(`Unknown step type: ${(step as any).type}`),
         output: [],
-      } as TerminalStep
+      } as TerminalStep;
   }
 }
 
@@ -112,21 +117,22 @@ function convertEngineDecisionStep(step: EngineStep): DecisionStep {
     type: 'decision',
     branches: (step.branches ?? []).map(convertEngineBranch),
     defaultNextStepId: step.default_next ?? '',
-  }
+  };
 }
 
 function convertEngineBranch(branch: EngineBranch): Branch {
   // The engine returns conditions as parsed AST objects, not raw strings.
   // Convert AST → string first, then parse back to editor condition format.
-  const condStr = typeof branch.condition === 'string'
-    ? branch.condition
-    : engineExprAstToString(branch.condition)
+  const condStr =
+    typeof branch.condition === 'string'
+      ? branch.condition
+      : engineExprAstToString(branch.condition);
   return {
     id: generateId(),
     condition: parseConditionString(condStr),
     nextStepId: branch.next_step,
     label: condStr,
-  }
+  };
 }
 
 /**
@@ -141,66 +147,79 @@ function convertEngineBranch(branch: EngineBranch): Branch {
  *   { "Not": expr }
  */
 function engineExprAstToString(expr: any): string {
-  if (expr === null || expr === undefined) return 'true'
-  if (typeof expr === 'string') return expr
-  if (typeof expr === 'number' || typeof expr === 'boolean') return String(expr)
+  if (expr === null || expr === undefined) return 'true';
+  if (typeof expr === 'string') return expr;
+  if (typeof expr === 'number' || typeof expr === 'boolean') return String(expr);
 
-  if ('Field' in expr) return String(expr.Field)
+  if ('Field' in expr) return String(expr.Field);
   if ('Literal' in expr) {
-    const v = expr.Literal
-    if (typeof v === 'string') return `"${v}"`
-    if (v === null) return 'null'
-    return String(v)
+    const v = expr.Literal;
+    if (typeof v === 'string') return `"${v}"`;
+    if (v === null) return 'null';
+    return String(v);
   }
   if ('Binary' in expr) {
-    const { op, left, right } = expr.Binary
-    const opStr = engineOpToString(op)
-    return `${engineExprAstToString(left)} ${opStr} ${engineExprAstToString(right)}`
+    const { op, left, right } = expr.Binary;
+    const opStr = engineOpToString(op);
+    return `${engineExprAstToString(left)} ${opStr} ${engineExprAstToString(right)}`;
   }
   if ('And' in expr) {
-    return (expr.And as any[]).map(engineExprAstToString).join(' && ')
+    return (expr.And as any[]).map(engineExprAstToString).join(' && ');
   }
   if ('Or' in expr) {
-    return (expr.Or as any[]).map(engineExprAstToString).join(' || ')
+    return (expr.Or as any[]).map(engineExprAstToString).join(' || ');
   }
   if ('Not' in expr) {
-    return `!${engineExprAstToString(expr.Not)}`
+    return `!${engineExprAstToString(expr.Not)}`;
   }
   if ('Unary' in expr) {
-    const { op, expr: inner } = expr.Unary
-    if (op === 'Not') return `!${engineExprAstToString(inner)}`
-    return `${op}(${engineExprAstToString(inner)})`
+    const { op, expr: inner } = expr.Unary;
+    if (op === 'Not') return `!${engineExprAstToString(inner)}`;
+    return `${op}(${engineExprAstToString(inner)})`;
   }
 
   // Unknown AST node — stringify as fallback
-  return JSON.stringify(expr)
+  return JSON.stringify(expr);
 }
 
 const ENGINE_OP_MAP: Record<string, string> = {
-  Eq: '==', Ne: '!=', Gt: '>', Lt: '<', Ge: '>=', Le: '<=',
-  Add: '+', Sub: '-', Mul: '*', Div: '/', Mod: '%',
-  And: '&&', Or: '||',
-}
+  Eq: '==',
+  Ne: '!=',
+  Gt: '>',
+  Lt: '<',
+  Ge: '>=',
+  Le: '<=',
+  Add: '+',
+  Sub: '-',
+  Mul: '*',
+  Div: '/',
+  Mod: '%',
+  And: '&&',
+  Or: '||',
+};
 
 function engineOpToString(op: string): string {
-  return ENGINE_OP_MAP[op] ?? op
+  return ENGINE_OP_MAP[op] ?? op;
 }
 
 function convertEngineActionStep(step: EngineStep): ActionStep {
-  const assignments: ActionStep['assignments'] = []
-  let logging: ActionStep['logging'] | undefined
+  const assignments: ActionStep['assignments'] = [];
+  const externalCalls: NonNullable<ActionStep['externalCalls']> = [];
+  let logging: ActionStep['logging'] | undefined;
 
   for (const action of step.actions ?? []) {
     if (action.action === 'set_variable' && action.name !== undefined) {
       assignments.push({
         name: action.name,
         value: convertFromEngineExpr(action.value),
-      })
+      });
     } else if (action.action === 'log') {
       logging = {
         message: Expr.string(action.message ?? ''),
         level: (action.level as any) ?? 'info',
-      }
+      };
+    } else if (action.action === 'external_call') {
+      externalCalls.push(convertEngineExternalCall(action));
     }
   }
 
@@ -209,17 +228,62 @@ function convertEngineActionStep(step: EngineStep): ActionStep {
     name: step.name,
     type: 'action',
     assignments,
+    externalCalls,
     logging,
     nextStepId: step.next_step ?? '',
+  };
+}
+
+function convertEngineExternalCall(
+  action: Extract<EngineAction, { action: 'external_call' }> | EngineAction
+): NonNullable<ActionStep['externalCalls']>[number] {
+  const params = Object.fromEntries(
+    (action.params ?? [])
+      .filter(([name]) => name !== 'url' && name !== 'json_body')
+      .map(([name, expr]) => [name, convertFromEngineExpr(expr)])
+  );
+
+  if (action.service === 'network.http') {
+    const urlEntry = (action.params ?? []).find(([name]) => name === 'url');
+    const jsonBodyEntry = (action.params ?? []).find(([name]) => name === 'json_body');
+    const url = urlEntry ? extractLiteralString(urlEntry[1]) : '';
+    const method = (action.method ?? 'post').toUpperCase();
+    const target = method === 'POST' ? url : `${method} ${url}`.trim();
+
+    return {
+      type: 'http',
+      target,
+      params:
+        jsonBodyEntry && isEngineObjectExpr(jsonBodyEntry[1])
+          ? Object.fromEntries(
+              jsonBodyEntry[1].Object.map(([name, expr]: [string, any]) => [
+                name,
+                convertFromEngineExpr(expr),
+              ])
+            )
+          : undefined,
+      resultVariable: action.result_variable,
+      timeout: action.timeout_ms,
+    };
   }
+
+  const target = formatCapabilityTarget(action.service, action.method);
+
+  return {
+    type: isGrpcCapability(action.service) ? 'grpc' : 'function',
+    target,
+    params: Object.keys(params).length > 0 ? params : undefined,
+    resultVariable: action.result_variable,
+    timeout: action.timeout_ms,
+  };
 }
 
 function convertEngineTerminalStep(step: EngineStep): TerminalStep {
-  const result = step.result
+  const result = step.result;
   const output = (result?.output ?? []).map(([name, expr]) => ({
     name,
     value: convertFromEngineExpr(expr),
-  }))
+  }));
 
   return {
     id: step.id,
@@ -228,7 +292,7 @@ function convertEngineTerminalStep(step: EngineStep): TerminalStep {
     code: result?.code ?? 'UNKNOWN',
     message: result?.message ? Expr.string(result.message) : undefined,
     output,
-  }
+  };
 }
 
 /**
@@ -238,32 +302,153 @@ function convertEngineTerminalStep(step: EngineStep): TerminalStep {
  */
 function convertFromEngineExpr(expr: any): any {
   if (expr === null || expr === undefined) {
-    return { type: 'literal', value: null, valueType: 'null' }
+    return { type: 'literal', value: null, valueType: 'null' };
   }
 
   // { "Literal": <value> }
   if (typeof expr === 'object' && 'Literal' in expr) {
-    const v = expr.Literal
+    const v = expr.Literal;
     return {
       type: 'literal',
       value: v,
-      valueType: v === null ? 'null' : typeof v === 'boolean' ? 'boolean' : typeof v === 'number' ? 'number' : 'string',
-    }
+      valueType:
+        v === null
+          ? 'null'
+          : typeof v === 'boolean'
+            ? 'boolean'
+            : typeof v === 'number'
+              ? 'number'
+              : 'string',
+    };
   }
 
   // { "Field": "<path>" }
   if (typeof expr === 'object' && 'Field' in expr) {
-    const path = typeof expr.Field === 'string' ? expr.Field : String(expr.Field)
-    return { type: 'variable', path }
+    const path = typeof expr.Field === 'string' ? expr.Field : String(expr.Field);
+    return { type: 'variable', path };
+  }
+
+  if (typeof expr === 'object' && 'Binary' in expr) {
+    return {
+      type: 'binary',
+      op: fromEngineBinaryOp(expr.Binary.op),
+      left: convertFromEngineExpr(expr.Binary.left),
+      right: convertFromEngineExpr(expr.Binary.right),
+    };
+  }
+
+  if (typeof expr === 'object' && 'Unary' in expr) {
+    return {
+      type: 'unary',
+      op: fromEngineUnaryOp(expr.Unary.op),
+      operand: convertFromEngineExpr(expr.Unary.operand),
+    };
+  }
+
+  if (typeof expr === 'object' && 'Call' in expr) {
+    return {
+      type: 'function',
+      name: expr.Call.name,
+      args: (expr.Call.args ?? []).map(convertFromEngineExpr),
+    };
+  }
+
+  if (typeof expr === 'object' && 'Conditional' in expr) {
+    return {
+      type: 'conditional',
+      condition: convertFromEngineExpr(expr.Conditional.condition),
+      thenExpr: convertFromEngineExpr(expr.Conditional.then_branch),
+      elseExpr: convertFromEngineExpr(expr.Conditional.else_branch),
+    };
+  }
+
+  if (typeof expr === 'object' && 'Array' in expr) {
+    return {
+      type: 'array',
+      elements: (expr.Array ?? []).map(convertFromEngineExpr),
+    };
+  }
+
+  if (typeof expr === 'object' && 'Object' in expr) {
+    return {
+      type: 'object',
+      properties: Object.fromEntries(
+        (expr.Object ?? []).map(([name, value]: [string, any]) => [
+          name,
+          convertFromEngineExpr(value),
+        ])
+      ),
+    };
   }
 
   // Primitives (edge case: engine may return untagged scalars in some versions)
   if (typeof expr === 'string' || typeof expr === 'number' || typeof expr === 'boolean') {
-    return { type: 'literal', value: expr, valueType: typeof expr }
+    return { type: 'literal', value: expr, valueType: typeof expr };
   }
 
   // Fallback: wrap as literal
-  return { type: 'literal', value: expr, valueType: 'object' }
+  return { type: 'literal', value: expr, valueType: 'object' };
+}
+
+function isEngineObjectExpr(expr: any): expr is { Object: Array<[string, any]> } {
+  return typeof expr === 'object' && expr !== null && Array.isArray(expr.Object);
+}
+
+function extractLiteralString(expr: any): string {
+  if (typeof expr === 'object' && expr !== null && 'Literal' in expr) {
+    return String(expr.Literal ?? '');
+  }
+  return '';
+}
+
+function formatCapabilityTarget(service?: string, method?: string): string {
+  const normalizedService = service ?? '';
+  const normalizedMethod = method ?? 'invoke';
+
+  if (!normalizedService) {
+    return normalizedMethod;
+  }
+
+  if (normalizedMethod === 'invoke' || normalizedMethod === 'call') {
+    return normalizedService;
+  }
+
+  return `${normalizedService}#${normalizedMethod}`;
+}
+
+function isGrpcCapability(service?: string): boolean {
+  return !!service && service.includes('grpc');
+}
+
+function fromEngineBinaryOp(op: string): string {
+  const operatorMap: Record<string, string> = {
+    Eq: 'eq',
+    Ne: 'ne',
+    Gt: 'gt',
+    Ge: 'gte',
+    Lt: 'lt',
+    Le: 'lte',
+    And: 'and',
+    Or: 'or',
+    Add: 'add',
+    Sub: 'sub',
+    Mul: 'mul',
+    Div: 'div',
+    Mod: 'mod',
+    In: 'in',
+    Contains: 'contains',
+  };
+
+  return operatorMap[op] ?? op.toLowerCase();
+}
+
+function fromEngineUnaryOp(op: string): string {
+  const operatorMap: Record<string, string> = {
+    Not: 'not',
+    Neg: 'neg',
+  };
+
+  return operatorMap[op] ?? op.toLowerCase();
 }
 
 /**
@@ -278,36 +463,36 @@ function convertFromEngineExpr(expr: any): any {
  */
 function parseConditionString(expr: string): any {
   if (!expr || expr === 'true') {
-    return { type: 'expression', expression: expr || 'true' }
+    return { type: 'expression', expression: expr || 'true' };
   }
 
   // Strip optional outer parens
-  const trimmed = expr.trim()
+  const trimmed = expr.trim();
   if (trimmed.startsWith('(') && trimmed.endsWith(')')) {
-    const inner = trimmed.slice(1, -1).trim()
+    const inner = trimmed.slice(1, -1).trim();
     // Only strip if the parens are truly wrapping the whole expression
     if (parenDepthIsZeroAfterOpen(inner)) {
-      return parseConditionString(inner)
+      return parseConditionString(inner);
     }
   }
 
   // Split on top-level ' && ' / ' || ' (left-to-right, shortest match)
-  const andParts = splitTopLevel(trimmed, '&&')
+  const andParts = splitTopLevel(trimmed, '&&');
   if (andParts.length > 1) {
     return {
       type: 'logical',
       operator: 'and',
       conditions: andParts.map(parseConditionString),
-    }
+    };
   }
 
-  const orParts = splitTopLevel(trimmed, '||')
+  const orParts = splitTopLevel(trimmed, '||');
   if (orParts.length > 1) {
     return {
       type: 'logical',
       operator: 'or',
       conditions: orParts.map(parseConditionString),
-    }
+    };
   }
 
   // Try to parse simple binary expressions: "left op right"
@@ -318,14 +503,14 @@ function parseConditionString(expr: string): any {
     { op: '==', editorOp: 'eq' },
     { op: '>', editorOp: 'gt' },
     { op: '<', editorOp: 'lt' },
-  ]
+  ];
 
   for (const { op, editorOp } of simpleOps) {
-    const idx = trimmed.indexOf(op)
-    if (idx === -1) continue
+    const idx = trimmed.indexOf(op);
+    if (idx === -1) continue;
 
-    const left = trimmed.slice(0, idx).trim()
-    const right = trimmed.slice(idx + op.length).trim()
+    const left = trimmed.slice(0, idx).trim();
+    const right = trimmed.slice(idx + op.length).trim();
 
     // Only parse if both sides look simple (no parens, no logical ops)
     if (left && right && !/[()&|]/.test(left) && !/[()&|]/.test(right)) {
@@ -334,12 +519,12 @@ function parseConditionString(expr: string): any {
         left: parseValueToken(left),
         operator: editorOp,
         right: parseValueToken(right),
-      }
+      };
     }
   }
 
   // Fall back to raw expression
-  return { type: 'expression', expression: trimmed }
+  return { type: 'expression', expression: trimmed };
 }
 
 /**
@@ -348,68 +533,77 @@ function parseConditionString(expr: string): any {
  * if the operator is not found at the top level.
  */
 function splitTopLevel(expr: string, op: string): string[] {
-  const parts: string[] = []
-  let depth = 0
-  let start = 0
-  const opLen = op.length
+  const parts: string[] = [];
+  let depth = 0;
+  let start = 0;
+  const opLen = op.length;
 
   for (let i = 0; i < expr.length; i++) {
-    const ch = expr[i]
-    if (ch === '(') { depth++; continue }
-    if (ch === ')') { depth--; continue }
+    const ch = expr[i];
+    if (ch === '(') {
+      depth++;
+      continue;
+    }
+    if (ch === ')') {
+      depth--;
+      continue;
+    }
 
     if (depth === 0 && expr.slice(i, i + opLen) === op) {
       // Ensure it's surrounded by whitespace so we don't split inside tokens
-      const before = expr[i - 1]
-      const after = expr[i + opLen]
+      const before = expr[i - 1];
+      const after = expr[i + opLen];
       if ((!before || before === ' ') && (!after || after === ' ')) {
-        parts.push(expr.slice(start, i).trim())
-        start = i + opLen
-        i += opLen - 1
+        parts.push(expr.slice(start, i).trim());
+        start = i + opLen;
+        i += opLen - 1;
       }
     }
   }
 
-  parts.push(expr.slice(start).trim())
-  return parts.length > 1 ? parts.filter(Boolean) : [expr]
+  parts.push(expr.slice(start).trim());
+  return parts.length > 1 ? parts.filter(Boolean) : [expr];
 }
 
 /** Return true when `s` (the content after the opening paren was stripped)
  *  never goes negative depth — meaning the original outer parens truly wrapped everything. */
 function parenDepthIsZeroAfterOpen(s: string): boolean {
-  let depth = 0
+  let depth = 0;
   for (const ch of s) {
-    if (ch === '(') depth++
+    if (ch === '(') depth++;
     if (ch === ')') {
-      if (depth === 0) return false
-      depth--
+      if (depth === 0) return false;
+      depth--;
     }
   }
-  return depth === 0
+  return depth === 0;
 }
 
 function parseValueToken(token: string): any {
   // Quoted string literal
-  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith("'") && token.endsWith("'"))) {
-    return { type: 'literal', value: token.slice(1, -1), valueType: 'string' }
+  if (
+    (token.startsWith('"') && token.endsWith('"')) ||
+    (token.startsWith("'") && token.endsWith("'"))
+  ) {
+    return { type: 'literal', value: token.slice(1, -1), valueType: 'string' };
   }
   // Numeric literal
   if (/^-?\d+(\.\d+)?$/.test(token)) {
-    return { type: 'literal', value: parseFloat(token), valueType: 'number' }
+    return { type: 'literal', value: parseFloat(token), valueType: 'number' };
   }
   // Boolean literal
   if (token === 'true' || token === 'false') {
-    return { type: 'literal', value: token === 'true', valueType: 'boolean' }
+    return { type: 'literal', value: token === 'true', valueType: 'boolean' };
   }
   // Null
   if (token === 'null') {
-    return { type: 'literal', value: null, valueType: 'null' }
+    return { type: 'literal', value: null, valueType: 'null' };
   }
   // Field reference (dotted path like user.age)
-  return { type: 'variable', path: token }
+  return { type: 'variable', path: token };
 }
 
-let _idCounter = 0
+let _idCounter = 0;
 function generateId(): string {
-  return `b-${Date.now()}-${_idCounter++}`
+  return `b-${Date.now()}-${_idCounter++}`;
 }
diff --git a/ordo-editor/packages/core/src/model/decision-table-compiler.ts b/ordo-editor/packages/core/src/model/decision-table-compiler.ts
index 9726e800..fe909174 100644
--- a/ordo-editor/packages/core/src/model/decision-table-compiler.ts
+++ b/ordo-editor/packages/core/src/model/decision-table-compiler.ts
@@ -405,8 +405,14 @@ export function decompileStepsToTable(
         break;
       }
       if (cell.type === 'exact') {
-        if (typeof cell.value === 'number') { col.type = 'number'; break; }
-        if (typeof cell.value === 'boolean') { col.type = 'boolean'; break; }
+        if (typeof cell.value === 'number') {
+          col.type = 'number';
+          break;
+        }
+        if (typeof cell.value === 'boolean') {
+          col.type = 'boolean';
+          break;
+        }
       }
     }
   }
@@ -417,8 +423,14 @@ export function decompileStepsToTable(
       const cell = row.outputValues[col.id];
       if (!cell) continue;
       if (cell.type === 'exact') {
-        if (typeof cell.value === 'number') { col.type = 'number'; break; }
-        if (typeof cell.value === 'boolean') { col.type = 'boolean'; break; }
+        if (typeof cell.value === 'number') {
+          col.type = 'number';
+          break;
+        }
+        if (typeof cell.value === 'boolean') {
+          col.type = 'boolean';
+          break;
+        }
       }
     }
   }
diff --git a/ordo-editor/packages/core/src/serializer/index.ts b/ordo-editor/packages/core/src/serializer/index.ts
index 48ea0d29..47179fda 100644
--- a/ordo-editor/packages/core/src/serializer/index.ts
+++ b/ordo-editor/packages/core/src/serializer/index.ts
@@ -134,7 +134,9 @@ function deserializeStep(data: unknown): Step {
         externalCalls: step.externalCalls as Step['type'] extends 'action'
           ? NonNullable<Extract<Step, { type: 'action' }>['externalCalls']>
           : never,
-        logging: step.logging as { message: Expr; level?: 'debug' | 'info' | 'warn' | 'error' } | undefined,
+        logging: step.logging as
+          | { message: Expr; level?: 'debug' | 'info' | 'warn' | 'error' }
+          | undefined,
         nextStepId: step.nextStepId as string,
       };
 
diff --git a/ordo-editor/packages/vue/src/components/flow/nodes/ActionNode.vue b/ordo-editor/packages/vue/src/components/flow/nodes/ActionNode.vue
index d97e3f68..ac1c738f 100644
--- a/ordo-editor/packages/vue/src/components/flow/nodes/ActionNode.vue
+++ b/ordo-editor/packages/vue/src/components/flow/nodes/ActionNode.vue
@@ -111,7 +111,9 @@ function formatValue(assignment: VariableAssignment): string {
     <!-- Info chips (logging, external call) -->
     <div class="node-section info-section" v-if="hasLogging || hasExternalCall">
       <div class="info-row">
-        <span class="info-chip" v-if="hasLogging"> <OrdoIcon name="check" :size="10" /> {{ t('step.logging') }} </span>
+        <span class="info-chip" v-if="hasLogging">
+          <OrdoIcon name="check" :size="10" /> {{ t('step.logging') }}
+        </span>
         <span class="info-chip external" v-if="hasExternalCall">
           <OrdoIcon name="action" :size="10" /> {{ t('flow.externalCall') }}
         </span>
diff --git a/ordo-editor/packages/vue/src/components/form/OrdoStepList.vue b/ordo-editor/packages/vue/src/components/form/OrdoStepList.vue
index 54b0a8f2..0b5863ca 100644
--- a/ordo-editor/packages/vue/src/components/form/OrdoStepList.vue
+++ b/ordo-editor/packages/vue/src/components/form/OrdoStepList.vue
@@ -45,8 +45,10 @@ const expandedGroups = ref<Set<string>>(new Set(['ungrouped']));
 const expandedSteps = ref<Set<string>>(new Set());
 
 // Get groups from ruleset
-const groups = computed(() => Array.isArray(props.modelValue.groups) ? props.modelValue.groups : []);
-const steps = computed(() => Array.isArray(props.modelValue.steps) ? props.modelValue.steps : []);
+const groups = computed(() =>
+  Array.isArray(props.modelValue.groups) ? props.modelValue.groups : []
+);
+const steps = computed(() => (Array.isArray(props.modelValue.steps) ? props.modelValue.steps : []));
 
 // Get steps organized by group
 const stepsInGroups = computed(() => {
diff --git a/ordo-editor/packages/vue/src/components/step/OrdoDecisionEditor.vue b/ordo-editor/packages/vue/src/components/step/OrdoDecisionEditor.vue
index b6e3ecb7..f771d801 100644
--- a/ordo-editor/packages/vue/src/components/step/OrdoDecisionEditor.vue
+++ b/ordo-editor/packages/vue/src/components/step/OrdoDecisionEditor.vue
@@ -4,12 +4,7 @@
  * 决策步骤编辑器
  */
 import { computed } from 'vue';
-import type {
-  DecisionStep,
-  Branch,
-  Step,
-  SchemaContext,
-} from '@ordo-engine/editor-core';
+import type { DecisionStep, Branch, Step, SchemaContext } from '@ordo-engine/editor-core';
 import { Condition as ConditionFactory, Expr, generateId } from '@ordo-engine/editor-core';
 import OrdoConditionBuilder from '../base/OrdoConditionBuilder.vue';
 import OrdoSmartConditionBuilder from '../base/OrdoSmartConditionBuilder.vue';
diff --git a/ordo-editor/packages/vue/src/components/table/OrdoDecisionTable.vue b/ordo-editor/packages/vue/src/components/table/OrdoDecisionTable.vue
index 3515330b..f0d29eef 100644
--- a/ordo-editor/packages/vue/src/components/table/OrdoDecisionTable.vue
+++ b/ordo-editor/packages/vue/src/components/table/OrdoDecisionTable.vue
@@ -62,7 +62,10 @@ function commitEditCol() {
   const colId = editingColId.value;
   if (!colId) return;
   const field = editingColField.value.trim();
-  if (!field) { editingColId.value = null; return; }
+  if (!field) {
+    editingColId.value = null;
+    return;
+  }
 
   const inputIdx = props.modelValue.inputColumns.findIndex((c) => c.id === colId);
   if (inputIdx !== -1) {
@@ -133,13 +136,17 @@ function evaluateCell(cell: CellValue, actual: unknown): { verdict: TraceVerdict
     case 'exact':
       return {
         verdict: valuesEqual(actual, cell.value),
-        reason: `${formatTraceValue(actual)} ${valuesEqual(actual, cell.value) ? '==' : '!='} ${formatTraceValue(cell.value)}`,
+        reason: `${formatTraceValue(actual)} ${
+          valuesEqual(actual, cell.value) ? '==' : '!='
+        } ${formatTraceValue(cell.value)}`,
       };
     case 'in': {
       const matched = cell.values.some((value) => valuesEqual(actual, value));
       return {
         verdict: matched,
-        reason: `${formatTraceValue(actual)} ${matched ? 'in' : 'not in'} [${cell.values.map(formatTraceValue).join(', ')}]`,
+        reason: `${formatTraceValue(actual)} ${matched ? 'in' : 'not in'} [${cell.values
+          .map(formatTraceValue)
+          .join(', ')}]`,
       };
     }
     case 'range': {
@@ -147,9 +154,11 @@ function evaluateCell(cell: CellValue, actual: unknown): { verdict: TraceVerdict
         return { verdict: false, reason: `${formatTraceValue(actual)} is not a number` };
       }
       const minOk =
-        cell.min === undefined || (cell.minInclusive !== false ? actual >= cell.min : actual > cell.min);
+        cell.min === undefined ||
+        (cell.minInclusive !== false ? actual >= cell.min : actual > cell.min);
       const maxOk =
-        cell.max === undefined || (cell.maxInclusive !== false ? actual <= cell.max : actual < cell.max);
+        cell.max === undefined ||
+        (cell.maxInclusive !== false ? actual <= cell.max : actual < cell.max);
       return {
         verdict: minOk && maxOk,
         reason: `${actual} in ${cellValueToString(cell)}`,
@@ -187,19 +196,23 @@ const traceRowState = computed(() => {
   });
 });
 
-const traceActiveRowId = computed(() => traceRowState.value.find((row) => row.matched)?.rowId ?? null);
+const traceActiveRowId = computed(
+  () => traceRowState.value.find((row) => row.matched)?.rowId ?? null
+);
 
 function traceCellState(rowId: string, columnId: string): TraceVerdict {
   return (
-    traceRowState.value.find((row) => row.rowId === rowId)?.cellChecks.find((cell) => cell.columnId === columnId)
-      ?.verdict ?? null
+    traceRowState.value
+      .find((row) => row.rowId === rowId)
+      ?.cellChecks.find((cell) => cell.columnId === columnId)?.verdict ?? null
   );
 }
 
 function traceCellReason(rowId: string, columnId: string): string {
   return (
-    traceRowState.value.find((row) => row.rowId === rowId)?.cellChecks.find((cell) => cell.columnId === columnId)
-      ?.reason ?? ''
+    traceRowState.value
+      .find((row) => row.rowId === rowId)
+      ?.cellChecks.find((cell) => cell.columnId === columnId)?.reason ?? ''
   );
 }
 
@@ -531,18 +544,27 @@ function cellTypeClass(cell: CellValue): string {
             <th
               v-if="hasTrace"
               class="ordo-decision-table__group-th ordo-decision-table__group-th--trace"
-            >{{ t('table.traceStatus') }}</th>
+            >
+              {{ t('table.traceStatus') }}
+            </th>
             <th
               v-if="modelValue.inputColumns.length > 0"
               :colspan="modelValue.inputColumns.length"
               class="ordo-decision-table__group-th ordo-decision-table__group-th--input"
-            >{{ t('table.groupInput') }}</th>
+            >
+              {{ t('table.groupInput') }}
+            </th>
             <th
               v-if="modelValue.outputColumns.length > 0"
               :colspan="modelValue.outputColumns.length"
               class="ordo-decision-table__group-th ordo-decision-table__group-th--output"
-            >{{ t('table.groupOutput') }}</th>
-            <th colspan="2" class="ordo-decision-table__group-th ordo-decision-table__group-th--result">
+            >
+              {{ t('table.groupOutput') }}
+            </th>
+            <th
+              colspan="2"
+              class="ordo-decision-table__group-th ordo-decision-table__group-th--result"
+            >
               {{ t('table.groupResult') }}
             </th>
             <th v-if="!disabled" class="ordo-decision-table__group-spacer"></th>
@@ -585,7 +607,10 @@ function cellTypeClass(cell: CellValue): string {
                   </svg>
                 </button>
               </div>
-              <div class="ordo-decision-table__col-path" @click="startEditCol(col.id, col.fieldPath)">
+              <div
+                class="ordo-decision-table__col-path"
+                @click="startEditCol(col.id, col.fieldPath)"
+              >
                 <input
                   v-if="editingColId === col.id"
                   class="ordo-decision-table__col-input"
@@ -633,7 +658,10 @@ function cellTypeClass(cell: CellValue): string {
                   </svg>
                 </button>
               </div>
-              <div class="ordo-decision-table__col-path" @click="startEditCol(col.id, col.fieldName)">
+              <div
+                class="ordo-decision-table__col-path"
+                @click="startEditCol(col.id, col.fieldName)"
+              >
                 <input
                   v-if="editingColId === col.id"
                   class="ordo-decision-table__col-input"
@@ -649,7 +677,9 @@ function cellTypeClass(cell: CellValue): string {
             </th>
 
             <!-- Result columns -->
-            <th class="ordo-decision-table__th ordo-decision-table__th--result col-group-start--result">
+            <th
+              class="ordo-decision-table__th ordo-decision-table__th--result col-group-start--result"
+            >
               <div class="ordo-decision-table__col-header">
                 <span class="ordo-decision-table__col-badge ordo-decision-table__col-badge--result"
                   >CODE</span
@@ -685,7 +715,9 @@ function cellTypeClass(cell: CellValue): string {
               :key="`trace-input-${col.id}`"
               class="ordo-decision-table__th ordo-decision-table__th--input"
             >
-              <div class="ordo-decision-table__trace-actual ordo-decision-table__trace-actual--neutral">
+              <div
+                class="ordo-decision-table__trace-actual ordo-decision-table__trace-actual--neutral"
+              >
                 {{ formatTraceValue(traceCellActual(col)) }}
               </div>
             </th>
@@ -695,12 +727,18 @@ function cellTypeClass(cell: CellValue): string {
               class="ordo-decision-table__th ordo-decision-table__th--output"
               :class="{ 'col-group-start--output': index === 0 }"
             >
-              <div class="ordo-decision-table__trace-actual ordo-decision-table__trace-actual--neutral">
+              <div
+                class="ordo-decision-table__trace-actual ordo-decision-table__trace-actual--neutral"
+              >
                 {{ formatTraceValue(traceOutputValue(col.fieldName)) }}
               </div>
             </th>
-            <th class="ordo-decision-table__th ordo-decision-table__th--result col-group-start--result">
-              <div class="ordo-decision-table__trace-actual ordo-decision-table__trace-actual--neutral">
+            <th
+              class="ordo-decision-table__th ordo-decision-table__th--result col-group-start--result"
+            >
+              <div
+                class="ordo-decision-table__trace-actual ordo-decision-table__trace-actual--neutral"
+              >
                 {{ formatTraceValue(traceResultCode) }}
               </div>
             </th>
@@ -710,7 +748,10 @@ function cellTypeClass(cell: CellValue): string {
 
         <tbody>
           <tr v-if="!hasRows">
-            <td :colspan="allColumns.length + (hasTrace ? 5 : 4)" class="ordo-decision-table__empty-row">
+            <td
+              :colspan="allColumns.length + (hasTrace ? 5 : 4)"
+              class="ordo-decision-table__empty-row"
+            >
               {{ t('table.noRows') }}
             </td>
           </tr>
@@ -824,7 +865,9 @@ function cellTypeClass(cell: CellValue): string {
             </td>
 
             <!-- Result Code -->
-            <td class="ordo-decision-table__td ordo-decision-table__td--result col-group-start--result">
+            <td
+              class="ordo-decision-table__td ordo-decision-table__td--result col-group-start--result"
+            >
               <input
                 :value="row.resultCode || ''"
                 class="ordo-decision-table__inline-input"