diff --git a/src-tauri/src/dap.rs b/src-tauri/src/dap.rs
index e8543071..46ce5a10 100644
--- a/src-tauri/src/dap.rs
+++ b/src-tauri/src/dap.rs
@@ -202,6 +202,93 @@ pub fn dap_stop(state: State<'_, DapState>, session: String) -> Result<(), Strin
     Ok(())
 }
 
+/// 为调试构建编译型语言，返回可执行文件路径。
+/// Rust: cargo build → target/debug/<package>；C/C++: 用 cc/c++ -g 编译到临时文件。
+#[tauri::command]
+pub async fn dap_build(
+    language: String,
+    file_path: String,
+    root: String,
+) -> Result<String, String> {
+    tokio::task::spawn_blocking(move || match language.as_str() {
+        "rust" => build_rust(&root),
+        "c" => build_cc("cc", &file_path),
+        "cpp" => build_cc("c++", &file_path),
+        _ => Err(format!("{} 暂不支持编译调试", language)),
+    })
+    .await
+    .map_err(|e| format!("构建任务失败: {}", e))?
+}
+
+fn build_rust(root: &str) -> Result<String, String> {
+    let exe =
+        find_in_path("cargo").ok_or_else(|| "未找到 cargo（请安装 Rust 工具链）".to_string())?;
+    let out = Command::new(&exe)
+        .args(["build"])
+        .current_dir(root)
+        .env("PATH", augmented_path())
+        .output()
+        .map_err(|e| format!("执行 cargo 失败: {}", e))?;
+    if !out.status.success() {
+        return Err(format!(
+            "cargo build 失败:\n{}",
+            String::from_utf8_lossy(&out.stderr)
+        ));
+    }
+    // 解析 Cargo.toml 的 package name
+    let toml = std::fs::read_to_string(std::path::Path::new(root).join("Cargo.toml"))
+        .map_err(|e| format!("读取 Cargo.toml 失败: {}", e))?;
+    let mut name = String::new();
+    for line in toml.lines() {
+        let l = line.trim();
+        if let Some(rest) = l.strip_prefix("name") {
+            if let Some(v) = rest.trim_start_matches(['=', ' ']).strip_prefix('"') {
+                if let Some(end) = v.find('"') {
+                    name = v[..end].to_string();
+                    break;
+                }
+            }
+        }
+    }
+    if name.is_empty() {
+        return Err("无法从 Cargo.toml 解析 package name".to_string());
+    }
+    let mut bin = std::path::Path::new(root).join("target/debug").join(&name);
+    if cfg!(windows) {
+        bin.set_extension("exe");
+    }
+    if !bin.is_file() {
+        return Err(format!("未找到可执行文件: {}", bin.display()));
+    }
+    Ok(bin.to_string_lossy().to_string())
+}
+
+fn build_cc(compiler: &str, file_path: &str) -> Result<String, String> {
+    let exe =
+        find_in_path(compiler).ok_or_else(|| format!("未找到编译器 {}（请安装）", compiler))?;
+    let stamp = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_nanos())
+        .unwrap_or(0);
+    let mut out_path = std::env::temp_dir().join(format!("codeforge-dbg-{}", stamp));
+    if cfg!(windows) {
+        out_path.set_extension("exe");
+    }
+    let out_str = out_path.to_string_lossy().to_string();
+    let result = Command::new(&exe)
+        .args(["-g", "-O0", "-o", &out_str, file_path])
+        .env("PATH", augmented_path())
+        .output()
+        .map_err(|e| format!("执行 {} 失败: {}", compiler, e))?;
+    if !result.status.success() {
+        return Err(format!(
+            "编译失败:\n{}",
+            String::from_utf8_lossy(&result.stderr)
+        ));
+    }
+    Ok(out_str)
+}
+
 // 可安装的调试适配器：(id, 展示名, 安装命令)
 fn adapter_defs() -> Vec<(&'static str, &'static str, &'static str)> {
     vec![
@@ -215,6 +302,7 @@ fn adapter_defs() -> Vec<(&'static str, &'static str, &'static str)> {
             "Go (delve)",
             "go install github.com/go-delve/delve/cmd/dlv@latest",
         ),
+        ("lldb-dap", "Rust / C / C++ (lldb-dap)", "brew install llvm"),
     ]
 }
 
@@ -223,6 +311,12 @@ fn adapter_installed(id: &str) -> bool {
         // debugpy 校验模块可导入
         "debugpy" => dap_available("python".to_string()),
         "delve" => find_in_path("dlv").is_some(),
+        // lldb-dap 随 LLVM 提供，brew 的 llvm 是 keg-only 不在 PATH，额外探测常见路径
+        "lldb-dap" => {
+            find_in_path("lldb-dap").is_some()
+                || std::path::Path::new("/opt/homebrew/opt/llvm/bin/lldb-dap").is_file()
+                || std::path::Path::new("/usr/local/opt/llvm/bin/lldb-dap").is_file()
+        }
         _ => false,
     }
 }
diff --git a/src-tauri/src/db/duckdb.rs b/src-tauri/src/db/duckdb.rs
index 27798a77..29f0a650 100644
--- a/src-tauri/src/db/duckdb.rs
+++ b/src-tauri/src/db/duckdb.rs
@@ -1,9 +1,84 @@
-use super::{DataSource, DbExecutor, SqlResultSet, SqlRunResult, split_sql};
+use super::{DataSource, DbExecutor, SqlResultSet, SqlRunResult, TxnConn, split_sql};
 use duckdb::Connection;
 use serde_json::Value as JsonValue;
 
 pub(crate) struct DuckdbExecutor;
 
+fn open_conn(source: &DataSource) -> Result<Connection, String> {
+    let conn = match source.file.as_deref() {
+        Some(p) if !p.trim().is_empty() => Connection::open(p),
+        _ => Connection::open_in_memory(),
+    };
+    conn.map_err(|e| format!("打开 DuckDB 失败: {}", e))
+}
+
+/// 在已有连接上执行脚本（run 与事务会话共用）
+fn run_on_conn(conn: &Connection, sql: &str) -> SqlRunResult {
+    let mut result = SqlRunResult::new();
+    'stmts: for stmt_sql in split_sql(sql) {
+        let mut stmt = match conn.prepare(&stmt_sql) {
+            Ok(s) => s,
+            Err(e) => {
+                result.error = Some(e.to_string());
+                break 'stmts;
+            }
+        };
+        let ncol = stmt.column_count();
+        if ncol > 0 {
+            let columns: Vec<String> = stmt.column_names().iter().map(|s| s.to_string()).collect();
+            let rows_iter = stmt.query_map([], |row| {
+                let mut v = Vec::with_capacity(ncol);
+                for idx in 0..ncol {
+                    v.push(value_to_json(row.get(idx)?));
+                }
+                Ok(v)
+            });
+            match rows_iter {
+                Ok(it) => {
+                    let mut rows = Vec::new();
+                    for r in it {
+                        match r {
+                            Ok(rw) => rows.push(rw),
+                            Err(e) => {
+                                result.error = Some(e.to_string());
+                                break 'stmts;
+                            }
+                        }
+                    }
+                    result.result_sets.push(SqlResultSet { columns, rows });
+                }
+                Err(e) => {
+                    result.error = Some(e.to_string());
+                    break 'stmts;
+                }
+            }
+        } else {
+            match stmt.execute([]) {
+                Ok(affected) => result.messages.push(format!("OK，影响 {} 行", affected)),
+                Err(e) => {
+                    result.error = Some(e.to_string());
+                    break 'stmts;
+                }
+            }
+        }
+    }
+    result
+}
+
+struct DuckdbTxn {
+    conn: Connection,
+}
+impl TxnConn for DuckdbTxn {
+    fn exec(&mut self, sql: &str) -> SqlRunResult {
+        run_on_conn(&self.conn, sql)
+    }
+    fn finish(&mut self, commit: bool) -> Result<(), String> {
+        self.conn
+            .execute_batch(if commit { "COMMIT" } else { "ROLLBACK" })
+            .map_err(|e| e.to_string())
+    }
+}
+
 fn value_to_json(v: duckdb::types::Value) -> JsonValue {
     use duckdb::types::Value::*;
     match v {
@@ -33,67 +108,20 @@ impl DbExecutor for DuckdbExecutor {
     }
 
     fn run(&self, sql: &str, source: &DataSource) -> SqlRunResult {
-        let mut result = SqlRunResult::new();
-        let conn = match source.file.as_deref() {
-            Some(p) if !p.trim().is_empty() => Connection::open(p),
-            _ => Connection::open_in_memory(),
-        };
-        let conn = match conn {
-            Ok(c) => c,
+        match open_conn(source) {
+            Ok(conn) => run_on_conn(&conn, sql),
             Err(e) => {
-                result.error = Some(format!("打开 DuckDB 失败: {}", e));
-                return result;
-            }
-        };
-
-        'stmts: for stmt_sql in split_sql(sql) {
-            let mut stmt = match conn.prepare(&stmt_sql) {
-                Ok(s) => s,
-                Err(e) => {
-                    result.error = Some(e.to_string());
-                    break 'stmts;
-                }
-            };
-            let ncol = stmt.column_count();
-            if ncol > 0 {
-                let columns: Vec<String> =
-                    stmt.column_names().iter().map(|s| s.to_string()).collect();
-                let rows_iter = stmt.query_map([], |row| {
-                    let mut v = Vec::with_capacity(ncol);
-                    for idx in 0..ncol {
-                        v.push(value_to_json(row.get(idx)?));
-                    }
-                    Ok(v)
-                });
-                match rows_iter {
-                    Ok(it) => {
-                        let mut rows = Vec::new();
-                        for r in it {
-                            match r {
-                                Ok(rw) => rows.push(rw),
-                                Err(e) => {
-                                    result.error = Some(e.to_string());
-                                    break 'stmts;
-                                }
-                            }
-                        }
-                        result.result_sets.push(SqlResultSet { columns, rows });
-                    }
-                    Err(e) => {
-                        result.error = Some(e.to_string());
-                        break 'stmts;
-                    }
-                }
-            } else {
-                match stmt.execute([]) {
-                    Ok(affected) => result.messages.push(format!("OK，影响 {} 行", affected)),
-                    Err(e) => {
-                        result.error = Some(e.to_string());
-                        break 'stmts;
-                    }
-                }
+                let mut result = SqlRunResult::new();
+                result.error = Some(e);
+                result
             }
         }
-        result
+    }
+
+    fn begin(&self, source: &DataSource) -> Result<Box<dyn TxnConn>, String> {
+        let conn = open_conn(source)?;
+        conn.execute_batch("BEGIN TRANSACTION")
+            .map_err(|e| format!("开启事务失败: {}", e))?;
+        Ok(Box::new(DuckdbTxn { conn }))
     }
 }
diff --git a/src-tauri/src/db/mod.rs b/src-tauri/src/db/mod.rs
index adbb2735..d1108fe2 100644
--- a/src-tauri/src/db/mod.rs
+++ b/src-tauri/src/db/mod.rs
@@ -118,12 +118,103 @@ pub(crate) fn resolve_endpoint(source: &DataSource, default_port: u16) -> Result
     }
 }
 
