@@ -28,6 +28,8 @@ use crate::video_profile_domain::DomainKind;
 
 /// 一周秒数（草案 due_at 换算：第 N 周 = created_at + N*7d）。
 const WEEK_SECS: i64 = 7 * 86_400;
+/// 访谈答案文本上限（防御超大 payload；chips/填空兜底的答案均为短文本）。
+const INTENT_FIELD_MAX: usize = 200;
 
 /// 新建目标入参（前端访谈结果全量提交；serde camelCase 契约）。
 #[derive(Debug, Clone, Deserialize)]
@@ -273,13 +275,14 @@ pub(crate) fn create_goal_inner(db: &Db, input: &GoalCreateInput) -> Result<Goal
     // 访谈校验：tier 与 scenario 同缺=快速模式；缺一=必答拦截（第 1/3 问必答）
     let tier_explicit = input.tier.as_deref().map(str::trim).filter(|s| !s.is_empty());
     let tier = tier_explicit.unwrap_or(TIER_DEFAULT);
-    let scenario = trimmed(input.scenario.as_deref());
+    let scenario = bounded(input.scenario.as_deref());
     if tier_explicit.is_some() && scenario.is_none() {
         return Err("第 1 问「学会以后想用它做什么？」必答".to_string());
     }
     let domain = parse_domain(input.domain_tag.as_deref())?;
     let now = unix_seconds();
