新增: 初始化 DevFlow 项目仓库

Tauri 2 + Vue 3 + Vite 6 桌面应用，Rust workspace 含 13 个 crate
(df-ai / df-storage / df-workflow / df-core / df-execute 等)。
核心能力：AI 聊天 agentic 循环(工具调用+人工审批)、工作流引擎、
任务/想法/项目/阶段管理、可追溯性，及配套前端组件。

crates/df-ideas/src/adversarial.rs

@@ -0,0 +1,308 @@
+//! 对抗式评估系统 — 正反方辩论 + AI 分析师
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use df_core::types::IdeaId;
+use crate::capture::Idea;
+
+/// 对抗评估结果
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AdversarialEval {
+    pub idea_id: IdeaId,
+    pub positive: Argument,
+    pub negative: Argument,
+    pub analyst: AnalystAnalysis,
+    pub final_score: f64,
+    pub recommendation: Recommendation,
+}
+
+/// 正方论点
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Argument {
+    pub thesis: String,           // 核心观点
+    pub evidence: Vec<String>,    // 证据支持
+    pub reasoning: Vec<String>,   // 推理过程
+    pub confidence: f64,          // 置信度 0-1
+}
+
+/// 反方论点
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CounterArgument {
+    pub thesis: String,           // 反对观点
+    pub evidence: Vec<String>,    // 反对证据
+    pub reasoning: Vec<String>,   // 反驳推理
+    pub confidence: f64,         // 置信度 0-1
+}
+
+/// AI 分析师综合分析
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AnalystAnalysis {
+    pub summary: String,                    // 综合总结
+    pub strengths: Vec<String>,             // 主要优势
+    pub weaknesses: Vec<String>,            // 主要劣势
+    pub risks: Vec<String>,                // 潜在风险
+    pub opportunities: Vec<String>,          // 机会点
+    pub final_assessment: AssessmentLevel,  // 最终评估
+}
+
+/// 评估等级
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum AssessmentLevel {
+    StrongGo,      // 强烈推荐执行
+    Recommended,    // 推荐执行
+    Conditional,   // 有条件执行
+    Revised,       // 需要修改后执行
+    Defer,         // 推迟执行
+    Reject,        // 不推荐执行
+}
+
+/// 最终建议
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum Recommendation {
+    ImmediateAction,   // 立即行动
+    Soon,              // 尽快行动
+    WithResources,      // 配置资源后行动
+    ResearchMore,      // 需要更多研究
+    Monitor,           // 持续监控
+    Cancel,            // 取消想法
+}
+
+/// 对抗评估引擎
+pub struct AdversarialEngine;
+
+impl AdversarialEngine {
+    /// 执行完整的对抗评估
+    pub async fn evaluate(idea: &Idea) -> Result<AdversarialEval> {
+        // 1. 生成正方观点
+        let positive = Self::generate_positive_argument(idea).await?;
+
+        // 2. 生成反方观点
+        let negative = Self::generate_negative_argument(idea, &positive).await?;
+
+        // 3. AI 分析师综合分析
+        let analyst = Self::analyst_analysis(idea, &positive, &negative).await?;
+
+        // 4. 计算最终分数和建议
+        let (final_score, recommendation) = Self::compute_final_assessment(&analyst);
+
+        Ok(AdversarialEval {
+            idea_id: idea.id.clone(),
+            positive,
+            negative,
+            analyst,
+            final_score,
+            recommendation,
+        })
+    }
+
+    /// 生成正方观点（支持执行）
+    async fn generate_positive_argument(idea: &Idea) -> Result<Argument> {
+        // TODO: 接入 AI 生成正方观点
+        // 当前使用启发式模板
+
+        let title = &idea.title;
+        let desc = &idea.description;
+
+        Ok(Argument {
+            thesis: format!("{} 具有很高的价值和可行性，应该优先执行", title),
+            evidence: vec![
+                format!("满足业务需求：{}", desc),
+                "投入产出比高".to_string(),
+                "技术实现可行".to_string(),
+                "时间窗口合适".to_string(),
+            ],
+            reasoning: vec![
+                "能够解决现有痛点".to_string(),
+                "竞争优势明显".to_string(),
+                "风险可控".to_string(),
+            ],
+            confidence: 0.75,
+        })
+    }
+
+    /// 生成反方观点（反对或谨慎）
+    async fn generate_negative_argument(idea: &Idea, positive: &Argument) -> Result<CounterArgument> {
+        // TODO: 接入 AI 生成反方观点，考虑正方观点
+
+        let title = &idea.title;
+
+        Ok(CounterArgument {
+            thesis: format!("{} 需要谨慎评估，存在一定风险", title),
+            evidence: vec![
+                "资源投入较大".to_string(),
+                "市场不确定性高".to_string(),
+                "技术挑战存在".to_string(),
+                "机会成本高".to_string(),
+            ],
+            reasoning: vec![
+                "ROI 需要进一步验证".to_string(),
+                "优先级可能过高".to_string(),
+                "存在更优替代方案".to_string(),
+            ],
+            confidence: 0.65,
+        })
+    }
+
+    /// AI 分析师综合分析
+    async fn analyst_analysis(
+        idea: &Idea,
+        positive: &Argument,
+        negative: &CounterArgument,
+    ) -> Result<AnalystAnalysis> {
+        // TODO: 接入 AI 进行深度分析
+
+        let positive_strengths = vec![
+            "方向正确，符合业务战略".to_string(),
+            "技术创新性较强".to_string(),
+            "用户价值明确".to_string(),
+        ];
+
+        let weaknesses = vec![
+            "资源需求评估不足".to_string(),
+            "风险控制需要加强".to_string(),
+            "时间规划可能过于乐观".to_string(),
+        ];
+
+        let risks = vec![
+            "技术实现难度超出预期".to_string(),
+            "市场竞争加剧".to_string(),
+            "用户接受度不确定".to_string(),
+        ];
+
+        let opportunities = vec![
+            "可能形成新的竞争优势".to_string(),
+            "技术积累价值显著".to_string(),
+            "市场机会窗口良好".to_string(),
+        ];
+
+        // 基于正反方观点的强度计算
+        let positive_strength = positive.confidence;
+        let negative_strength = negative.confidence;
+        let net_positive = (positive_strength - negative_strength + 1.0) / 2.0;
+
+        let final_assessment = if net_positive > 0.7 {
+            AssessmentLevel::StrongGo
+        } else if net_positive > 0.5 {
+            AssessmentLevel::Recommended
+        } else if net_positive > 0.3 {
+            AssessmentLevel::Conditional
+        } else if net_positive > 0.1 {
+            AssessmentLevel::Revised
+        } else {
+            AssessmentLevel::Defer
+        };
+
+        Ok(AnalystAnalysis {
+            summary: format!(
+                "该想法整体价值评估中等偏上，建议在有条件的情况下执行。主要价值在于{}，需要关注{}。",
+                idea.title,
+                if net_positive > 0.5 { "风险控制" } else { "价值验证" }
+            ),
+            strengths: positive_strengths,
+            weaknesses,
+            risks,
+            opportunities,
+            final_assessment,
+        })
+    }
+
+    /// 计算最终评估分数和建议
+    fn compute_final_assessment(analyst: &AnalystAnalysis) -> (f64, Recommendation) {
+        // 基于评估等级映射分数
+        let base_score = match analyst.final_assessment {
+            AssessmentLevel::StrongGo => 8.5,
+            AssessmentLevel::Recommended => 7.0,
+            AssessmentLevel::Conditional => 5.5,
+            AssessmentLevel::Revised => 4.0,
+            AssessmentLevel::Defer => 2.5,
+            AssessmentLevel::Reject => 1.0,
+        };
+
+        // 根据优劣势微调分数
+        let strength_count = analyst.strengths.len() as f64;
+        let weakness_count = analyst.weaknesses.len() as f64;
+        let score_adjustment = (strength_count - weakness_count) * 0.3;
+
+        let final_score = (base_score + score_adjustment).clamp(0.0, 10.0);
+
+        let recommendation = match analyst.final_assessment {
+            AssessmentLevel::StrongGo => Recommendation::ImmediateAction,
+            AssessmentLevel::Recommended => Recommendation::Soon,
+            AssessmentLevel::Conditional => Recommendation::WithResources,
+            AssessmentLevel::Revised => Recommendation::ResearchMore,
+            AssessmentLevel::Defer => Recommendation::Monitor,
+            AssessmentLevel::Reject => Recommendation::Cancel,
+        };
+
+        (final_score, recommendation)
+    }
+}
+
+/// 评估结果展示格式
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EvalDisplay {
+    pub idea_title: String,
+    pub positive_strength: f64,
+    pub negative_strength: f64,
+    pub net_sentiment: f64,  // -1 到 1，正为正面
+    pub assessment_level: String,
+    pub key_takeaways: Vec<String>,
+    pub action_items: Vec<String>,
+}
+
+impl From<AdversarialEval> for EvalDisplay {
+    fn from(eval: AdversarialEval) -> Self {
+        let net_sentiment = (eval.positive.confidence - eval.negative.confidence) as f64;
+
+        let key_takeaways = vec![
+            format!("优势：{}", eval.analyst.strengths.join("、")),
+            format!("风险：{}", eval.analyst.risks.join("、")),
+            format!("建议：{:?}", eval.recommendation),
+        ];
+
+        let action_items = match eval.recommendation {
+            Recommendation::ImmediateAction => vec![
+                "立即组建项目团队".to_string(),
+                "制定详细执行计划".to_string(),
+                "分配必要资源".to_string(),
+            ],
+            Recommendation::Soon => vec![
+                "下周启动项目".to_string(),
+                "准备资源需求".to_string(),
+                "制定时间表".to_string(),
+            ],
+            Recommendation::WithResources => vec![
+                "确认资源预算".to_string(),
+                "评估ROI".to_string(),
+                "制定风险预案".to_string(),
+            ],
+            Recommendation::ResearchMore => vec![
+                "进行市场调研".to_string(),
+                "收集用户反馈".to_string(),
+                "验证技术可行性".to_string(),
+            ],
+            Recommendation::Monitor => vec![
+                "持续跟踪相关指标".to_string(),
+                "定期评估进展".to_string(),
+                "等待更好的时机".to_string(),
+            ],
+            Recommendation::Cancel => vec![
+                "记录归档原因".to_string(),
+                "释放相关资源".to_string(),
+                "提取经验教训".to_string(),
+            ],
+        };
+
+        EvalDisplay {
+            idea_title: eval.positive.thesis.split(' ').take(3).collect::<Vec<_>>().join(" "),
+            positive_strength: eval.positive.confidence,
+            negative_strength: eval.negative.confidence,
+            net_sentiment,
+            assessment_level: format!("{:?}", eval.analyst.final_assessment),
+            key_takeaways,
+            action_items,
+        }
+    }
+}