+/// 交互式事务会话：持有一条连接，跨多次调用在同一连接上执行。
+pub(crate) trait TxnConn: Send {
+    /// 在持有连接上执行 SQL（错误写入 result.error）
+    fn exec(&mut self, sql: &str) -> SqlRunResult;
+    /// 结束事务：commit=true 提交，否则回滚
+    fn finish(&mut self, commit: bool) -> Result<(), String>;
+}
+
 /// 数据库执行器接口：新增数据库类型只需实现本 trait 并在 executors() 注册。
 pub(crate) trait DbExecutor: Send + Sync {
     /// 是否处理该数据源类型（如 sqlite 同时处理 "sqlite" 与 "memory"）
     fn handles(&self, kind: &str) -> bool;
     /// 执行脚本，返回结构化结果（错误写入 result.error，不以 Err 形式返回）
     fn run(&self, sql: &str, source: &DataSource) -> SqlRunResult;
+    /// 开启交互式事务，返回持有连接的会话；不支持事务的执行器返回 Err。
+    fn begin(&self, _source: &DataSource) -> Result<Box<dyn TxnConn>, String> {
+        Err("该数据源暂不支持交互式事务".to_string())
+    }
+}
+
+/// 全局事务状态：同一时刻仅允许一个进行中的交互式事务（一个编辑器一个事务）。
+pub struct TxnState(pub std::sync::Arc<std::sync::Mutex<Option<Box<dyn TxnConn>>>>);
+
+impl TxnState {
+    pub fn new() -> Self {
+        Self(std::sync::Arc::new(std::sync::Mutex::new(None)))
+    }
+}
+
+impl Default for TxnState {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// 开启事务（已有进行中的事务会先回滚丢弃）。
+#[tauri::command]
+pub async fn tx_begin(source: DataSource, state: tauri::State<'_, TxnState>) -> Result<(), String> {
+    let slot = state.0.clone();
+    tokio::task::spawn_blocking(move || {
+        let execs = executors();
+        let exec = execs
+            .iter()
+            .find(|e| e.handles(&source.kind))
+            .ok_or_else(|| format!("不支持的数据源类型: {}", source.kind))?;
+        let conn = exec.begin(&source)?;
+        let mut guard = slot.lock().map_err(|e| e.to_string())?;
+        if let Some(mut old) = guard.take() {
+            let _ = old.finish(false);
+        }
+        *guard = Some(conn);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("事务任务失败: {}", e))?
+}
+
+/// 在进行中的事务上执行 SQL。
+#[tauri::command]
+pub async fn tx_exec(
+    sql: String,
+    state: tauri::State<'_, TxnState>,
+) -> Result<SqlRunResult, String> {
+    let slot = state.0.clone();
+    tokio::task::spawn_blocking(move || {
+        let mut guard = slot.lock().map_err(|e| e.to_string())?;
+        let conn = guard
+            .as_mut()
+            .ok_or_else(|| "没有进行中的事务".to_string())?;
+        Ok(conn.exec(&sql))
+    })
+    .await
+    .map_err(|e| format!("事务任务失败: {}", e))?
+}
+
+/// 结束事务：commit=true 提交，否则回滚。
+#[tauri::command]
+pub async fn tx_finish(commit: bool, state: tauri::State<'_, TxnState>) -> Result<(), String> {
+    let slot = state.0.clone();
+    tokio::task::spawn_blocking(move || {
+        let mut guard = slot.lock().map_err(|e| e.to_string())?;
+        match guard.take() {
+            Some(mut conn) => conn.finish(commit),
+            None => Err("没有进行中的事务".to_string()),
+        }
+    })
+    .await
+    .map_err(|e| format!("事务任务失败: {}", e))?
+}
+
+/// 是否有进行中的事务。
+#[tauri::command]
+pub async fn tx_active(state: tauri::State<'_, TxnState>) -> Result<bool, String> {
+    let slot = state.0.clone();
+    tokio::task::spawn_blocking(move || Ok(slot.lock().map(|g| g.is_some()).unwrap_or(false)))
+        .await
+        .map_err(|e| format!("事务任务失败: {}", e))?
 }
 
 /// 已注册的执行器。新增数据库类型：在此加一行。
diff --git a/src-tauri/src/db/mysql.rs b/src-tauri/src/db/mysql.rs
index 29d61e9d..af463544 100644
--- a/src-tauri/src/db/mysql.rs
+++ b/src-tauri/src/db/mysql.rs
@@ -1,8 +1,88 @@
-use super::{DataSource, DbExecutor, SqlResultSet, SqlRunResult, resolve_endpoint, split_sql};
+use super::{
+    DataSource, DbExecutor, Endpoint, SqlResultSet, SqlRunResult, TxnConn, resolve_endpoint,
+    split_sql,
+};
 use serde_json::Value as JsonValue;
 
 pub(crate) struct MysqlExecutor;
 
+// 建连并返回连接 + 端点（端点持有 SSH 隧道，须随连接一起存活）
+fn connect(source: &DataSource) -> Result<(mysql::Conn, Endpoint), String> {
+    let endpoint = resolve_endpoint(source, 3306)?;
+    let mut builder = mysql::OptsBuilder::new()
+        .ip_or_hostname(Some(endpoint.host.clone()))
+        .tcp_port(endpoint.port)
+        .user(source.user.clone())
+        .pass(source.password.clone())
+        .db_name(source.database.clone());
+    if source.ssl.unwrap_or(false) {
+        builder = builder.ssl_opts(Some(
+            mysql::SslOpts::default()
+                .with_danger_accept_invalid_certs(true)
+                .with_danger_skip_domain_validation(true),
+        ));
+    }
+    let conn = mysql::Conn::new(builder).map_err(|e| format!("连接 MySQL 失败: {}", e))?;
+    Ok((conn, endpoint))
+}
+
+/// 在已有连接上执行脚本（run 与事务会话共用）
+fn run_on_conn(conn: &mut mysql::Conn, sql: &str) -> SqlRunResult {
+    use mysql::prelude::Queryable;
+    let mut result = SqlRunResult::new();
+    'stmts: for stmt_sql in split_sql(sql) {
+        let mut qr = match conn.query_iter(&stmt_sql) {
+            Ok(q) => q,
+            Err(e) => {
+                result.error = Some(e.to_string());
+                break 'stmts;
+            }
+        };
+        let columns: Vec<String> = qr
+            .columns()
+            .as_ref()
+            .iter()
+            .map(|c| c.name_str().to_string())
+            .collect();
+        if columns.is_empty() {
+            let affected = qr.affected_rows();
+            result.messages.push(format!("OK，影响 {} 行", affected));
+        } else {
+            let mut rows = Vec::new();
+            for r in qr.by_ref() {
+                match r {
+                    Ok(row) => {
+                        let vals = row.unwrap();
+                        rows.push(vals.iter().map(value_to_json).collect());
+                    }
+                    Err(e) => {
+                        result.error = Some(e.to_string());
+                        break 'stmts;
+                    }
+                }
+            }
+            result.result_sets.push(SqlResultSet { columns, rows });
+        }
+    }
+    result
+}
+
+struct MysqlTxn {
+    conn: mysql::Conn,
+    _endpoint: Endpoint,
+}
+impl TxnConn for MysqlTxn {
+    fn exec(&mut self, sql: &str) -> SqlRunResult {
+        run_on_conn(&mut self.conn, sql)
+    }
+    fn finish(&mut self, commit: bool) -> Result<(), String> {
+        use mysql::prelude::Queryable;
+        self.conn
+            .query_drop(if commit { "COMMIT" } else { "ROLLBACK" })
+            .map_err(|e| e.to_string())
+    }
+}
+
 fn value_to_json(v: &mysql::Value) -> JsonValue {
     use mysql::Value::*;
     match v {
@@ -36,76 +116,25 @@ impl DbExecutor for MysqlExecutor {
     }
 
     fn run(&self, sql: &str, source: &DataSource) -> SqlRunResult {
-        use mysql::prelude::Queryable;
-        let mut result = SqlRunResult::new();
-
-        // 解析端点：启用 SSH 时隧道转发到本地端口（隧道随 endpoint 在本函数结束时关闭）
-        let endpoint = match resolve_endpoint(source, 3306) {
-            Ok(e) => e,
+        match connect(source) {
+            // endpoint 持有隧道，run 期间保持存活
+            Ok((mut conn, _endpoint)) => run_on_conn(&mut conn, sql),
             Err(e) => {
+                let mut result = SqlRunResult::new();
                 result.error = Some(e);
-                return result;
+                result
             }
-        };
-
-        let mut builder = mysql::OptsBuilder::new()
-            .ip_or_hostname(Some(endpoint.host.clone()))
-            .tcp_port(endpoint.port)
-            .user(source.user.clone())
-            .pass(source.password.clone())
-            .db_name(source.database.clone());
-
-        // 启用 SSL：rustls 加密连接（开发场景放宽证书校验）
-        if source.ssl.unwrap_or(false) {
-            builder = builder.ssl_opts(Some(
-                mysql::SslOpts::default()
-                    .with_danger_accept_invalid_certs(true)
-                    .with_danger_skip_domain_validation(true),
-            ));
         }
+    }
 
-        let mut conn = match mysql::Conn::new(builder) {
-            Ok(c) => c,
-            Err(e) => {
-                result.error = Some(format!("连接 MySQL 失败: {}", e));
-                return result;
-            }
-        };
-
-        'stmts: for stmt_sql in split_sql(sql) {
-            let mut qr = match conn.query_iter(&stmt_sql) {
-                Ok(q) => q,
-                Err(e) => {
-                    result.error = Some(e.to_string());
-                    break 'stmts;
-                }
-            };
-            let columns: Vec<String> = qr
-                .columns()
-                .as_ref()
-                .iter()
-                .map(|c| c.name_str().to_string())
-                .collect();
-            if columns.is_empty() {
-                let affected = qr.affected_rows();
-                result.messages.push(format!("OK，影响 {} 行", affected));
-            } else {
-                let mut rows = Vec::new();
-                for r in qr.by_ref() {
-                    match r {
-                        Ok(row) => {
-                            let vals = row.unwrap();
-                            rows.push(vals.iter().map(value_to_json).collect());
-                        }
-                        Err(e) => {
-                            result.error = Some(e.to_string());
-                            break 'stmts;
-                        }
-                    }
-                }
-                result.result_sets.push(SqlResultSet { columns, rows });
-            }
-        }
-        result
+    fn begin(&self, source: &DataSource) -> Result<Box<dyn TxnConn>, String> {
+        use mysql::prelude::Queryable;
+        let (mut conn, endpoint) = connect(source)?;
+        conn.query_drop("START TRANSACTION")
+            .map_err(|e| format!("开启事务失败: {}", e))?;
+        Ok(Box::new(MysqlTxn {
+            conn,
+            _endpoint: endpoint,
+        }))
     }
 }
diff --git a/src-tauri/src/db/postgres.rs b/src-tauri/src/db/postgres.rs
index 91d54974..56717b79 100644
--- a/src-tauri/src/db/postgres.rs
+++ b/src-tauri/src/db/postgres.rs
@@ -1,89 +1,61 @@
-use super::{DataSource, DbExecutor, SqlResultSet, SqlRunResult, resolve_endpoint};
+use super::{
+    DataSource, DbExecutor, Endpoint, SqlResultSet, SqlRunResult, TxnConn, resolve_endpoint,
+};
 use postgres::config::SslMode;
-use postgres::{Config, NoTls, SimpleQueryMessage};
+use postgres::{Client, Config, NoTls, SimpleQueryMessage};
 use serde_json::Value as JsonValue;
 
 pub(crate) struct PostgresExecutor;
 
-impl DbExecutor for PostgresExecutor {
-    fn handles(&self, kind: &str) -> bool {
-        kind == "postgres" || kind == "postgresql"
+// 建连并返回客户端 + 端点（端点持有 SSH 隧道，须随客户端一起存活）
+fn connect(source: &DataSource) -> Result<(Client, Endpoint), String> {
+    let endpoint = resolve_endpoint(source, 5432)?;
+    let use_ssl = source.ssl.unwrap_or(false);
+    let mut cfg = Config::new();
+    cfg.host(&endpoint.host)
+        .port(endpoint.port)
+        .user(source.user.as_deref().unwrap_or("postgres"))
+        .ssl_mode(if use_ssl {
+            SslMode::Require
+        } else {
+            SslMode::Disable
+        });
+    if let Some(pwd) = source.password.as_deref() {
+        cfg.password(pwd);
     }
+    if let Some(db) = source.database.as_deref() {
+        cfg.dbname(db);
+    }
+    let client = if use_ssl {
+        let connector = native_tls::TlsConnector::builder()
+            .danger_accept_invalid_certs(true)
+            .danger_accept_invalid_hostnames(true)
+            .build()
+            .map_err(|e| format!("初始化 TLS 失败: {}", e))?;
+        let tls = postgres_native_tls::MakeTlsConnector::new(connector);
+        cfg.connect(tls)
+            .map_err(|e| format!("连接 PostgreSQL 失败: {}", e))?
+    } else {
+        cfg.connect(NoTls)
+            .map_err(|e| format!("连接 PostgreSQL 失败: {}", e))?
+    };
+    Ok((client, endpoint))
+}
 
-    fn run(&self, sql: &str, source: &DataSource) -> SqlRunResult {
-        let mut result = SqlRunResult::new();
-
-        // 解析端点：启用 SSH 时隧道转发到本地端口（隧道随 endpoint 在本函数结束时关闭）
-        let endpoint = match resolve_endpoint(source, 5432) {
-            Ok(e) => e,
-            Err(e) => {
-                result.error = Some(e);
-                return result;
-            }
-        };
-
-        let use_ssl = source.ssl.unwrap_or(false);
-        let mut cfg = Config::new();
-        cfg.host(&endpoint.host)
-            .port(endpoint.port)
-            .user(source.user.as_deref().unwrap_or("postgres"))
-            .ssl_mode(if use_ssl {
-                SslMode::Require
-            } else {
-                SslMode::Disable
-            });
-        if let Some(pwd) = source.password.as_deref() {
-            cfg.password(pwd);
+/// 在已有客户端上执行脚本（run 与事务会话共用）。simple_query 一次执行整段，按消息流切分结果集。
+fn run_on_client(client: &mut Client, sql: &str) -> SqlRunResult {
+    let mut result = SqlRunResult::new();
+    let messages = match client.simple_query(sql) {
+        Ok(m) => m,
+        Err(e) => {
+            result.error = Some(e.to_string());
+            return result;
         }
-        if let Some(db) = source.database.as_deref() {
-            cfg.dbname(db);
-        }
-
-        // 启用 SSL：native-tls 加密连接（开发场景放宽证书校验）；否则 NoTls 明文
-        let mut client = if use_ssl {
-            let connector = match native_tls::TlsConnector::builder()
-                .danger_accept_invalid_certs(true)
-                .danger_accept_invalid_hostnames(true)
-                .build()
-            {
-                Ok(c) => c,
-                Err(e) => {
-                    result.error = Some(format!("初始化 TLS 失败: {}", e));
-                    return result;
-                }
-            };
-            let tls = postgres_native_tls::MakeTlsConnector::new(connector);
-            match cfg.connect(tls) {
-                Ok(c) => c,
-                Err(e) => {
-                    result.error = Some(format!("连接 PostgreSQL 失败: {}", e));
-                    return result;
-                }
-            }
-        } else {
-            match cfg.connect(NoTls) {
-                Ok(c) => c,
-                Err(e) => {
-                    result.error = Some(format!("连接 PostgreSQL 失败: {}", e));
-                    return result;
-                }
-            }
-        };
-
-        // simple_query 一次执行整段脚本，按消息流切分结果集与影响行数
-        let messages = match client.simple_query(sql) {
-            Ok(m) => m,
-            Err(e) => {
-                result.error = Some(e.to_string());
-                return result;
-            }
-        };
-
-        let mut columns: Vec<String> = Vec::new();
-        let mut rows: Vec<Vec<JsonValue>> = Vec::new();
-        let flush = |columns: &mut Vec<String>,
-                     rows: &mut Vec<Vec<JsonValue>>,
-                     result: &mut SqlRunResult| {
+    };
+    let mut columns: Vec<String> = Vec::new();
+    let mut rows: Vec<Vec<JsonValue>> = Vec::new();
+    let flush =
+        |columns: &mut Vec<String>, rows: &mut Vec<Vec<JsonValue>>, result: &mut SqlRunResult| {
             if !columns.is_empty() {
                 result.result_sets.push(SqlResultSet {
                     columns: std::mem::take(columns),
@@ -91,32 +63,74 @@ impl DbExecutor for PostgresExecutor {
                 });
             }
         };
-
-        for msg in messages {
-            match msg {
-                SimpleQueryMessage::Row(row) => {
-                    if columns.is_empty() {
-                        columns = row.columns().iter().map(|c| c.name().to_string()).collect();
-                    }
-                    let vals = (0..row.len())
-                        .map(|i| match row.get(i) {
-                            Some(s) => JsonValue::from(s.to_string()),
-                            None => JsonValue::Null,
-                        })
-                        .collect();
-                    rows.push(vals);
+    for msg in messages {
+        match msg {
+            SimpleQueryMessage::Row(row) => {
+                if columns.is_empty() {
+                    columns = row.columns().iter().map(|c| c.name().to_string()).collect();
                 }
-                SimpleQueryMessage::CommandComplete(n) => {
-                    if columns.is_empty() {
-                        result.messages.push(format!("OK，影响 {} 行", n));
-                    } else {
-                        flush(&mut columns, &mut rows, &mut result);
-                    }
+                let vals = (0..row.len())
+                    .map(|i| match row.get(i) {
+                        Some(s) => JsonValue::from(s.to_string()),
+                        None => JsonValue::Null,
+                    })
+                    .collect();
+                rows.push(vals);
+            }
+            SimpleQueryMessage::CommandComplete(n) => {
+                if columns.is_empty() {
+                    result.messages.push(format!("OK，影响 {} 行", n));
+                } else {
+                    flush(&mut columns, &mut rows, &mut result);
                 }
-                _ => {}
+            }
+            _ => {}
+        }
+    }
+    flush(&mut columns, &mut rows, &mut result);
+    result
+}
+
+struct PostgresTxn {
+    client: Client,
+    _endpoint: Endpoint,
+}
+impl TxnConn for PostgresTxn {
+    fn exec(&mut self, sql: &str) -> SqlRunResult {
+        run_on_client(&mut self.client, sql)
+    }
+    fn finish(&mut self, commit: bool) -> Result<(), String> {
+        self.client
+            .simple_query(if commit { "COMMIT" } else { "ROLLBACK" })
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+    }
+}
+
+impl DbExecutor for PostgresExecutor {
+    fn handles(&self, kind: &str) -> bool {
+        kind == "postgres" || kind == "postgresql"
+    }
+
+    fn run(&self, sql: &str, source: &DataSource) -> SqlRunResult {
+        match connect(source) {
+            Ok((mut client, _endpoint)) => run_on_client(&mut client, sql),
+            Err(e) => {
+                let mut result = SqlRunResult::new();
+                result.error = Some(e);
+                result
             }
         }
-        flush(&mut columns, &mut rows, &mut result);
-        result
+    }
+
+    fn begin(&self, source: &DataSource) -> Result<Box<dyn TxnConn>, String> {
+        let (mut client, endpoint) = connect(source)?;
+        client
+            .simple_query("BEGIN")
+            .map_err(|e| format!("开启事务失败: {}", e))?;
+        Ok(Box::new(PostgresTxn {
+            client,
+            _endpoint: endpoint,
+        }))
     }
 }
diff --git a/src-tauri/src/db/sqlite.rs b/src-tauri/src/db/sqlite.rs
index 9c563a5e..05ed25fc 100644
--- a/src-tauri/src/db/sqlite.rs
+++ b/src-tauri/src/db/sqlite.rs
@@ -1,9 +1,84 @@
-use super::{DataSource, DbExecutor, SqlResultSet, SqlRunResult, split_sql};
+use super::{DataSource, DbExecutor, SqlResultSet, SqlRunResult, TxnConn, split_sql};
 use rusqlite::Connection;
 use serde_json::Value as JsonValue;
 
 pub(crate) struct SqliteExecutor;
 
+fn open_conn(source: &DataSource) -> Result<Connection, String> {
+    let conn = match source.file.as_deref() {
+        Some(p) if !p.trim().is_empty() => Connection::open(p),
+        _ => Connection::open_in_memory(),
+    };
+    conn.map_err(|e| format!("打开数据库失败: {}", e))
+}
+
+/// 在已有连接上执行脚本（run 与事务会话共用）
+fn run_on_conn(conn: &Connection, sql: &str) -> SqlRunResult {
+    let mut result = SqlRunResult::new();
+    'stmts: for stmt_sql in split_sql(sql) {
+        let mut stmt = match conn.prepare(&stmt_sql) {
+            Ok(s) => s,
+            Err(e) => {
+                result.error = Some(e.to_string());
+                break 'stmts;
+            }
+        };
+        let ncol = stmt.column_count();
+        if ncol > 0 {
+            let columns: Vec<String> = stmt.column_names().iter().map(|s| s.to_string()).collect();
+            let rows_iter = stmt.query_map([], |row| {
+                let mut v = Vec::with_capacity(ncol);
+                for idx in 0..ncol {
+                    v.push(value_to_json(row.get(idx)?));
+                }
+                Ok(v)
+            });
+            match rows_iter {
+                Ok(it) => {
+                    let mut rows = Vec::new();
+                    for r in it {
+                        match r {
+                            Ok(rw) => rows.push(rw),
+                            Err(e) => {
+                                result.error = Some(e.to_string());
+                                break 'stmts;
+                            }
+                        }
+                    }
+                    result.result_sets.push(SqlResultSet { columns, rows });
+                }
+                Err(e) => {
+                    result.error = Some(e.to_string());
+                    break 'stmts;
+                }
+            }
+        } else {
+            match stmt.execute([]) {
+                Ok(affected) => result.messages.push(format!("OK，影响 {} 行", affected)),
+                Err(e) => {
+                    result.error = Some(e.to_string());
+                    break 'stmts;
+                }
+            }
+        }
+    }
+    result
+}
+
+struct SqliteTxn {
+    conn: Connection,
+}
+impl TxnConn for SqliteTxn {
+    fn exec(&mut self, sql: &str) -> SqlRunResult {
+        run_on_conn(&self.conn, sql)
+    }
+    fn finish(&mut self, commit: bool) -> Result<(), String> {
+        self.conn
+            .execute_batch(if commit { "COMMIT" } else { "ROLLBACK" })
+            .map_err(|e| e.to_string())
+    }
+}
+
 fn value_to_json(v: rusqlite::types::Value) -> JsonValue {
     use rusqlite::types::Value::*;
     match v {
@@ -21,67 +96,20 @@ impl DbExecutor for SqliteExecutor {
     }
 
     fn run(&self, sql: &str, source: &DataSource) -> SqlRunResult {
-        let mut result = SqlRunResult::new();
-        let conn = match source.file.as_deref() {
-            Some(p) if !p.trim().is_empty() => Connection::open(p),
-            _ => Connection::open_in_memory(),
-        };
-        let conn = match conn {
-            Ok(c) => c,
+        match open_conn(source) {
+            Ok(conn) => run_on_conn(&conn, sql),
             Err(e) => {
-                result.error = Some(format!("打开数据库失败: {}", e));
-                return result;
-            }
-        };
-
-        'stmts: for stmt_sql in split_sql(sql) {
-            let mut stmt = match conn.prepare(&stmt_sql) {
-                Ok(s) => s,
-                Err(e) => {
-                    result.error = Some(e.to_string());
-                    break 'stmts;
-                }
-            };
-            let ncol = stmt.column_count();
-            if ncol > 0 {
-                let columns: Vec<String> =
-                    stmt.column_names().iter().map(|s| s.to_string()).collect();
-                let rows_iter = stmt.query_map([], |row| {
-                    let mut v = Vec::with_capacity(ncol);
-                    for idx in 0..ncol {
-                        v.push(value_to_json(row.get(idx)?));
-                    }
-                    Ok(v)
-                });
-                match rows_iter {
-                    Ok(it) => {
-                        let mut rows = Vec::new();
-                        for r in it {
-                            match r {
-                                Ok(rw) => rows.push(rw),
-                                Err(e) => {
-                                    result.error = Some(e.to_string());
-                                    break 'stmts;
-                                }
-                            }
-                        }
-                        result.result_sets.push(SqlResultSet { columns, rows });
-                    }
-                    Err(e) => {
-                        result.error = Some(e.to_string());
-                        break 'stmts;
-                    }
-                }
-            } else {
-                match stmt.execute([]) {
-                    Ok(affected) => result.messages.push(format!("OK，影响 {} 行", affected)),
-                    Err(e) => {
-                        result.error = Some(e.to_string());
-                        break 'stmts;
-                    }
-                }
+                let mut result = SqlRunResult::new();
+                result.error = Some(e);
+                result
             }
         }
-        result
+    }
+
+    fn begin(&self, source: &DataSource) -> Result<Box<dyn TxnConn>, String> {
+        let conn = open_conn(source)?;
+        conn.execute_batch("BEGIN")
+            .map_err(|e| format!("开启事务失败: {}", e))?;
+        Ok(Box::new(SqliteTxn { conn }))
     }
 }
diff --git a/src-tauri/src/filesystem.rs b/src-tauri/src/filesystem.rs
index 4016702d..452e9920 100644
--- a/src-tauri/src/filesystem.rs
+++ b/src-tauri/src/filesystem.rs
@@ -498,6 +498,232 @@ pub async fn git_init(root: String) -> Result<String, String> {
         .map_err(|e| format!("git 任务失败: {}", e))?
 }
 
+#[derive(Serialize, Default)]
+pub struct EditorConfigResolved {
+    /// "tab" | "space"
+    indent_style: Option<String>,
+    indent_size: Option<u32>,
+    tab_width: Option<u32>,
+    trim_trailing_whitespace: Option<bool>,
+    insert_final_newline: Option<bool>,
+}
+
+/// 把 editorconfig glob 转为正则（覆盖 * ** ? {a,b} [..]）
+fn editorconfig_glob_to_regex(glob: &str) -> String {
+    let chars: Vec<char> = glob.chars().collect();
+    let mut re = String::from("^");
+    let mut i = 0;
+    while i < chars.len() {
+        let c = chars[i];
+        match c {
+            '*' => {
+                if i + 1 < chars.len() && chars[i + 1] == '*' {
+                    re.push_str(".*");
+                    i += 1;
+                } else {
+                    re.push_str("[^/]*");
+                }
+            }
+            '?' => re.push_str("[^/]"),
+            '{' => {
+                // {a,b,c} -> (a|b|c)
+                let mut j = i + 1;
+                let mut buf = String::new();
+                let mut alts = String::from("(");
+                let mut closed = false;
+                while j < chars.len() {
+                    match chars[j] {
+                        '}' => {
+                            alts.push_str(&regex::escape(&buf));
+                            alts.push(')');
+                            closed = true;
+                            j += 1;
+                            break;
+                        }
+                        ',' => {
+                            alts.push_str(&regex::escape(&buf));
+                            alts.push('|');
+                            buf.clear();
+                        }
+                        ch => buf.push(ch),
+                    }
+                    j += 1;
+                }
+                if closed {
+                    re.push_str(&alts);
+                    i = j;
+                    continue;
+                } else {
+                    re.push_str("\\{");
+                }
+            }
+            '[' => {
+                re.push('[');
+                let mut j = i + 1;
+                if j < chars.len() && chars[j] == '!' {
+                    re.push('^');
+                    j += 1;
+                }
+                while j < chars.len() && chars[j] != ']' {
+                    re.push(chars[j]);
+                    j += 1;
+                }
+                re.push(']');
+                i = j;
+                continue;
+            }
+            '.' | '(' | ')' | '+' | '|' | '^' | '$' | '\\' => {
+                re.push('\\');
+                re.push(c);
+            }
+            _ => re.push(c),
+        }
+        i += 1;
+    }
+    re.push('$');
+    re
+}
+
+fn editorconfig_is_root(content: &str) -> bool {
+    for line in content.lines() {
+        let l = line.trim();
+        if l.starts_with('[') {
+            break;
+        }
+        if let Some((k, v)) = l.split_once('=') {
+            if k.trim().eq_ignore_ascii_case("root") && v.trim().eq_ignore_ascii_case("true") {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn editorconfig_apply(
+    content: &str,
+    rel_path: &str,
+    file_name: &str,
+    out: &mut EditorConfigResolved,
+) {
+    let mut matched = false;
+    for line in content.lines() {
+        let l = line.trim();
+        if l.is_empty() || l.starts_with('#') || l.starts_with(';') {
+            continue;
+        }
+        if let Some(glob) = l.strip_prefix('[').and_then(|s| s.strip_suffix(']')) {
+            // 含 '/' 按相对路径匹配，否则按文件名匹配
+            let (pat, target) = if glob.contains('/') {
+                (glob.trim_start_matches('/'), rel_path)
+            } else {
+                (glob, file_name)
+            };
+            matched = regex::Regex::new(&editorconfig_glob_to_regex(pat))
+                .map(|re| re.is_match(target))
+                .unwrap_or(false);
+            continue;
+        }
+        if !matched {
+            continue;
+        }
+        if let Some((k, v)) = l.split_once('=') {
+            let key = k.trim().to_lowercase();
+            let val = v.trim().to_string();
+            match key.as_str() {
+                "indent_style" => out.indent_style = Some(val.to_lowercase()),
+                "indent_size" => {
+                    if let Ok(n) = val.parse::<u32>() {
+                        out.indent_size = Some(n);
+                    }
+                }
+                "tab_width" => {
+                    if let Ok(n) = val.parse::<u32>() {
+                        out.tab_width = Some(n);
+                    }
+                }
+                "trim_trailing_whitespace" => {
+                    out.trim_trailing_whitespace = Some(val.eq_ignore_ascii_case("true"))
+                }
+                "insert_final_newline" => {
+                    out.insert_final_newline = Some(val.eq_ignore_ascii_case("true"))
+                }
+                _ => {}
+            }
+        }
+    }
+}
+
+/// 解析某文件适用的 .editorconfig（向上查找，近的覆盖远的，遇 root=true 停）。
+#[tauri::command]
+pub async fn resolve_editorconfig(file_path: String) -> Result<EditorConfigResolved, String> {
+    tokio::task::spawn_blocking(move || {
+        let path = std::path::PathBuf::from(&file_path);
+        let file_name = path
+            .file_name()
+            .map(|n| n.to_string_lossy().to_string())
+            .unwrap_or_default();
+        // 自近向远收集 .editorconfig，遇 root 停
+        let mut configs: Vec<std::path::PathBuf> = Vec::new();
+        let mut dir = path.parent();
+        while let Some(d) = dir {
+            let cfg = d.join(".editorconfig");
+            if cfg.is_file() {
+                let is_root = std::fs::read_to_string(&cfg)
+                    .map(|c| editorconfig_is_root(&c))
+                    .unwrap_or(false);
+                configs.push(cfg);
+                if is_root {
+                    break;
+                }
+            }
+            dir = d.parent();
+        }
+        // 自远向近应用（近的覆盖）
+        let mut out = EditorConfigResolved::default();
+        for cfg in configs.iter().rev() {
+            if let (Ok(content), Some(cfg_dir)) = (std::fs::read_to_string(cfg), cfg.parent()) {
+                let rel = path
+                    .strip_prefix(cfg_dir)
+                    .map(|p| p.to_string_lossy().replace('\\', "/"))
+                    .unwrap_or_default();
+                editorconfig_apply(&content, &rel, &file_name, &mut out);
+            }
+        }
+        Ok(out)
+    })
+    .await
+    .map_err(|e| format!(".editorconfig 解析失败: {}", e))?
+}
+
+/// 追加一段 .gitignore 模板块（按首行标题去重，已存在则跳过）。
+#[tauri::command]
+pub async fn git_ignore_append_block(root: String, content: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        let block = content.trim_end_matches('\n');
+        if block.trim().is_empty() {
+            return Ok(());
+        }
+        let path = std::path::Path::new(&root).join(".gitignore");
+        let mut existing = std::fs::read_to_string(&path).unwrap_or_default();
+        // 用块首行（通常是 # 标题）判重，避免重复插入
+        let header = block.lines().next().unwrap_or("").trim();
+        if !header.is_empty() && existing.lines().any(|l| l.trim() == header) {
+            return Ok(());
+        }
+        if !existing.is_empty() {
+            if !existing.ends_with('\n') {
+                existing.push('\n');
+            }
+            existing.push('\n'); // 与上一块隔一空行
+        }
+        existing.push_str(block);
+        existing.push('\n');
+        std::fs::write(&path, existing).map_err(|e| format!("写入 .gitignore 失败: {}", e))
+    })
+    .await
+    .map_err(|e| format!("git 任务失败: {}", e))?
+}
+
 /// 把一个匹配模式追加到 .gitignore（已存在则跳过）。
 #[tauri::command]
 pub async fn git_ignore_add(root: String, pattern: String) -> Result<(), String> {
diff --git a/src-tauri/src/gitignore_templates.rs b/src-tauri/src/gitignore_templates.rs
new file mode 100644
index 00000000..779b734f
--- /dev/null
+++ b/src-tauri/src/gitignore_templates.rs
@@ -0,0 +1,99 @@
+use crate::execution::get_codeforge_db_path;
+use rusqlite::{Connection, params};
+use serde::{Deserialize, Serialize};
+use std::sync::Mutex as StdMutex;
+use tauri::State;
+
+/// 用户自定义 .gitignore 模板，存于同一个 codeforge.sqlite 库的独立表。
+pub struct GitignoreStore {
+    conn: StdMutex<Connection>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct GitignoreTemplate {
+    pub id: String,
+    pub label: String,
+    pub content: String,
+}
+
+impl GitignoreStore {
+    pub fn new() -> Result<Self, String> {
+        let db_path = get_codeforge_db_path()?;
+        let conn = Connection::open(&db_path).map_err(|e| format!("打开数据库失败: {}", e))?;
+        let _ = conn.pragma_update(None, "journal_mode", "WAL");
+        let _ = conn.pragma_update(None, "synchronous", "NORMAL");
+        let _ = conn.busy_timeout(std::time::Duration::from_secs(5));
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS gitignore_templates (
+                id TEXT PRIMARY KEY,
+                label TEXT NOT NULL,
+                content TEXT NOT NULL,
+                updated_at INTEGER NOT NULL DEFAULT 0
+            )",
+            [],
+        )
+        .map_err(|e| format!("初始化 .gitignore 模板表失败: {}", e))?;
+
+        Ok(Self {
+            conn: StdMutex::new(conn),
+        })
+    }
+}
+
+/// 列出自定义 .gitignore 模板（按名称排序）
+#[tauri::command]
+pub async fn gitignore_templates_list(
+    state: State<'_, GitignoreStore>,
+) -> Result<Vec<GitignoreTemplate>, String> {
+    let conn = state.conn.lock().map_err(|_| "数据库锁错误".to_string())?;
+    let mut stmt = conn
+        .prepare("SELECT id, label, content FROM gitignore_templates ORDER BY label")
+        .map_err(|e| format!("查询模板失败: {}", e))?;
+    let rows = stmt
+        .query_map([], |row| {
+            Ok(GitignoreTemplate {
+                id: row.get(0)?,
+                label: row.get(1)?,
+                content: row.get(2)?,
+            })
+        })
+        .map_err(|e| format!("读取模板失败: {}", e))?;
+    let mut out = Vec::new();
+    for r in rows {
+        out.push(r.map_err(|e| format!("读取模板失败: {}", e))?);
+    }
+    Ok(out)
+}
+
+/// 新增/更新一条自定义模板（按 id upsert）
+#[tauri::command]
+pub async fn gitignore_template_save(
+    template: GitignoreTemplate,
+    state: State<'_, GitignoreStore>,
+) -> Result<(), String> {
+    let conn = state.conn.lock().map_err(|_| "数据库锁错误".to_string())?;
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis() as i64)
+        .unwrap_or(0);
+    conn.execute(
+        "INSERT INTO gitignore_templates (id, label, content, updated_at)
+         VALUES (?1, ?2, ?3, ?4)
+         ON CONFLICT(id) DO UPDATE SET label=?2, content=?3, updated_at=?4",
+        params![template.id, template.label, template.content, now],
+    )
+    .map_err(|e| format!("保存模板失败: {}", e))?;
+    Ok(())
+}
+
+/// 删除一条自定义模板
+#[tauri::command]
+pub async fn gitignore_template_delete(
+    id: String,
+    state: State<'_, GitignoreStore>,
+) -> Result<(), String> {
+    let conn = state.conn.lock().map_err(|_| "数据库锁错误".to_string())?;
+    conn.execute("DELETE FROM gitignore_templates WHERE id = ?1", params![id])
+        .map_err(|e| format!("删除模板失败: {}", e))?;
+    Ok(())
+}
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index affbb8e6..b5e3a37c 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -19,6 +19,7 @@ mod execution;
 mod filesystem;
 mod font;
 mod geo;
+mod gitignore_templates;
 mod kv;
 mod logger;
 mod lsp;
@@ -41,9 +42,10 @@ use crate::custom_plugin_commands::{
     update_custom_plugin,
 };
 use crate::dap::{
-    DapState, dap_adapter_list, dap_available, dap_install, dap_send, dap_start, dap_stop,
+    DapState, dap_adapter_list, dap_available, dap_build, dap_install, dap_send, dap_start,
+    dap_stop,
 };
-use crate::db::{run_sql, run_sql_paged};
+use crate::db::{TxnState, run_sql, run_sql_paged, tx_active, tx_begin, tx_exec, tx_finish};
 use crate::db_connections::{
     DbConnStore, db_connection_delete, db_connection_save, db_connections_list,
 };
@@ -67,16 +69,20 @@ use crate::filesystem::{
     git_branches, git_checkout, git_checkout_track, git_cherry_pick, git_clean, git_clean_preview,
     git_clone, git_commit, git_compare, git_delete_remote_branch, git_diff, git_discard, git_fetch,
     git_file_diff, git_file_head, git_get_identity, git_get_signing, git_graph, git_hook_delete,
-    git_hook_read, git_hook_save, git_hooks, git_ignore_add, git_init, git_log, git_log_file,
-    git_merge, git_op_abort, git_op_continue, git_op_skip, git_op_state, git_pull, git_pull_rebase,
-    git_push, git_push_force, git_push_tags, git_rebase_interactive, git_reflog, git_remote_add,
-    git_remote_branches, git_remote_remove, git_remotes, git_reset, git_restore_file, git_revert,
-    git_set_identity, git_set_signing, git_set_upstream, git_show, git_stage, git_stash_apply,
-    git_stash_drop, git_stash_list, git_stash_pop, git_stash_push, git_stash_show, git_status,
-    git_submodule_sync, git_submodule_update, git_submodules, git_tag_create, git_tag_delete,
-    git_tags, git_unstage, git_worktree_add, git_worktree_prune, git_worktree_remove,
-    git_worktrees, list_files, read_directory_tree, read_file_lines, read_file_text, rename_path,
-    replace_in_files, reveal_path, search_in_files, watch_directory, write_file_text,
+    git_hook_read, git_hook_save, git_hooks, git_ignore_add, git_ignore_append_block, git_init,
+    git_log, git_log_file, git_merge, git_op_abort, git_op_continue, git_op_skip, git_op_state,
+    git_pull, git_pull_rebase, git_push, git_push_force, git_push_tags, git_rebase_interactive,
+    git_reflog, git_remote_add, git_remote_branches, git_remote_remove, git_remotes, git_reset,
+    git_restore_file, git_revert, git_set_identity, git_set_signing, git_set_upstream, git_show,
+    git_stage, git_stash_apply, git_stash_drop, git_stash_list, git_stash_pop, git_stash_push,
+    git_stash_show, git_status, git_submodule_sync, git_submodule_update, git_submodules,
+    git_tag_create, git_tag_delete, git_tags, git_unstage, git_worktree_add, git_worktree_prune,
+    git_worktree_remove, git_worktrees, list_files, read_directory_tree, read_file_lines,
+    read_file_text, rename_path, replace_in_files, resolve_editorconfig, reveal_path,
+    search_in_files, watch_directory, write_file_text,
+};
+use crate::gitignore_templates::{
+    GitignoreStore, gitignore_template_delete, gitignore_template_save, gitignore_templates_list,
 };
 use crate::kv::{KvStore, kv_delete, kv_get_all, kv_set};
 use crate::lsp::{
@@ -122,9 +128,11 @@ fn main() {
         .manage(Snippets::new().expect("failed to initialize snippets database"))
         .manage(KvStore::new().expect("failed to initialize kv store database"))
         .manage(DbConnStore::new().expect("failed to initialize db connections database"))
+        .manage(GitignoreStore::new().expect("failed to initialize gitignore templates database"))
         .manage(TerminalState::new())
         .manage(LspState::new())
         .manage(DapState::new())
+        .manage(TxnState::new())
         .manage(ExecutionPluginManagerState::new(PluginManager::new()))
         .manage(EnvironmentManagerState::new(env_manager))
         .setup(|app| {
@@ -279,6 +287,8 @@ fn main() {
             git_set_upstream,
             git_init,
             git_ignore_add,
+            git_ignore_append_block,
+            resolve_editorconfig,
             git_clone,
             git_clean_preview,
             git_clean,
@@ -319,6 +329,10 @@ fn main() {
             db_connections_list,
             db_connection_save,
             db_connection_delete,
+            // 自定义 .gitignore 模板
+            gitignore_templates_list,
+            gitignore_template_save,
+            gitignore_template_delete,
             // 集成终端
             terminal_create,
             terminal_write,
@@ -327,6 +341,11 @@ fn main() {
             // SQL 执行
             run_sql,
             run_sql_paged,
+            // 交互式事务
+            tx_begin,
+            tx_exec,
+            tx_finish,
+            tx_active,
             // LSP 桥接
             lsp_available,
             lsp_start,
@@ -340,7 +359,8 @@ fn main() {
             dap_send,
             dap_stop,
             dap_adapter_list,
-            dap_install
+            dap_install,
+            dap_build
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
diff --git a/src/App.vue b/src/App.vue
index 93ef9f21..69ad0a2e 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -79,7 +79,7 @@
               <EditorTabs :tabs="editorTabs" :active-id="activeTabId" @switch="switchTab" @close="handleCloseTab" @new="handleNewTab"
                           @close-others="closeOthers" @close-right="closeToRight" @move="moveTab" @copy-path="handleCopyPath"/>
               <div v-if="!showViewer" class="bg-gray-100 dark:bg-gray-800 px-4 py-2 border-b border-gray-200 dark:border-gray-700 flex items-center justify-between flex-shrink-0">
-                <div class="flex items-center space-x-3 min-w-0 flex-1">
+                <div class="flex items-center space-x-3 min-w-0 flex-1 overflow-x-auto [&::-webkit-scrollbar]:hidden [-ms-overflow-style:none] [scrollbar-width:none]">
                   <img :src="`/icons/${currentLanguage.replace(/\d+$/, '')}.svg`" class="w-5 h-5 flex-shrink-0" :alt="currentLanguage" @error="onIconError"/>
                   <h2 class="text-sm font-medium text-gray-700 dark:text-gray-200 whitespace-nowrap flex-shrink-0">{{ getLanguageDisplayName(currentLanguage) }} {{ t('app.codeEditor') }}</h2>
                   <template v-if="currentFilePath">
@@ -95,6 +95,8 @@
                   <SqlSourceSelect v-if="currentLanguage === 'sql'" class="flex-shrink-0"/>
                   <SchemaBrowser v-if="currentLanguage === 'sql'" class="flex-shrink-0" @preview="previewTable" @insert="insertAtCursor"/>
                   <AiSql v-if="currentLanguage === 'sql'" class="flex-shrink-0" @generated="insertAtCursor"/>
+                  <ErDiagram v-if="currentLanguage === 'sql'" class="flex-shrink-0"/>
+                  <TxnControl v-if="currentLanguage === 'sql'" class="flex-shrink-0" @notice="onTxnNotice"/>
                 </div>
 
                 <div class="flex items-center space-x-2 text-xs text-gray-500 whitespace-nowrap flex-shrink-0 pl-3">
@@ -233,6 +235,8 @@
             <SqlSourceSelect v-if="currentLanguage === 'sql'" class="flex-shrink-0"/>
             <SchemaBrowser v-if="currentLanguage === 'sql'" class="flex-shrink-0" @preview="previewTable" @insert="insertAtCursor"/>
                   <AiSql v-if="currentLanguage === 'sql'" class="flex-shrink-0" @generated="insertAtCursor"/>
+                  <ErDiagram v-if="currentLanguage === 'sql'" class="flex-shrink-0"/>
+                  <TxnControl v-if="currentLanguage === 'sql'" class="flex-shrink-0" @notice="onTxnNotice"/>
           </div>
 
           <div class="flex items-center space-x-2 text-xs text-gray-500 whitespace-nowrap flex-shrink-0 pl-3">
@@ -370,6 +374,9 @@
     <AiCodeAction v-if="aiCodeCtx" :language="currentLanguage" :code="aiCodeCtx.code" :action="aiCodeCtx.action"
                   @replace="onAiReplace" @insert="onAiInsert" @close="aiCodeCtx = null"/>
 
+    <!-- .gitignore 模板 -->
+    <GitIgnoreTemplates v-if="showGitignore && rootDir" :root-dir="rootDir" @close="showGitignore = false"/>
+
     <!-- 运行任务 -->
     <TaskRunner v-if="showTasks && rootDir" :root-dir="rootDir" @run="runTask" @close="showTasks = false"/>
 
@@ -509,9 +516,13 @@ import BlameView from './components/BlameView.vue'
 import GitLog from './components/GitLog.vue'
 import GitPanel from './components/GitPanel.vue'
 import TaskRunner from './components/TaskRunner.vue'
+import GitIgnoreTemplates from './components/GitIgnoreTemplates.vue'
 import DebugToolbar from './components/DebugToolbar.vue'
 import DebugPanel from './components/DebugPanel.vue'
 import AiCodeAction from './components/AiCodeAction.vue'
+import ErDiagram from './components/ErDiagram.vue'
+import TxnControl from './components/TxnControl.vue'
+import {useSqlTxn} from './composables/useSqlTxn'
 import GoToLine from './components/GoToLine.vue'
 import Outline from './components/Outline.vue'
 import SnippetManager from './components/SnippetManager.vue'
@@ -1158,6 +1169,16 @@ const toggleTerminal = () => {
   }
 }
 
+// ===== .gitignore 模板（F2）=====
+const showGitignore = ref(false)
+const openGitignore = () => {
+  if (!rootDir.value) {
+    toast.info(t('app.openFolderFirst'))
+    return
+  }
+  showGitignore.value = true
+}
+
 // ===== 运行任务（B4）：在集成终端中执行预设命令 =====
 const showTasks = ref(false)
 const openTasks = () => {
@@ -1195,7 +1216,10 @@ const startDebug = async () => {
     ok = false
   }
   if (!ok) {
-    toast.error(lang === 'go' ? t('debug.installGo') : t('debug.installPython'))
+    const hint = lang === 'go' ? t('debug.installGo')
+      : (lang === 'rust' || lang === 'c' || lang === 'cpp') ? t('debug.installLldb')
+        : t('debug.installPython')
+    toast.error(hint)
     return
   }
   try {
@@ -1590,6 +1614,16 @@ watch(editorView, () => applyDiffMarkers())
 
 // ===== 断点（B1-P2）：把当前文件的断点 + 执行行派发到编辑器 =====
 const debug = useDebug()
+const sqlTxn = useSqlTxn()
+
+// 事务开启/提交/回滚的反馈写入结果面板
+const onTxnNotice = (text: string) => {
+  if (layoutMode.value === 'editor') {
+    showConsole.value = true
+  }
+  output.value = JSON.stringify({result_sets: [], messages: [text], error: null})
+  isSuccess.value = true
+}
 const applyBreakpoints = () => {
   const view = editorView.value
   if (!view) {
@@ -1836,6 +1870,32 @@ const runSql = async (sqlOverride?: string) => {
     toast.info(t('app.noSql'))
     return
   }
+  // 事务进行中：整段在持有连接上执行（不走分页，否则分页用的是另一条连接看不到未提交数据）
+  if (sqlTxn.active.value) {
+    output.value = ''
+    isSuccess.value = false
+    if (layoutMode.value === 'editor') {
+      showConsole.value = true
+    }
+    isRunning.value = true
+    try {
+      const res = await sqlTxn.exec(sql)
+      output.value = JSON.stringify(res)
+      isSuccess.value = !res.error
+      lastExecutionTime.value = res.elapsed_ms || 0
+      if (res.error) {
+        toast.error(t('app.sqlFailed'))
+      }
+    }
+    catch (error) {
+      output.value = JSON.stringify({result_sets: [], messages: [], error: String(error)})
+      toast.error(t('app.sqlFailedColon') + error)
+    }
+    finally {
+      isRunning.value = false
+    }
+    return
+  }
   const source = resolveActiveSource()
   output.value = ''
   isSuccess.value = false
@@ -2106,6 +2166,7 @@ const paletteCommands = computed<PaletteCommand[]>(() => [
   {id: 'preview', label: t('command.preview'), icon: Eye, run: () => togglePreview()},
   {id: 'git', label: t('command.git'), icon: GitBranch, run: () => openGit()},
   {id: 'tasks', label: t('command.tasks'), icon: ListChecks, run: () => openTasks()},
+  {id: 'gitignore', label: t('command.gitignore'), icon: GitBranch, run: () => openGitignore()},
   {id: 'runTests', label: t('command.runTests'), icon: ListChecks, run: () => runTests()},
   {id: 'startDebug', label: t('command.startDebug'), icon: Play, run: () => startDebug()},
   {id: 'sendToTerminal', label: t('command.sendToTerminal'), icon: TerminalIcon, run: () => sendToTerminal()},
diff --git a/src/components/CodeEditor.vue b/src/components/CodeEditor.vue
index 2a6ae95a..4e68ac8f 100644
--- a/src/components/CodeEditor.vue
+++ b/src/components/CodeEditor.vue
@@ -4,8 +4,8 @@
                 :style="{ width: '100%', height: '100%', fontSize: editorConfig?.font_size ? `${editorConfig.font_size}px` : undefined }"
                 :model-value="modelValue"
                 :extensions="extensions"
-                :indent-with-tab="editorConfig?.indent_with_tab"
-                :tab-size="editorConfig?.tab_size"
+                :indent-with-tab="effectiveIndentWithTab"
+                :tab-size="effectiveTabSize"
                 @change="handleInput"
                 @ready="onReady"/>
   </div>
@@ -32,6 +32,8 @@ const {
   isReady,
   extensions,
   editorConfig,
+  effectiveTabSize,
+  effectiveIndentWithTab,
   initializeEditor
 } = useCodeMirrorEditor(props)
 
diff --git a/src/components/DebugPanel.vue b/src/components/DebugPanel.vue
index 02087bf2..1d84fa93 100644
--- a/src/components/DebugPanel.vue
+++ b/src/components/DebugPanel.vue
@@ -10,9 +10,11 @@
         <Bug class="w-4 h-4 text-gray-400"/>
         <span>{{ t('debug.panelTitle') }}</span>
       </div>
-      <button class="text-gray-400 hover:text-red-500 cursor-pointer" :title="t('debug.stop')" @click="debug.stopSession()">
-        <Square class="w-4 h-4"/>
-      </button>
+      <Tooltip :text="t('debug.stop')">
+        <button class="text-gray-400 hover:text-red-500 cursor-pointer" @click="debug.stopSession()">
+          <Square class="w-4 h-4"/>
+        </button>
+      </Tooltip>
     </div>
 
     <div class="flex-1 min-h-0 overflow-y-auto">
@@ -104,6 +106,7 @@ import {Bug, ChevronRight, Square} from 'lucide-vue-next'
 import {useI18n} from 'vue-i18n'
 import {useDebug, type DapVariable, type Scope} from '../composables/useDebug'
 import {kvGet, kvSet} from '../composables/useKvStore'
+import Tooltip from '../ui/Tooltip.vue'
 import DebugVarNode from './DebugVarNode.vue'
 
 const {t} = useI18n()
diff --git a/src/components/DebugToolbar.vue b/src/components/DebugToolbar.vue
index 3a949190..b5c94f20 100644
--- a/src/components/DebugToolbar.vue
+++ b/src/components/DebugToolbar.vue
@@ -1,34 +1,48 @@
 <template>
   <div v-if="debug.status.value !== 'inactive'"
        class="fixed top-2 left-1/2 -translate-x-1/2 z-40 flex items-center gap-1 px-2 py-1 rounded-lg bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 shadow-lg">
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 text-emerald-600 dark:text-emerald-400 disabled:opacity-30 cursor-pointer"
-            :disabled="debug.status.value !== 'stopped'" :title="t('debug.continue')" @click="debug.continue()">
-      <Play class="w-4 h-4"/>
-    </button>
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
-            :disabled="debug.status.value !== 'running'" :title="t('debug.pause')" @click="debug.pause()">
-      <Pause class="w-4 h-4"/>
-    </button>
+    <Tooltip :text="t('debug.continue')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 text-emerald-600 dark:text-emerald-400 disabled:opacity-30 cursor-pointer"
+              :disabled="debug.status.value !== 'stopped'" @click="debug.continue()">
+        <Play class="w-4 h-4"/>
+      </button>
+    </Tooltip>
+    <Tooltip :text="t('debug.pause')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
+              :disabled="debug.status.value !== 'running'" @click="debug.pause()">
+        <Pause class="w-4 h-4"/>
+      </button>
+    </Tooltip>
     <div class="w-px h-4 bg-gray-200 dark:bg-gray-700 mx-0.5"></div>
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
-            :disabled="debug.status.value !== 'stopped'" :title="t('debug.stepOver')" @click="debug.stepOver()">
-      <StepForward class="w-4 h-4"/>
-    </button>
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
-            :disabled="debug.status.value !== 'stopped'" :title="t('debug.stepIn')" @click="debug.stepIn()">
-      <ArrowDownToLine class="w-4 h-4"/>
-    </button>
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
-            :disabled="debug.status.value !== 'stopped'" :title="t('debug.stepOut')" @click="debug.stepOut()">
-      <ArrowUpFromLine class="w-4 h-4"/>
-    </button>
+    <Tooltip :text="t('debug.stepOver')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
+              :disabled="debug.status.value !== 'stopped'" @click="debug.stepOver()">
+        <StepForward class="w-4 h-4"/>
+      </button>
+    </Tooltip>
+    <Tooltip :text="t('debug.stepIn')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
+              :disabled="debug.status.value !== 'stopped'" @click="debug.stepIn()">
+        <ArrowDownToLine class="w-4 h-4"/>
+      </button>
+    </Tooltip>
+    <Tooltip :text="t('debug.stepOut')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-30 cursor-pointer"
+              :disabled="debug.status.value !== 'stopped'" @click="debug.stepOut()">
+        <ArrowUpFromLine class="w-4 h-4"/>
+      </button>
+    </Tooltip>
     <div class="w-px h-4 bg-gray-200 dark:bg-gray-700 mx-0.5"></div>
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 cursor-pointer" :title="t('debug.restart')" @click="debug.restart()">
-      <RotateCcw class="w-4 h-4"/>
-    </button>
-    <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 text-red-500 cursor-pointer" :title="t('debug.stop')" @click="debug.stopSession()">
-      <Square class="w-4 h-4"/>
-    </button>
+    <Tooltip :text="t('debug.restart')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 cursor-pointer" @click="debug.restart()">
+        <RotateCcw class="w-4 h-4"/>
+      </button>
+    </Tooltip>
+    <Tooltip :text="t('debug.stop')">
+      <button class="p-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-700 text-red-500 cursor-pointer" @click="debug.stopSession()">
+        <Square class="w-4 h-4"/>
+      </button>
+    </Tooltip>
     <span class="ml-1 text-[11px] text-gray-400 select-none">{{ statusLabel }}</span>
   </div>
 </template>
@@ -37,6 +51,7 @@
 import {computed} from 'vue'
 import {ArrowDownToLine, ArrowUpFromLine, Pause, Play, RotateCcw, Square, StepForward} from 'lucide-vue-next'
 import {useI18n} from 'vue-i18n'
+import Tooltip from '../ui/Tooltip.vue'
 import {useDebug} from '../composables/useDebug'
 
 const {t} = useI18n()
diff --git a/src/components/ErDiagram.vue b/src/components/ErDiagram.vue
new file mode 100644
index 00000000..d11dda91
--- /dev/null
+++ b/src/components/ErDiagram.vue
@@ -0,0 +1,260 @@
+<template>
+  <div class="inline-block">
+    <Tooltip :text="t('er.title')">
+      <button class="inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs text-gray-500 hover:bg-gray-100 dark:hover:bg-gray-700 cursor-pointer" @click="open">
+        <Network class="w-3.5 h-3.5"/>
+      </button>
+    </Tooltip>
+
+    <Teleport to="body">
+      <div v-if="visible" class="fixed inset-0 z-50 flex items-start justify-center pt-10 px-6 pb-6" @click="visible = false">
+        <div class="w-full max-w-[1100px] h-[80vh] bg-white dark:bg-gray-900 dark:text-gray-100 rounded-lg shadow-2xl border border-gray-200 dark:border-gray-700 flex flex-col overflow-hidden" @click.stop>
+          <div class="flex items-center justify-between px-4 py-2.5 border-b border-gray-200 dark:border-gray-700 flex-shrink-0">
+            <div class="flex items-center gap-2 text-sm font-medium text-gray-700 dark:text-gray-200">
+              <Network class="w-4 h-4 text-gray-400"/>
+              <span>{{ t('er.title') }} · {{ activeLabel() }}</span>
+              <span v-if="pickedDb" class="text-[11px] text-gray-400">/ {{ pickedDb }}</span>
+              <button v-if="pickedDb" class="text-[11px] text-blue-500 hover:underline cursor-pointer" @click="backToPick">{{ t('er.switchDb') }}</button>
+              <span v-if="!loading && !picking" class="text-[11px] text-gray-400">{{ t('er.summary', { tables: tables.length, fks: fks.length }) }}</span>
+            </div>
+            <button class="text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 cursor-pointer" @click="visible = false">
+              <X class="w-4 h-4"/>
+            </button>
+          </div>
+
+          <div class="flex-1 relative overflow-auto bg-gray-50 dark:bg-gray-950">
+            <div v-if="loading" class="absolute inset-0 flex items-center justify-center text-sm text-gray-400">{{ t('er.loading') }}</div>
+            <div v-else-if="error" class="absolute inset-0 flex items-center justify-center text-sm text-red-500 px-6 text-center">{{ error }}</div>
+            <div v-else-if="picking" class="absolute inset-0 overflow-auto p-4">
+              <div class="text-xs text-gray-500 dark:text-gray-400 mb-2">{{ t('er.pickDb') }}</div>
+              <div v-if="dbList.length" class="flex flex-wrap gap-2">
+                <button v-for="d in dbList" :key="d" class="px-3 py-1.5 text-xs rounded border border-gray-300 dark:border-gray-600 hover:border-blue-400 hover:text-blue-500 cursor-pointer" @click="selectDb(d)">{{ d }}</button>
+              </div>
+              <div v-else class="text-xs text-gray-400">{{ t('er.empty') }}</div>
+            </div>
+            <div v-else-if="!tables.length" class="absolute inset-0 flex items-center justify-center text-sm text-gray-400">{{ t('er.empty') }}</div>
+            <div v-else class="relative" :style="{ width: canvas.w + 'px', height: canvas.h + 'px' }">
+              <!-- 外键连线 -->
+              <svg class="absolute inset-0 pointer-events-none" :width="canvas.w" :height="canvas.h">
+                <path v-for="(e, i) in edges" :key="i" :d="e.d" fill="none" stroke="#60a5fa" stroke-width="1.5"/>
+              </svg>
+              <!-- 表卡片 -->
+              <div v-for="tbl in tables" :key="tbl.name"
+                   class="absolute select-none rounded-md border border-gray-300 dark:border-gray-700 bg-white dark:bg-gray-800 shadow-sm"
+                   :style="{ left: posOf(tbl.name).x + 'px', top: posOf(tbl.name).y + 'px', width: CARD_W + 'px' }">
+                <div class="px-2 py-1 text-xs font-semibold bg-gray-100 dark:bg-gray-700 rounded-t-md cursor-move truncate"
+                     @mousedown="startDrag(tbl.name, $event)">{{ tbl.name }}</div>
+                <div class="py-0.5">
+                  <div v-for="col in tbl.columns" :key="col.name" class="flex items-center gap-1 px-2 text-[11px] font-mono leading-5">
+                    <span class="flex-shrink-0 w-2 text-amber-500">{{ fkCols.has(tbl.name + '.' + col.name) ? '◆' : '' }}</span>
+                    <span class="text-gray-800 dark:text-gray-100 truncate">{{ col.name }}</span>
+                    <span class="ml-auto text-gray-400 truncate">{{ col.type }}</span>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </Teleport>
+  </div>
+</template>
+
+<script setup lang="ts">
+import {computed, reactive, ref} from 'vue'
+import {invoke} from '@tauri-apps/api/core'
+import {Network, X} from 'lucide-vue-next'
+import {useI18n} from 'vue-i18n'
+import {useDbConnections} from '../composables/useDbConnections'
+import Tooltip from '../ui/Tooltip.vue'
+import {columnsSql, fksSql} from '../utils/dbSchema'
+
+interface Col { name: string; type: string }
+interface Tbl { name: string; columns: Col[] }
+interface Fk { tbl: string; col: string; refTbl: string; refCol: string }
+
+const {t} = useI18n()
+const {resolveActiveSource, activeLabel} = useDbConnections()
+
+const CARD_W = 200
+const HEADER_H = 26
+const ROW_H = 20
+const GAP_X = 80
+const GAP_Y = 50
+
+const visible = ref(false)
+const loading = ref(false)
+const error = ref('')
+const tables = ref<Tbl[]>([])
+const fks = ref<Fk[]>([])
+// MySQL 未选库时的内联数据库选择
+const picking = ref(false)
+const dbList = ref<string[]>([])
+const pickedDb = ref('')
+const pos = reactive<Record<string, {x: number; y: number}>>({})
+
+const cardH = (tbl: Tbl) => HEADER_H + tbl.columns.length * ROW_H + 4
+const posOf = (name: string) => pos[name] || {x: 0, y: 0}
+
+// 外键源列集合（用于打 ◆ 标记）
+const fkCols = computed(() => new Set(fks.value.map(f => `${f.tbl}.${f.col}`)))
+
+const canvas = computed(() => {
+  let w = 400
+  let h = 300
+  for (const tbl of tables.value) {
+    const p = posOf(tbl.name)
+    w = Math.max(w, p.x + CARD_W + 40)
+    h = Math.max(h, p.y + cardH(tbl) + 40)
+  }
+  return {w, h}
+})
+
+// 外键连线：源卡右缘中点 → 目标卡左缘中点（贝塞尔）
+const edges = computed(() => {
+  const byName = new Map(tables.value.map(t => [t.name, t]))
+  const out: {d: string}[] = []
+  for (const f of fks.value) {
+    const s = byName.get(f.tbl)
+    const tt = byName.get(f.refTbl)
+    if (!s || !tt) {
+      continue
+    }
+    const sp = posOf(f.tbl)
+    const tp = posOf(f.refTbl)
+    const x1 = sp.x + CARD_W
+    const y1 = sp.y + cardH(s) / 2
+    const x2 = tp.x
+    const y2 = tp.y + cardH(tt) / 2
+    const mx = (x1 + x2) / 2
+    out.push({d: `M ${x1} ${y1} C ${mx} ${y1}, ${mx} ${y2}, ${x2} ${y2}`})
+  }
+  return out
+})
+
+// 自动网格布局
+const layout = () => {
+  const perRow = Math.max(1, Math.floor(1000 / (CARD_W + GAP_X)))
+  let x = 20
+  let y = 20
+  let rowMaxH = 0
+  let col = 0
+  for (const tbl of tables.value) {
+    pos[tbl.name] = {x, y}
+    rowMaxH = Math.max(rowMaxH, cardH(tbl))
+    col++
+    if (col >= perRow) {
+      col = 0
+      x = 20
+      y += rowMaxH + GAP_Y
+      rowMaxH = 0
+    }
+    else {
+      x += CARD_W + GAP_X
+    }
+  }
+}
+
+const groupTables = (rows: any[][]): Tbl[] => {
+  const map = new Map<string, Tbl>()
+  for (const row of rows) {
+    const name = String(row[0])
+    if (!map.has(name)) {
+      map.set(name, {name, columns: []})
+    }
+    map.get(name)!.columns.push({name: String(row[1]), type: String(row[2] ?? '')})
+  }
+  return [...map.values()]
+}
+
+const runRows = async (sql: string): Promise<any[][]> => {
+  const source = resolveActiveSource()
+  const res = await invoke<any>('run_sql', {sql, source})
+  if (res.error) {
+    throw new Error(res.error)
+  }
+  return (res.result_sets || [])[0]?.rows || []
+}
+
+const load = async () => {
+  loading.value = true
+  error.value = ''
+  try {
+    const source = resolveActiveSource()
+    // MySQL 未选具体数据库时，先列出数据库让用户在此选择
+    if (source.kind === 'mysql' && !source.database && !pickedDb.value) {
+      picking.value = true
+      dbList.value = (await runRows(
+        'SELECT schema_name FROM information_schema.schemata '
+        + "WHERE schema_name NOT IN ('information_schema','mysql','performance_schema','sys') "
+        + 'ORDER BY schema_name'
+      )).map(r => String(r[0]))
+      return
+    }
+    picking.value = false
+    const db = source.kind === 'mysql' ? source.database || pickedDb.value || undefined : undefined
+    tables.value = groupTables(await runRows(columnsSql(source.kind, db)))
+    const fkQuery = fksSql(source.kind, db)
+    if (fkQuery) {
+      const rows = await runRows(fkQuery).catch(() => [] as any[][])
+      fks.value = rows.map(r => ({tbl: String(r[0]), col: String(r[1]), refTbl: String(r[2]), refCol: String(r[3])}))
+    }
+    else {
+      fks.value = []
+    }
+    layout()
+  }
+  catch (e: any) {
+    error.value = String(e?.message || e)
+  }
+  finally {
+    loading.value = false
+  }
+}
+
+const open = () => {
+  visible.value = true
+  pickedDb.value = ''
+  picking.value = false
+  load()
+}
+
+// 选择数据库后加载该库的 ER
+const selectDb = (name: string) => {
+  pickedDb.value = name
+  load()
+}
+// 返回数据库选择
+const backToPick = () => {
+  pickedDb.value = ''
+  load()
+}
+
+// ===== 拖拽表卡 =====
+let dragName = ''
+let startX = 0
+let startY = 0
+let baseX = 0
+let baseY = 0
+const onDrag = (e: MouseEvent) => {
+  if (!dragName) {
+    return
+  }
+  pos[dragName] = {x: Math.max(0, baseX + (e.clientX - startX)), y: Math.max(0, baseY + (e.clientY - startY))}
+}
+const stopDrag = () => {
+  dragName = ''
+  document.removeEventListener('mousemove', onDrag)
+  document.removeEventListener('mouseup', stopDrag)
+}
+const startDrag = (name: string, e: MouseEvent) => {
+  e.preventDefault()
+  dragName = name
+  startX = e.clientX
+  startY = e.clientY
+  baseX = posOf(name).x
+  baseY = posOf(name).y
+  document.addEventListener('mousemove', onDrag)
+  document.addEventListener('mouseup', stopDrag)
+}
+</script>
diff --git a/src/components/GitIgnoreTemplates.vue b/src/components/GitIgnoreTemplates.vue
new file mode 100644
index 00000000..c0042c3d
--- /dev/null
+++ b/src/components/GitIgnoreTemplates.vue
@@ -0,0 +1,97 @@
+<template>
+  <div class="fixed inset-0 z-50 flex items-start justify-center pt-16 px-6 pb-6" @click="emit('close')">
+    <div class="w-full max-w-[520px] max-h-full bg-white dark:bg-gray-900 dark:text-gray-100 rounded-lg shadow-2xl border border-gray-200 dark:border-gray-700 overflow-hidden flex flex-col"
+         @click.stop>
+      <div class="flex items-center justify-between px-4 py-2.5 border-b border-gray-200 dark:border-gray-700 flex-shrink-0">
+        <div class="flex items-center gap-2 text-sm font-medium text-gray-700 dark:text-gray-200">
+          <FileCode2 class="w-4 h-4 text-gray-400"/>
+          <span>{{ t('gitignore.title') }}</span>
+        </div>
+        <button class="text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 cursor-pointer" @click="emit('close')">
+          <X class="w-4 h-4"/>
+        </button>
+      </div>
+
+      <div class="px-4 py-2 text-[11px] text-gray-400 border-b border-gray-100 dark:border-gray-800 flex-shrink-0">{{ t('gitignore.hint') }}</div>
+
+      <div class="flex-1 overflow-y-auto p-2">
+        <label v-for="tpl in templates" :key="tpl.id"
+               class="flex items-start gap-2 px-2 py-1.5 rounded hover:bg-gray-100 dark:hover:bg-gray-800 cursor-pointer">
+          <input type="checkbox" class="mt-0.5 cursor-pointer" :checked="selected.has(tpl.id)" @change="toggle(tpl.id)"/>
+          <div class="min-w-0">
+            <div class="text-sm text-gray-800 dark:text-gray-100">{{ tpl.label }}</div>
+            <div class="text-[11px] text-gray-400 font-mono truncate">{{ firstPatterns(tpl.content) }}</div>
+          </div>
+        </label>
+      </div>
+
+      <div class="flex items-center justify-end gap-2 px-4 py-2.5 border-t border-gray-200 dark:border-gray-700 flex-shrink-0">
+        <Button size="sm" type="secondary" @click="emit('close')">{{ t('gitignore.cancel') }}</Button>
+        <Button size="sm" :loading="busy" :disabled="!selected.size" @click="apply">{{ t('gitignore.apply') }}</Button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import {onMounted, ref} from 'vue'
+import {invoke} from '@tauri-apps/api/core'
+import {FileCode2, X} from 'lucide-vue-next'
+import Button from '../ui/Button.vue'
+import {useToast} from '../plugins/toast'
+import {useI18n} from 'vue-i18n'
+import {gitignoreTemplates, type GitignoreTemplate} from '../data/gitignoreTemplates'
+
+const props = defineProps<{ rootDir: string }>()
+const emit = defineEmits<{ close: [] }>()
+
+const toast = useToast()
+const {t} = useI18n()
+// 内置 + 用户自定义（独立表）
+const templates = ref<GitignoreTemplate[]>([...gitignoreTemplates])
+const selected = ref<Set<string>>(new Set())
+const busy = ref(false)
+
+onMounted(async () => {
+  try {
+    const custom = await invoke<GitignoreTemplate[]>('gitignore_templates_list')
+    templates.value = [...gitignoreTemplates, ...custom]
+  }
+  catch {
+    // 忽略，仅用内置
+  }
+})
+
+const firstPatterns = (content: string) =>
+  content.split('\n').filter(l => l.trim() && !l.trim().startsWith('#')).slice(0, 4).join('  ')
+
+const toggle = (id: string) => {
+  const s = new Set(selected.value)
+  if (s.has(id)) {
+    s.delete(id)
+  }
+  else {
+    s.add(id)
+  }
+  selected.value = s
+}
+
+const apply = async () => {
+  busy.value = true
+  try {
+    for (const tpl of templates.value) {
+      if (selected.value.has(tpl.id)) {
+        await invoke('git_ignore_append_block', {root: props.rootDir, content: tpl.content})
+      }
+    }
+    toast.success(t('gitignore.applied'))
+    emit('close')
+  }
+  catch (e) {
+    toast.error(t('gitignore.failed') + ': ' + e)
+  }
+  finally {
+    busy.value = false
+  }
+}
+</script>
diff --git a/src/components/GitRebase.vue b/src/components/GitRebase.vue
index 485d3be5..c590574f 100644
--- a/src/components/GitRebase.vue
+++ b/src/components/GitRebase.vue
@@ -29,12 +29,16 @@
              class="flex items-center gap-2 px-4 py-2 border-b border-gray-100 dark:border-gray-800"
              :class="row.action === 'drop' ? 'opacity-50' : ''">
           <div class="flex flex-col flex-shrink-0">
-            <button class="text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 disabled:opacity-20 cursor-pointer leading-none" :disabled="i === 0" :title="t('git.rebaseMoveUp')" @click="move(i, -1)">
-              <ChevronUp class="w-3.5 h-3.5"/>
-            </button>
-            <button class="text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 disabled:opacity-20 cursor-pointer leading-none" :disabled="i === rows.length - 1" :title="t('git.rebaseMoveDown')" @click="move(i, 1)">
-              <ChevronDown class="w-3.5 h-3.5"/>
-            </button>
+            <Tooltip :text="t('git.rebaseMoveUp')">
+              <button class="text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 disabled:opacity-20 cursor-pointer leading-none" :disabled="i === 0" @click="move(i, -1)">
+                <ChevronUp class="w-3.5 h-3.5"/>
+              </button>
+            </Tooltip>
+            <Tooltip :text="t('git.rebaseMoveDown')">
+              <button class="text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 disabled:opacity-20 cursor-pointer leading-none" :disabled="i === rows.length - 1" @click="move(i, 1)">
+                <ChevronDown class="w-3.5 h-3.5"/>
+              </button>
+            </Tooltip>
           </div>
           <select v-model="row.action" class="flex-shrink-0 w-32 text-xs border border-gray-300 dark:border-gray-600 dark:bg-gray-800 rounded px-1.5 py-1 focus:outline-none cursor-pointer">
             <option value="pick" class="dark:bg-gray-800">{{ t('git.rebaseActionPick') }}</option>
@@ -60,6 +64,7 @@ import {onMounted, ref} from 'vue'
 import {invoke} from '@tauri-apps/api/core'
 import {ChevronDown, ChevronUp, ListOrdered, X} from 'lucide-vue-next'
 import Button from '../ui/Button.vue'
+import Tooltip from '../ui/Tooltip.vue'
 import {useToast} from '../plugins/toast'
 import {useI18n} from 'vue-i18n'
 
diff --git a/src/components/GitWorktrees.vue b/src/components/GitWorktrees.vue
index b068a443..0a8a38c6 100644
--- a/src/components/GitWorktrees.vue
+++ b/src/components/GitWorktrees.vue
@@ -37,9 +37,11 @@
             </div>
             <div class="text-[11px] text-gray-400 truncate">{{ wt.path }}</div>
           </div>
-          <button class="text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 opacity-0 group-hover:opacity-100 cursor-pointer flex-shrink-0" :title="t('git.worktreeReveal')" @click="reveal(wt.path)">
-            <FolderOpen class="w-3.5 h-3.5"/>
-          </button>
+          <Tooltip :text="t('git.worktreeReveal')">
+            <button class="text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 opacity-0 group-hover:opacity-100 cursor-pointer flex-shrink-0" @click="reveal(wt.path)">
+              <FolderOpen class="w-3.5 h-3.5"/>
+            </button>
+          </Tooltip>
           <button class="text-xs text-red-500 hover:underline opacity-0 group-hover:opacity-100 cursor-pointer flex-shrink-0" :disabled="busy" @click="remove(wt.path)">{{ t('git.worktreeRemove') }}</button>
         </div>
       </div>
@@ -52,6 +54,7 @@ import {onMounted, ref} from 'vue'
 import {invoke} from '@tauri-apps/api/core'
 import {FolderOpen, TreeDeciduous, X} from 'lucide-vue-next'
 import Button from '../ui/Button.vue'
+import Tooltip from '../ui/Tooltip.vue'
 import {useToast} from '../plugins/toast'
 import {useI18n} from 'vue-i18n'
 
diff --git a/src/components/Settings.vue b/src/components/Settings.vue
index 1735fd28..e2bf8310 100644
--- a/src/components/Settings.vue
+++ b/src/components/Settings.vue
@@ -41,6 +41,11 @@
         <Lsp v-if="activeTab === 'lsp'"/>
       </template>
 
+      <!-- .gitignore 模板 -->
+      <template #gitignore>
+        <Gitignore v-if="activeTab === 'gitignore'"/>
+      </template>
+
       <!-- 网络配置 -->
       <template #network>
         <Network v-if="activeTab === 'network'" @settings-changed="handleNetworkSettingsChanged" @error="handleEditorError"/>
@@ -76,6 +81,7 @@ import Shortcut from './setting/Shortcut.vue'
 import Ai from './setting/Ai.vue'
 import Database from './setting/Database.vue'
 import Lsp from './setting/Lsp.vue'
+import Gitignore from './setting/Gitignore.vue'
 import Network from './setting/Network.vue'
 import Cache from './setting/Cache.vue'
 import Logs from './setting/Logs.vue'
diff --git a/src/components/TaskRunner.vue b/src/components/TaskRunner.vue
index 44338bc9..f9cbe6bc 100644
--- a/src/components/TaskRunner.vue
+++ b/src/components/TaskRunner.vue
@@ -24,9 +24,11 @@
         <div v-if="!tasks.length" class="px-4 py-10 text-center text-sm text-gray-400">{{ t('task.empty') }}</div>
         <div v-for="(tk, i) in tasks" :key="i"
              class="group flex items-center gap-2 px-4 py-2 border-b border-gray-100 dark:border-gray-800">
-          <button class="text-emerald-600 dark:text-emerald-400 hover:text-emerald-500 cursor-pointer flex-shrink-0" :title="t('task.run')" @click="run(tk)">
-            <Play class="w-4 h-4"/>
-          </button>
+          <Tooltip :text="t('task.run')">
+            <button class="text-emerald-600 dark:text-emerald-400 hover:text-emerald-500 cursor-pointer flex-shrink-0" @click="run(tk)">
+              <Play class="w-4 h-4"/>
+            </button>
+          </Tooltip>
           <div class="flex-1 min-w-0">
             <div class="text-sm font-medium text-gray-800 dark:text-gray-100 truncate">{{ tk.label }}</div>
             <div class="text-[11px] text-gray-400 font-mono truncate">{{ tk.command }}</div>
@@ -42,6 +44,7 @@
 import {onMounted, ref} from 'vue'
 import {ListChecks, Play, X} from 'lucide-vue-next'
 import Button from '../ui/Button.vue'
+import Tooltip from '../ui/Tooltip.vue'
 import {kvGetJSON, kvSetJSON} from '../composables/useKvStore'
 import {useI18n} from 'vue-i18n'
 
diff --git a/src/components/TxnControl.vue b/src/components/TxnControl.vue
new file mode 100644
index 00000000..10d66436
--- /dev/null
+++ b/src/components/TxnControl.vue
@@ -0,0 +1,68 @@
+<template>
+  <div class="inline-flex items-center gap-1">
+    <template v-if="!txn.active.value">
+      <Tooltip :text="t('txn.beginTitle')">
+        <button class="inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs text-amber-600 dark:text-amber-400 hover:bg-amber-50 dark:hover:bg-amber-900/30 cursor-pointer"
+                :disabled="busy" @click="begin">
+          <PlayCircle class="w-3.5 h-3.5"/>
+          <span>{{ t('txn.begin') }}</span>
+        </button>
+      </Tooltip>
+    </template>
+    <template v-else>
+      <span class="inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-xs bg-amber-100 text-amber-700 dark:bg-amber-900/40 dark:text-amber-300">
+        <span class="w-1.5 h-1.5 rounded-full bg-amber-500 animate-pulse"/>{{ t('txn.inTxn') }}
+      </span>
+      <button class="px-2 py-0.5 rounded text-xs text-emerald-600 dark:text-emerald-400 hover:bg-emerald-50 dark:hover:bg-emerald-900/30 cursor-pointer" :disabled="busy" @click="finish(true)">{{ t('txn.commit') }}</button>
+      <button class="px-2 py-0.5 rounded text-xs text-red-500 hover:bg-red-50 dark:hover:bg-red-900/30 cursor-pointer" :disabled="busy" @click="finish(false)">{{ t('txn.rollback') }}</button>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import {ref} from 'vue'
+import {PlayCircle} from 'lucide-vue-next'
+import {useI18n} from 'vue-i18n'
+import Tooltip from '../ui/Tooltip.vue'
+import {useSqlTxn} from '../composables/useSqlTxn'
+import {useDbConnections} from '../composables/useDbConnections'
+import {useToast} from '../plugins/toast'
+
+const emit = defineEmits<{ notice: [text: string] }>()
+const {t} = useI18n()
+const txn = useSqlTxn()
+const {resolveActiveSource} = useDbConnections()
+const toast = useToast()
+const busy = ref(false)
+
+const begin = async () => {
+  busy.value = true
+  try {
+    await txn.begin(resolveActiveSource())
+    toast.success(t('txn.began'))
+    emit('notice', t('txn.began'))
+  }
+  catch (e) {
+    toast.error(t('txn.failed') + ': ' + e)
+  }
+  finally {
+    busy.value = false
+  }
+}
+
+const finish = async (commit: boolean) => {
+  busy.value = true
+  try {
+    await txn.finish(commit)
+    const msg = commit ? t('txn.committed') : t('txn.rolledBack')
+    toast.success(msg)
+    emit('notice', msg)
+  }
+  catch (e) {
+    toast.error(t('txn.failed') + ': ' + e)
+  }
+  finally {
+    busy.value = false
+  }
+}
+</script>
diff --git a/src/components/setting/Gitignore.vue b/src/components/setting/Gitignore.vue
new file mode 100644
index 00000000..d1ad6706
--- /dev/null
+++ b/src/components/setting/Gitignore.vue
@@ -0,0 +1,121 @@
+<template>
+  <div class="-mt-1">
+    <p class="text-sm text-gray-600 dark:text-gray-300 mb-3">
+      {{ t('settings.gitignore.desc') }}
+    </p>
+
+    <!-- 主从布局：左侧模板列表 + 右侧表单 -->
+    <div class="flex gap-4 items-start">
+      <!-- 左：模板列表 -->
+      <div class="w-64 flex-shrink-0 space-y-2">
+        <Button size="sm" :icon="Plus" class="w-full" :type="editingId ? 'secondary' : 'primary'" @click="resetForm">{{ t('settings.gitignore.add') }}</Button>
+        <div class="space-y-1 max-h-[55vh] overflow-y-auto pr-0.5">
+          <button v-for="tpl in list" :key="tpl.id"
+                  class="group w-full text-left rounded-lg border px-2.5 py-2 transition-colors cursor-pointer"
+                  :class="editingId === tpl.id ? 'border-blue-400 bg-blue-50 dark:border-blue-500 dark:bg-blue-900/20' : 'border-gray-200 dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-800'"
+                  @click="edit(tpl)">
+            <div class="flex items-center gap-2">
+              <span class="flex-1 truncate text-sm font-medium text-gray-800 dark:text-gray-100">{{ tpl.label }}</span>
+              <Trash2 class="w-3.5 h-3.5 text-gray-400 hover:text-red-500 opacity-0 group-hover:opacity-100 flex-shrink-0" :title="t('settings.gitignore.delete')" @click.stop="remove(tpl.id)"/>
+            </div>
+            <div class="text-xs text-gray-400 truncate mt-0.5 font-mono">{{ preview(tpl.content) }}</div>
+          </button>
+          <div v-if="!list.length" class="text-xs text-gray-400 text-center py-6">{{ t('settings.gitignore.empty') }}</div>
+        </div>
+      </div>
+
+      <!-- 右：表单 -->
+      <div class="flex-1 min-w-0 border border-gray-200 dark:border-gray-700 rounded-lg p-4 space-y-4">
+        <div class="text-sm font-medium text-gray-700 dark:text-gray-200">{{ editingId ? t('settings.gitignore.editTitle') : t('settings.gitignore.newTitle') }}</div>
+
+        <Label :label="t('settings.gitignore.name')">
+          <Input v-model="label" :placeholder="t('settings.gitignore.labelPlaceholder')"/>
+        </Label>
+        <Label :label="t('settings.gitignore.content')">
+          <textarea v-model="content" rows="10"
+                    class="w-full text-xs font-mono border border-gray-300 dark:border-gray-600 dark:bg-gray-800 rounded px-2 py-1.5 focus:outline-none focus:border-blue-500"
+                    :placeholder="t('settings.gitignore.contentPlaceholder')"/>
+        </Label>
+
+        <div class="flex items-center gap-2 pt-1">
+          <Button size="sm" :disabled="!label.trim() || !content.trim()" @click="save">{{ editingId ? t('settings.gitignore.update') : t('settings.gitignore.add') }}</Button>
+          <Button v-if="editingId" size="sm" type="secondary" @click="resetForm">{{ t('settings.gitignore.cancel') }}</Button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import {onMounted, ref} from 'vue'
+import {invoke} from '@tauri-apps/api/core'
+import {Plus, Trash2} from 'lucide-vue-next'
+import {useI18n} from 'vue-i18n'
+import Input from '../../ui/Input.vue'
+import Button from '../../ui/Button.vue'
+import Label from '../../ui/Label.vue'
+import {useToast} from '../../plugins/toast'
+
+interface Tpl { id: string; label: string; content: string }
+
+const {t} = useI18n()
+const toast = useToast()
+const list = ref<Tpl[]>([])
+const label = ref('')
+const content = ref('')
+const editingId = ref('')
+
+const preview = (c: string) => c.split('\n').filter(l => l.trim() && !l.trim().startsWith('#')).slice(0, 3).join('  ')
+
+const load = async () => {
+  try {
+    list.value = await invoke<Tpl[]>('gitignore_templates_list')
+  }
+  catch {
+    list.value = []
+  }
+}
+
+const resetForm = () => {
+  label.value = ''
+  content.value = ''
+  editingId.value = ''
+}
+
+const save = async () => {
+  if (!label.value.trim() || !content.value.trim()) {
+    return
+  }
+  const id = editingId.value || crypto.randomUUID()
+  try {
+    await invoke('gitignore_template_save', {template: {id, label: label.value.trim(), content: content.value}})
+    toast.success(t('settings.gitignore.saved'))
+    resetForm()
+    await load()
+  }
+  catch (e) {
+    toast.error(t('settings.gitignore.failed') + ': ' + e)
+  }
+}
+
+const edit = (tpl: Tpl) => {
+  editingId.value = tpl.id
+  label.value = tpl.label
+  content.value = tpl.content
+}
+
+const remove = async (id: string) => {
+  try {
+    await invoke('gitignore_template_delete', {id})
+    if (editingId.value === id) {
+      resetForm()
+    }
+    await load()
+  }
+  catch (e) {
+    toast.error(t('settings.gitignore.failed') + ': ' + e)
+  }
+}
+
+onMounted(load)
+</script>
diff --git a/src/composables/useCodeMirrorEditor.ts b/src/composables/useCodeMirrorEditor.ts
index cac465c6..dcd36104 100644
--- a/src/composables/useCodeMirrorEditor.ts
+++ b/src/composables/useCodeMirrorEditor.ts
@@ -1,4 +1,4 @@
-import {nextTick, ref, shallowRef, watch} from 'vue'
+import {computed, nextTick, ref, shallowRef, watch} from 'vue'
 import {debounce} from 'lodash-es'
 import {useTheme} from './useTheme'
 import {i18n} from '../i18n'
@@ -293,6 +293,36 @@ export function useCodeMirrorEditor(props: Props)
     // 仅在显式整体赋值 extensions.value = result 时才触发重建。
     const extensions = shallowRef<any[]>([])
     const editorConfig = ref<EditorConfig>({})
+
+    // 当前文件的 .editorconfig 覆盖（按文件解析，覆盖全局缩进设置）
+    const ecOverride = ref<{indentWithTab?: boolean; tabSize?: number}>({})
+    const resolveEditorconfig = async () => {
+        if (!props.filePath) {
+            ecOverride.value = {}
+            return
+        }
+        try {
+            const r = await invoke<any>('resolve_editorconfig', {filePath: props.filePath})
+            const o: {indentWithTab?: boolean; tabSize?: number} = {}
+            if (r?.indent_style === 'tab') {
+                o.indentWithTab = true
+            }
+            else if (r?.indent_style === 'space') {
+                o.indentWithTab = false
+            }
+            const size = r?.indent_size ?? r?.tab_width
+            if (typeof size === 'number' && size > 0) {
+                o.tabSize = size
+            }
+            ecOverride.value = o
+        }
+        catch {
+            ecOverride.value = {}
+        }
+    }
+    // 实际生效的缩进：.editorconfig 优先，否则用全局配置
+    const effectiveTabSize = computed(() => ecOverride.value.tabSize ?? editorConfig.value?.tab_size)
+    const effectiveIndentWithTab = computed(() => ecOverride.value.indentWithTab ?? editorConfig.value?.indent_with_tab)
     const defaultConfig = {
         theme: 'githubLight',
         indent_with_tab: true,
@@ -739,6 +769,7 @@ export function useCodeMirrorEditor(props: Props)
     // 初始化编辑器
     const initializeEditor = async () => {
         await loadEditorConfig()
+        await resolveEditorconfig()
     }
 
     // 监听语言变化
@@ -747,8 +778,9 @@ export function useCodeMirrorEditor(props: Props)
         await reRenderEditor()
     }, {immediate: false})
 
-    // 文件切换：重建扩展以切换 LSP 文档（就地重配置，避免闪烁）
+    // 文件切换：重建扩展以切换 LSP 文档（就地重配置，避免闪烁）；并重解析 .editorconfig
     watch(() => props.filePath, async () => {
+        await resolveEditorconfig()
         await updateExtensions()
     }, {immediate: false})
 
@@ -802,6 +834,8 @@ export function useCodeMirrorEditor(props: Props)
         isReady,
         extensions,
         editorConfig,
+        effectiveTabSize,
+        effectiveIndentWithTab,
 
         // 方法
         initializeEditor,
diff --git a/src/composables/useDebug.ts b/src/composables/useDebug.ts
index 400d6b70..1f79aebc 100644
--- a/src/composables/useDebug.ts
+++ b/src/composables/useDebug.ts
@@ -1,5 +1,6 @@
 // 调试状态共享 store（单例）。P2：断点与执行位置；P3：会话编排与控制。
 import {reactive, ref} from 'vue'
+import {invoke} from '@tauri-apps/api/core'
 import {DapClient} from '../debug/dapClient'
 
 export type DebugStatus = 'inactive' | 'starting' | 'running' | 'stopped'
@@ -263,16 +264,31 @@ async function requestVariables(variablesReference: number): Promise<DapVariable
 }
 
 // 各语言 launch 请求参数（Python=debugpy 源码级 / Go=delve 源码级）
-function buildLaunchArgs(config: LaunchConfig): Record<string, any> {
+const COMPILED = ['rust', 'c', 'cpp']
+function adapterIdFor(language: string): string {
+  if (language === 'go') {
+    return 'go'
+  }
+  if (COMPILED.includes(language)) {
+    return 'lldb'
+  }
+  return 'debugpy'
+}
+
+function buildLaunchArgs(config: LaunchConfig, program: string): Record<string, any> {
   const base: Record<string, any> = {
     request: 'launch',
     name: 'CodeForge',
-    program: config.filePath,
+    program,
     cwd: config.cwd || undefined
   }
   if (config.language === 'go') {
     return {...base, mode: 'debug'}
   }
+  if (COMPILED.includes(config.language)) {
+    // lldb-dap：program 为编译产物
+    return {...base, args: [], stopOnEntry: false}
+  }
   return {...base, type: 'python', console: 'internalConsole', justMyCode: true, stopOnEntry: false}
 }
 
@@ -287,6 +303,23 @@ async function startSession(config: LaunchConfig): Promise<void> {
   status.value = 'starting'
   consoleLines.value = []
   threadId = 0
+  // 编译型语言：先构建拿到可执行文件作为 program
+  let program = config.filePath
+  if (COMPILED.includes(config.language)) {
+    pushOut('console', '正在构建…\n')
+    try {
+      program = await invoke<string>('dap_build', {
+        language: config.language,
+        filePath: config.filePath,
+        root: config.cwd || ''
+      })
+    }
+    catch (e) {
+      pushOut('stderr', `${e}\n`)
+      cleanup()
+      throw e
+    }
+  }
   const c = new DapClient('debug', config.language)
   client = c
 
@@ -315,7 +348,7 @@ async function startSession(config: LaunchConfig): Promise<void> {
     const caps = await c.request('initialize', {
       clientID: 'codeforge',
       clientName: 'CodeForge',
-      adapterID: config.language === 'go' ? 'go' : 'debugpy',
+      adapterID: adapterIdFor(config.language),
       locale: 'en',
       linesStartAt1: true,
       columnsStartAt1: true,
@@ -330,7 +363,7 @@ async function startSession(config: LaunchConfig): Promise<void> {
       )
     }
     // launch 在 configurationDone 后才返回，故不在主流程等待
-    c.request('launch', buildLaunchArgs(config)).catch((e) => {
+    c.request('launch', buildLaunchArgs(config, program)).catch((e) => {
       pushOut('stderr', `launch 失败: ${e}\n`)
       stopSession()
     })
diff --git a/src/composables/useSettings.ts b/src/composables/useSettings.ts
index 279bdd5a..146b3f47 100644
--- a/src/composables/useSettings.ts
+++ b/src/composables/useSettings.ts
@@ -1,5 +1,5 @@
 import { computed, nextTick, ref } from 'vue'
-import { BracesIcon, CodeIcon, Cpu, Database, FileText, Globe, Keyboard, Languages, Server, ShieldIcon, Sparkles } from 'lucide-vue-next'
+import { BracesIcon, CodeIcon, Cpu, Database, FileCode2, FileText, Globe, Keyboard, Languages, Server, ShieldIcon, Sparkles } from 'lucide-vue-next'
 import { i18n } from '../i18n'
 
 export function useSettings(emit: any)
@@ -19,6 +19,7 @@ export function useSettings(emit: any)
         { key: 'database', label: t('settings.nav.database'), icon: Server },
         { key: 'language', label: t('settings.nav.language'), icon: BracesIcon },
         { key: 'lsp', label: t('settings.nav.lsp'), icon: Cpu },
+        { key: 'gitignore', label: t('settings.nav.gitignore'), icon: FileCode2 },
         { key: 'network', label: t('settings.nav.network'), icon: Globe },
         { key: 'cache', label: t('settings.nav.cache'), icon: Database },
         { key: 'logs', label: t('settings.nav.logs'), icon: FileText },
diff --git a/src/composables/useSqlTxn.ts b/src/composables/useSqlTxn.ts
new file mode 100644
index 00000000..1183800c
--- /dev/null
+++ b/src/composables/useSqlTxn.ts
@@ -0,0 +1,28 @@
+// 交互式 SQL 事务（单例）。后端按会话持有一条连接，跨多次执行在同一连接上跑。
+import {ref} from 'vue'
+import {invoke} from '@tauri-apps/api/core'
+
+const active = ref(false)
+
+async function begin(source: any): Promise<void> {
+  await invoke('tx_begin', {source})
+  active.value = true
+}
+
+// 在事务连接上执行 SQL，返回与 run_sql 同结构的结果
+async function exec(sql: string): Promise<any> {
+  return await invoke('tx_exec', {sql})
+}
+
+async function finish(commit: boolean): Promise<void> {
+  try {
+    await invoke('tx_finish', {commit})
+  }
+  finally {
+    active.value = false
+  }
+}
+
+export function useSqlTxn() {
+  return {active, begin, exec, finish}
+}
diff --git a/src/data/gitignoreTemplates.ts b/src/data/gitignoreTemplates.ts
new file mode 100644
index 00000000..b3caef32
--- /dev/null
+++ b/src/data/gitignoreTemplates.ts
@@ -0,0 +1,111 @@
+// 常用 .gitignore 模板块（按语言/框架/平台）。每块首行为标题注释，用于去重。
+export interface GitignoreTemplate { id: string; label: string; content: string }
+
+export const gitignoreTemplates: GitignoreTemplate[] = [
+  {
+    id: 'node',
+    label: 'Node',
+    content: `# Node
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+.pnpm-store/
+dist/
+.cache/`
+  },
+  {
+    id: 'python',
+    label: 'Python',
+    content: `# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+venv/
+env/
+.pytest_cache/
+.mypy_cache/
+build/
+dist/`
+  },
+  {
+    id: 'rust',
+    label: 'Rust',
+    content: `# Rust
+/target/
+**/*.rs.bk
+Cargo.lock`
+  },
+  {
+    id: 'go',
+    label: 'Go',
+    content: `# Go
+/bin/
+/vendor/
+*.exe
+*.test
+*.out
+go.work`
+  },
+  {
+    id: 'java',
+    label: 'Java / Maven / Gradle',
+    content: `# Java
+*.class
+target/
+build/
+.gradle/
+*.jar
+*.war
+hs_err_pid*`
+  },
+  {
+    id: 'macos',
+    label: 'macOS',
+    content: `# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+._*`
+  },
+  {
+    id: 'windows',
+    label: 'Windows',
+    content: `# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+$RECYCLE.BIN/
+*.lnk`
+  },
+  {
+    id: 'ide',
+    label: 'IDE / 编辑器',
+    content: `# IDE / Editors
+.idea/
+.vscode/
+*.swp
+*.swo
+*~`
+  },
+  {
+    id: 'env',
+    label: '环境与密钥',
+    content: `# Env & secrets
+.env
+.env.local
+.env.*.local
+*.pem
+*.key`
+  },
+  {
+    id: 'logs',
+    label: '日志',
+    content: `# Logs
+logs/
+*.log`
+  }
+]
diff --git a/src/debug/dapClient.ts b/src/debug/dapClient.ts
index 3b31dfdd..fc3f2eda 100644
--- a/src/debug/dapClient.ts
+++ b/src/debug/dapClient.ts
@@ -4,8 +4,8 @@
 import {invoke} from '@tauri-apps/api/core'
 import {listen, type UnlistenFn} from '@tauri-apps/api/event'
 
-// 已打通的可调试语言（源码级）。Rust/C/C++ 为编译型，需先构建再调试可执行文件，留待 P6b。
-const DAP_LANGUAGES = new Set(['python', 'python3', 'python2', 'go'])
+// 已打通的可调试语言。Rust/C/C++ 为编译型：先 dap_build 构建，再用产物经 lldb-dap 调试。
+const DAP_LANGUAGES = new Set(['python', 'python3', 'python2', 'go', 'rust', 'c', 'cpp'])
 export function dapSupportsLanguage(language?: string): boolean {
   return !!language && DAP_LANGUAGES.has(language)
 }
diff --git a/src/i18n/locales/en.json b/src/i18n/locales/en.json
index a98d1125..a0aba794 100644
--- a/src/i18n/locales/en.json
+++ b/src/i18n/locales/en.json
@@ -10,6 +10,7 @@
       "database": "Database",
       "language": "Languages",
       "lsp": "Language Server",
+      "gitignore": ".gitignore",
       "network": "Network",
       "cache": "Cache",
       "logs": "Logs",
@@ -213,6 +214,24 @@
       "installDone": "✓ Installation complete",
       "installFailed": "✗ Installation failed"
     },
+    "gitignore": {
+      "title": "Custom .gitignore templates",
+      "desc": "Manage custom ignore templates (stored in a dedicated local DB table); they appear alongside built-in ones in \"Insert .gitignore template\".",
+      "newTitle": "New template",
+      "editTitle": "Edit template",
+      "name": "Template name",
+      "content": "Ignore rules",
+      "labelPlaceholder": "Template name, e.g. My frontend project",
+      "contentPlaceholder": "# My template\nnode_modules/\ndist/\n…",
+      "add": "Add",
+      "update": "Save",
+      "cancel": "Cancel",
+      "edit": "Edit",
+      "delete": "Delete",
+      "empty": "No custom templates yet",
+      "saved": "Saved",
+      "failed": "Operation failed"
+    },
     "language": {
       "filter": "Filter languages",
       "addCustom": "Add custom language",
@@ -661,6 +680,7 @@
     "preview": "Live preview (Markdown / HTML)",
     "git": "Git source control",
     "tasks": "Run tasks",
+    "gitignore": "Insert .gitignore template",
     "runTests": "Run tests (auto-detect)",
     "startDebug": "Debug current file",
     "sendToTerminal": "Send selection to terminal",
@@ -1030,6 +1050,34 @@
     "revealIn": "Reveal in file manager: {path}",
     "unsaved": "Unsaved changes"
   },
+  "gitignore": {
+    "title": ".gitignore templates",
+    "hint": "Pick languages/frameworks/platforms to ignore; appended to the project root .gitignore (existing blocks are skipped).",
+    "apply": "Add to .gitignore",
+    "cancel": "Cancel",
+    "applied": "Added to .gitignore",
+    "failed": "Write failed"
+  },
+  "txn": {
+    "begin": "Transaction",
+    "beginTitle": "Begin a transaction (runs on one connection until commit/rollback)",
+    "inTxn": "In transaction",
+    "commit": "Commit",
+    "rollback": "Rollback",
+    "began": "Transaction started",
+    "committed": "Committed",
+    "rolledBack": "Rolled back",
+    "failed": "Transaction failed"
+  },
+  "er": {
+    "title": "ER diagram",
+    "summary": "{tables} tables · {fks} foreign keys",
+    "loading": "Loading schema…",
+    "empty": "No tables to show",
+    "pickDb": "Choose a database to view:",
+    "switchDb": "Switch DB",
+    "tip": "Drag a table header to rearrange"
+  },
   "aiCode": {
     "title": {
       "explain": "AI: Explain code",
@@ -1069,6 +1117,7 @@
     "langUnsupported": "Debugging not supported for this language",
     "installPython": "debugpy not found — install it: pip install debugpy",
     "installGo": "delve not found — install it: go install github.com/go-delve/delve/cmd/dlv@latest",
+    "installLldb": "lldb-dap not found — install LLVM (includes lldb-dap) and ensure it's on PATH",
     "startFailed": "Failed to start debugging",
     "panelTitle": "Debug",
     "callStack": "Call stack",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index ed31c4c9..14e7fae4 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -10,6 +10,7 @@
       "database": "数据库",
       "language": "语言",
       "lsp": "语言服务",
+      "gitignore": ".gitignore",
       "network": "网络",
       "cache": "缓存",
       "logs": "日志",
@@ -213,6 +214,24 @@
       "installDone": "✓ 安装完成",
       "installFailed": "✗ 安装失败"
     },
+    "gitignore": {
+      "title": "自定义 .gitignore 模板",
+      "desc": "在此管理自定义忽略模板（保存到本地数据库独立表），可在「插入 .gitignore 模板」中与内置模板一起选用。",
+      "newTitle": "新增模板",
+      "editTitle": "编辑模板",
+      "name": "模板名称",
+      "content": "忽略规则",
+      "labelPlaceholder": "模板名称，如 我的前端项目",
+      "contentPlaceholder": "# 我的模板\nnode_modules/\ndist/\n…",
+      "add": "添加",
+      "update": "保存修改",
+      "cancel": "取消",
+      "edit": "编辑",
+      "delete": "删除",
+      "empty": "还没有自定义模板",
+      "saved": "已保存",
+      "failed": "操作失败"
+    },
     "language": {
       "filter": "筛选语言",
       "addCustom": "添加自定义语言",
@@ -661,6 +680,7 @@
     "preview": "实时预览（Markdown / HTML）",
     "git": "Git 源代码管理",
     "tasks": "运行任务",
+    "gitignore": "插入 .gitignore 模板",
     "runTests": "运行测试（自动识别）",
     "startDebug": "开始调试当前文件",
     "sendToTerminal": "发送选区到终端",
@@ -1030,6 +1050,34 @@
     "revealIn": "在访达中显示：{path}",
     "unsaved": "有未保存的修改"
   },
+  "gitignore": {
+    "title": ".gitignore 模板",
+    "hint": "勾选要忽略的语言/框架/平台，追加到项目根目录的 .gitignore（已存在的块会跳过）。",
+    "apply": "添加到 .gitignore",
+    "cancel": "取消",
+    "applied": "已添加到 .gitignore",
+    "failed": "写入失败"
+  },
+  "txn": {
+    "begin": "事务",
+    "beginTitle": "开启事务（在同一连接上执行，直到提交/回滚）",
+    "inTxn": "事务中",
+    "commit": "提交",
+    "rollback": "回滚",
+    "began": "事务已开启",
+    "committed": "已提交",
+    "rolledBack": "已回滚",
+    "failed": "事务操作失败"
+  },
+  "er": {
+    "title": "ER 图",
+    "summary": "{tables} 张表 · {fks} 个外键",
+    "loading": "加载结构中…",
+    "empty": "没有可显示的表",
+    "pickDb": "请选择要查看的数据库：",
+    "switchDb": "换库",
+    "tip": "拖动表头可调整布局"
+  },
   "aiCode": {
     "title": {
       "explain": "AI 解释代码",
@@ -1069,6 +1117,7 @@
     "langUnsupported": "当前语言暂不支持调试",
     "installPython": "未检测到 debugpy，请先安装：pip install debugpy",
     "installGo": "未检测到 delve，请先安装：go install github.com/go-delve/delve/cmd/dlv@latest",
+    "installLldb": "未检测到 lldb-dap，请安装 LLVM（含 lldb-dap）并确保在 PATH 中",
     "startFailed": "启动调试失败",
     "panelTitle": "调试",
     "callStack": "调用栈",
diff --git a/src/utils/dbSchema.ts b/src/utils/dbSchema.ts
new file mode 100644
index 00000000..53ab712e
--- /dev/null
+++ b/src/utils/dbSchema.ts
@@ -0,0 +1,56 @@
+// 按数据库类型构造「列」与「外键」查询。用于 schema 浏览 / ER 图。
+const esc = (s: string) => s.replace(/'/g, "''")
+
+// 返回 (tbl, col, typ) 行
+export function columnsSql(kind: string, db?: string): string {
+  if (kind === 'mysql') {
+    return 'SELECT table_name AS tbl, column_name AS col, column_type AS typ '
+      + `FROM information_schema.columns WHERE table_schema = '${esc(db || '')}' `
+      + 'ORDER BY table_name, ordinal_position'
+  }
+  if (kind === 'postgres') {
+    return 'SELECT table_name AS tbl, column_name AS col, data_type AS typ '
+      + 'FROM information_schema.columns '
+      + "WHERE table_schema NOT IN ('pg_catalog', 'information_schema') "
+      + 'ORDER BY table_name, ordinal_position'
+  }
+  if (kind === 'clickhouse') {
+    return 'SELECT table AS tbl, name AS col, type AS typ '
+      + 'FROM system.columns WHERE database = currentDatabase() '
+      + 'ORDER BY table, position'
+  }
+  if (kind === 'duckdb') {
+    return 'SELECT table_name AS tbl, column_name AS col, data_type AS typ '
+      + 'FROM information_schema.columns '
+      + "WHERE table_schema NOT IN ('information_schema', 'pg_catalog') "
+      + 'ORDER BY table_name, ordinal_position'
+  }
+  return 'SELECT m.name AS tbl, p.name AS col, p.type AS typ '
+    + 'FROM sqlite_master m JOIN pragma_table_info(m.name) p '
+    + "WHERE m.type IN ('table','view') AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\' "
+    + 'ORDER BY m.name, p.cid'
+}
+
+// 返回 (tbl, col, ref_table, ref_col) 行；无外键内省能力的库返回空串
+export function fksSql(kind: string, db?: string): string {
+  if (kind === 'mysql') {
+    return 'SELECT table_name AS tbl, column_name AS col, referenced_table_name AS ref_tbl, referenced_column_name AS ref_col '
+      + `FROM information_schema.key_column_usage WHERE table_schema = '${esc(db || '')}' `
+      + 'AND referenced_table_name IS NOT NULL'
+  }
+  if (kind === 'postgres') {
+    return 'SELECT tc.table_name AS tbl, kcu.column_name AS col, ccu.table_name AS ref_tbl, ccu.column_name AS ref_col '
+      + 'FROM information_schema.table_constraints tc '
+      + 'JOIN information_schema.key_column_usage kcu ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema '
+      + 'JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema '
+      + "WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')"
+  }
+  // clickhouse / duckdb 等无外键内省，返回空
+  if (kind === 'clickhouse' || kind === 'duckdb') {
+    return ''
+  }
+  // sqlite / 内存库：用 pragma_foreign_key_list
+  return 'SELECT m.name AS tbl, f."from" AS col, f."table" AS ref_tbl, f."to" AS ref_col '
+    + 'FROM sqlite_master m JOIN pragma_foreign_key_list(m.name) f '
+    + "WHERE m.type = 'table' AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\'"
+}