magic-agent 2.1.5 → 2.3.0

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)
+}

package/internal/suggest/suggest_test.go

@@ -0,0 +1,218 @@
+package suggest
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// fakeEngine 记录请求，原样回一段文本（不发网络、不起 CLI）。
+type fakeEngine struct {
+	name string
+	text string
+	got  agent.Request
+}
+
+func (f *fakeEngine) Name() string           { return f.name }
+func (f *fakeEngine) Detect() (bool, string) { return true, "fake://" + f.name }
+func (f *fakeEngine) Complete(_ context.Context, req agent.Request) (agent.Response, error) {
+	f.got = req
+	return agent.Response{Text: f.text, Model: "fake-model"}, nil
+}
+
+func TestParseJSONObjectWithFence(t *testing.T) {
+	raw := "好的，这是建议：\n```json\n{\"suggestions\":[\"好的，执行吧\",\"先看一下 diff\"]}\n```\n"
+	got := Parse(raw, 3)
+	want := []string{"好的，执行吧", "先看一下 diff"}
+	if len(got) != len(want) {
+		t.Fatalf("Parse = %#v，期望 %#v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("Parse[%d] = %q，期望 %q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestParseBareArray(t *testing.T) {
+	got := Parse(`["继续","跑一遍测试"]`, 3)
+	if len(got) != 2 || got[0] != "继续" || got[1] != "跑一遍测试" {
+		t.Fatalf("Parse = %#v", got)
+	}
+}
+
+func TestParseLineFallback(t *testing.T) {
+	// 模型没按 JSON 回：只认「像一句指令」的短行，带解释/代码的丢掉。
+	raw := "1. 好的，执行吧。\n2、先看一下 diff\n- 这是解释：它改了三个文件\n```\ncode\n```"
+	got := Parse(raw, 3)
+	want := []string{"好的，执行吧", "先看一下 diff"}
+	if len(got) != len(want) {
+		t.Fatalf("Parse = %#v，期望 %#v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("Parse[%d] = %q，期望 %q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestParseRejectsNoise(t *testing.T) {
+	long := strings.Repeat("很", MaxLabelRunes+1)
+	raw := `{"suggestions":[
+		"继续",
+		"继续",
+		"AI 已经完成了这一步",
+		"助手建议你先跑测试",
+		"…半句话被截断了",
+		"` + long + `",
+		"好的，执行吧"
+	]}`
+	got := Parse(raw, 3)
+	if len(got) != 2 || got[0] != "继续" || got[1] != "好的，执行吧" {
+		t.Fatalf("Parse = %#v，去重/噪声过滤不对", got)
+	}
+	if n := len(Parse(raw, 1)); n != 1 {
+		t.Fatalf("count=1 时给了 %d 条", n)
+	}
+}
+
+func TestParseEmpty(t *testing.T) {
+	for _, raw := range []string{"", "   ", "{}", `{"suggestions":[]}`} {
+		if got := Parse(raw, 3); len(got) != 0 {
+			t.Fatalf("Parse(%q) = %#v，期望空", raw, got)
+		}
+	}
+}
+
+func TestNormalizeTrimsPunctuationAndQuotes(t *testing.T) {
+	got := Parse(`{"suggestions":["「好的，执行吧」。"]}`, 3)
+	if len(got) != 1 || got[0] != "好的，执行吧" {
+		t.Fatalf("Parse = %#v", got)
+	}
+}
+
+func TestPromptCarriesBothSides(t *testing.T) {
+	p := Prompt("帮我把登录页改完", "改动只在移动端静态资源。要我继续吗？", 3)
+	for _, want := range []string{"帮我把登录页改完", "要我继续吗？", "最多 3 条", `{"suggestions"`} {
+		if !strings.Contains(p, want) {
+			t.Fatalf("提示词缺少 %q：\n%s", want, p)
+		}
+	}
+	// 回复取结尾：超长时保留最后一段（下一步在那里）。
+	tail := strings.Repeat("前", 7000) + "最后一句：要我继续吗？"
+	p2 := Prompt("", tail, 3)
+	if !strings.Contains(p2, "最后一句：要我继续吗？") {
+		t.Fatalf("超长回复的结尾被截掉了")
+	}
+}
+
+func TestGenerateUsesToolsOffAndNoSession(t *testing.T) {
+	f := &fakeEngine{name: "fake-suggest", text: `{"suggestions":["好的，执行吧"]}`}
+	agent.Register(f) // 注册在 Engines() 首次调用之前：本包只找这个假引擎
+	res, err := Generate(context.Background(), Request{User: "改完了吗", Reply: "要我继续吗？", Engine: f.name})
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	if len(res.Suggestions) != 1 || res.Suggestions[0] != "好的，执行吧" {
+		t.Fatalf("Suggestions = %#v", res.Suggestions)
+	}
+	if res.Engine != f.name {
+		t.Fatalf("Engine = %q", res.Engine)
+	}
+	if f.got.Tools == nil || !f.got.Tools.IsOff() {
+		t.Fatalf("建议调用必须 ToolsOff（不带工具），实际 %#v", f.got.Tools)
+	}
+	if f.got.SessionID != "" || f.got.Continue {
+		t.Fatalf("建议调用不能续接会话（会污染上下文）：session=%q continue=%v", f.got.SessionID, f.got.Continue)
+	}
+	if f.got.JSONSchema == nil || len(f.got.JSONSchema.Required) != 1 {
+		t.Fatalf("缺少结构化输出契约")
+	}
+}
+
+func TestDropCreativeRestarts(t *testing.T) {
+	user := "写一个短篇恋爱小说"
+	complete := "# 她算得比天气预报准\n\n……林知夏把笔帽放回兜里，从此再也没咬扁过。"
+	cases := []struct {
+		name  string
+		items []string
+		reply string
+		want  []string
+	}{
+		{"另起一篇", []string{"再来一篇职场题材的", "跑一下测试"}, complete, []string{"跑一下测试"}},
+		{"再写一个故事", []string{"再写一个校园故事"}, complete, []string{}},
+		{"再来个职场篇", []string{"再来个职场篇"}, complete, []string{}},
+		{"换个校园题材", []string{"换个校园题材的"}, complete, []string{}},
+		{"下一篇", []string{"下一篇写职场"}, complete, []string{}},
+		{"写个番外", []string{"写个番外"}, complete, []string{}},
+		{"换题材", []string{"换个题材"}, complete, []string{}},
+		{"成品后继续写", []string{"继续写下一章"}, complete, []string{}},
+		{"未完待续保留", []string{"继续写下一章"}, "# 第三章\n\n……未完待续", []string{"继续写下一章"}},
+		{"AI 主动邀请保留", []string{"再来一篇"}, complete + "\n\n要不要我再写一篇？", []string{"再来一篇"}},
+		{"成品后裸继续", []string{"继续"}, complete, []string{}},
+		{"AI 问要继续保留", []string{"继续"}, complete + "\n\n要继续吗？", []string{"继续"}},
+		{"写代码不误杀", []string{"再写一个单元测试"}, "func Add() {}", []string{"再写一个单元测试"}},
+	}
+	for _, tc := range cases {
+		got := dropCreativeRestarts(tc.items, user, tc.reply)
+		if len(got) != len(tc.want) {
+			t.Fatalf("%s: dropCreativeRestarts = %#v，期望 %#v", tc.name, got, tc.want)
+		}
+		for i := range tc.want {
+			if got[i] != tc.want[i] {
+				t.Fatalf("%s: [%d] = %q，期望 %q", tc.name, i, got[i], tc.want[i])
+			}
+		}
+	}
+	// 非创作轮次不启用这条过滤：写代码时「再来一篇」虽怪，但不能由这里替用户判死。
+	if got := dropCreativeRestarts([]string{"再来一篇职场题材的"}, "修一下登录 bug", complete); len(got) != 1 {
+		t.Fatalf("非创作轮次被误过滤：%#v", got)
+	}
+	// 用户只说「继续」，但 AI 交的是一篇完整创作：也按创作轮次处理。
+	longStory := "# 长夜\n\n" + strings.Repeat("这是一段完整的故事。", 60)
+	if got := dropCreativeRestarts([]string{"再来一篇职场题材的"}, "继续", longStory); len(got) != 0 {
+		t.Fatalf("创作成品后的续篇没被过滤：%#v", got)
+	}
+	// 带代码块的工程回答不能被当成创作成品。
+	codeDoc := "# 修复说明\n\n```go\nfunc Add(){}\n```\n" + strings.Repeat("测试通过。", 100)
+	if got := dropCreativeRestarts([]string{"再写一个测试"}, "继续", codeDoc); len(got) != 1 {
+		t.Fatalf("工程回答被误判成创作：%#v", got)
+	}
+}
+
+func TestGenerateFiltersCreativeRestart(t *testing.T) {
+	f := &fakeEngine{name: "fake-suggest-creative", text: `{"suggestions":["再来一篇职场题材的","跑一下测试"]}`}
+	agent.Register(f)
+	res, err := Generate(context.Background(), Request{
+		User: "写一个短篇恋爱小说", Reply: "# 标题\n\n……故事收尾，没有提问。", Engine: f.name,
+	})
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	if len(res.Suggestions) != 1 || res.Suggestions[0] != "跑一下测试" {
+		t.Fatalf("Suggestions = %#v，另起一篇应被过滤", res.Suggestions)
+	}
+}
+
+func TestPromptStopsCreativeRestart(t *testing.T) {
+	p := Prompt("再来一篇职场题材的", "# 甲方的那句话\n\n……沈清把合同收进抽屉。", 3)
+	for _, want := range []string{"交付型任务", "必须给空数组", "再来一篇", "用户上一句就是"} {
+		if !strings.Contains(p, want) {
+			t.Fatalf("提示词缺少 %q：\n%s", want, p)
+		}
+	}
+}
+
+func TestGenerateEmptyReplyShortCircuits(t *testing.T) {
+	f := &fakeEngine{name: "fake-suggest-empty", text: "不该被调用"}
+	agent.Register(f)
+	res, err := Generate(context.Background(), Request{Reply: "   ", Engine: f.name})
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	if len(res.Suggestions) != 0 || f.got.Messages != nil {
+		t.Fatalf("空正文不该调引擎：%#v %#v", res.Suggestions, f.got.Messages)
+	}
+}