-    let criteria = derive_criteria(tier, input.non_scope.as_deref());
+    let non_scope = bounded(input.non_scope.as_deref());
+    let criteria = derive_criteria(tier, non_scope.as_deref());
     // 边界校验：group_ids 逐组存在；草案 due_weeks 有界防溢出
     for gid in &input.group_ids {
         if db.get_group(*gid).map_err(|e| e.to_string())?.is_none() {
@@ -338,7 +341,10 @@ pub(crate) fn list_goals_inner(db: &Db) -> Result<Vec<GoalCardView>, String> {
 
 pub(crate) fn get_goal_detail_inner(db: &Db, id: i64) -> Result<GoalDetailView, String> {
     require_goal(db, id)?;
-    let goal = db.get_goal(id).map_err(|e| e.to_string())?.unwrap();
+    let goal = db
+        .get_goal(id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("目标不存在: {}", id))?;
     let milestones = db.list_milestones(id).map_err(|e| e.to_string())?;
     let group_ids = db.list_goal_group_ids(id).map_err(|e| e.to_string())?;
     let mut groups = Vec::new();
@@ -378,7 +384,10 @@ pub(crate) fn get_goal_detail_inner(db: &Db, id: i64) -> Result<GoalDetailView,
 
 pub(crate) fn get_goal_progress_inner(db: &Db, id: i64) -> Result<GoalProgressView, String> {
     require_goal(db, id)?;
-    let goal = db.get_goal(id).map_err(|e| e.to_string())?.unwrap();
+    let goal = db
+        .get_goal(id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("目标不存在: {}", id))?;
     let signals = collect_signals(db, id)?;
     let progress = build_report(&signals);
     let statement = progress_statement(&progress);
@@ -400,14 +409,22 @@ pub(crate) fn update_goal_inner(
     horizon: Option<String>,
 ) -> Result<bool, String> {
     require_goal(db, id)?;
-    let goal = db.get_goal(id).map_err(|e| e.to_string())?.unwrap();
+    let goal = db
+        .get_goal(id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("目标不存在: {}", id))?;
     let domain = parse_domain(domain_tag.as_deref())?;
     let now = unix_seconds();
+    // horizon 未填（None/空白）= 不改变时限锚点——防「改名顺手抹掉无期限锚点」
+    let horizon_end = match horizon.as_deref().map(str::trim).filter(|s| !s.is_empty()) {
+        Some(_) => horizon_end_secs(horizon.as_deref(), now),
+        None => goal.horizon_end,
+    };
     db.update_goal_core(
         id,
         &normalize_title(name.to_string(), "未命名目标"),
         domain.as_deref(),
-        horizon_end_secs(horizon.as_deref(), now),
+        horizon_end,
         &goal.success_criteria_json,
         &goal.intent_json,
     )
@@ -416,22 +433,28 @@ pub(crate) fn update_goal_inner(
 
 pub(crate) fn update_goal_interview_inner(db: &Db, id: i64, input: &GoalCreateInput) -> Result<bool, String> {
     require_goal(db, id)?;
-    let goal = db.get_goal(id).map_err(|e| e.to_string())?.unwrap();
-    // 配方重推（答案可回溯编辑——判据/意图整体重写；名字与绑组不变）
+    let goal = db
+        .get_goal(id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("目标不存在: {}", id))?;
+    // 配方重推（答案可回溯编辑——判据/意图整体重写；绑组不变；名称随对话窗口
+    // 一并生效——空名回退旧名，防「编辑态改名不落地」契约陷阱）
     let tier_explicit = input.tier.as_deref().map(str::trim).filter(|s| !s.is_empty());
     let tier = tier_explicit.unwrap_or(TIER_DEFAULT);
-    let scenario = trimmed(input.scenario.as_deref());
+    let scenario = bounded(input.scenario.as_deref());
     if tier_explicit.is_some() && scenario.is_none() {
         return Err("第 1 问「学会以后想用它做什么？」必答".to_string());
     }
-    let criteria = derive_criteria(tier, input.non_scope.as_deref());
+    let non_scope = bounded(input.non_scope.as_deref());
+    let criteria = derive_criteria(tier, non_scope.as_deref());
     let intent = build_intent(input);
+    let name = normalize_title(input.name.clone(), &goal.name);
     let criteria_json = serde_json::to_string(&criteria).map_err(|e| e.to_string())?;
     let intent_json = serde_json::to_string(&intent).map_err(|e| e.to_string())?;
     let now = unix_seconds();
     db.update_goal_core(
         id,
-        &goal.name,
+        &name,
         goal.domain_tag.as_deref(),
         horizon_end_secs(input.horizon.as_deref(), now),
         &criteria_json,
@@ -451,7 +474,10 @@ pub(crate) fn delete_goal_inner(db: &Db, id: i64) -> Result<bool, String> {
 
 pub(crate) fn update_goal_status_inner(db: &Db, id: i64, status: &str) -> Result<bool, String> {
     require_goal(db, id)?;
-    let goal = db.get_goal(id).map_err(|e| e.to_string())?.unwrap();
+    let goal = db
+        .get_goal(id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("目标不存在: {}", id))?;
     // M1 只开放 active⇄paused（状态机守卫总入口；放弃/毕业随 M2 流程）
     if status != "active" && status != "paused" {
         return Err(format!("v0.18.0 M1 仅支持暂停/恢复（收到 {}）", status));
@@ -496,11 +522,11 @@ pub(crate) fn set_goal_milestone_status_inner(db: &Db, id: i64, status: &str) ->
         return Err(format!("不支持的里程碑状态: {}（支持: {}）", status, MILESTONE_STATUSES.join("/")));
     }
     // 取旧状态（幂等埋点判据：仅「未完成 → 完成」的转变记 goal_milestone_done）
-    let prev = db.get_milestone(id).map_err(|e| e.to_string())?;
-    if prev.is_none() {
-        return Err(format!("里程碑不存在: {}", id));
-    }
-    let was_done = prev.unwrap().status == MILESTONE_DONE;
+    let prev = db
+        .get_milestone(id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("里程碑不存在: {}", id))?;
+    let was_done = prev.status == MILESTONE_DONE;
     let ok = db.set_milestone_status(id, status).map_err(|e| e.to_string())?;
     if !ok {
         return Err(format!("里程碑不存在: {}", id));
@@ -540,17 +566,22 @@ fn trimmed(s: Option<&str>) -> Option<String> {
     s.map(str::trim).filter(|v| !v.is_empty()).map(str::to_string)
 }
 
-/// 访谈答案 → GoalIntent（全部可选字段过 trimmed 归一）。
+/// 访谈答案：空白归一 + 长度截断（防超大 payload 入库；truncate 保留前 200 字）。
+fn bounded(s: Option<&str>) -> Option<String> {
+    trimmed(s).map(|v| v.chars().take(INTENT_FIELD_MAX).collect())
+}
+
+/// 访谈答案 → GoalIntent（全部可选字段过 bounded 归一）。
 fn build_intent(input: &GoalCreateInput) -> GoalIntent {
     GoalIntent {
-        scenario: trimmed(input.scenario.as_deref()),
-        level: trimmed(input.level.as_deref()),
-        driver: trimmed(input.driver.as_deref()),
-        criteria_statement: trimmed(input.criteria_statement.as_deref()),
-        horizon: trimmed(input.horizon.as_deref()),
-        non_scope: trimmed(input.non_scope.as_deref()),
-        weekly_commitment: trimmed(input.weekly_commitment.as_deref()),
-        obstacles: trimmed(input.obstacles.as_deref()),
+        scenario: bounded(input.scenario.as_deref()),
+        level: bounded(input.level.as_deref()),
+        driver: bounded(input.driver.as_deref()),
+        criteria_statement: bounded(input.criteria_statement.as_deref()),
+        horizon: bounded(input.horizon.as_deref()),
+        non_scope: bounded(input.non_scope.as_deref()),
+        weekly_commitment: bounded(input.weekly_commitment.as_deref()),
+        obstacles: bounded(input.obstacles.as_deref()),
     }
 }
 
 
@@ -186,9 +186,19 @@ fn update_and_delete_goal() {
     assert!(update_goal_inner(&db, goal.id, "改名", None, Some("6m".to_string())).expect("改"));
     let g = db.get_goal(goal.id).expect("读").unwrap();
     assert_eq!(g.name, "改名");
+    assert!(g.horizon_end.is_some(), "改名传 6m 重设时限锚点");
     assert!(update_goal_status_inner(&db, goal.id, "paused").is_ok());
-    // 重访谈：信息仍可编辑 → 非法状态转移拦截（paused 状态更新元数据合法，但状态不在这条命令）
+    // 重访谈：名称随对话窗口生效（空名回退旧名），判据/意图重推
     assert!(update_goal_interview_inner(&db, goal.id, &input(Some(TIER_HANDS_ON), Some("新场景"), vec![])).expect("重访谈"));
+    let g2 = db.get_goal(goal.id).expect("读").unwrap();
+    assert_eq!(g2.name, "学会 Python", "重访谈名称生效（input 名称）");
+    assert!(g2.intent_json.contains("新场景"));
+    // 改名不传 horizon（None）= 不改变时限锚点——防无期限目标被顺带抹掉
+    let horizon_before = g2.horizon_end;
+    assert!(update_goal_inner(&db, goal.id, "再改名", None, None).expect("改2"));
+    let g3 = db.get_goal(goal.id).expect("读").unwrap();
+    assert_eq!(g3.horizon_end, horizon_before, "horizon=None 保持原锚点");
+    assert_eq!(g3.name, "再改名");
     assert!(delete_goal_inner(&db, goal.id).expect("删除"));
     assert!(require_goal(&db, goal.id).is_err());
 }
@@ -210,6 +220,21 @@ fn milestone_validation_whitelists() {
     assert!(err3.contains("不支持的里程碑状态"));
 }
 
+#[test]
+fn interview_texts_bounded_in_storage() {
+    let db = mem_db();
+    let mut inp = input(Some(TIER_HANDS_ON), Some("场景"), vec![]);
+    inp.scenario = Some("长".repeat(300));
+    inp.non_scope = Some("宽".repeat(300));
+    let goal = create_goal_inner(&db, &inp).expect("建");
+    let intent: crate::goal_schema::GoalIntent = serde_json::from_str(&goal.intent_json).expect("解析");
+    assert_eq!(intent.scenario.as_deref().unwrap().chars().count(), 200, "超长截断保留 200 字");
+    // 判据 statement 的边界文案同样截断（derive_criteria 入参 bounded）
+    let criteria: crate::goal_schema::SuccessCriteria =
+        serde_json::from_str(&goal.success_criteria_json).expect("解析");
+    assert!(!criteria.statement.contains("宽".repeat(250).as_str()), "边界文案截断入配方");
+}
+
 #[test]
 fn bind_unbind_guards() {
     let db = mem_db();
 
@@ -31,10 +31,11 @@ impl Db {
         // 绑定组先取（独立锁窗口——闭包内不可再进锁）
         let group_ids = self.list_goal_group_ids(goal_id)?;
         self.with_conn(|conn| {
-            // 里程碑计数（判据①）
+            // 里程碑计数（判据①）：skipped=废弃计划项——不计入分母与分子，
+            // 防「跳过」拖死毕业判据（里程碑全部 done 的语义=活跃计划全完成）
             let (m_total, m_done): (i64, i64) = conn.query_row(
                 "SELECT COUNT(*), COALESCE(SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END), 0)
-                 FROM goal_milestones WHERE goal_id = ?1",
+                 FROM goal_milestones WHERE goal_id = ?1 AND status != 'skipped'",
                 params![goal_id],
                 |r| Ok((r.get(0)?, r.get(1)?)),
             )?;
 
@@ -196,6 +196,26 @@ fn weak_groups_ratio_and_top_ordering() {
     assert_eq!(s.weak_groups[2].group_id, gid_strong, "0% 弱垫底");
 }
 
+#[test]
+fn skipped_milestones_excluded_from_progress() {
+    // 审查修复（2026-09-02）：skipped=废弃计划项——不计入进度分母与毕业判据，
+    // 防「跳过」拖死整个目标（里程碑全部 done 的语义=活跃计划全完成）
+    let db = mem_db();
+    let goal_id = goal_with(&db, "跳过测试", vec![]);
+    let m1 = db.add_milestone(goal_id, &crate::goal_schema::NewMilestone {
+        title: "做".to_string(), due_at: None, order_idx: 0,
+        criteria_type: "manual".to_string(), ref_group_id: None,
+    }).expect("m1").id;
+    let m2 = db.add_milestone(goal_id, &crate::goal_schema::NewMilestone {
+        title: "跳过".to_string(), due_at: None, order_idx: 1,
+        criteria_type: "manual".to_string(), ref_group_id: None,
+    }).expect("m2").id;
+    db.set_milestone_status(m2, "skipped").expect("跳过");
+    db.set_milestone_status(m1, "done").expect("完成");
+    let s = db.goal_progress_signals(goal_id, NOW).expect("信号");
+    assert_eq!((s.milestone_total, s.milestone_done), (1, 1), "skipped 不计入分母分子");
+}
+
 #[test]
 fn weak_groups_ignores_invalid_state_json_and_missing_group() {
     let db = mem_db();
 
@@ -126,6 +126,8 @@ pub fn suggest_milestones(level: Option<&str>, weekly_commitment: Option<&str>)
 /// @ai-context: 第 5 步确认前的回显文案——criteria_statement 优先（用户
 ///              原始表述），缺失时回退配方的可读 statement（未填第 3 问但
 ///              档位已定——配方语义兜底，不是只有一条路径）。
+/// @ai-context: 无期限（none）是「长期目标」语义——文案走「长期目标（无期限）：
+///              学会…」而非「用无期限学会…」（语法与语义双重校准，审查 2026-09-02）。
 pub fn assemble_declaration(
     name: &str,
     scenario: Option<&str>,
@@ -134,7 +136,6 @@ pub fn assemble_declaration(
     non_scope: Option<&str>,
     horizon: Option<&str>,
 ) -> String {
-    let horizon_label = horizon_label(horizon);
     let goal = name.trim();
     let scene = scenario
         .map(|s| s.trim())
@@ -146,14 +147,24 @@ pub fn assemble_declaration(
         .filter(|s| !s.is_empty())
         .map(|s| s.to_string())
         .unwrap_or_else(|| criteria_fallback.to_string());
-    format!(
-        "用{}学会{}{}，达成标准：{}；边界：{}",
-        horizon_label,
-        goal,
-        scene,
-        standard,
-        non_scope_label(non_scope)
-    )
+    if horizon == Some("none") {
+        format!(
+            "长期目标（无期限）：学会{}{}，达成标准：{}；边界：{}",
+            goal,
+            scene,
+            standard,
+            non_scope_label(non_scope)
+        )
+    } else {
+        format!(
+            "用{}学会{}{}，达成标准：{}；边界：{}",
+            horizon_label(horizon),
+            goal,
+            scene,
+            standard,
+            non_scope_label(non_scope)
+        )
+    }
 }
 
 /// 时限 → 中周期锚点（Unix 秒；None=无期限——合法非 KPI 截止日）。
@@ -170,14 +181,13 @@ pub fn horizon_end_secs(horizon: Option<&str>, now_secs: i64) -> Option<i64> {
     }
 }
 
-/// 时限 → 展示文案（宣言回显用）。
+/// 时限 → 展示文案（宣言回显用；none 走 assemble_declaration 的长期目标分支）。
 fn horizon_label(horizon: Option<&str>) -> String {
     match horizon {
         Some("3m") => "3 个月".to_string(),
         Some("6m") => "半年".to_string(),
         Some("2w") => "先试两周".to_string(),
-        // none/None/未知 → 默认节奏（12 周——与里程碑草案的通用节奏呼应，
-        // 展示层文案不是 KPI，用户可在声明页/详情改期）
+        // None/未知 → 默认节奏（展示层文案不是 KPI，用户可在声明页/详情改期）
         _ => "12 周".to_string(),
     }
 }
 
@@ -89,7 +89,7 @@ const PATHS: [Path; 6] = [
         expect_drafts: 3,
         expect_due_weeks: &[8, 16, 24],
         expect_horizon_end: None,
-        expect_decl_contains: "用12 周学会",
+        expect_decl_contains: "长期目标（无期限）：学会",
     },
     Path {
         name: "说不清→默认档×系统学过一半",
@@ -264,4 +264,8 @@ fn matrix_declaration_components() {
     assert!(blank.contains("学会水彩"));
     assert!(!blank.contains("（场景："));
     assert!(blank.contains("达成标准：配方兜底"));
+    // 无期限（none）= 长期目标语义——不走「用无期限学会」病句
+    let none = assemble_declaration("乐理", None, None, "配方兜底", None, Some("none"));
+    assert!(none.starts_with("长期目标（无期限）：学会乐理"));
+    assert!(!none.contains("用无期限"));
 }