lxy/DevFlow
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

优化: AI Chat 体验全面升级(图标/审批/目标提取/窗口管理)

Browse Source 
- AI 入口图标:灯泡→星花 sparkles+发光,与灵感入口区分
- 目标提取根本性改造:用户消息规则→工具调用推理(infer_goal_from_tool_calls)
  - Vec<String>→Vec<GoalEntry>(text+status),active→completed 状态流转
  - 多条/轮提取,system_prompt 仅注入 active 目标
  - 代码拆分到 helpers.rs(解决 brace 嵌套致 pub(crate) 不可见)
- 审批修复:patch_file 全档位自动放行,批量审批防抖,乐观更新竞态保护
- 审批通知浮层:全局右上角 ApprovalOverlay,窗口遮挡时可见
- 设置导入导出移除:价值低占用空间,跨设备同步建议复制 SQLite
- 分离窗口默认置顶+置顶状态持久化(刷新后保持)
- header 菜单聚合:清空/压缩上下文收入 ... popout
- LLM 文字重叠防御:delta 重复检测+丢弃
- 置顶图标:星→大头针 pushpin
- 文档/注释更新:过期 Vec<String>/chat.rs 提取描述修正
This commit is contained in:
绝尘
2026-07-03 13:07:03 +08:00
parent aa0701a2ea
commit 0dfaeb0f5b
26 changed files with 929 additions and 753 deletions
Download Patch File Download Diff File Expand all files Collapse all files

235
src-tauri/src/commands/ai/agentic/helpers.rs Normal file
View File

