@@ -169,6 +169,8 @@ Supply the original checker's required tool/configuration options to `task verif
 | `rules whitelist list / explain / propose` | Inspect/propose false-positive dispositions and corrections | No public approval or activation |
 | `gate pre-commit` | Git-index path-safety observation | Not a full content/security gate |
 
+For Python edit feedback, run `codeguard lint python . --file src/changed.py --format json`. `--file` is repeatable with a limit of eight distinct paths, 512 bytes per path and 2 KiB combined. The response declares `scan_scope=selected_files` and observes only those files; it is not imported as a full workspace scan and cannot approve delivery. Without `--file`, the existing command still scans discovered Python files and synchronizes its local report.
+
 Generic `dependencies`, generic `security`, arbitrary category/language combinations, `fix`, `gate pre-push`, `gate ci`, `mcp serve`, and the legacy compatibility dispatcher are target-design surfaces, not available commands in this baseline.
 
 ### Native-first entry points and syntax fallback — design target
 
@@ -168,6 +168,8 @@ codeguard task verify "$TASK_ID" . --format json
 | `rules whitelist list / explain / propose` | 查询或提出误报处置与纠错 | 无公开批准或生效入口 |
 | `gate pre-commit` | Git index 路径安全观察 | 尚非完整内容或安全门禁 |
 
+Python 编辑快反馈可执行 `codeguard lint python . --file src/changed.py --format json`；`--file` 可重复，最多 8 个不同路径，单路径 512 字节、总计 2 KiB。报告标明 `scan_scope=selected_files`，只观察选中文件；局部反馈不导入完整工作台，也不代表全项目或交付通过。原有不带 `--file` 的命令仍扫描发现到的 Python 文件并同步局部报告。
+
 通用 `dependencies`、通用 `security`、任意类别/语言组合、`fix`、`gate pre-push`、`gate ci`、`mcp serve` 和旧协议兼容调度均属目标设计，在本基线中不能作为已实现命令调用。
 
 ### 原生优先的统一入口与语法兜底——设计目标
 
@@ -23,6 +23,9 @@ fn main() -> ExitCode {
                 env!("CARGO_PKG_VERSION")
             );
             println!("check all 可汇总已接入的原生结果与未完成义务；完整质量门禁尚未实现。");
+            println!(
+                "lint python [path] 可重复使用 --file REL_PATH 指定最多 8 个本轮编辑文件作局部 Ruff 反馈；不会把局部报告同步成完整工作台扫描，也不签发交付通过。"
+            );
             println!(
                 "宿主事件只读规划：hook plan [--format=json] 从 stdin 读取 hook_trigger_request 1.0.0，返回 hook_trigger_plan 1.1.0 与退出码 3；批量编辑超出快检预算时要求改用有界批量范围，尚不执行检查或阻断宿主。"
             );
 
@@ -5,7 +5,9 @@ use crate::check_budget::{
 };
 use crate::discovery::discover;
 use crate::next_command::read_local_brief;
-use crate::python_lint_scan::{PythonLintScanRequest, python_lint_feedback, scan_python_lint};
+use crate::python_lint_scan::{
+    PythonLintScanRequest, python_lint_feedback, scan_python_lint, select_checker,
+};
 use crate::work_sync::{save_local_report, sync_local_workspace};
 use crate::workspace_refresh::read_workspace_baseline;
 use codeguard_adapters::{bundled_ruff_rulepack, legacy_registry};
@@ -14,7 +16,7 @@ use codeguard_runtime::{
 };
 use serde_json::Value;
 use sha2::{Digest, Sha256};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
 use std::os::unix::fs::PermissionsExt;
 use std::path::{Path, PathBuf};
@@ -26,6 +28,7 @@ struct Arguments {
     root: PathBuf,
     json: bool,
     ruff_tool: Option<PathBuf>,
+    selected_paths: Vec<String>,
     timeout_ms: u64,
     timeout_source: &'static str,
 }
@@ -74,19 +77,34 @@ pub fn run(args: &[String]) -> ExitCode {
         }
     }
     let deadline = started + Duration::from_millis(parsed.timeout_ms);
