@@ -101,6 +101,12 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
     // v0.5.0 M8（REQ-055）：补缝式 AI 护栏骨架（配额/缓存/审计；云端 V1.0 生效）
     let ai_guardrails =
         std::sync::Arc::new(std::sync::Mutex::new(crate::ai_guardrails::AiGuardrails::default()));
+    // v0.11.1：功能开关（feed_capture 默认关——v4 §11.3；JSON 持久化，
+    // 缺失/损坏回退默认不阻断启动；同 ai_settings 模式）
+    let feature_flags_path = data_dir.join("feature_flags.json");
+    let feature_flags = std::sync::Arc::new(std::sync::Mutex::new(
+        crate::feature_flags::FeatureFlags::load(&feature_flags_path),
+    ));
     // v0.6.0 M1（REQ-083/060）：可校准配置——ui_junk.json 黑名单与
     // symbol_map.json 映射表（缺失走内置默认；损坏回退默认，不阻断启动）
     let ui_junk = crate::ui_junk::UiJunkList::load(&data_dir.join("ui_junk.json"));
@@ -210,6 +216,8 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
         profile_memory,
         data_dir,
         ai_guardrails,
+        feature_flags,
+        feature_flags_path,
         structure_downloader,
         speaker_downloader,
         structure_tier_path,
 
