新增: 批次工作落地(推进链/评估闭环/事件总线/并发/加固) + 技术债清理 + 文档整理

后端:
- 工作流推进链(D-03):advance_task/状态机/闸门走 df-nodes Node trait,conditions 条件引擎扩展
- 想法评估闭环:启发式评分+对抗评估,df-ideas/scoring + df-storage/idea_eval_repo + idea 前端打通
- 全局事件数据总线:df-ai/context+context_helpers+augmentation 跨模块解耦
- AI planner/plan_hint/intent:aichat B 路线并行多轮基础
- patch_file 加固(TD-03/04):读改写整体锁防 lost update,expected_hash 合约闭环
- 压缩超时兜底(F-15 卡死根治)
- F-09 多会话并发:LlmConcurrency per-conv + streamingGuard 前端守护 + verify 脚本
- 知识注入 DRY/skills/audit 扩展

清理:
- aichat 技术债(误报 allow/死导入/过时注释 30 项)
- URGENT.md 删除(11 项加急全解决/迁 todo)
- 文档整理(todo/待决策/待审查/ARCHITECTURE/INDEX + 总线/技术债审查新文档)

src-tauri/src/commands/ai/audit/mod.rs

@@ -15,7 +15,7 @@ use crate::state::AppState;
 
 use crate::commands::err_str;
 
-use super::{AiChatEvent, AiSession, PathAuthRequest, PendingApproval, ToolCallDraft};
+use super::{AiChatEvent, AiSession, ApprovalKind, PathAuthRequest, PendingApproval, ToolCallDraft};
 // tool_registry::generate_diff 经 audit/diff.rs 直接 use（build_write_file_diff 内调用），
 // 本文件不再裸名用 generate_diff，故不再在此 use（避免 unused import warning）。
 
@@ -116,9 +116,10 @@ pub(crate) use finalize::{audit_finalize, audit_tool_call};
 
 // cache(audit/cache.rs):F-260616-05 高危工具去重缓存。
 // 第三批从本文件抽离,行为零变更。pub(super) use 供本文件 process_tool_calls 裸名调用
-// (find_cached_high_risk_result),PENDING_APPROVAL_PLACEHOLDER 供 process_tool_calls 占位回填共享。
+// (find_cached_high_risk_result)。阶段2:prior placeholder 现经 pending_placeholder_for
+// (内嵌 __PENDING__:tc_id 标记)生成,PENDING_APPROVAL_PLACEHOLDER 基础常量留在 cache.rs 内部。
 mod cache;
-pub(super) use cache::{find_cached_high_risk_result, PENDING_APPROVAL_PLACEHOLDER};
+pub(super) use cache::{find_cached_high_risk_result, pending_placeholder_for};
 
 // data_change(audit/data_change.rs):AR-11 数据变更联动刷新。
 // 第四批从本文件抽离,行为零变更。pub(crate) use 保持 emit_data_changed 对 crate 内可见
@@ -135,7 +136,7 @@ pub(crate) use idea_source::maybe_fill_idea_source;
 /// F-260619-03 Phase B: 提取文件工具的路径参数(用于路径授权预校验)。
 ///
 /// 仅对走 resolve_workspace_path 校验的文件工具返回路径;非文件工具返回空 Vec(不预校验)。
-/// - 单路径工具(read_file/write_file/list_directory/patch_file/file_info/append_file/delete_file/search_files)
+/// - 单路径工具(read_file/write_file/list_directory/patch_file/file_info/append_file/delete_file/search_files/grep)
 ///   取 args["path"]
 /// - rename_file 双路径取 args["from"] + args["to"](两个都需授权)
 /// - run_command 不返回(它只走 validate_path 黑名单,不限定 workspace,High risk 靠人工审批)
@@ -152,7 +153,7 @@ fn extract_file_tool_paths(tool_name: &str, args: &serde_json::Value) -> Vec<Str
             v
         }
         "read_file" | "write_file" | "list_directory" | "patch_file" | "file_info"