-    let mut feedback = match scan_and_sync_report_with_deadline(
-        &root,
-        parsed.ruff_tool.as_deref(),
-        deadline,
-        &AtomicBool::new(false),
-    ) {
+    let mut feedback = match if parsed.selected_paths.is_empty() {
+        scan_and_sync_report_with_deadline(
+            &root,
+            parsed.ruff_tool.as_deref(),
+            deadline,
+            &AtomicBool::new(false),
+        )
+    } else {
+        scan_selected_report_with_deadline(
+            &root,
+            parsed.ruff_tool.as_deref(),
+            &parsed.selected_paths,
+            deadline,
+            &AtomicBool::new(false),
+        )
+    } {
         Ok(feedback) => feedback,
         Err(_) => {
             eprintln!("内置语言清单损坏");
             return ExitCode::from(4);
         }
     };
     annotate_conversation_budget(&mut feedback, parsed.timeout_ms, parsed.timeout_source);
+    feedback["schema_version"] = Value::String("0.13.0".into());
+    if parsed.selected_paths.is_empty() {
+        feedback["scan_scope"] = Value::String("discovered_python".into());
+        feedback["requested_paths"] = Value::Null;
+    }
     let request_cancelled = codeguard_runtime::sigint_cancellation_requested()
         || feedback["incomplete_reasons"]
             .as_array()
@@ -184,6 +202,41 @@ pub fn annotate_conversation_budget(feedback: &mut Value, timeout_ms: u64, sourc
     document.insert("execution_budget".into(), budget_record(timeout_ms, source));
 }
 
+/// 编辑快反馈仅观察指定文件，不把局部报告作为完整工作区报告导入工作台。
+fn scan_selected_report_with_deadline(
+    root: &Path,
+    ruff_tool: Option<&Path>,
+    selected_paths: &[String],
+    deadline: Instant,
+    cancelled: &AtomicBool,
+) -> Result<Value, &'static str> {
+    let mut feedback = scan_local_report_scoped_with_deadline(
+        root,
+        ruff_tool,
+        Some(selected_paths),
+        deadline,
+        cancelled,
+    )?;
+    let document = feedback.as_object_mut().expect("反馈根为对象");
+    document.insert("scan_scope".into(), Value::String("selected_files".into()));
+    document.insert("requested_paths".into(), serde_json::json!(selected_paths));
+    document.insert(
+        "backlog_status".into(),
+        Value::String("not_synced_scoped".into()),
+    );
+    document.insert("backlog_sync".into(), Value::Null);
+    document.insert(
+        "repair_brief_status".into(),
+        Value::String("unavailable".into()),
+    );
+    document.insert(
+        "repair_brief_reason".into(),
+        Value::String("not_synced_scoped".into()),
+    );
+    document.insert("next".into(), Value::Null);
+    Ok(feedback)
+}
+
 /// 对项目运行同一条局部原生 Ruff 检查链，返回可供持久同步的 0.9 报告。
 ///
 /// 参数 `root` 是规范化的项目根，`ruff_tool` 是可选的绝对可执行路径；
@@ -203,13 +256,33 @@ pub fn scan_local_report_with_deadline(
     ruff_tool: Option<&Path>,
     deadline: Instant,
     cancelled: &AtomicBool,
+) -> Result<Value, &'static str> {
+    scan_local_report_scoped_with_deadline(root, ruff_tool, None, deadline, cancelled)
+}
+
+fn scan_local_report_scoped_with_deadline(
+    root: &Path,
+    ruff_tool: Option<&Path>,
+    selected_paths: Option<&[String]>,
+    deadline: Instant,
+    cancelled: &AtomicBool,
 ) -> Result<Value, &'static str> {
     let registry = legacy_registry().map_err(|_| "registry_invalid")?;
     let discovery = discover(root, &registry, &NativeObservation);
     let run_id = run_id();