@@ -113,6 +113,10 @@ pub struct AppState {
     /// v0.5.0 M8（REQ-055）：补缝式 AI 护栏状态（每日配额 + 同图 hash 缓存；
     /// 云端 V1.0 实装后生效，骨架就位）
     pub ai_guardrails: std::sync::Arc<std::sync::Mutex<crate::ai_guardrails::AiGuardrails>>,
+    /// v0.11.1：功能开关内存态单点（锁内 read-modify-write，同词表模式防 TOCTOU）
+    pub feature_flags: std::sync::Arc<std::sync::Mutex<crate::feature_flags::FeatureFlags>>,
+    /// v0.11.1：功能开关 JSON 路径（应用数据目录）
+    pub feature_flags_path: std::path::PathBuf,
     /// v0.5.0 模型版（REQ-047/049/050）：结构模型下载器（版面/表格/公式按需下载）
     pub structure_downloader: crate::structure_models::StructureModelDownloader,
     /// TD-2026-08-20-D 清偿（G1）：说话人模型下载器（wespeaker 应用内一键下载）
 
@@ -0,0 +1,199 @@
+//! 碎片捕获与功能开关 commands（v0.11.1；feed 进料口系统层）。
+//!
+//! @ai-context: v4 §11.3 裁决——feed 能力功能开关默认关：capture_fragment
+//!              后端二次校验开关（不信前端隐藏）；碎片 DomainTag 自动归组
+//!              复用 detect_domain 纯函数（领域粒度=契约一，拒绝大类）。
+//! @ai-context: 本层只做参数校验、调用数据层、错误映射（AGENTS.md §6）；
+//!              图片解码验证用 image crate（白名单格式，防任意字节落盘）。
+
+use tauri::State;
+
+use crate::commands::AppState;
+use crate::db_fragments::NewFragment;
+use crate::types::{Fragment, NewNoteGroup};
+use crate::video_profile_domain::{detect_domain, DomainSignals};
+
+/// 碎片文本最大长度（防超大 payload 拖垮 IPC/DB；几句话的碎片远用不到）。
+const FRAGMENT_TEXT_MAX: usize = 2000;
+/// 碎片图片最大字节数（示范画面截图级；超限拒绝可诊断）。
+const FRAGMENT_IMAGE_MAX_BYTES: usize = 10 * 1024 * 1024;
+/// 碎片列表单次上限（防无界查询）。
+const FRAGMENT_LIST_LIMIT_MAX: usize = 500;
+
+/// 读取功能开关集（前端据此显隐 feed 捕获面）。
+#[tauri::command]
+pub fn get_feature_flags(state: State<'_, AppState>) -> Result<crate::feature_flags::FeatureFlags, String> {
+    let guard = state.feature_flags.lock().map_err(|e| format!("开关锁失败: {}", e))?;
+    Ok(guard.clone())
+}
+
+/// 设置功能开关（白名单在 FeatureFlags::set 内；持久化失败回滚内存态）。
+#[tauri::command]
+pub fn set_feature_flag(
+    state: State<'_, AppState>,
+    name: String,
+    value: bool,
+) -> Result<bool, String> {
+    let mut guard = state.feature_flags.lock().map_err(|e| format!("开关锁失败: {}", e))?;
+    let mut next = guard.clone();
+    if !next.set(&name, value) {
+        return Err(format!("未知功能开关: {}", name));
+    }
+    // 先落盘再更新内存态（落盘失败不留半态）
+    next.save(&state.feature_flags_path).map_err(|e| format!("开关持久化失败: {}", e))?;
+    *guard = next;
+    Ok(value)
+}
+
+/// 碎片快速捕获（feed 进料口；文本 + 可选图片字节）。
+///
+/// @ai-context: 流程——开关准入 → 文本校验 → 图片解码验证落盘 →
+///              DomainTag 检测 → feed 主题组查/建 → 碎片落库。
+///              图片失败不阻断文本捕获（诚实降级：纯文本碎片）。
+#[tauri::command]
+pub async fn capture_fragment(
+    state: State<'_, AppState>,
+    text: String,
+    image_bytes: Option<Vec<u8>>,
+    source: Option<String>,
+) -> Result<Fragment, String> {
+    // 开关准入（后端不信前端隐藏——v4 §11.3 默认关纪律）
+    {
+        let guard = state.feature_flags.lock().map_err(|e| format!("开关锁失败: {}", e))?;
+        if !guard.feed_capture {
+            return Err("碎片捕获未启用（请在设置中开启 feed 捕获开关）".to_string());
+        }
+    }
+    let text: String = text.trim().chars().take(FRAGMENT_TEXT_MAX).collect();
+    if text.is_empty() {
+        return Err("碎片内容不能为空".to_string());
+    }
+    let source = match source.as_deref() {
+        Some("clipboard") => "clipboard".to_string(),
+        _ => "manual".to_string(),
+    };
+    // 图片：解码验证 + 统一转 PNG 落盘（白名单格式由解码器把关）
+    let image_path = match image_bytes {
+        Some(bytes) if !bytes.is_empty() => {
+            match save_fragment_image(&state.data_dir, &bytes) {
+                Ok(rel) => Some(rel),
+                Err(e) => {
+                    // 图片失败不阻断文本捕获（降级为纯文本碎片，留日志线索）
+                    eprintln!("[fragments] 图片落盘失败（降级纯文本碎片）: {e}");
+                    None
+                }
+            }
+        }
+        _ => None,
+    };
+    // DomainTag 自动归组（detect_domain 标题词路径——碎片文本即判据源）
+    let detection = detect_domain(&DomainSignals {
+        title: Some(text.clone()),
+        ..Default::default()
+    });
+    let (domain_tag, group_id) = match detection.kind {
+        Some(kind) => {
+            let tag = kind.as_str().to_string();
+            let gid = resolve_feed_topic_group(&state.db, &tag, kind.label())?;
+            (Some(tag), Some(gid))
+        }
+        None => (None, None), // 未命中 → 无组（结算面兜底归组，不硬塞大类）
+    };
+    let fragment = state
+        .db
+        .create_fragment(&NewFragment {
+            text,
+            image_path,
+            domain_tag,
+            group_id,
+            source,
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(fragment)
+}
+
+/// 列出碎片（status 过滤 + 数量上限）。
+#[tauri::command]
+pub fn list_fragments(
+    state: State<'_, AppState>,
+    status: Option<String>,
+    limit: Option<usize>,
+) -> Result<Vec<Fragment>, String> {
+    let status = status.as_deref().filter(|s| !s.trim().is_empty());
+    if let Some(s) = status {
+        if s != "active" && s != "archived" {
+            return Err(format!("不支持的碎片状态: {}（支持: active/archived）", s));
+        }
+    }
+    let limit = limit.unwrap_or(200).min(FRAGMENT_LIST_LIMIT_MAX);
+    state.db.list_fragments(status, limit).map_err(|e| e.to_string())
+}
+
+/// 组内碎片列表（feed 组详情消费）。
+#[tauri::command]
+pub fn list_group_fragments(state: State<'_, AppState>, group_id: i64) -> Result<Vec<Fragment>, String> {
+    if group_id <= 0 {
+        return Err("无效的组 id".to_string());
+    }
+    state.db.list_fragments_by_group(group_id).map_err(|e| e.to_string())
+}
+
+/// 解码验证并落盘碎片图片（返回 fragments/ 下相对路径）。
+///
+/// @ai-context: image::load_from_memory 把关格式白名单（png/jpeg/webp/gif/bmp…
+///              解码器支持集）；统一转 PNG 存储（前端展示口径单一）；
+///              超限字节数前置拒绝（解码前，省 CPU）。
+fn save_fragment_image(data_dir: &std::path::Path, bytes: &[u8]) -> Result<String, String> {
+    if bytes.len() > FRAGMENT_IMAGE_MAX_BYTES {
+        return Err(format!("图片超限（上限 {} MB）", FRAGMENT_IMAGE_MAX_BYTES / 1024 / 1024));
+    }
+    let img = image::load_from_memory(bytes).map_err(|e| format!("图片解码失败: {}", e))?;
+    let dir = data_dir.join("fragments");
+    std::fs::create_dir_all(&dir).map_err(|e| format!("创建碎片图目录失败: {}", e))?;
+    // 文件名 = 毫秒时间戳 + 随机后缀（防同毫秒碰撞）
+    let name = format!(
+        "{}-{}.png",
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_millis())
+            .unwrap_or(0),
+        rand_suffix()
+    );
+    let path = dir.join(&name);
+    img.save(&path).map_err(|e| format!("图片保存失败: {}", e))?;
+    Ok(format!("fragments/{}", name))
+}
+
+/// 文件名随机后缀（4 位十六进制——无 rand crate 依赖，系统熵足够防碰撞）。
+fn rand_suffix() -> String {
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.subsec_nanos())
+        .unwrap_or(0);
+    format!("{:04x}", now & 0xFFFF)
+}
+
+/// feed 主题组查/建（契约一：同领域同地形唯一）。
+fn resolve_feed_topic_group(
+    db: &crate::db::Db,
+    domain_tag: &str,
+    label: &str,
+) -> Result<i64, String> {
+    if let Some(existing) = db.find_topic_group(domain_tag, "feed").map_err(|e| e.to_string())? {
+        return Ok(existing.id);
+    }
+    let group = db
+        .create_group(&NewNoteGroup {
+            name: label.to_string(),
+            terrain: "feed".to_string(),
+            kind: "topic".to_string(),
+            domain_tag: Some(domain_tag.to_string()),
+            source: "route".to_string(),
+            series_key: None,
+            route_reason: Some(
+                serde_json::json!({"action":"topic","reasons":["碎片 DomainTag 自动归组"]}).to_string(),
+            ),
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(group.id)
+}
@@ -0,0 +1,148 @@
+//! 碎片数据层（v0.11.1；fragments 原料层 CRUD）。
+//!
+//! @ai-context: 碎片与笔记分表是 v4 契约明确要求（不与课程笔记混装）；
+//!              本层只管读写——DomainTag 归组判定在 commands_fragments.rs
+//!              （复用 detect_domain 纯函数），组 CRUD 在 db_note_groups.rs。
+
+use rusqlite::params;
+
+use crate::db::{unix_seconds, Db};
+use crate::error::Result;
+use crate::types::Fragment;
+
+/// fragments 表统一查询列（列顺序与 row_to_fragment 严格对应）。
+const FRAGMENT_COLUMNS: &str =
+    "id, text, image_path, domain_tag, group_id, source, status, created_at";
+
+/// 新建碎片入参（id/created_at 由数据层填充）。
+pub struct NewFragment {
+    pub text: String,
+    pub image_path: Option<String>,
+    pub domain_tag: Option<String>,
+    pub group_id: Option<i64>,
+    pub source: String,
+}
+
+impl Db {
+    /// 新建碎片，返回完整记录。
+    pub fn create_fragment(&self, new: &NewFragment) -> Result<Fragment> {
+        let now = unix_seconds();
+        self.with_conn(|conn| {
+            conn.execute(
+                "INSERT INTO fragments (text, image_path, domain_tag, group_id, source, status, created_at)
+                 VALUES (?1, ?2, ?3, ?4, ?5, 'active', ?6)",
+                params![new.text, new.image_path, new.domain_tag, new.group_id, new.source, now],
+            )?;
+            let id = conn.last_insert_rowid();
+            Ok(Fragment {
+                id,
+                text: new.text.clone(),
+                image_path: new.image_path.clone(),
+                domain_tag: new.domain_tag.clone(),
+                group_id: new.group_id,
+                source: new.source.clone(),
+                status: "active".to_string(),
+                created_at: now,
+            })
+        })
+    }
+
+    /// 列出碎片（status 过滤：active/archived/None=全部；按创建时间倒序，
+    /// 同秒按 id 倒序——id 单调递增，后者更新，排序稳定）。
+    pub fn list_fragments(&self, status: Option<&str>, limit: usize) -> Result<Vec<Fragment>> {
+        self.with_conn(|conn| {
+            let sql = match status {
+                Some(_) => format!(
+                    "SELECT {} FROM fragments WHERE status = ?1 ORDER BY created_at DESC, id DESC LIMIT ?2",
+                    FRAGMENT_COLUMNS
+                ),
+                None => format!(
+                    "SELECT {} FROM fragments ORDER BY created_at DESC, id DESC LIMIT ?1",
+                    FRAGMENT_COLUMNS
+                ),
+            };
+            let mut stmt = conn.prepare(&sql)?;
+            let rows = match status {
+                Some(s) => stmt.query_map(params![s, limit as i64], row_to_fragment)?,
+                None => stmt.query_map(params![limit as i64], row_to_fragment)?,
+            };
+            rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into)
+        })
+    }
+
+    /// 按组列出碎片（组详情/结算消费；仅 active——归档项不进学习循环）。
+    pub fn list_fragments_by_group(&self, group_id: i64) -> Result<Vec<Fragment>> {
+        self.with_conn(|conn| {
+            let mut stmt = conn.prepare(&format!(
+                "SELECT {} FROM fragments
+                 WHERE group_id = ?1 AND status = 'active'
+                 ORDER BY created_at DESC, id DESC",
+                FRAGMENT_COLUMNS
+            ))?;
+            let rows = stmt.query_map(params![group_id], row_to_fragment)?;
+            rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into)
+        })
+    }
+
+    /// 碎片计数（组结算触发信号；按组+status 统计）。
+    pub fn count_fragments(&self, group_id: Option<i64>, status: Option<&str>) -> Result<i64> {
+        self.with_conn(|conn| {
+            let mut sql = "SELECT COUNT(*) FROM fragments WHERE 1=1".to_string();
+            if group_id.is_some() {
+                sql.push_str(" AND group_id = ?1");
+            }
+            if status.is_some() {
+                sql.push_str(if group_id.is_some() { " AND status = ?2" } else { " AND status = ?1" });
+            }
+            let mut stmt = conn.prepare(&sql)?;
+            let count = match (group_id, status) {
+                (Some(g), Some(s)) => stmt.query_row(params![g, s], |r| r.get(0))?,
+                (Some(g), None) => stmt.query_row(params![g], |r| r.get(0))?,
+                (None, Some(s)) => stmt.query_row(params![s], |r| r.get(0))?,
+                (None, None) => stmt.query_row([], |r| r.get(0))?,
+            };
+            Ok(count)
+        })
+    }
+
+    /// 移动碎片到组（None=移出；用户纠错/结算归组共用）。
+    pub fn update_fragment_group(&self, id: i64, group_id: Option<i64>) -> Result<bool> {
+        self.with_conn(|conn| {
+            let affected = conn.execute(
+                "UPDATE fragments SET group_id = ?1 WHERE id = ?2",
+                params![group_id, id],
+            )?;
+            Ok(affected > 0)
+        })
+    }
+
+    /// 标记碎片状态（v0.11.3 结算归档：active↔archived）。
+    pub fn set_fragment_status(&self, id: i64, status: &str) -> Result<bool> {
+        self.with_conn(|conn| {
+            let affected = conn.execute(
+                "UPDATE fragments SET status = ?1 WHERE id = ?2",
+                params![status, id],
+            )?;
+            Ok(affected > 0)
+        })
+    }
+}
+
+/// 把 rusqlite 行映射为 Fragment。
+fn row_to_fragment(row: &rusqlite::Row<'_>) -> rusqlite::Result<Fragment> {
+    Ok(Fragment {
+        id: row.get(0)?,
+        text: row.get(1)?,
+        image_path: row.get(2)?,
+        domain_tag: row.get(3)?,
+        group_id: row.get(4)?,
+        source: row.get(5)?,
+        status: row.get(6)?,
+        created_at: row.get(7)?,
+    })
+}
+
+/// 单测独立文件。
+#[cfg(test)]
+#[path = "db_fragments_tests.rs"]
+mod tests;