magic-agent 1.0.111 → 2.3.0

package/internal/session/delete_test.go

@@ -69,6 +69,146 @@ func TestDeleteRemovesEverything(t *testing.T) {
 	}
 }
 
+/*
+删除主会话要把**子任务会话**一起删（2026-10-23 用户：「列表中删除主会话时要把
+子任务的会话也删除」）。
+
+	团队模式拆出的子任务是普通会话：各自有登记记录、日志、标题与状态，靠
+	ParentRunID / ParentSessionID 挂在主会话下。只删主会话会留下一批「没有父行可挂、
+	却仍在列表 / 磁盘上」的孤儿 —— 和 2026-10-19「一端删了另一端还在」同一类错位。
+	还要正向确认：删子会话**不该**反向带走主会话。
+*/
+func TestDeleteCascadesToSubSessions(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv(EnvDir, dir)
+
+	parent, err := Begin(BeginOptions{Engine: "claude", PromptHead: "团队主会话"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	parent.Finish("sess-parent", StateDone)
+
+	// 子会话 1：父会话已有 session_id，两个父指针都有。
+	kid1, err := Begin(BeginOptions{
+		Engine: "claude", PromptHead: "子任务 1",
+		ParentRunID: parent.RunID(), ParentSessionID: "sess-parent",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid1.Finish("sess-kid-1", StateDone)
+
+	// 子会话 2：创建时父会话还没拿到 session_id，只能按 parent_run_id 认亲。
+	kid2, err := Begin(BeginOptions{
+		Engine: "codex", PromptHead: "子任务 2", ParentRunID: parent.RunID(),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid2.Finish("sess-kid-2", StateDone)
+
+	// 子会话 1 的第二轮（同 session_id、没有父指针）：按「同会话多轮」也归它。
+	kid1b, err := Begin(BeginOptions{Engine: "claude", PromptHead: "子任务 1 追问", SessionID: "sess-kid-1"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid1b.Finish("sess-kid-1", StateDone)
+
+	// 无关会话：同引擎、同目录，但不是这条主会话的子会话 —— 必须留下。
+	other, err := Begin(BeginOptions{Engine: "claude", PromptHead: "无关会话"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	other.Finish("sess-other", StateDone)
+
+	// 每个名字都落一份日志（run_id 与 session_id 两种命名都覆盖）。
+	names := []string{
+		parent.RunID(), "sess-parent",
+		kid1.RunID(), "sess-kid-1", kid1b.RunID(),
+		kid2.RunID(), "sess-kid-2",
+		other.RunID(), "sess-other",
+	}
+	for _, name := range names {
+		if err := os.WriteFile(filepath.Join(dir, name+".jsonl"), []byte("{\"seq\":1}\n"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, id := range []string{"sess-parent", "sess-kid-1", "sess-kid-2", "sess-other"} {
+		if err := SetTitle(id, "标题 "+id); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	res, err := Delete("sess-parent")
+	if err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	// parent + kid1 / kid1b / kid2 共 4 条记录；无关会话不算。
+	if res.RecordsRemoved != 4 {
+		t.Errorf("登记记录删了 %d 条，want 4（主会话 + 3 条子会话记录）", res.RecordsRemoved)
+	}
+	if res.ChildSessionsRemoved != 2 {
+		t.Errorf("子会话删了 %d 条，want 2（sess-kid-1 / sess-kid-2）", res.ChildSessionsRemoved)
+	}
+	if res.LogsRemoved != 7 {
+		t.Errorf("日志删了 %d 份，want 7（主/子会话的 run_id 与 session_id 两个名字）", res.LogsRemoved)
+	}
+	if res.TitlesRemoved != 3 {
+		t.Errorf("标题清了 %d 条，want 3（主会话 + 两个子会话）", res.TitlesRemoved)
+	}
+
+	recs, _ := List()
+	if len(recs) != 1 || recs[0].RunID != other.RunID() {
+		t.Fatalf("登记表应只剩无关会话 %s，实得 %+v", other.RunID(), recs)
+	}
+	for _, name := range []string{
+		parent.RunID(), "sess-parent",
+		kid1.RunID(), "sess-kid-1", kid1b.RunID(),
+		kid2.RunID(), "sess-kid-2",
+	} {
+		if fileExists(filepath.Join(dir, name+".jsonl")) {
+			t.Errorf("日志 %s.jsonl 还在（子会话必须跟着主会话一起删）", name)
+		}
+	}
+	if !fileExists(filepath.Join(dir, other.RunID()+".jsonl")) {
+		t.Error("无关会话的日志被误删了")
+	}
+	for _, id := range []string{"sess-parent", "sess-kid-1", "sess-kid-2"} {
+		if got := TitleFor(id); got != "" {
+			t.Errorf("标题 %s 还有 %q，want 空", id, got)
+		}
+		if got := StatusFor(id); got != "" {
+			t.Errorf("状态 %s 还有 %q，want 空", id, got)
+		}
+	}
+	if TitleFor("sess-other") == "" || StatusFor("sess-other") == "" {
+		t.Error("无关会话的标题 / 状态被误删了")
+	}
+}
+
+// 删子会话只删它自己 —— 父指针是单向认亲，不能反向把主会话带走。
+func TestDeleteSubSessionKeepsParent(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	parent, err := Begin(BeginOptions{Engine: "claude"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	parent.Finish("sess-parent", StateDone)
+	kid, err := Begin(BeginOptions{Engine: "claude", ParentRunID: parent.RunID(), ParentSessionID: "sess-parent"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	kid.Finish("sess-kid", StateDone)
+
+	if _, err := Delete("sess-kid"); err != nil {
+		t.Fatalf("Delete: %v", err)
+	}
+	recs, _ := List()
+	if len(recs) != 1 || recs[0].SessionID != "sess-parent" {
+		t.Fatalf("删子会话后应只剩主会话，实得 %+v", recs)
+	}
+}
+
 /*
 幂等：id 不认识 / 文件本来就不在 / 再删一次 —— 都算成功。
 

package/internal/session/session.go

@@ -323,6 +323,8 @@ type Handle struct {
 	// 照常接受 pid / 状态 / 收尾回写，只是**不写文件** —— 调用方（CLI 默认）
 	// 因此不留痕，而 run_id 仍能当追加入口的地址（见 AppendSocketPath）。
 	noPersist bool
+	// lastTouch 上次 Touch 续期的时间（节流用，见 Touch）。
+	lastTouch time.Time
 }
 
 // RunID 本次运行的 id。
@@ -379,6 +381,29 @@ func (h *Handle) Mark(state string) {
 	h.write()
 }
 
+// Touch 续期一条活着的会话：只刷新 updated_at，状态不变。
+//
+// 为什么 Mark 不够（2026-10-22 真机复现）：Mark 在「新旧状态相同」时直接 return，
+// 一次盘都不写 —— 调用方以为自己在「每来一条事件就续一次期」，实际上 updated_at
+// 从第一条事件起就冻住了。别端的尾随连接（followStateEvery=5s）靠 updated_at 判活，
+// 团队模式计划 + 子任务几分钟不动，就被归一成 gone，画面提前落「这一轮已结束」。
+//
+// 节流：调用方可能每秒来几十条事件，没必要每条都落盘；minGap 内直接跳过。
+// 状态已进终态（或进程已不在）时不动 —— 终态是结论，不许被心跳续活。
+func (h *Handle) Touch(minGap time.Duration) {
+	if h == nil || h.noPersist {
+		return
+	}
+	if !isLiveState(normalizeState(h.rec.State)) {
+		return
+	}
+	if !h.lastTouch.IsZero() && time.Since(h.lastTouch) < minGap {
+		return
+	}
+	h.lastTouch = time.Now()
+	h.write()
+}
+
 // Finish 收尾：写最终状态（done / failed / cancelled / interrupted）+ 回填会话 id。
 //
 // 一个刻意的小保护：被别人 `--stop` 停掉、或用户中途打断时，磁盘上已经是

package/internal/session/session_mark_test.go

@@ -3,6 +3,7 @@ package session
 import (
 	"os"
 	"testing"
+	"time"
 )
 
 /* Handle.Mark：唯一的中途写状态入口（2026-09-29 统一会话状态词表时新增）。
@@ -132,3 +133,64 @@ func TestNormalizeLegacyState(t *testing.T) {
 		t.Errorf("不认识的词原样返回，得到 %q", got)
 	}
 }
+
+/* Handle.Touch：只续期，不改状态（2026-10-22 报障「团队模式子任务还在跑 主会话
+ * 就说结束了」的真因之一）。
+ *
+ * 为什么 Mark 顶不上：Mark 在新旧状态相同时**直接 return、一次盘都不写**。流式路径
+ * 里每条事件都喊一次 Mark(running)，看起来像在续期，实际 updated_at 从第一条事件
+ * 起就冻住了 —— 团队模式计划 + 子任务几分钟不动，网关尾随连接据此判终态，
+ * 画面提前落「这一轮已结束」。 */
+func TestHandleTouchRefreshesUpdatedAt(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	h, err := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	runID := h.RunID()
+
+	// Mark 同值不写盘：这是 Touch 存在的理由，钉住它免得日后被「顺手优化」掉
+	before, _ := readRecord(h.path)
+	h.Mark(StateRunning)
+	after, _ := readRecord(h.path)
+	if !after.UpdatedAt.Equal(before.UpdatedAt) {
+		t.Errorf("Mark 同值不该写盘：%v → %v", before.UpdatedAt, after.UpdatedAt)
+	}
+
+	// Touch 必须真的把 updated_at 往前推
+	h.lastTouch = time.Time{} // 跳过节流
+	h.Touch(0)
+	rec, found, _ := Find(runID)
+	if !found {
+		t.Fatal("记录不见了")
+	}
+	if !rec.UpdatedAt.After(before.UpdatedAt) {
+		t.Errorf("Touch 没续期：%v → %v", before.UpdatedAt, rec.UpdatedAt)
+	}
+	if rec.State != StateRunning {
+		t.Errorf("Touch 不该改状态，得到 %q", rec.State)
+	}
+}
+
+func TestHandleTouchThrottlesAndRespectsTerminal(t *testing.T) {
+	t.Setenv(EnvDir, t.TempDir())
+	h, _ := Begin(BeginOptions{Engine: "claude", PID: os.Getpid()})
+	h.lastTouch = time.Time{}
+	h.Touch(time.Hour) // 第一次写
+	first, _ := readRecord(h.path)
+
+	h.Touch(time.Hour) // 节流窗口内：不写
+	second, _ := readRecord(h.path)
+	if !second.UpdatedAt.Equal(first.UpdatedAt) {
+		t.Errorf("节流窗口内不该写盘：%v → %v", first.UpdatedAt, second.UpdatedAt)
+	}
+
+	// 终态是结论，心跳不许把它续活
+	h.Finish("", StateDone)
+	h.lastTouch = time.Time{}
+	h.Touch(0)
+	final, _ := readRecord(h.path)
+	if final.State != StateDone {
+		t.Errorf("Touch 把终态改掉了：%q", final.State)
+	}
+}

package/internal/suggest/suggest.go

@@ -0,0 +1,421 @@
+// Package suggest - 生成「下一轮快捷回复」的建议（一轮对话结束后给用户可点的下一句）。
+//
+// 为什么要有它（用户 2026-10-23：「在回复结束后 ai 自动生成下一轮的建议，点击即可发送」）：
+// 每轮回答结束后，用户往往还要再打一句「继续 / 看下 diff / 先别动」。这些句子**就在回答里**
+// （AI 问「要我继续吗？」、AI 列了「下一步」），把它提炼成按钮能省一次打字 —— 但提炼必须
+// 来自模型对**这一轮原文**的理解，不能套模板硬凑（模板会给出与内容无关的噪音）。
+//
+// 三条纪律：
+//  1. **一次性旁路调用**：`agent.Runner` + `ToolsOff` + 不带 SessionID —— 独立进程、独立会话，
+//     不续接也不污染用户正在聊的那条上下文；不经过 CLI 的 ask 通道，不留会话登记。
+//  2. **宁缺毋滥**：模型没给出可用句子、或这轮本来就没有下一步时返回空数组，调用方据此不画按钮。
+//  3. **不编造**：提示词明确禁止引入对话里没出现过的文件 / 数字 / 结论；解析侧再做一层长度、
+//     去重、形态校验，挡掉「AI 的回答」冒充「用户的话」。
+//
+// 与 `--summarize-title`（internal/session/title.go::Summarize）的分工：那条把会话首问压成
+// 标题、结果落进标题表；这条只产出一组**临时**建议，不落盘、不缓存 —— 下一轮结束就重算。
+package suggest
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// 默认参数。取「短、快」：建议是锦上添花，不能让它拖住下一轮。
+const (
+	// DefaultEngine 默认用 llm：纯文本、不带工具、没有 CLI 会话副作用（与 --title-engine 同口径）。
+	DefaultEngine = "llm"
+	// DefaultCount 最多给几条建议（UI 一行放得下 3 枚）。
+	DefaultCount = 3
+	// MaxLabelRunes 单条建议的字数上限。提示词要求 ≤16；解析时放宽到 28 仍然接受，
+	// 再长就不是「随手发的一句话」了，直接丢掉（不截断 —— 截断后的半句话发出去更糟）。
+	MaxLabelRunes = 28
+	// DefaultTimeout 单次旁路调用的超时。到点没有结果就当没有建议（调用方不等待）。
+	DefaultTimeout = 22 * time.Second
+)
+
+// Request 生成建议的输入。
+type Request struct {
+	// User 用户最新那一句（可为空：比如本轮是系统派发的任务）。
+	User string
+	// Reply 引擎这一轮的**权威正文**（必填；空 = 没有可提炼的内容）。
+	Reply string
+	// Engine 用哪个引擎生成（空 = DefaultEngine）。
+	Engine string
+	// Model 模型标识（空 = 引擎默认）。
+	Model string
+	// Count 最多几条（<=0 = DefaultCount）。
+	Count int
+	// Timeout 单次调用超时（<=0 = DefaultTimeout）。
+	Timeout time.Duration
+}
+
+// Result 生成结果。
+type Result struct {
+	Suggestions []string `json:"suggestions"`
+	Engine      string   `json:"engine,omitempty"`
+	Model       string   `json:"model,omitempty"`
+	ElapsedMS   int64    `json:"elapsedMs,omitempty"`
+}
+
+// RequestBody 是 CLI / 插件之间传的 JSON 形状（只含对话内容，引擎走 -e/-m）。
+type RequestBody struct {
+	User  string `json:"user"`
+	Reply string `json:"reply"`
+}
+
+// Prompt 拼提示词。截断策略：用户那句取**开头**（它通常很短），回复取**结尾** ——
+// 下一步 / 待确认的问题几乎都在最后一段，截掉尾部等于把要提炼的东西扔了。
+func Prompt(user, reply string, count int) string {
+	if count <= 0 || count > DefaultCount {
+		count = DefaultCount
+	}
+	u := strings.TrimSpace(user)
+	if n := len([]rune(u)); n > 1500 {
+		u = string([]rune(u)[:1500]) + "…"
+	}
+	r := strings.TrimSpace(reply)
+	if n := len([]rune(r)); n > 6000 {
+		r = "…" + string([]rune(r)[n-6000:])
+	}
+	var b strings.Builder
+	b.WriteString("你是「下一句」建议器，服务于一个正在用 AI agent 干活的用户。\n")
+	b.WriteString("读完下面这一轮对话，给出用户此刻最可能**直接发出去**的简短指令。\n\n")
+	b.WriteString("硬约束：\n")
+	fmt.Fprintf(&b, "1. 最多 %d 条；每条 ≤ 16 个汉字，口语，像用户随手打的；不要编号、引号、句末标点。\n", count)
+	b.WriteString("2. 必须是**用户对 AI 说的话**，不是 AI 的回答，也不是给用户的说明。\n")
+	b.WriteString("3. 只依据这一轮里**已经出现**的内容（AI 问的问题、列出的下一步、给出的选项）。\n")
+	b.WriteString("   不许编造对话里没有的文件、数字、结论；拿不准就不要写。\n")
+	b.WriteString("4. AI 在等拍板 → 给直接的肯定/否定答复；AI 列了下一步 → 挑最关键的 1-2 条；\n")
+	b.WriteString("   给多条时按「最该先做」排序，**第一条就是最佳建议**（托管模式会直接发它）；\n")
+	b.WriteString("   这一轮已经彻底结束、没有下一步 → 给空数组。宁缺毋滥。\n")
+	b.WriteString("5. 只输出 JSON：{\"suggestions\":[\"…\",\"…\"]}，不要解释、不要 markdown 围栏。\n")
+	b.WriteString("6. 这一轮如果是**交付型任务**（小说 / 故事 / 文章 / 诗 / 剧本 / 文案 / 报告 / 代码 / 图纸），\n")
+	b.WriteString("   而 AI 已经把成品完整交出来、没有提问、也没有列出下一步 → **必须给空数组**。\n")
+	b.WriteString("   不要建议「再来一篇」「换个题材」「再写一个」「继续写」这类**另起一篇**的话；\n")
+	b.WriteString("   除非 AI 在这一轮明确问「要不要再来一篇 / 下一篇写什么」。即使用户上一句就是\n")
+	b.WriteString("   「再来一篇」，只要这一篇已经交付完、没有新问题，也算结束。\n\n")
+	b.WriteString("例 1（交付完成 → 空）：\n")
+	b.WriteString("用户：写一个短篇恋爱小说\n")
+	b.WriteString("AI：# 标题 …（完整故事，结尾收束，没有提问）\n")
+	b.WriteString("输出：{\"suggestions\":[]}\n\n")
+	b.WriteString("例 2（AI 在等拍板 → 1-2 条）：\n")
+	b.WriteString("用户：修一下登录 bug\n")
+	b.WriteString("AI：修好了，测试通过。要不要我顺手把过期 token 也处理掉？\n")
+	b.WriteString("输出：{\"suggestions\":[\"处理过期 token\",\"先这样\"]}\n\n")
+	b.WriteString("用户刚才说：\n")
+	if u == "" {
+		b.WriteString("（本轮由系统派发，没有用户原话）\n")
+	} else {
+		b.WriteString(u + "\n")
+	}
+	b.WriteString("\nAI 的回复：\n")
+	b.WriteString(r)
+	b.WriteString("\n")
+	return b.String()
+}
+
+// Schema 结构化输出契约（llm 引擎会按它做一次 JSON 后处理；其余引擎靠提示词约束）。
+func Schema() *agent.JSONSchema {
+	return &agent.JSONSchema{
+		Type: "object",
+		Properties: map[string]map[string]any{
+			"suggestions": {"type": "array", "items": map[string]any{"type": "string"}},
+		},
+		Required: []string{"suggestions"},
+	}
+}
+
+// Parse 从模型输出里抽建议。容忍三种形态：JSON 对象 {"suggestions":[…]}
+// （带不带 ``` 围栏都行）、裸 JSON 数组、以及一眼能认出的逐行短句。
+// 解析失败 / 全是废句 → 返回空切片（不是错误：没有建议是合法结果）。
+func Parse(raw string, count int) []string {
+	if count <= 0 || count > DefaultCount {
+		count = DefaultCount
+	}
+	text := strings.TrimSpace(raw)
+	if text == "" {
+		return []string{}
+	}
+	if obj := firstJSONValue(text); obj != nil {
+		var arr []any
+		switch v := obj.(type) {
+		case map[string]any:
+			if a, ok := v["suggestions"].([]any); ok {
+				arr = a
+			}
+		case []any:
+			arr = v
+		}
+		if arr != nil {
+			return normalize(arrToStrings(arr), count)
+		}
+	}
+	return normalize(splitLines(text), count)
+}
+
+// Generate 跑一次旁路生成。失败时返回空建议 + error（调用方如实降级：不画按钮）。
+func Generate(ctx context.Context, in Request) (Result, error) {
+	reply := strings.TrimSpace(in.Reply)
+	if reply == "" {
+		return Result{Suggestions: []string{}}, nil
+	}
+	name := strings.TrimSpace(in.Engine)
+	if name == "" {
+		name = DefaultEngine
+	}
+	engine := agent.Lookup(name)
+	if engine == nil {
+		return Result{}, fmt.Errorf("建议生成：未知引擎 %q", name)
+	}
+	timeout := in.Timeout
+	if timeout <= 0 {
+		timeout = DefaultTimeout
+	}
+	cctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+	start := time.Now()
+	runner := &agent.Runner{Engine: engine, Timeout: timeout}
+	resp, err := runner.Run(cctx, agent.Request{
+		Model:      strings.TrimSpace(in.Model),
+		Tools:      agent.ToolsOff,
+		Reasoning:  "off", // 建议要快；思考过程只会拖长等待
+		MaxTokens:  300,
+		Messages:   []agent.Message{{Role: "user", Content: Prompt(in.User, reply, in.Count)}},
+		JSONSchema: Schema(),
+	})
+	if err != nil {
+		return Result{}, err
+	}
+	items := Parse(resp.Text, in.Count)
+	items = dropCreativeRestarts(items, in.User, reply)
+	return Result{
+		Suggestions: items,
+		Engine:      engine.Name(),
+		Model:       resp.Model,
+		ElapsedMS:   time.Since(start).Milliseconds(),
+	}, nil
+}
+
+// ── 交付完成后的「另起一篇」过滤（2026-10-23 用户实测）─────────────────
+//
+// 提示词已经要求「交付完就给空数组」，但模型仍会把「再写一篇 / 换个题材」当成下一步
+// （用户截图：短篇写完，托管自动发出「再来一篇职场题材的」，又生成一篇）。
+// 这一层是**确定性兜底**：只在创作类轮次里，丢掉「另起一篇」形态的建议；
+// AI 明确问「要不要再来一篇 / 下一篇写什么」时放行。
+
+var (
+	creativeTurnRe = regexp.MustCompile(`小说|故事|文章|短篇|长篇|诗歌?|剧本|文案|作文|题材|写一篇|再写一篇|再来一篇|创作`)
+	// 「再来一篇 / 再写一章 / 再画一首」：量词是篇/章/首/部，基本只用于创作。
+	anotherWritingRe = regexp.MustCompile(`^(再|又)?(来|写|生成|创作|画|做)(一|两)?(篇|章|首|部)`)
+	// 「再来个职场篇 / 再写一个短篇」：没有创作名词，但以篇/章/首/部收尾。
+	anotherPieceRe = regexp.MustCompile(`^(再|又)?(来|写|生成|创作|画|做)(一|个)?[^，。！？]{0,10}(篇|章|首|部)$`)
+	// 「再写一个校园故事 / 来个职场段子」：量词是「个/段」时必须带创作名词。
+	anotherCreativeRe = regexp.MustCompile(`^(再|又)?(来|写|生成|创作|画|做)(一|个|段)?[^，。！？]{0,8}(小说|故事|文章|散文|诗歌?|剧本|文案|作文|童话|段子|番外|续集|续篇)`)
+	switchTopicRe     = regexp.MustCompile(`^(换|改)(一|个)?[^，。！？]{0,8}(题材|主题|方向|背景)`)
+	nextPieceRe       = regexp.MustCompile(`^下一(篇|章|首|部)`)
+	continueWriteRe   = regexp.MustCompile(`^(继续|接着)(写|创作|生成|画)`)
+	bareContinueRe    = regexp.MustCompile(`^(继续|接着)(吧|来)?$`)
+	inviteAnotherRe   = regexp.MustCompile(`(要不要|需要我|想不想|是否).{0,10}(再|下一|续)|要继续吗|接着(写|来)吗|下一(篇|章|个)|续写|告诉我.{0,10}(题材|主题|方向)`)
+)
+
+// looksLikeCreativeReply 识别「用户只说继续，但 AI 交的是一篇完整创作」：
+// Markdown 一级标题 + 超过 400 字 + 没有代码块。技术长文也按此处理（成品交付完不该再
+// 建议「另起一篇」），带代码块的工程回答则排除，避免误杀「再写一个测试」。
+func looksLikeCreativeReply(reply string) bool {
+	r := strings.TrimSpace(reply)
+	if !strings.HasPrefix(r, "# ") || strings.Contains(r, "```") {
+		return false
+	}
+	return utf8.RuneCountInString(r) >= 400
+}
+
+// dropCreativeRestarts 把「成品交付完之后的另起一篇」过滤掉。
+// 只在创作类轮次（用户这句本身是创作请求，或 AI 交了一篇完整创作）生效 ——
+// 写代码时「再写一个测试」是正常下一步，不能误杀。
+func dropCreativeRestarts(items []string, user, reply string) []string {
+	if !creativeTurnRe.MatchString(strings.TrimSpace(user)) && !looksLikeCreativeReply(reply) {
+		return items
+	}
+	tail := []rune(strings.TrimSpace(reply))
+	if len(tail) > 600 {
+		tail = tail[len(tail)-600:]
+	}
+	invited := inviteAnotherRe.MatchString(string(tail))
+	unfinished := strings.Contains(string(tail), "未完") || strings.Contains(string(tail), "待续") || strings.Contains(string(tail), "下一章")
+	explicitCreative := creativeTurnRe.MatchString(strings.TrimSpace(user))
+	out := make([]string, 0, len(items))
+	for _, s := range items {
+		t := strings.TrimSpace(s)
+		if t == "" {
+			continue
+		}
+		restart := anotherWritingRe.MatchString(t) || anotherPieceRe.MatchString(t) ||
+			anotherCreativeRe.MatchString(t) || switchTopicRe.MatchString(t) || nextPieceRe.MatchString(t)
+		if restart && !invited {
+			continue
+		}
+		if continueWriteRe.MatchString(t) && !invited && !unfinished {
+			continue
+		}
+		/* 光秃秃一句「继续」是最容易把成品续写成第二篇的：只在用户这句本身是创作请求时挡。 */
+		if bareContinueRe.MatchString(t) && explicitCreative && !invited && !unfinished {
+			continue
+		}
+		out = append(out, s)
+	}
+	return out
+}
+
+// ── 解析辅助 ──────────────────────────────────────────────────────────────
+
+// firstJSONValue 从可能裹着围栏 / 解释文字的输出里抠出**第一个** JSON 值。
+// 用 json.Decoder 逐个 '{' / '[' 试（比正则稳：能正确处理字符串里的括号）。
+func firstJSONValue(s string) any {
+	s = stripFence(s)
+	for i := 0; i < len(s); i++ {
+		if s[i] != '{' && s[i] != '[' {
+			continue
+		}
+		dec := json.NewDecoder(strings.NewReader(s[i:]))
+		dec.UseNumber()
+		var v any
+		if err := dec.Decode(&v); err == nil {
+			return v
+		}
+	}
+	return nil
+}
+
+// dropFenced 去掉整段 ``` 围栏（含围栏里的代码）：逐行兜底时不能把代码示例当建议。
+func dropFenced(s string) string {
+	var b strings.Builder
+	inFence := false
+	for _, ln := range strings.Split(s, "\n") {
+		if strings.HasPrefix(strings.TrimSpace(ln), "```") {
+			inFence = !inFence
+			continue
+		}
+		if !inFence {
+			b.WriteString(ln)
+			b.WriteString("\n")
+		}
+	}
+	return b.String()
+}
+
+func stripFence(s string) string {
+	t := strings.TrimSpace(s)
+	if !strings.HasPrefix(t, "```") {
+		return t
+	}
+	if i := strings.Index(t, "\n"); i >= 0 {
+		t = t[i+1:]
+	} else {
+		t = strings.TrimPrefix(t, "```")
+	}
+	if i := strings.LastIndex(t, "```"); i >= 0 {
+		t = t[:i]
+	}
+	return strings.TrimSpace(t)
+}
+
+func arrToStrings(a []any) []string {
+	out := make([]string, 0, len(a))
+	for _, v := range a {
+		if s, ok := v.(string); ok {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+// splitLines 兜底：模型没按 JSON 回（或只回了一串短句）时，按行取。
+// 只保留「像一句指令」的行 —— 带冒号解释、带代码、太长的一律不要。
+func splitLines(text string) []string {
+	var out []string
+	for _, ln := range strings.Split(dropFenced(text), "\n") {
+		ln = strings.TrimSpace(ln)
+		if ln == "" {
+			continue
+		}
+		ln = trimListPrefix(ln)
+		if strings.ContainsAny(ln, "`{}<>") || strings.Contains(ln, "：") || strings.Contains(ln, "://") {
+			continue
+		}
+		out = append(out, ln)
+	}
+	return out
+}
+
+// normalize 归一 + 校验：剥引号/列表号/句末标点，丢弃过长、多行、像 AI 回答的句子，去重截断。
+func normalize(in []string, count int) []string {
+	out := make([]string, 0, count)
+	seen := make(map[string]bool, len(in))
+	for _, raw := range in {
+		s := strings.TrimSpace(raw)
+		s = trimListPrefix(s)
+		/* 引号与句末标点会互相挡着（「好的」。 里右引号在句号前面）：多剥两轮。 */
+		for i := 0; i < 2; i++ {
+			s = strings.TrimRight(s, "。．.！!？?；;，,")
+			s = strings.Trim(s, " \t\r\n\"'“”‘’「」『』")
+		}
+		s = strings.TrimRight(s, "。．.！!？?；;，,")
+		s = strings.Join(strings.Fields(s), " ")
+		if s == "" || utf8.RuneCountInString(s) > MaxLabelRunes {
+			continue
+		}
+		/* 以省略号开头 = 上游被截断的半句话（见 Prompt 的截断），发出去会缺主语。 */
+		if strings.HasPrefix(s, "…") || strings.ContainsAny(s, "\n\r") {
+			continue
+		}
+		/* 「AI 的答复」冒充「用户的话」：这类开头一定不是用户要发的。 */
+		if strings.HasPrefix(s, "AI") || strings.HasPrefix(s, "助手") || strings.HasPrefix(s, "Agent") {
+			continue
+		}
+		if seen[s] {
+			continue
+		}
+		seen[s] = true
+		out = append(out, s)
+		if len(out) >= count {
+			break
+		}
+	}
+	return out
+}
+
+// trimListPrefix 去掉「1. / 1、/ - / • / (1)」这类列表前缀（模型偶尔会自作主张编号）。
+func trimListPrefix(s string) string {
+	t := strings.TrimSpace(s)
+	for i := 0; i < 3; i++ { // 最多剥三层（如 "- 1. xxx"）
+		prev := t
+		t = strings.TrimLeft(t, "-*•· ")
+		for _, sep := range []string{".", "、", ")", "）", ":"} {
+			if j := strings.Index(t, sep); j > 0 && j <= 3 {
+				allDigit := true
+				for _, r := range t[:j] {
+					if r < '0' || r > '9' {
+						allDigit = false
+						break
+					}
+				}
+				if allDigit {
+					t = strings.TrimSpace(t[j+len(sep):])
+					break
+				}
+			}
+		}
+		if t == prev {
+			break
+		}
+	}
+	return strings.TrimSpace(t)
+}