-        | "append_file" | "delete_file" | "search_files" => {
+        | "append_file" | "delete_file" | "search_files" | "grep" => {
             args.get("path").and_then(|x| x.as_str()).map(|s| vec![s.to_string()]).unwrap_or_default()
         }
         _ => Vec::new(),
@@ -182,21 +183,66 @@ fn check_file_tool_auth(
         // 非文件工具或无路径参数(如缺 path 的异常调用)→ 放行,走原流程(handler 内会因缺参 Err)
         return FileToolAuthOutcome::Authorized;
     }
-    let mut pending_dir: Option<std::path::PathBuf> = None;
+    // L1 补丁(rename_file 双路径漏校):收集**所有**未授权父目录(去重),
+    // 不只首个。rename_file 的 from/to 若分属不同未授权目录,两个 dir 都需挂起授权。
+    let mut pending_dirs: Vec<std::path::PathBuf> = Vec::new();
     for p in &paths {
         match check_path_authorization(p, allowed) {
             PathAuthDecision::Denied { reason } => return FileToolAuthOutcome::Denied(reason),
             PathAuthDecision::NeedsAuthorization { dir } => {
-                if pending_dir.is_none() {
-                    pending_dir = Some(dir);
+                if !pending_dirs.contains(&dir) {
+                    pending_dirs.push(dir);
                 }
             }
             PathAuthDecision::Authorized => {}
         }
     }
-    match pending_dir {
-        Some(dir) => FileToolAuthOutcome::NeedsAuth(PathAuthRequest { dir, raw_paths: paths }),
-        None => FileToolAuthOutcome::Authorized,
+    if pending_dirs.is_empty() {
+        FileToolAuthOutcome::Authorized
+    } else if tool_name == "search_files" {
+        // 核心设计5:search_files 兜底 — 盲搜语义应拒不应询。
+        // search_files 仅在已授权目录可用;用户已通过 @项目 提供项目上下文,无需搜索文件系统。
+        // (黑名单已在上方 for 循环内短路返 Denied,走到此处均为 NeedsAuthorization 场景。)
+        // 其他文件工具(read_file/write_file/list_directory/patch_file/file_info/
+        // append_file/delete_file/rename_file)保持原 NeedsAuth 弹窗逻辑完全不变。
+        FileToolAuthOutcome::Denied(
+            "search_files 仅在已授权目录可用;请用 @[项目] 引用或提供绝对路径,不要盲搜文件系统。".to_string(),
+        )
+    } else {
+        FileToolAuthOutcome::NeedsAuth(PathAuthRequest { dirs: pending_dirs, raw_paths: paths })
+    }
+}
+
+/// 阶段4(容错/恢复,开关 `df-ai-approval-retry`):查审计表推算同 tc_id 重试计数。
+///
+/// 返回语义:
+/// - 0:审计表无该 tc_id 落定记录(或仅 pending),属首次审批执行,正常挂起。
+/// - ≥1:审计表已有该 tc_id 的落定记录(executed/failed/rejected/skipped_retry),即该
+///   tc_id 此前已被审批执行过一次,LLM 又用同 id 重试 → 调用方据 ≥1 跳过执行 + emit Completed,
+///   断「超时/权限错→LLM 死循环重试同 id→重新挂起→用户被迫二次授权」循环。
+///
+/// 实现:查 `find_by_tool_call_id`,status 为 pending 视为"尚未落定"(返 0,首次挂起审批的
+/// 正常态);其余落定状态返 1。retry_count 当前仅取 0/1(断路器语义:第二次即跳过),
+/// 字段类型 u32 留给未来"允许多次重试"扩展(配置上限阈值)。
+///
+/// 兜底/回退:flag 关(文档标记)或审计查询失败 → 返 0,等价原行为(单次审批执行,无重试防护)。
+async fn detect_retry_count(audit_repo: &AiToolExecutionRepo, tc_id: &str) -> u32 {
+    // 审计查询失败不阻断主流程(DB 故障等降级为无重试防护,返回 0 走原审批流程)
+    let rec = match audit_repo.find_by_tool_call_id(tc_id).await {
+        Ok(opt) => match opt {
+            Some(r) => r,
+            None => return 0, // 无记录 = 首次
+        },
+        Err(e) => {
+            tracing::warn!("[阶段4-retry] 查审计表 tc_id={} 失败(降级无重试防护): {}", tc_id, e);
+            return 0;
+        }
+    };
+    // pending = 首次挂起审批(尚未落定);其余落定状态 = 已执行过 → 计 1 次重试
+    if rec.status == "pending" {
+        0
+    } else {
+        1
     }
 }
 
@@ -223,7 +269,7 @@ pub(crate) async fn process_tool_calls(
     let audit_repo = AiToolExecutionRepo::new(db);
 
     // F-260619-04 P1 消息级溯源:取当前 assistant 消息 id。
-    // 调用前 agentic.rs 已把本轮 assistant_with_tools 消息(LLM 返回带 tool_calls 的那条)
+    // 调用前 agentic/mod.rs 已把本轮 assistant_with_tools 消息(LLM 返回带 tool_calls 的那条)
     // push 到 per_conv.messages(audit/mod.rs:882),此处取末条 assistant id 作为本轮工具
     // 调用所属的溯源 message_id,贯穿所有 audit_tool_call 写入。None 表示无 assistant 消息
     // (异常路径/老数据无 id),audit 落 message_id=None,展示侧兼容。
@@ -298,8 +344,37 @@ pub(crate) async fn process_tool_calls(
     // pending_count 计入(让 agentic loop 检测到挂起并暂停,等 ai_authorize_dir → try_continue 恢复)。
     for (draft, args, req) in path_auth_pending {
         pending_count += 1;
-        let dir_str = req.dir.to_string_lossy().to_string();
+        // L1 补丁:req.dirs 含所有未授权父目录;emit 用首个作主展示目录(前端弹窗主显)。
+        // ai_authorize_dir 消费时遍历所有 dirs 写白名单。
+        let dir_str = req.dirs.first()
+            .map(|d| d.to_string_lossy().to_string())
+            .unwrap_or_default();
         let path_str = req.raw_paths.first().cloned().unwrap_or_default();
+        // 阶段4(容错/恢复,开关 df-ai-approval-retry):同 tc_id 重试检测。
+        // 同 tool_call_id 在审计表已有一条落定记录(executed/failed/rejected,即已审批执行过一次)
+        // → 推算 retry_count≥1,跳过 insert pending + emit Completed 带"已跳过重试"提示,
+        // 断「超时/权限错→LLM 死循环重试同 id→重新挂起→用户被迫二次授权」循环。
+        // 兜底:flag 关或无审计记录 → retry_count=0,等价原行为(正常挂起审批)。
+        let retry_count = detect_retry_count(&audit_repo, &draft.id).await;
+        if retry_count >= 1 {
+            let skip_msg = format!(
+                "已跳过重试(同 tool_call_id={} 此前已审批执行过,防 LLM 死循环重试同卡死工具)",
+                draft.id
+            );
+            session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &skip_msg));
+            let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiToolCallCompleted {
+                id: draft.id.clone(),
+                result: serde_json::Value::String(skip_msg.clone()),
+                conversation_id: Some(conv_id.to_string()),
+            });
+            let risk_level = tools_arc.get(&draft.name).map(|t| t.risk_level).unwrap_or(RiskLevel::High);
+            audit_tool_call(
+                &audit_repo, conv_id, &draft.id, &draft.name, &draft.args,
+                "skipped_retry", risk_level, Some(skip_msg), Some("auto_retry_guard"),
+                current_message_id,
+            ).await;
+            continue;
+        }
         session.pending_approvals.insert(
             draft.id.clone(),
             PendingApproval {
@@ -308,12 +383,16 @@ pub(crate) async fn process_tool_calls(
                 arguments: args.clone(),
                 conversation_id: Some(conv_id.to_string()),
                 recovered: false,
-                diff: None,
-                path_auth: Some(req),
+                // 阶段3a:路径授权挂起标 kind=Path(req)(下沉原 path_auth 字段)。
+                kind: ApprovalKind::Path(req),
+                retry_count,
             },
         );
-        // 占位 tool_result(与 RiskLevel 审批一致),ai_authorize_dir 批准后替换为真实结果
-        session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, PENDING_APPROVAL_PLACEHOLDER));
+        // 占位 tool_result(与 RiskLevel 审批一致),ai_authorize_dir 批准后替换为真实结果。
+        // 阶段2:用 pending_placeholder_for 内嵌 __PENDING__:tc_id 标记,供 sanitize 反向 orphan
+        // 检测豁免保留 + 出口断言自愈补头(防占位头被裁后 orphan result 触发 provider 400)。
+        session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &pending_placeholder_for(&draft.id)));
+        tracing::debug!(target: "ai_dirauth", conv = %conv_id, tool = %draft.name, tc_id = %draft.id, "emit AiDirAuthRequired(路径授权挂起,等 ai_authorize_dir 恢复)");
         let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiDirAuthRequired {
             id: draft.id.clone(),
             tool: draft.name.clone(),
@@ -413,16 +492,38 @@ pub(crate) async fn process_tool_calls(
                 } else {
                     None
                 };
+                // 阶段4(容错/恢复,开关 df-ai-approval-retry):同 tc_id 重试检测。
+                // 与 High risk 的 find_cached_high_risk_result 互补:去重按 (tool_name,args) 匹配
+                // (High only),本 guard 按 tc_id 匹配(覆盖 Med + High 残留场景)。
+                // 同 tc_id 已有审计落定记录 → retry_count≥1,跳过审批 + emit Completed,断死循环。
+                // 兜底:flag 关或无审计记录 → retry_count=0,等价原行为。
+                let retry_count = detect_retry_count(&audit_repo, &draft.id).await;
+                if retry_count >= 1 {
+                    let skip_msg = format!(
+                        "已跳过重试(同 tool_call_id={} 此前已审批执行过,防 LLM 死循环重试同卡死工具)",
+                        draft.id
+                    );
+                    session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &skip_msg));
+                    let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiToolCallCompleted {
+                        id: draft.id.clone(),
+                        result: serde_json::Value::String(skip_msg.clone()),
+                        conversation_id: Some(conv_id.to_string()),
+                    });
+                    audit_tool_call(&audit_repo, conv_id, &draft.id, &draft.name, &draft.args, "skipped_retry", risk_level, Some(skip_msg), Some("auto_retry_guard"), current_message_id).await;
+                    continue;
+                }
                 session.pending_approvals.insert(draft.id.clone(), PendingApproval {
                     tool_call_id: draft.id.clone(),
                     tool_name: draft.name.clone(),
                     arguments: args.clone(),
                     conversation_id: Some(conv_id.to_string()),
                     recovered: false,
-                    diff: approval_diff.clone(),
-                    path_auth: None,
+                    // 阶段3a:普通 RiskLevel 审批标 kind=Risk{diff}(下沉原 diff 字段)。
+                    kind: ApprovalKind::Risk { diff: approval_diff.clone() },
+                    retry_count,
                 });