@@ -0,0 +1,235 @@
//! 审批后循环恢复 — 从 agentic/mod.rs 拆分。
//! 原代码被嵌套在 run_agentic_loop 内部导致 pub(crate) 不可见。
use tauri::{AppHandle, Emitter, Manager};
use crate::state::AppState;
use super::approval_timeout;
use crate::commands::ai::prompt::{build_system_prompt, get_active_provider};
use crate::commands::ai::knowledge_inject::inject_knowledge_into_prompt;
use crate::commands::ai::{AiChatEvent, ErrorType, SessionState, GoalEntry};
use super::conv_state::ConvState;
/// BUG-260617-05: try_continue_agent_loop 续跑判定所需 session 字段的一次性快照。
struct ContinueSnapshot {
is_generating: bool,
has_pending: bool,
pending_conv_id: Option<String>,
agent_language: Option<String>,
model_override: Option<String>,
pinned_goals_snapshot: Vec<GoalEntry>,
}
/// 检查是否所有待审批已处理，如果是则恢复 agentic 循环
pub async fn try_continue_agent_loop(
app: &AppHandle,
state: &AppState,
conv_id: &str,
start_iteration: usize,
) {
approval_timeout::cleanup_expired_approvals(app, state, conv_id).await;
let snap = {
let session = state.ai_session.lock().await;
let has_pending = session.session_state(conv_id) == SessionState::AwaitingApproval;
let pending_conv_id = session.pending_approvals.values()
.find_map(|a| a.conversation_id.clone());
let conv = session.conv_read(conv_id);
let is_generating = conv.map(|c| c.conv_state.is_active()).unwrap_or(false);
let agent_language = conv.and_then(|c| c.agent_language.clone());
let model_override = conv.and_then(|c| c.model_override.clone());
let pinned_goals_snapshot = conv.map(|c| c.pinned_goals.clone()).unwrap_or_default();
ContinueSnapshot {
is_generating,
has_pending,
pending_conv_id,
agent_language,
model_override,
pinned_goals_snapshot,
}
};
let should_continue = snap.is_generating && !snap.has_pending;
if !should_continue {
if snap.is_generating {
tracing::info!(conv_id = %conv_id, "[ai] try_continue 跳过:仍有待审批,转审批等待态");
} else {
tracing::info!(conv_id = %conv_id, "[ai] try_continue 跳过:generating 已复位");
let emit_conv_id = match snap.pending_conv_id.clone() {
Some(cid) => cid,
None => conv_id.to_string(),
};
let ev = AiChatEvent::AiCompleted {
total_tokens: 0, prompt_tokens: 0, completion_tokens: 0,
incomplete: None,
conversation_id: Some(emit_conv_id),
pinned_goals: snap.pinned_goals_snapshot.clone(),
};
let _ = app.emit("ai-chat-event", ev.clone());
let _ = app.state::<crate::state::AppState>().ai_event_bus.publish_event(ev);
}
return;
}
let provider_config = match get_active_provider(state).await {
Ok(p) => p,
Err(e) => {
let mut session = state.ai_session.lock().await;
match session.conv(conv_id).conv_state.transition_to(ConvState::Idle) {
Ok(ns) => session.conv(conv_id).conv_state = ns,
Err(e2) => tracing::warn!(conv_id = %conv_id, error = %e2, "ConvState→Idle 非法"),
}
drop(session);
let _ = app.emit("ai-chat-event", AiChatEvent::AiError {
error: e.clone(), error_type: Some(ErrorType::ProviderConfig),
conversation_id: Some(conv_id.to_string()),
});
let _ = app.state::<crate::state::AppState>().ai_event_bus.publish_event(AiChatEvent::AiError {
error: e, error_type: None,
conversation_id: Some(conv_id.to_string()),
});
return;
}
};
let lang = snap.agent_language.clone().unwrap_or_else(|| "zh-CN".to_string());
let conv_id_owned = conv_id.to_string();
let system_prompt = build_system_prompt(state, &lang).await;
let session_arc = state.ai_session.clone();
let tools_arc = state.ai_tools.clone();
let db = state.db.clone();
let app_handle = app.clone();
let knowledge_config = state.knowledge_config.lock().await.clone();
let llm_concurrency = state.llm_concurrency.clone();
let system_prompt = inject_knowledge_into_prompt(state, conv_id, system_prompt, &knowledge_config).await;
let max_iterations = state.agent_max_iterations.load(std::sync::atomic::Ordering::SeqCst);
let max_retries = state.agent_max_retries.load(std::sync::atomic::Ordering::SeqCst);
let model_override = snap.model_override.clone();
let still_generating = {
let session = state.ai_session.lock().await;
session.conv_read(conv_id).map(|c| c.conv_state.is_active()).unwrap_or(false)
};
if !still_generating {
let ev = AiChatEvent::AiCompleted {
total_tokens: 0, prompt_tokens: 0, completion_tokens: 0,
incomplete: None,
conversation_id: Some(conv_id_owned.clone()),
pinned_goals: snap.pinned_goals_snapshot.clone(),
};
let _ = app.emit("ai-chat-event", ev.clone());
let _ = app.state::<crate::state::AppState>().ai_event_bus.publish_event(ev);
return;
}
let _ = app.emit("ai-chat-event", AiChatEvent::AiAgentRound {
round: 0, conversation_id: Some(conv_id_owned.clone()),
});
let _ = app.state::<crate::state::AppState>().ai_event_bus.publish_event(AiChatEvent::AiAgentRound {
round: 0, conversation_id: Some(conv_id_owned.clone()),
});
tauri::async_runtime::spawn(async move {
super::run_agentic_loop(session_arc, tools_arc, db, app_handle, provider_config, system_prompt, conv_id_owned, knowledge_config, llm_concurrency, max_iterations, max_retries, start_iteration, model_override).await;
});
}
/// 从 LLM 本轮调用的工具中推理目标描述(本轮可能多个,全部提取)。
/// 工具调用是结构化数据(工具名+参数),比从文本中提取更可靠。
pub(crate) fn infer_goal_from_tool_calls(tool_calls: &std::collections::HashMap<u32, crate::commands::ai::ToolCallDraft>) -> Vec<String> {
if tool_calls.is_empty() { return vec![]; }
let mut goals: Vec<String> = Vec::new();
for tc in tool_calls.values() {
let goal = match tc.name.as_str() {
"patch_file" | "write_file" | "edit_file" | "append_file" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("path").and_then(|v| v.as_str()).map(|p| {
let f = p.rsplit('/').next().or_else(|| p.rsplit('\\').next()).unwrap_or(p);
format!("修改 {}", f)
}))
}
"read_file" | "file_info" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("path").and_then(|v| v.as_str()).map(|p| {
let f = p.rsplit('/').next().or_else(|| p.rsplit('\\').next()).unwrap_or(p);
format!("查看 {}", f)
}))
}
"search_files" | "grep" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("pattern").or_else(|| args.get("query")).and_then(|v| v.as_str()).map(|q| {
let s = if q.len() > 25 { &q[..25] } else { q };
format!("搜索 {}", s)
}))
.or_else(|| Some("搜索文件".to_string()))
}
"run_command" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("command").and_then(|v| v.as_str()).map(|c| {
let s = if c.len() > 25 { &c[..25] } else { c };
format!("执行 {}", s)
}))
.or_else(|| Some("执行命令".to_string()))
}
"create_project" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("name").and_then(|v| v.as_str()).map(|n| format!("创建项目 {}", n)))
}
"create_idea" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("title").and_then(|v| v.as_str()).map(|t| format!("捕获灵感 {}", t)))
}
"run_workflow" => Some("执行工作流".to_string()),
"delete_file" | "rename_file" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("path").and_then(|v| v.as_str()).map(|p| {
let f = p.rsplit('/').next().or_else(|| p.rsplit('\\').next()).unwrap_or(p);
format!("处理 {}", f)
}))
}
"list_directory" => {
serde_json::from_str::<serde_json::Value>(&tc.args).ok()
.and_then(|args| args.get("path").and_then(|v| v.as_str()).map(|p| format!("浏览 {}", p)))
}
_ => None,
};
if let Some(g) = goal { if !goals.contains(&g) { goals.push(g); } }
}
goals
}
/// G2 探索熔断:判定工具结果是否为「空结果」(空成功,非失败)。
pub(crate) fn is_empty_tool_result(content: &str) -> bool {
let trimmed = content.trim();
if trimmed.is_empty() { return true; }
const EMPTY_MARKERS: &[&str] = &[
"\"total\":0", "\"entries\":[]", "\"matches\":[]", "\"results\":[]", "\"files\":[]",
];
for marker in EMPTY_MARKERS {
if trimmed.contains(marker) { return true; }
}
const EMPTY_TEXT: &[&str] = &[
"未找到", "没有找到", "无匹配", "没有匹配", "未匹配", "未发现", "无记录",
"No matches", "no matches", "0 results", "0 matches", "没有数据", "没有符合",
];
for marker in EMPTY_TEXT {
if trimmed.contains(marker) { return true; }
}
false
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_empty_tool_result() {
assert!(is_empty_tool_result(""));
assert!(is_empty_tool_result(" "));
assert!(is_empty_tool_result(r#"{"total":0}"#));
assert!(is_empty_tool_result(r#"{"entries":[]}"#));
assert!(is_empty_tool_result("未找到相关文件"));
assert!(!is_empty_tool_result(r#"{"total":5}"#));
assert!(!is_empty_tool_result(r#"{"entries":["a.txt"]}"#));
}
}

450
src-tauri/src/commands/ai/agentic/mod.rs
View File

@@ -45,12 +45,17 @@ use crate::state::{AppState, LlmConcurrency};
use super::audit::process_tool_calls;
// compress_via_llm 已随压缩逻辑迁至 context_lifecycle.rs(maybe_auto_compress 内调用)。
use super::conversation::{save_conversation, TokenAccumulator};
use super::knowledge_inject::{inject_knowledge_into_prompt, maybe_spawn_extraction};
use super::knowledge_inject::{maybe_spawn_extraction};
#[allow(unused_imports)]
use super::knowledge_inject::inject_knowledge_into_prompt;
#[allow(unused_imports)]
use super::prompt::{build_system_prompt, get_active_provider};
use super::stream_recv::{stream_llm, StreamResult};
use super::title::{ensure_conversation_title, spawn_ensure_title};
#[allow(unused_imports)]
use super::{AiChatEvent, AiSession, ErrorType, SessionState};
#[allow(unused_imports)]
use super::ToolCallDraft;
// ConvState 经本文件内 `pub mod conv_state;` 同 crate 直接访问(conv_state::ConvState)。
/// L1 补丁:run_agentic_loop 入口 provider 解析超时保护的内部错误类型。
@@ -105,8 +110,9 @@ pub const TOPIC_MARKER_ENABLED: bool = true;
// ============================================================
// G1 目标钉扎(治 R1 目标消息被压缩出局 + R3 重锚定 + R5 prompt 无锚点,2026-06-26)
//
// 机制:首条 active user 消息提取目标存 PerConvState.pinned_goal(内容态字段,绕过
// sanitize step0 is_active 过滤),run_agentic_loop 入口拼进 system_prompt 尾部。
// 机制:run_agentic_loop 每轮从 LLM 工具调用推理目标(infer_goal_from_tool_calls),
// 存 PerConvState.pinned_goals(Vec<GoalEntry>,内容态字段,绕过 sanitize step0 is_active 过滤),
// run_agentic_loop 入口拼 active 目标进 system_prompt 尾部。
// system_prompt 是 loop 不变量 + build_for_request 不裁剪,故目标天然免疫压缩/裁剪,
// 彻底治 R1(目标消息物理出局)/R5(prompt 说教无锚点),无 insert_at(0) 的连续 System
// 1214/首位锚点稀释/小预算被裁三重风险。
@@ -114,10 +120,12 @@ pub const TOPIC_MARKER_ENABLED: bool = true;
/// G1 总开关:目标钉扎是否启用(默认 true)。
///
/// true(默认):chat.rs 两处 push 后提取首条 user 目标存 pinned_goal + loop 入口拼 system_prompt。
/// false(回退):两处提取跳过 + loop 入口拼接跳过,pinned_goal 永远 None,system_prompt 零变化,
/// true(默认):run_agentic_loop 每轮从 LLM 工具调用推理目标(infer_goal_from_tool_calls),
/// 存入 PerConvState.pinned_goals(Vec<GoalEntry>) + loop 入口拼 active 目标进 system_prompt。
/// false(回退):提取跳过 + loop 入口拼接跳过,pinned_goals 永远空 Vec,system_prompt 零变化,
/// 完全退回改动前行为(目标靠压缩摘要 + topic marker + 聚焦准则 prompt 续命)。单点回退,
/// 不影响 G2/G4/G5(对齐 KEYWORD_FALLBACK_ENABLED 模式:每改配开关 + 兜底降级旧行为)。
/// 2026-07-03 改:提取从 chat.rs 用户消息规则 → run_agentic_loop 工具调用推理(helpers.rs)。
pub const GOAL_PIN_ENABLED: bool = true;
/// G1 banner 开关:目标拼进 system_prompt 时是否加「## 当前目标」分隔标题(默认 true)。
@@ -272,6 +280,10 @@ mod knowledge_lifecycle;
// ============================================================
pub mod conv_state;
pub mod command_lock;
pub(crate) mod helpers;
pub(crate) use helpers::try_continue_agent_loop;
pub(crate) use helpers::infer_goal_from_tool_calls;
pub(crate) use helpers::is_empty_tool_result;
// ============================================================
// F-260614-04 / F-260614-04b: 单 Provider 流式结果 + fallback 辅助
@@ -798,19 +810,26 @@ pub(crate) async fn run_agentic_loop(
// pinned_goals 永远空 Vec(单点回退等价改动前)。拼接在 sys_tokens 估算前。
//
// 注:仅 run_agentic_loop 入口注入。手动压缩/标题/提炼等路径不注入目标。
//
// 目标提取方式(2026-07-03 改):从 LLM 本轮工具调用推理目标描述(工具名+路径),
// 不再从用户消息规则提取,也不依赖 LLM 输出结构化标记。
// 推理结果存入 pinned_goals: Vec<GoalEntry>,含 text+status 状态追踪。
// 新目标加入时自动标记之前的 active 为 completed。
let mut system_prompt = system_prompt;
if GOAL_PIN_ENABLED {
let goals: Vec<String> = {
let goals: Vec<super::GoalEntry> = {
let session = session_arc.lock().await;
session
.conv_read(&conv_id)
.map(|c| c.pinned_goals.clone())
.unwrap_or_default()
};
if !goals.is_empty() {
let goal_lines: Vec<String> = goals.iter().enumerate().map(|(i, g)| {
let g = g.trim();
let truncated: String = g.chars().take(GOAL_MAX_CHARS).collect();
// 只把 active 目标注入 system_prompt(completed 不干扰 LLM 注意力)
let active_goals: Vec<&super::GoalEntry> = goals.iter().filter(|g| matches!(g.status, super::GoalStatus::Active)).collect();
if !active_goals.is_empty() {
let goal_lines: Vec<String> = active_goals.iter().enumerate().map(|(i, g)| {
let trimmed = g.text.trim();
let truncated: String = trimmed.chars().take(GOAL_MAX_CHARS).collect();
let truncated = if truncated.chars().count() >= GOAL_MAX_CHARS {
format!("{}…", truncated)
} else {
@@ -830,7 +849,7 @@ pub(crate) async fn run_agentic_loop(
tracing::info!(
conv_id = %conv_id,
count = goals.len(),
first_goal = %goals.first().map(|g| &g[..std::cmp::min(120, g.len())]).unwrap_or(""),
first_goal = %goals.first().map(|g| &g.text[..std::cmp::min(120, g.text.len())]).unwrap_or(""),
"[ai] G1 目标钉扎:已把 {} 个 pinned_goals 拼进 system_prompt",
goals.len()
);
@@ -848,9 +867,9 @@ pub(crate) async fn run_agentic_loop(
system_prompt = format!("{}\n\n{}\n\n{}", system_prompt, env_prompt, behavior_prompt);
// ── 多 Agent 并行执行:Coordinator 分解(plan_execution_enabled 时) ──
// 关闭时退单 Agent(等价原行为);开启时分解意图→Plan,dispatch+merge→合并产出落回主对话
// 对话透明化 L1:拍快照供 AiCompleted 事件携带(coordinator 路径出口也用)
let pinned_goals_snapshot: Vec<String> = {
// 只取 text(前端不需要状态信息)
let pinned_goals_snapshot: Vec<super::GoalEntry> = {
let session = session_arc.lock().await;
session
.conv_read(&conv_id)
@@ -1444,7 +1463,55 @@ pub(crate) async fn run_agentic_loop(
msg.reasoning_content = last_reasoning_content.clone();
session.conv(&conv_id).messages.push(msg);
}
}
// G1 目标提取: 从工具调用推理目标描述。
// 工具调用是结构化数据(工具名+路径),比从文本中提取更可靠。
// 无工具调用时不提取(已有目标保持不变,该轮无新目标)。
if GOAL_PIN_ENABLED {
// 从工具调用推理目标(本轮可能多个工具,全部提取)
let new_goals = infer_goal_from_tool_calls(&tool_calls_acc);
if !new_goals.is_empty() {
let goal_conv = session.conv(&conv_id);
let mut added = false;
for g in &new_goals {
// 去重:文本不在已有目标中(包含关系检查)
let is_dup = goal_conv.pinned_goals.iter().any(|e|
e.text.contains(g.as_str()) || g.contains(&e.text)
);
if !is_dup {
goal_conv.pinned_goals.push(super::GoalEntry::new(g.clone()));
added = true;
}
}
// 有新目标 → 标记之前的 active 为 completed(LLM 进入下一任务)
if added && goal_conv.pinned_goals.len() > new_goals.len() {
let active_until = goal_conv.pinned_goals.len() - new_goals.len();
for entry in goal_conv.pinned_goals.iter_mut().take(active_until) {
if matches!(entry.status, super::GoalStatus::Active) {
entry.status = super::GoalStatus::Completed;
}
}
}
// 超上限时保留 active,淘汰最早 completed
if goal_conv.pinned_goals.len() > MAX_GOALS {
let active: Vec<super::GoalEntry> = goal_conv.pinned_goals.iter()
.filter(|g| matches!(g.status, super::GoalStatus::Active))
.cloned().collect();
if active.len() <= MAX_GOALS {
let keep = MAX_GOALS - active.len();
let completed: Vec<super::GoalEntry> = goal_conv.pinned_goals.iter()
.filter(|g| matches!(g.status, super::GoalStatus::Completed))
.rev().take(keep).cloned().collect();
let mut merged = active;
merged.extend(completed.into_iter().rev());
goal_conv.pinned_goals = merged;
} else {
goal_conv.pinned_goals.truncate(MAX_GOALS);
}
}
}
// L3 [UPDATE_GOALS] 标记:LLM 可主动修正目标列表(意图增强/纠偏)。
// 后续独立 PR 实现:解析 [UPDATE_GOALS]...[END] 块并替换 pinned_goals。
}
// 停止信号：已生成文本入库后退出，不再执行后续工具调用
if stop_flag.load(Ordering::SeqCst) {
@@ -1472,7 +1539,9 @@ pub(crate) async fn run_agentic_loop(
}
// 无工具调用 → 最终文本响应，正常收敛退出
#[allow(unused_assignments)]
if !has_tool_calls { converged = true; break; }
let _ = converged;
// 处理工具调用（Low 自动执行 / Medium+High 待审批）
let pending_count = {
@@ -1637,7 +1706,7 @@ pub(crate) async fn run_agentic_loop(
String::new()
} else {
let goal_summary = goals.iter()
.map(|g| g.trim())
.map(|g| g.text.trim())
.filter(|g| !g.is_empty())
.collect::<Vec<_>>()
.join("; ");
@@ -1784,353 +1853,4 @@ pub(crate) async fn run_agentic_loop(
pinned_goals: pinned_goals_snapshot.clone(),
});
}
/// G2 探索熔断:判定工具结果是否为「空结果」(空成功,非失败)。
///
/// 关键词表**对齐真实 tool_result 格式**(audit.rs tool 执行经 `serde_json::Value::to_string()`
/// 序列化为紧凑 JSON,无空格):
/// - search_files / grep 空 → `{"total":0,...}` → 命中 `"total":0`(紧凑,冒号后无空格)。
/// - list_directory 空 → `{"entries":[],...}` → 命中 `"entries":[]`。
/// - read_symbol 未找到 → 含「未找到」回退提示。
/// - 通用空 → `"matches":[]` / `"results":[]` / `No matches` / `无匹配` / `未找到` / `没有找到`。
///
/// 与 L1 is_failure(禁止/失败/Error)**不重叠**:空结果「total:0」不含失败关键词,L1 不命中。
/// 漏判风险由 STALL_BREAKER_THRESHOLD=3 + 两段式 WARN_FIRST 容错(多轮漏判才误熔断,最坏退 max_iterations)。
pub(crate) fn is_empty_tool_result(content: &str) -> bool {
let trimmed = content.trim();
if trimmed.is_empty() {
return true;
}
// 紧凑 JSON 空结果标记(对齐 serde_json::Value::to_string() 输出,冒号后无空格)。
// search_files/grep:"total":0 ;list_directory:"entries":[];通用空数组 matches/results/files。
const EMPTY_MARKERS: &[&str] = &[
"\"total\":0",
"\"entries\":[]",
"\"matches\":[]",
"\"results\":[]",
"\"files\":[]",
];
for marker in EMPTY_MARKERS {
if trimmed.contains(marker) {
return true;
}
}
// 中文 / 英文「未找到」类提示(read_symbol 等回退文本)。
const EMPTY_TEXT: &[&str] = &[
"未找到",
"没有找到",
"无匹配",
"没有匹配",
"未匹配",
"未发现",
"无记录",
"No matches",
"no matches",
"0 results",
"0 matches",
"没有数据",
"没有符合",
];
for marker in EMPTY_TEXT {
if trimmed.contains(marker) {
return true;
}
}
false
}
/// 检查是否所有待审批已处理，如果是则恢复 agentic 循环
///
/// B-260615-08:所有静默 return 点显式 emit 收尾事件,避免前端 streaming=true 永久卡。
/// 各 return 点的语义判断:
/// 1) should_continue=false(generating 已复位 / pending_approvals 非空):
/// - generating=false → 用户点了停止(ai_chat_stop 复位)或会话已结束,emit AiCompleted 标当前轮收敛
/// (streaming=true 由 AiCompleted 清理)
/// - pending_approvals 非空 → 转入审批等待态(其他审批未决),emit AiCompleted 标当前轮结束
/// (前端审批态 watchdog 已 clear,不卡)
/// 2) get_active_provider Err → 无可用 provider(配置丢失/全删),无法续生成,emit AiError
/// (语义:配置错误,用户需设 provider;非 generating 复位可恢复)
///
/// R-PD-6: conv_id 来源从全局 active_conversation_id 解耦到审批所属会话。
/// 触发本函数的 ai_approve 已 remove 触发审批,但 pending_approvals 内剩余审批(若 has_pending)
/// 仍各自携带 conversation_id(审批产生时由 process_tool_calls 写入,业务真相源)。
/// 故 has_pending=true 分支(审批等待态)直接取剩余审批的 conversation_id 做 conv_id,
/// 不读 active_conversation_id 全局单例——该字段在审批等待态(非 generating-only 期)可被
/// ai_chat_stop/clear/switch 并发改写,属竞态耦合。has_pending=false(全部审批已处理,续生成)
/// 分支:审批已被 remove,改为以剩余 pending_approvals 任一 conversation_id 做一致性校验
/// (此处空,校验通过即沿用全局值,该期 generating=true 且 switch 为 readonly 不并发)。
pub(crate) async fn try_continue_agent_loop(
app: &AppHandle,
state: &AppState,
conv_id: &str,
start_iteration: usize,
) {
// 审批超时检测:超时取消在本函数入口进行(本函数是所有审批恢复路径的入口——
// ai_approve / ai_authorize_dir / ai_continue_loop / ai_chat_stop 都调它)。
// 这里检测后把超时审批转为拒绝状态,避免用户离开后 pending 永久挂起死锁会话。
// 0 表示禁用超时(不推荐,但保留用户选择权)。检测失败(如锁中毒)不阻断续跑。
approval_timeout::cleanup_expired_approvals(app, state, conv_id).await;
// BUG-260617-05: 原 5 次独立 lock().await 造成 TOCTOU 竞态——should_continue=true 判出后、
// spawn 前用户点 stop(ai_chat_stop 复位 generating=false),续跑仍按过时快照继续 spawn。
// 修复:单次 lock 取结构化快照(所有续跑判定所需字段),无锁态判定;spawn 前单次 lock 原子
// 重检 generating 仍为 true 才续跑,stop 后中途插入的直接收敛退出。
//
// F-260616-09 B 批2(设计 §4.4):conv_id 改显式入参(替代从 pending/active 推断),
// has_pending 按 conv_id 过滤(决策 e 真并发准备);generating/agent_language/model_override
// 读 per_conv(批2 桥接期与顶层等价,per_conv 未建 fallback 顶层)。
// conv_id 来源:调用方 ai_approve 传 approval.conversation_id;ai_continue_loop/ai_stop_loop
// 传 IPC 参数 conversation_id。
let snap = {
let session = state.ai_session.lock().await;
// path_auth 审批链阶段1:has_pending 改调 session_state(conv_id) 收敛状态机判定,
// 替代手写 path_auth+risk 两表 any 合并(mod.rs 已统一封装)。
// 阶段3a 单真相源合并后:两表合一进 pending_approvals,session_state 单表 any 判定。
// 两表语义不变——任一类挂起都阻塞续跑(agentic loop 在 path_auth 挂起时也已 return 等待,
// 漏任一会致 loop 误续跑空转)。
//
// 兜底/快速回退:若需切回手写 has_pending,原双表组合保留如下(改一行即可):
// let has_pending = session.pending_approvals.values()
// .any(|a| a.conversation_id.as_deref() == Some(conv_id));
let has_pending = session.session_state(conv_id) == SessionState::AwaitingApproval;
// pending_conv_id 保留(should_continue=false 路径的 emit conv_id 回退逻辑)。
// 阶段3a:单表 find_map(原两表合一)。
let pending_conv_id = session.pending_approvals.values()
.find_map(|a| a.conversation_id.clone());
let conv = session.conv_read(conv_id);
// F-09 B 批4:per_conv 唯一真相源,删顶层 fallback(conv 不存在则各字段默认值)。
// L2 读侧(双轨收口批2):统一读 conv_state.is_active()(Generating+Compressed),删除
// CONV_STATE_ENABLED off 回退分支(enum 单路径)。用于 ai_can_continue 继续按钮是否可点判断,
// is_active() 与原 generating 语义一致(压缩期间 loop 仍活跃,应判为仍在生成)。
let is_generating = conv.map(|c| c.conv_state.is_active()).unwrap_or(false);
let agent_language = conv.and_then(|c| c.agent_language.clone());
let model_override = conv.and_then(|c| c.model_override.clone());
let pinned_goals_snapshot = conv.map(|c| c.pinned_goals.clone()).unwrap_or_default();
ContinueSnapshot {
is_generating,
has_pending,
pending_conv_id,
agent_language,
model_override,
pinned_goals_snapshot,
}
};
let should_continue = snap.is_generating && !snap.has_pending;
if !should_continue {
// generating=false(被 stop)或仍有审批(pending_approvals 非空):
// 统一 emit AiCompleted 标当前轮收敛,清前端 streaming。
// 轮 token 已在前序 AiCompleted/AiApprovalResult 流程落库,此处零 token 上报仅作收敛信号。
if snap.is_generating {
// pending_approvals 非空但 generating 仍 true:转审批态,前端审批态 watchdog 已 clear,不卡
tracing::info!(conv_id = %conv_id, "[ai] try_continue 跳过:仍有待审批,转审批等待态");
} else {
// generating 已复位(用户 stop 或前序循环已 emit Completed):补发 AiCompleted 防前端卡住
tracing::info!(conv_id = %conv_id, "[ai] try_continue 跳过:generating 已复位(被 stop/已结束),补发 AiCompleted 清前端 streaming");
// R-PD-6: 优先用审批所属 conversation_id(审批等待态被 stop 触发,审批仍在 pending_approvals),
// 仅当无任何审批(has_pending=false 且 generating=false)时回退入参 conv_id(批2 显式参数)。
let emit_conv_id = match snap.pending_conv_id.clone() {
Some(cid) => cid,
None => conv_id.to_string(),
};
let ev = AiChatEvent::AiCompleted {
total_tokens: 0,
prompt_tokens: 0,
completion_tokens: 0,
incomplete: None,
conversation_id: Some(emit_conv_id),
pinned_goals: snap.pinned_goals_snapshot.clone(),
};
let _ = app.emit("ai-chat-event", ev.clone());
// L3 emit 双写:tunnel subscriber(阶段2)透传 miniapp
let _ = app.state::<AppState>().ai_event_bus.publish_event(ev);
}
return;
}
let provider_config = match get_active_provider(state).await {
Ok(p) => p,
Err(e) => {
// 无可用 provider(配置丢失/全删):无法续生成,emit AiError。
// 语义:配置错误,用户需在 Settings 设 provider;generating 复位由 run_agentic_loop 内
// build_provider_for Err 分支处理(同样 emit AiError),此处与之一致。
// 不用 GeneratingGuard:try_continue 的 should_continue=false 路径需保生成态(审批等待态),
// 全函数 guard 会误复位。此点单点 provider-Err 复位,语义独立。
// 批3 双轨收口:generating bool 已退役,复位经 ConvState 迁移(Generating→Idle)单一表达。
let mut session = state.ai_session.lock().await;
// 持久化层 ConvState→Idle 复位(对齐 guard.reset 收敛路径,非配置错误不阻断)。
match session.conv(conv_id).conv_state.transition_to(conv_state::ConvState::Idle) {
Ok(ns) => session.conv(conv_id).conv_state = ns,
Err(e) => tracing::warn!(
conv_id = %conv_id,
error = %e,
"[ai] try_continue provider-Err ConvState→Idle 非法(不阻断 emit AiError)"
),
}
drop(session);
tracing::warn!(conv_id = %conv_id, error = %e, "[ai] try_continue 失败:无可用 provider");
let _ = app.emit("ai-chat-event", AiChatEvent::AiError {
error: e.clone(),
// 无可用 provider(配置丢失/全删):用户需在 Settings 设 provider,归 ProviderConfig
error_type: Some(ErrorType::ProviderConfig),
conversation_id: Some(conv_id.to_string()),
});
// L3 emit 双写:try_continue provider-Err AiError publish 到事件总线(门控在 publish 内)。
let _ = app.state::<AppState>().ai_event_bus.publish_event(AiChatEvent::AiError {
error: e,
error_type: None,
conversation_id: Some(conv_id.to_string()),
});
return;
}
};
// F-09 B 批2:续生成路径 conv_id 用入参(显式,不再从 active 推断),语言/override 读 per_conv 快照。
let lang = snap.agent_language.clone().unwrap_or_else(|| "zh-CN".to_string());
let conv_id_owned = conv_id.to_string();
let system_prompt = build_system_prompt(state, &lang).await;
let session_arc = state.ai_session.clone();
let tools_arc = state.ai_tools.clone();
let db = state.db.clone();
let app_handle = app.clone();
let knowledge_config = state.knowledge_config.lock().await.clone();
let llm_concurrency = state.llm_concurrency.clone();
// 知识注入:DRY(B):收敛至 inject_knowledge_into_prompt 单一入口。
// P1 修复(审批恢复路径缺知识注入):try_continue 续跑轮此前用裸 build_system_prompt,
// 不调 build_knowledge_context 致续跑轮丢知识库上下文。现与 chat.rs 四处同款走 helper。
// 同消息取 text+id(②口径修复):原 last_user_text 过滤 is_active / user_message_id 走
// last_user_message_id 不过滤 is_active,末条 user 压缩后两值取自不同消息;helper 单次
// 反向扫描同一条消息取两值。复用上方已 clone 的 knowledge_config 快照(避免重复加锁)。
let system_prompt = inject_knowledge_into_prompt(state, conv_id, system_prompt, &knowledge_config).await;
// F-260616-01: loop 入口 load 快照，当前续生成 loop 锁定边界（热改下次发消息生效）
let max_iterations = state.agent_max_iterations.load(Ordering::SeqCst);
// F-260616-07: 流式失败重试次数快照
let max_retries = state.agent_max_retries.load(Ordering::SeqCst);
// F-01 阶段6: 续跑沿用同一主对话的 model_override(审批续跑/达 max 续跑保持一致)。
let model_override = snap.model_override.clone();
// BUG-260617-05 续: provider 解析/build_system_prompt 期间用户可能点 stop。
// spawn 前单次 lock 原子重检 generating——若已被 stop 复位,收敛退出而非覆盖用户的 stop。
// (run_agentic_loop 入口 GeneratingGuard 会再次置 generating=true,若不重检会抹掉 stop。)
// F-09 B 批4:重检 per_conv.generating(唯一真相源;conv 不存在则 false)。
// L2 读侧(双轨收口批2):统一读 conv_state.is_active()(Generating+Compressed),删除
// CONV_STATE_ENABLED off 回退分支(enum 单路径)。spawn 前单次 lock 原子重检是否仍在生成,
// is_active() 与原 generating 语义一致。
let still_generating = {
let session = state.ai_session.lock().await;
session.conv_read(conv_id).map(|c| c.conv_state.is_active()).unwrap_or(false)
};
if !still_generating {
tracing::info!(conv_id = %conv_id, "[ai] try_continue 终止:spawn 前重检 generating 已被 stop 复位,补发 AiCompleted");
let ev = AiChatEvent::AiCompleted {
total_tokens: 0,
prompt_tokens: 0,
completion_tokens: 0,
incomplete: None,
conversation_id: Some(conv_id_owned.clone()),
pinned_goals: snap.pinned_goals_snapshot.clone(),
};
let _ = app.emit("ai-chat-event", ev.clone());
// L3 emit 双写:tunnel subscriber(阶段2)透传 miniapp
let _ = app.state::<AppState>().ai_event_bus.publish_event(ev);
return;
}
// 恢复循环前通知前端新建 assistant 消息：审批(通过/拒绝)后新一轮文本
// 不应追加到发起工具调用的旧消息，用 AiAgentRound 隔开
let _ = app.emit("ai-chat-event", AiChatEvent::AiAgentRound {
round: 0,
conversation_id: Some(conv_id_owned.clone()),
});
// L3 emit 双写:try_continue 续跑 AiAgentRound publish 到事件总线(门控在 publish 内)。
let _ = app.state::<AppState>().ai_event_bus.publish_event(AiChatEvent::AiAgentRound {
round: 0,
conversation_id: Some(conv_id_owned.clone()),
});
tauri::async_runtime::spawn(async move {
run_agentic_loop(session_arc, tools_arc, db, app_handle, provider_config, system_prompt, conv_id_owned, knowledge_config, llm_concurrency, max_iterations, max_retries, start_iteration, model_override).await;
});
}
/// BUG-260617-05: try_continue_agent_loop 续跑判定所需 session 字段的一次性快照。
/// 单次 lock 取出后无锁态判定,消除多 lock 间其他 IPC(ai_chat_stop/clear/switch)改写 session
/// 致续跑判断基于过时快照的 TOCTOU 竞态。
///
/// F-260616-09 B 批2:active_conversation_id 字段移除(改用入参 conv_id,不再从 snap 读)。
struct ContinueSnapshot {
is_generating: bool,
has_pending: bool,
pending_conv_id: Option<String>,
agent_language: Option<String>,
model_override: Option<String>,
/// 对话透明化 L1:快照 pinned_goals 供 AiCompleted emit 携带
pinned_goals_snapshot: Vec<String>,
}
#[cfg(test)]
mod tests {
use super::*;
// ============================================================
// G2 is_empty_tool_result 单测
// ============================================================
#[test]
fn test_empty_tool_result_empty_string() {
assert!(is_empty_tool_result(""));
}
#[test]
fn test_empty_tool_result_whitespace() {
assert!(is_empty_tool_result(" "));
}
#[test]
fn test_empty_tool_result_total_zero() {
assert!(is_empty_tool_result(r#"{"total":0}"#));
}
#[test]
fn test_empty_tool_result_entries_empty() {
assert!(is_empty_tool_result(r#"{"entries":[]}"#));
}
#[test]
fn test_empty_tool_result_matches_empty() {
assert!(is_empty_tool_result(r#"{"matches":[]}"#));
}
#[test]
fn test_empty_tool_result_results_empty() {
assert!(is_empty_tool_result(r#"{"results":[]}"#));
}
#[test]
fn test_empty_tool_result_files_empty() {
assert!(is_empty_tool_result(r#"{"files":[]}"#));
}
#[test]
fn test_empty_tool_result_chinese_no_match() {
assert!(is_empty_tool_result("未找到相关文件"));
}
#[test]
fn test_empty_tool_result_english_no_match() {
assert!(is_empty_tool_result("No matches found"));
}
#[test]
fn test_non_empty_tool_result() {
assert!(!is_empty_tool_result(r#"{"total":5}"#));
}
#[test]
fn test_non_empty_tool_result_with_content() {
assert!(!is_empty_tool_result(r#"{"entries":["a.txt","b.txt"]}"#));
}
}

19
src-tauri/src/commands/ai/audit/approval.rs
View File

@@ -34,20 +34,19 @@ pub(super) fn classify_risk_and_auto(
tool_name: &str,
args: &serde_json::Value,
) -> bool {
let mut should_auto = match risk_level {
let _ = args; // 预留扩展点(未来可加路径白名单/文件类型等维度)
// patch_file 是 AI 编码主力工具,改文件是 AI Coding 的工作常态。
// 原本“小改动(≤5 行)豁免、大改动审批”的设计在实际使用中频繁打断 AI 工作流
// (AI 改文件往往远超 5 行),且文件已写入会落 audit 表可追溯,审批价值低。
// 决策:patch_file 全档位自动放行(low/medium/all 均不审批),与 read_file 同级处理。
if tool_name == "patch_file" {
return true;
}
match risk_level {
RiskLevel::Low => true,
RiskLevel::Medium => auto_exec_mode == "medium" || auto_exec_mode == "all",
RiskLevel::High => auto_exec_mode == "all",
};
// C-260627：patch_file 小改动（≤5 行）自动放行，不阻塞 AI 工作流
if !should_auto && tool_name == "patch_file" {
if let Some(text) = args.get("new_text").and_then(|v| v.as_str()) {
if text.lines().count() <= 5 {
should_auto = true;
}
}
}
should_auto
}
/// 审批策略方案 B:Persona 维度判定。

19
src-tauri/src/commands/ai/audit/mod.rs
View File

@@ -325,6 +325,25 @@ pub(crate) async fn process_tool_calls(
.ok()
.flatten()
.unwrap_or_else(|| "low".to_string());
// F-#97 诊断:用户报「选 all 仍审批」时辅助定位 KV 是否真落库。
// df-ai-trace-approve 开关控制(默认开)。常见误以为已生效但实际未点确认按钮致 KV 未落。
let trace_on = app_handle
.state::<crate::state::AppState>()
.settings
.get("df-ai-trace-approve")
.await
.ok()
.flatten()
.map(|v| v == "true" || v == "1")
.unwrap_or(true);
if trace_on {
tracing::info!(
conv_id = %conv_id,
auto_exec_mode = %auto_exec_mode,
drafts_count = drafts.len(),
"[ai] 审批判定读取的自动执行模式"
);
}
// trust_hits 收集：AE-04 会话信任命中（同会话已批准同类操作），真实执行但移到锁外 spawn
// （对齐 Low risk 不持锁模式）。命中时此处只 emit toast + 收集，不 .await execute。
let mut trust_hits: Vec<(ToolCallDraft, serde_json::Value, String, RiskLevel)> = Vec::new();

65
src-tauri/src/commands/ai/commands/chat.rs
View File

@@ -24,7 +24,8 @@ use crate::state::AppState;
use crate::commands::{err_str, now_millis};
// chat.rs 的 super = commands,super::super = ai(与原 commands.rs 的 super=ai 等价)。
use super::super::agentic::{run_agentic_loop, try_continue_agent_loop, GOAL_MAX_CHARS, GOAL_PIN_ENABLED, MAX_GOALS};
use super::super::agentic::{run_agentic_loop, try_continue_agent_loop, GOAL_MAX_CHARS};
// G1 目标钉扎:GOAL_PIN_ENABLED/MAX_GOALS 已迁移至 agentic 侧使用,chat 不再需要(extract_pinned_goal 纯函数只依赖 GOAL_MAX_CHARS 截断)
// 双轨收口批1:读侧入口拦截用 ConvState(can_accept_request 的 unwrap_or 兜底初值)。
use super::super::agentic::conv_state::ConvState;
use super::super::audit::{audit_finalize, emit_data_changed};
@@ -72,20 +73,10 @@ pub(crate) fn finalize_pending_placeholders(session: &mut super::super::AiSessio
}
}
/// G1 目标钉扎:从 user 消息文本提取单条目标(纯函数,无 IO / 无额外 LLM 请求)。
/// 去噪助手:从文本中 strip `[kind:...]` mention 标签(纯函数,无 IO)。
///
/// 治 R1(目标消息被压缩出局)的提取侧:每次 user 消息的文本即潜在目标,
/// 提取后追加到 `PerConvState.pinned_goals` Vec(去重),即使原消息出局目标仍在。
///
/// 处理(零额外请求,对齐 GLM 限额口径 1 请求=1 次):
/// 1. strip 所有 `[kind:...]` mention 段(augmentation 已投影,目标文本去噪)。对齐 intent.rs
/// KINDS(项目/任务/想法/技能 + project/task/idea/skill),全文扫描移除(实测诊断 seq5 目标
/// `分析灵感模块不足 [项目: DevFlow]` mention 在**末尾**,非仅行首),冒号兼容全角：/半角:。
/// 2. trim 空白。
/// 3. 截断到 GOAL_MAX_CHARS(防长需求文档撑爆 system_prompt 占预算)。
///
/// 返回空串(纯 mention / 空消息)→ 调用方判非空才追加到 pinned_goals(避免空目标注入)。
/// 默认用原文非 LLM 提取(消息锚点派 keepIdeas:零额外请求)。
/// 原为 G1 目标钉扎的提取函数(2026-07-03 已改为工具调用推理),现保留供测试用例使用。
#[allow(dead_code)]
pub(crate) fn extract_pinned_goal(text: &str) -> String {
// strip 所有 [kind:...] mention 段(对齐 intent.rs strip_mention_tags/try_match_mention 逻辑,
// 单一真相源:KINDS 表与 intent.rs 一致)。全文扫描,非仅行首。
@@ -114,6 +105,7 @@ pub(crate) fn extract_pinned_goal(text: &str) -> String {
///
/// kind 大小写不敏感(ASCII)+ 中文直比;冒号接受全角：/半角:;kind 后允许空白;
/// 未闭合 `]` 返 None(不当 mention,保留原样 `[`)。对齐 intent.rs try_match_mention。
#[allow(dead_code)]
fn find_mention_close(chars: &[char], open: usize, kinds: &[&str]) -> Option<usize> {
let after = open + 1;
for k in kinds {
@@ -463,17 +455,11 @@ pub async fn ai_chat_send(
// DRY(B):知识注入已收敛至 inject_knowledge_into_prompt(helper 内部同消息取 text+id),
// 此处 user_msg_id 不再透传到注入逻辑,保留下划线占用(锁内 push 已发生,语义不变)。
let user_msg_id = conv.messages.last_user_message_id();
// G1 目标钉扎:push 后提取本次 user 目标追加到 pinned_goals(去重,支持累积多目标)。
// GOAL_PIN_ENABLED=false → 跳过;extract_pinned_goal 返空 → 不追加。
if GOAL_PIN_ENABLED {
let goal = extract_pinned_goal(&user_content);
if !goal.is_empty() && !conv.pinned_goals.contains(&goal) {
conv.pinned_goals.push(goal);
if conv.pinned_goals.len() > MAX_GOALS {
conv.pinned_goals.remove(0);
}
}
}
// G1 目标钉扎已迁移至 run_agentic_loop 工具调用推理(2026-07-03 改),
// 从 LLM 本轮调用的工具名+路径推理目标,不再从用户消息规则提取。
// 用户发送的短指令(如「继续」「确认」)不会产生低价值目标。
// 此处不再从原始用户消息提取。
// GOAL_PIN_ENABLED=false → 跳过整块。
(target, user_msg_id)
};
@@ -1359,16 +1345,7 @@ pub async fn ai_chat_edit(
conv.iteration_used = 0;
// F-01 阶段6: 记录用户指定模型 override(主对话专用)。
conv.model_override = model_override.clone();
// G1 目标钉扎:替换消息后重新提取目标(用户可能通过编辑改变了意图,与 send 路径一致)
if GOAL_PIN_ENABLED {
let goal = extract_pinned_goal(&new_message);
if !goal.is_empty() && !conv.pinned_goals.contains(&goal) {
conv.pinned_goals.push(goal);
if conv.pinned_goals.len() > MAX_GOALS {
conv.pinned_goals.remove(0);
}
}
}
// G1 目标钉扎已迁移至 run_agentic_loop 工具调用推理(提取方式同 ai_chat_send)
}
let _tool_defs = state.ai_tools.tool_definitions();
@@ -1534,17 +1511,7 @@ pub async fn ai_chat_force_send(
}
// F-260619-04 P1:push 后立即取末条 user 消息 id(供知识注入 referenced 溯源)。
let user_msg_id = conv.messages.last_user_message_id();
// G1 目标钉扎:push 后提取本次 user 目标追加到 pinned_goals(去重,与 send/edit 路径一致,支持累积多目标)。
// force_send 是用户新指令,审批续跑会复用已累积目标。
if GOAL_PIN_ENABLED {
let goal = extract_pinned_goal(&user_content);
if !goal.is_empty() && !conv.pinned_goals.contains(&goal) {
conv.pinned_goals.push(goal);
if conv.pinned_goals.len() > MAX_GOALS {
conv.pinned_goals.remove(0);
}
}
}
// G1 目标钉扎已迁移至 run_agentic_loop 工具调用推理(提取方式同 ai_chat_send)
(was_gen.then_some(target.clone()), target, user_msg_id, conv.pinned_goals.clone())
};
@@ -1782,7 +1749,7 @@ pub async fn ai_stop_loop(
state: State<'_, AppState>,
conversation_id: String,
) -> Result<String, String> {
let pinned_goals: Vec<String>;
let pinned_goals: Vec<crate::commands::ai::GoalEntry>;
{
let mut session = state.ai_session.lock().await;
// F-260616-09 B 批4(决策 e):conv_id 来源 IPC 参数 conversation_id,移除 active 一致性校验
@@ -1879,6 +1846,10 @@ mod tests {
assert_eq!(goal.chars().count(), GOAL_MAX_CHARS);
}
// ============================================================
// 低价值目标过滤
// ============================================================
#[test]
fn test_extract_mention_unclosed() {
let goal = extract_pinned_goal("测试 [项目: DevFlow");

43
src-tauri/src/commands/ai/commands/conversation.rs
View File

@@ -226,7 +226,8 @@ pub async fn ai_conversation_list(
.unwrap_or_default();
let pinned_goals: Vec<String> = r.pinned_goals
.as_deref()
.and_then(|s| serde_json::from_str(s).ok())
.and_then(|s| serde_json::from_str::<Vec<crate::commands::ai::GoalEntry>>(s).ok())
.map(|entries| entries.into_iter().map(|e| e.text).collect())
.unwrap_or_default();
serde_json::json!({
"id": r.id,
@@ -336,10 +337,34 @@ pub async fn ai_conversation_switch(
conv.iteration_used = 0;
conv.stop_flag.store(false, Ordering::SeqCst);
// 从 DB 恢复 pinned_goals 到 per_conv(G1 目标钉扎持久化)
let pinned_goals: Vec<String> = record.pinned_goals
.as_deref()
.and_then(|s| serde_json::from_str(s).ok())
.unwrap_or_default();
// 兼容旧格式:["text1","text2"] 转为 [{text, status: active}]
let pinned_goals: Vec<crate::commands::ai::GoalEntry> = {
let raw: Option<serde_json::Value> = record.pinned_goals
.as_deref()
.and_then(|s| serde_json::from_str(s).ok());
match raw {
Some(serde_json::Value::Array(arr)) => {
arr.iter().filter_map(|v| {
// 新格式: {"text":"...","status":"active"}
if let Some(obj) = v.as_object() {
let text = obj.get("text")?.as_str()?.to_string();
let status = obj.get("status").and_then(|s| s.as_str())
.map(|s| if s == "completed" {
crate::commands::ai::GoalStatus::Completed
} else {
crate::commands::ai::GoalStatus::Active
}).unwrap_or(crate::commands::ai::GoalStatus::Active);
Some(crate::commands::ai::GoalEntry { text, status })
} else {
// 旧格式: "text" → 转 active
let text = v.as_str()?.to_string();
Some(crate::commands::ai::GoalEntry::new(text))
}
}).collect()
}
_ => vec![],
}
};
conv.pinned_goals = pinned_goals;
}
// 仅清空目标对话自身的挂起审批,保留其他对话的(防 init 重建的内存 HashMap 被清空,
@@ -531,7 +556,11 @@ pub async fn ai_update_conversation_goals(
conversation_id: String,
goals: Vec<String>,
) -> Result<(), String> {
let goals_json = serde_json::to_string(&goals).map_err(|e| format!("序列化目标列表失败: {e}"))?;
// 前端传回的 string[] 转为 GoalEntry(假设全部 active)
let goal_entries: Vec<crate::commands::ai::GoalEntry> = goals.into_iter()
.map(|g| crate::commands::ai::GoalEntry::new(g))
.collect();
let goals_json = serde_json::to_string(&goal_entries).map_err(|e| format!("序列化目标列表失败: {e}"))?;
// 写 DB
state.ai_conversations
.update_field(&conversation_id, "pinned_goals", &goals_json)
@@ -540,7 +569,7 @@ pub async fn ai_update_conversation_goals(
// 同步内存 per_conv(若已加载)
let mut session = state.ai_session.lock().await;
if let Some(conv) = session.per_conv.get_mut(&conversation_id) {
conv.pinned_goals = goals;
conv.pinned_goals = goal_entries;
}
Ok(())
}

42
src-tauri/src/commands/ai/mod.rs
View File

@@ -140,7 +140,7 @@ pub enum AiChatEvent {
incomplete: Option<bool>,
conversation_id: Option<String>,
/// 当前会话 pinned_goals(G1 目标钉扎持久化,前端直接读取刷新)
pinned_goals: Vec<String>,
pinned_goals: Vec<GoalEntry>,
},
/// 错误
///
@@ -820,17 +820,15 @@ pub struct PerConvState {
/// 写收敛:经 GeneratingGuard/入口 transition_to 守卫迁移,非直接赋值。
/// 批3 双轨收口:generating bool 已退役,此 enum 成为生成态唯一真相源。
pub conv_state: ConvState,
/// G1 目标钉扎真相源:用户消息中提取的目标列表(内容态字段,与生命周期态正交)。
/// G1 目标钉扎真相源:从 LLM 工具调用推理的目标列表(内容态字段,与生命周期态正交)。
///
/// 治 R1(目标消息被压缩/compressed 物理出局,sanitize step0 过滤 is_active 致目标丢失):
/// 目标存本字段绕过消息 active 状态过滤,即使原始 user 消息出局,goal 仍在。
/// run_agentic_loop 入口拼进 system_prompt 尾部(system_prompt 是 loop 不变量,天然
/// 免疫压缩/裁剪/sanitize,见 agentic/mod.rs:683)。
/// run_agentic_loop 入口拼 active 目标进 system_prompt 尾部(system_prompt 是 loop 不变量)。
///
/// 写:chat.rs send/force_send/edit push 后提取目标追加到列表(去重,支持累积多目标);
/// 读:loop 入口拼接全部目标。GOAL_PIN_ENABLED=false 时不提取不注入,本字段永远空 Vec。
/// 随会话销毁不落库(对齐 knowledge_extracted 语义,PerConvState 无 serde derive)。
pub pinned_goals: Vec<String>,
/// 2026-07-03 改:提取从「用户消息规则」→「工具调用推理」(infer_goal_from_tool_calls),
/// 每轮 LLM 回复后从工具名+路径推理目标追加(去重),支持多条/轮 + active→completed 状态流转。
pub pinned_goals: Vec<GoalEntry>,
/// 停止信号(会话级):ai_chat_stop 置位,agentic loop / stream_llm 检测后尽快退出
pub stop_flag: Arc<AtomicBool>,
/// 即时停止唤醒(会话级):阻塞在 stream.next() 时 notify_one() 立即唤醒跳出 select!
@@ -863,6 +861,34 @@ pub struct PerConvState {
pub knowledge_extracted: bool,
}
/// 单个目标记录(含状态追踪)。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GoalEntry {
pub text: String,
#[serde(default = "default_goal_status")]
pub status: GoalStatus,
}
/// 目标状态。
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum GoalStatus {
/// 正在进行中(当前 LLM 正在处理)
Active,
/// 已完成(LLM 已进入下一任务)
Completed,
}
fn default_goal_status() -> GoalStatus {
GoalStatus::Active
}
impl GoalEntry {
pub fn new(text: String) -> Self {
GoalEntry { text, status: GoalStatus::Active }
}
}
impl PerConvState {
/// 新建默认会话级状态。
///

2
src-tauri/src/commands/ai/tool_registry.rs
View File

@@ -2036,7 +2036,7 @@ fn register_file_tools(
})
};
registry.register(
"patch_file", "局部更新文件内容（三模式互斥）。模式1 old_text：精确匹配原文替换（含空格/缩进，CAS 语义）。模式2 replace_lines：按行号区间 {start,end}（1-based 含首尾）替换，不需原文，配 expected_hash 防行号漂移。模式3 anchor：按首尾子串锚点 {start,end}（大小写敏感，子串匹配）定位行号区间替换，不需完整原文。三模式均需 path+new_text，expected_hash 可选通用。小改动(≤5 行)自动放行不阻塞，大改动需人工审批。注意：若文件已被外部修改，请先重新 read_file 获取最新内容",
"patch_file", "局部更新文件内容（三模式互斥）。模式1 old_text：精确匹配原文替换（含空格/缩进，CAS 语义）。模式2 replace_lines：按行号区间 {start,end}（1-based 含首尾）替换，不需原文，配 expected_hash 防行号漂移。模式3 anchor：按首尾子串锚点 {start,end}（大小写敏感，子串匹配）定位行号区间替换，不需完整原文。三模式均需 path+new_text，expected_hash 可选通用。注意：若文件已被外部修改，请先重新 read_file 获取最新内容。所有 patch_file 操作自动放行不阻塞 AI 工作流，写入会落 audit 表可追溯。",
patch_file_schema,
RiskLevel::Medium,
{ let allowed_dirs = allowed_dirs.clone(); Box::new(move |args: serde_json::Value| {

2
src-tauri/src/lib.rs
View File

@@ -112,7 +112,7 @@ pub fn run() {
}
}
// 对话透明化 L1:收集每个 dirty conv 的 pinned_goals 快照(供 emit AiCompleted 携带)
let pinned_goals_map: std::collections::HashMap<String, Vec<String>> = dirty_convs
let pinned_goals_map: std::collections::HashMap<String, Vec<commands::ai::GoalEntry>> = dirty_convs
.iter()
.filter_map(|cid| {
session.per_conv.get(cid).map(|c| (cid.clone(), c.pinned_goals.clone()))