-    let configured = discovery.checker_configurations.iter().any(|checker| {
-        checker.checker_id == "python.ruff" && checker.configuration == "configured"
-    });
+    let configured = selected_paths.map_or_else(
+        || {
+            discovery.checker_configurations.iter().any(|checker| {
+                checker.checker_id == "python.ruff" && checker.configuration == "configured"
+            })
+        },
+        |paths| {
+            paths.iter().any(|path| {
+                select_checker(&discovery, path)
+                    .is_some_and(|checker| checker.configuration == "configured")
+            })
+        },
+    );
     let tool = if configured {
         prepare_tool(root, ruff_tool, deadline, &run_id, cancelled)
     } else {
@@ -230,6 +303,7 @@ pub fn scan_local_report_with_deadline(
         &PythonLintScanRequest {
             root,
             discovery: &discovery,
+            selected_paths,
             tool: tool.path,
             tool_unavailable_reason: tool.unavailable_reason,
             expected_tool_sha256: tool.sha256,
@@ -357,12 +431,13 @@ fn parse_args(args: &[String]) -> Result<Arguments, String> {
     let mut root = None;
     let mut json = false;
     let mut ruff_tool = None;
+    let mut selected_paths = Vec::new();
     let mut timeout_ms = 0;
     let mut timeout_seen = false;
     let mut index = 1;
     while index < args.len() {
         let arg = &args[index];
-        if arg == "--format" || arg == "--ruff-tool" || arg == "--timeout" {
+        if arg == "--format" || arg == "--ruff-tool" || arg == "--timeout" || arg == "--file" {
             index += 1;
             let value = args.get(index).ok_or_else(|| format!("{arg} 缺少值"))?;
             if arg == "--format" {
@@ -373,6 +448,8 @@ fn parse_args(args: &[String]) -> Result<Arguments, String> {
                 }
                 timeout_ms = parse_check_timeout(value)?;
                 timeout_seen = true;
+            } else if arg == "--file" {
+                selected_paths.push(value.clone());
             } else if ruff_tool.replace(PathBuf::from(value)).is_some() {
                 return Err("--ruff-tool 重复".into());
             }
@@ -388,11 +465,34 @@ fn parse_args(args: &[String]) -> Result<Arguments, String> {
     if ruff_tool.as_ref().is_some_and(|tool| !tool.is_absolute()) {
         return Err("--ruff-tool 必须是绝对路径".into());
     }
+    let mut distinct = BTreeSet::new();
+    let mut total_bytes = 0;
+    for path in &selected_paths {
+        if path.is_empty()
+            || path.len() > 512
+            || path.starts_with('/')
+            || path.contains('\\')
+            || path.chars().any(char::is_control)
+            || path
+                .split('/')
+                .any(|part| part.is_empty() || part == "." || part == "..")
+        {
+            return Err("--file 必须是有效的工作区相对源码路径".into());
+        }
+        if distinct.insert(path.clone()) {
+            total_bytes += path.len();
+        }
+    }
+    if distinct.len() > 8 || total_bytes > 2048 {
+        return Err("--file 超出局部快检范围预算，请改用批量检查".into());
+    }
+    let selected_paths = distinct.into_iter().collect();
     let (timeout_ms, timeout_source) = select_check_timeout(timeout_seen.then_some(timeout_ms))?;
     Ok(Arguments {
         root: root.unwrap_or_else(|| PathBuf::from(".")),
         json,
         ruff_tool,
+        selected_paths,
         timeout_ms,
         timeout_source,
     })
@@ -532,6 +632,11 @@ fn create_scratch(run_id: &str) -> std::io::Result<PrivateScratch> {
 
 fn print_human(feedback: &Value) {
     println!("CodeGuard Python lint：局部原生检查；完整质量门禁尚未评估");
+    println!(
+        "本轮范围：{}；目标：{}",
+        feedback["scan_scope"].as_str().unwrap_or("unknown"),
+        feedback["requested_paths"]
+    );
     println!(
         "修复记录：{}",
         feedback["backlog_status"].as_str().unwrap_or("unknown")
 
@@ -17,6 +17,8 @@ use std::time::Instant;
 pub struct PythonLintScanRequest<'a> {
     pub root: &'a Path,
     pub discovery: &'a DiscoveryReport,
+    /// 编辑快反馈的精确工作区相对路径；None 才表示本轮发现到的全部 Python 源码。
+    pub selected_paths: Option<&'a [String]>,
     pub tool: Option<PathBuf>,
     pub tool_unavailable_reason: &'static str,
     pub expected_tool_sha256: [u8; 32],
@@ -218,12 +220,34 @@ pub fn scan_python_lint(
         output.incomplete_reasons.push("no_python_sources".into());
         return output;
     }
+    let sources: Vec<&String> = if let Some(selected) = request.selected_paths {
+        if selected.is_empty() {
+            output
+                .incomplete_reasons
+                .push("selected_scope_empty".into());
+            return output;
+        }
+        for target in selected {
+            if !python.source_files.contains(target) {
+                output
+                    .incomplete_reasons
+                    .push(format!("target_not_discovered:{target}"));
+            }
+        }
+        python
+            .source_files
+            .iter()
+            .filter(|source| selected.contains(source))
+            .collect()
+    } else {
+        python.source_files.iter().collect()
+    };
     let mut input_digests = BTreeMap::new();
-    for source in &python.source_files {
+    for source in &sources {
         let path = request.root.join(source);
         match digest_file(&path, 16 * 1024 * 1024) {
             Some(digest) => {
-                input_digests.insert(source.clone(), digest);
+                input_digests.insert((*source).clone(), digest);
             }
             None => {
                 output
@@ -238,7 +262,13 @@ pub fn scan_python_lint(
         .checker_configurations
         .iter()
         .filter(|checker| {
-            checker.checker_id == "python.ruff" && checker.configuration == "configured"
+            checker.checker_id == "python.ruff"
+                && checker.configuration == "configured"
+                && sources.iter().any(|source| {
+                    select_checker(request.discovery, source).is_some_and(|selected| {
+                        selected.configuration_ref == checker.configuration_ref
+                    })
+                })
         })
     {
         if let Some(digest) =
@@ -251,7 +281,8 @@ pub fn scan_python_lint(
                 .push(format!("config_unavailable:{}", checker.configuration_ref));
         }
     }
-    for (index, source) in python.source_files.iter().enumerate() {
+    for (index, source) in sources.iter().enumerate() {
+        let source = *source;
         let Some(checker) = select_checker(request.discovery, source) else {
             output
                 .files
@@ -335,7 +366,7 @@ pub fn scan_python_lint(
             reason = Some("finding_identity_unavailable".into());
         }
         output.files.push(PythonLintFileResult {
-            path: source.clone(),
+            path: (*source).clone(),
             config_ref: Some(checker.configuration_ref.clone()),
             config_sha256: completion.then(|| hex_digest(&config_digest)),
             tool_sha256: completion.then(|| hex_digest(&request.expected_tool_sha256)),