-                session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, PENDING_APPROVAL_PLACEHOLDER));
+                // 阶段2:占位带 __PENDING__:tc_id 标记,供 sanitize 豁免保留 + 出口断言自愈(防 400 orphan)
+                session.conv(conv_id).messages.push(ChatMessage::tool_result(&draft.id, &pending_placeholder_for(&draft.id)));
                 let reason = build_approval_reason(&draft.name, &args, risk_level, db).await;
                 let _ = app_handle.emit("ai-chat-event", AiChatEvent::AiApprovalRequired {
                     id: draft.id.clone(),
@@ -438,7 +539,7 @@ pub(crate) async fn process_tool_calls(
     }
 
     // AE-04 trust-hit 并行执行：execute + 即时 emit 在闭包内（闭包不访问 session，非"锁已释放"——
-    // session 锁仍由调用方 agentic.rs 持有至 process_tool_calls 返回，CR-53 审查纠正原"移锁外"误述），
+    // session 锁仍由调用方 agentic/mod.rs 持有至 process_tool_calls 返回，CR-53 审查纠正原"移锁外"误述），
     // push tool_result / audit 在 join_all 后串行回填（持锁）。对齐 Low risk 并行模式。
     // CR-51 修：原 inline .await execute 串行执行每个工具（阻塞期间锁被持有，run_command 慢命令
     // 阻塞同会话 IPC）；改 join_all 并行多工具减少总阻塞时间（锁持有时长不变，并行化降阻塞）。
@@ -551,5 +652,66 @@ pub(crate) async fn process_tool_calls(
         }
     }
 
+    // 阶段3a:单表 pending_approvals 统计 pending 总数(path/risk 合一,kind 区分)。
+    let (path_count, risk_count) = session.pending_approvals.values()
+        .fold((0usize, 0usize), |(p, r), a| match a.kind {
+            ApprovalKind::Path(_) => (p + 1, r),
+            ApprovalKind::Risk { .. } => (p, r + 1),
+        });
+    tracing::debug!(target: "ai_dirauth", pending_count, pending_approvals_len = session.pending_approvals.len(), path_count, risk_count, "process_tool_calls 返回(路径/风险挂起分布)");
     pending_count
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// grep 走单路径授权申请路径(NeedsAuth),非 search_files 盲拒(Denied)。
+    ///
+    /// F-260621:grep 加入 extract_file_tool_paths 单路径分支,未授权路径触发
+    /// AiDirAuthRequired 申请(对齐 read_file),不像 search_files 被硬拒。
+    /// 锁定此差异:grep 与 read_file 同款授权弹窗语义。
+    #[test]
+    fn test_grep_unauthorized_path_triggers_auth_not_denied() {
+        // 空白名单(不含 workspace_root 的目录):任何路径都未授权 → NeedsAuth
+        let allowed = crate::state::AllowedDirs::default();
+        let args = serde_json::json!({ "pattern": "foo", "path": "C:/some/unauthorized/dir" });
+
+        let outcome = check_file_tool_auth("grep", &args, &allowed);
+        match outcome {
+            FileToolAuthOutcome::NeedsAuth(_) => { /* 期望:grep 触发授权申请 */ }
+            FileToolAuthOutcome::Authorized => panic!("grep 未授权应返 NeedsAuth(申请授权),实际 Authorized"),
+            FileToolAuthOutcome::Denied(_) => panic!("grep 未授权应返 NeedsAuth(申请授权),实际 Denied(grep 不应像 search_files 盲拒)"),
+        }
+
+        // 对照:search_files 同样未授权但被硬拒(Denied),锁定两工具差异
+        let search_outcome = check_file_tool_auth("search_files", &args, &allowed);
+        match search_outcome {
+            FileToolAuthOutcome::Denied(_) => { /* 期望:search_files 盲拒 */ }
+            FileToolAuthOutcome::NeedsAuth(_) => panic!("search_files 未授权应返 Denied(盲拒),实际 NeedsAuth"),
+            FileToolAuthOutcome::Authorized => panic!("search_files 未授权应返 Denied(盲拒),实际 Authorized"),
+        }
+    }
+
+    /// grep 黑名单路径(.ssh 等)直接 Denied(不申请授权),对齐 read_file。
+    #[test]
+    fn test_grep_blacklisted_path_denied() {
+        let allowed = crate::state::AllowedDirs::default_with_root();
+        // .ssh 命中系统黑名单(is_in_system_blacklist)
+        let args = serde_json::json!({ "pattern": "foo", "path": "/home/user/.ssh/config" });
+        let outcome = check_file_tool_auth("grep", &args, &allowed);
+        match outcome {
+            FileToolAuthOutcome::Denied(_) => { /* 期望:黑名单硬拒 */ }
+            FileToolAuthOutcome::NeedsAuth(_) => panic!("grep 黑名单路径应返 Denied,实际 NeedsAuth"),
+            FileToolAuthOutcome::Authorized => panic!("grep 黑名单路径应返 Denied,实际 Authorized"),
+        }
+    }
+
+    /// extract_file_tool_paths:grep 取 args["path"](单路径分支)
+    #[test]
+    fn test_extract_grep_path() {
+        let args = serde_json::json!({ "pattern": "foo", "path": "src/main.rs", "glob": "*.rs" });
+        let paths = extract_file_tool_paths("grep", &args);
+        assert_eq!(paths, vec!["src/main.rs".to_string()], "grep 应取 path 参数(忽略 glob 等其他参数)");
+    }
+}