chore(version): release/v1.3.x 路牌推到 1.3.10（本版内容：输出次数不再受限的提示词 + type 缺省）

用户现场指出：**qq 插件的输出通道判据太严了**（那条判据在插件侧，已单独修：
`output_send__qq` 不再受"当前会话身份"限制）。同时内核提示词里还有一条**同类的凭空限制**：

  「每轮对话**通常只需调用一次** output_send__{通道名} 即可完成回复。
    仅在内容确实超过单条消息长度上限（如 >4000 字）时才拆分为多条」

可设计上输出是 agent 的**主动调用**：收到一次输入后，可以往**任意（已授权的）通道**
发**任意多次**（分段播报、先回执后结论、同时通知多个通道都合法）。这句话会让模型
自己收起合理的多次输出 —— 而且它不是任何机制的要求，只是当初为压 output-loop 写的
措辞（真正的防环机制是"回执只回 ok、不回传富结果"，那条保留）。

改法：
- 提示词改为明确授权：**输出次数与目标通道由你自己决定**，没有「一轮只能发一次」的限制；
  只保留两条真话：单条长度上限（超长拆完整段落）、别反复重发**完全相同**的内容。
- `output_send__*` 的 `type` 参数改为**可选**（缺省 text）：判据该拦的是"不知道发什么"，
  不是"没写众所周知的默认值"——此前缺 type 会直接失败并让模型重试一次。

判据 3 条（新增 `output_rules_test.go`）：提示词不得含输出次数限制且必须显式授权 /
省略 type 时按 text 发送成功且 schema 的 required 只有 payload / 空 payload 仍被拦。

internal/agent/core/inputroute_test.go

@@ -34,6 +34,11 @@ func TestResident_InputchRoutingIsExclusive(t *testing.T) {
 	if got := parent.DumpScheduler().Stats.Enqueued; got != before {
 		t.Fatalf("划给子的 inputch，父不应再入队（before=%d after=%d）", before, got)
 	}
+	// 轮次必须真的涨：此前 info() 根本没填 Rounds ⇒ 父永远读到 0
+	// （现场：子处理表已有 2 条，轮次却显示 0，被误判成"子没干活"）。
+	if got := parent.residents["r-route"].info().Rounds; got <= 0 {
+		t.Fatalf("子处理的轮次应 > 0，实际 %d", got)
+	}
 }
 
 // 归属到一个不存在（或已销毁）的 agent 时**不吞输入**：父兜底处理。

internal/agent/core/output.go

@@ -13,8 +13,13 @@ func (a *Agent) executeOutputSendTool(tc agentAPI.ToolCall) string {
 	channel := strings.TrimPrefix(tc.Name, "output_send__")
 	payload, _ := tc.Arguments["payload"].(string)
 	rawType, _ := tc.Arguments["type"].(string)
-	if channel == "" || payload == "" || rawType == "" {
-		return "工具名称格式: output_send__{channel}，payload 和 type 不能为空"
+	if channel == "" || payload == "" {
+		return "工具名称格式: output_send__{channel}，payload 不能为空"
+	}
+	// type 缺省按 text 处理：绝大多数输出就是文本，让模型为"省略一个默认值"付一次
+	// 失败重试没有意义（判据该拦的是"不知道发什么"，不是"没写众所周知的默认值"）。
+	if rawType == "" {
+		rawType = "text"
 	}
 	// 授权闸（纵深防御）：模型可能凭名字直接调未授权的输出门。
 	if !a.IsOutputAllowed(channel) {

internal/agent/core/output_rules_test.go

@@ -0,0 +1,100 @@
+package core
+
+import (
+	"strings"
+	"testing"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+)
+
+// 设计口径：输出是 agent 的**主动调用** —— 收到一次输入后，可以往任意（已授权的）
+// 通道发**任意多次**（分段播报、先回执后结论、同时通知多个通道都合法）。
+//
+// 这条判据钉住的是"提示词里不得出现输出次数限制"。此前 `tooldefs.go` 里写着
+// 「每轮对话通常只需调用一次 output_send__{通道名} 即可完成回复」—— 一条凭空的限制，
+// 会让模型自己收起合理的多次输出（用户现场指出）。
+func TestSystemPromptDoesNotRestrictOutputCount(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	defer parent.Stop()
+
+	prompt := parent.buildSystemPrompt("", "你好")
+	banned := []string{
+		"只需调用一次",
+		"只能调用一次",
+		"通常只需调用",
+		"不要重复发送",
+	}
+	for _, b := range banned {
+		if strings.Contains(prompt, b) {
+			t.Fatalf("系统提示词里仍有输出次数限制 %q —— 设计上次数不限", b)
+		}
+	}
+	if !strings.Contains(prompt, "输出次数与目标通道由你自己决定") {
+		t.Fatal("系统提示词应明确「输出次数与目标通道由你自己决定」")
+	}
+	if !strings.Contains(prompt, "没有任何「一轮只能发一次」的限制") {
+		t.Fatal("系统提示词应显式否认「一轮只能发一次」")
+	}
+}
+
+// 输出工具的 type 可省略，缺省按 text 处理（判据该拦的是"不知道发什么"，
+// 不是"没写众所周知的默认值"）。
+func TestOutputSendTypeDefaultsToText(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	defer parent.Stop()
+
+	dev := &outputTestDevice{name: "fakeout"}
+	if err := parent.io.RegisterDevice(dev); err != nil {
+		t.Fatal(err)
+	}
+
+	out := parent.executeOutputSendTool(agentAPI.ToolCall{
+		Name:      "output_send__fakeout",
+		Arguments: map[string]interface{}{"payload": "只给 payload，不给 type"},
+	})
+	if out != "ok" {
+		t.Fatalf("省略 type 时应默认 text 并发送成功，得到 %q", out)
+	}
+	if len(dev.sent) != 1 {
+		t.Fatalf("通道应收到 1 次输出，得到 %d", len(dev.sent))
+	}
+	if args, _ := dev.sent[0]["args"].(map[string]interface{}); args["type"] != "text" {
+		t.Fatalf("缺省类型应为 text，实际 %v", args["type"])
+	}
+
+	// 工具 schema：required 只应含 payload
+	var found bool
+	for _, td := range parent.buildToolDefs() {
+		entry, _ := td.(map[string]interface{})
+		fn, _ := entry["function"].(map[string]interface{})
+		if n, _ := fn["name"].(string); n != "output_send__fakeout" {
+			continue
+		}
+		found = true
+		params, _ := fn["parameters"].(map[string]interface{})
+		req, _ := params["required"].([]string)
+		if len(req) != 1 || req[0] != "payload" {
+			t.Fatalf("output_send 的 required 应只有 payload，实际 %v", req)
+		}
+	}
+	if !found {
+		t.Fatal("未生成 output_send__fakeout 工具")
+	}
+}
+
+// 空 payload 仍应被拦（这条判据是对的：不知道发什么不能放过）。
+func TestOutputSendStillRequiresPayload(t *testing.T) {
+	parent, _, _ := newRootForResidents(t)
+	defer parent.Stop()
+
+	if err := parent.io.RegisterDevice(&outputTestDevice{name: "fakeout"}); err != nil {
+		t.Fatal(err)
+	}
+	out := parent.executeOutputSendTool(agentAPI.ToolCall{
+		Name:      "output_send__fakeout",
+		Arguments: map[string]interface{}{"type": "text"},
+	})
+	if !strings.Contains(out, "payload 不能为空") {
+		t.Fatalf("空 payload 应被拦，得到 %q", out)
+	}
+}

internal/agent/core/resident.go

@@ -504,6 +504,13 @@ func (rc *residentChild) info() ResidentInfo {
 		ID: rc.id, State: state, InputChs: append([]string(nil), rc.inputChs...),
 		AllowedOutputs: append([]string(nil), rc.allowed...),
 		ContextFull:    full, CreatedAt: rc.createdAt, TableSize: len(table),
+		// Rounds = 子**已执行的轮次数**（调度器的执行计数，单调不减）。
+		//
+		// 此前这里根本没填这个字段 ⇒ 父看到的永远是 `轮次=0`，与"处理表已有 N 条"
+		// 自相矛盾（现场：子明明处理了两轮，父读到 rounds=0，误判成"子没干活"）。
+		// 注意它**不等于** len(table)：处理表记的是"当前上下文窗口内"的轮次，
+		// 压缩会清空（§8.3），所以窗口内的条数会被重置，而轮次总数不会。
+		Rounds: rc.agent.roundsExecuted(),
 	}
 	if len(table) > 0 {
 		info.Table = table

internal/agent/core/scheduler.go

@@ -745,6 +745,18 @@ func newKernelInterruptTask(evt *agentIO.InputEvent) *Task {
 }
 
 // DumpScheduler 返回调度器的原子快照（供状态页/测试断言）。
+// roundsExecuted 返回本 agent 已执行的轮次数（供驻留子状态面展示）。
+//
+// 一轮 = 一次被执行的输入（排队与中断都算）。为什么不用 inputch 处理表的条数：
+// 那张表记的是"当前上下文窗口内"的轮次，压缩会清空（设计 §8.3）——
+// 拿它当轮次会让父看到轮次倒退。
+func (a *Agent) roundsExecuted() int {
+	if a.sched == nil {
+		return 0
+	}
+	return int(a.DumpScheduler().Stats.Executed)
+}
+
 func (a *Agent) DumpScheduler() SchedulerSnapshot {
 	if a.sched == nil {
 		return SchedulerSnapshot{}

internal/agent/core/tooldefs.go

@@ -102,7 +102,14 @@ func (a *Agent) buildSystemPrompt(memContext string, userInput string) string {
 	prompt += "- 同步通道（webui / cli / 终端）：直接返回纯文本，内核会把文本交给等待方显示，无需调用工具。\n"
 	prompt += "- 异步通道（qq / wechat / 群聊等）：返回纯文本**【不会】**自动送达用户，必须调用 output_send__{通道名} 工具（注意 meta 里带上正确的 user_id 或 group_id）才能真正把消息发出去。\n"
 	prompt += "- 不确定当前通道的发送方式时，先用 output_send__{通道名}_help 查看该通道的 meta 格式和 type 枚举，再决定。\n"
-	prompt += "- 每轮对话**通常只需调用一次** output_send__{通道名} 即可完成回复。仅在内容确实超过单条消息长度上限（如 >4000 字）时才拆分为多条；拆分时每条应是完整段落，不要碎片化。\n"
+	// ❗这里**不得**限制"一轮只能发一次"。设计上输出是 agent 的**主动调用**：
+	// 收到一次输入后，可以往**任意（已授权的）通道**发**任意多次**（分段播报、
+	// 先回执后结论、同时通知多个通道都合法）。此前这里写着"每轮对话通常只需调用
+	// 一次 output_send"——那是一条**凭空的限制**，会让模型自己收起合理的多次输出。
+	// 真正需要提醒的只有两件事：单条长度上限（超长拆成完整段落）与"别反复重发
+	// 完全相同的内容"（自律，不是判据）。
+	prompt += "- **输出次数与目标通道由你自己决定**：一次输入可以对同一通道发多条（先回执后结论、分步播报、分段长文），也可以同时发到多个通道（例如同时通知 webui 与 qq）。**没有任何「一轮只能发一次」的限制。**\n"
+	prompt += "- 输出时只需注意两点：单条消息的长度上限（超长就拆成完整段落，不要碎片化）；别反复重发**完全相同**的内容（那是浪费，不是限制）。\n"
 	prompt += "- 需要多步执行的长任务：**必须先**向当前对话通道发一条确认消息告诉用户已收到（异步通道用输出门工具，同步通道直接返回文本），**然后再**执行具体排查工具。确认消息不代表任务完成，发出后仍需继续执行实际工具并最终汇报结果。\n"
 	prompt += "- 用户从其他渠道发来「在哪里/怎么样了」这类追问时，先回忆上次任务的通道与上下文，再回同一通道。"
 
@@ -624,7 +631,7 @@ func (a *Agent) buildToolDefs() []interface{} {
 			"type": "function",
 			"function": map[string]interface{}{
 				"name":        "output_send__" + ch.Name,
-				"description": desc + "。能力: " + capStr + "。payload 为消息载荷，meta 为 JSON 发送元数据，type 为载荷类型。用 _help 查看 meta 格式和 type 枚举。",
+				"description": desc + "。能力: " + capStr + "。payload 为消息载荷（type 默认 text，可省略），meta 为 JSON 发送元数据。用 _help 查看 meta 格式与 type 枚举。",
 				"parameters": map[string]interface{}{
 					"type": "object",
 					"properties": map[string]interface{}{
@@ -638,10 +645,10 @@ func (a *Agent) buildToolDefs() []interface{} {
 						},
 						"type": map[string]interface{}{
 							"type":        "string",
-							"description": "载荷类型，用 channel._help 查看支持的枚举值",
+							"description": "载荷类型，默认 text；其它枚举用 channel._help 查看",
 						},
 					},
-					"required": []string{"payload", "type"},
+					"required": []string{"payload"},
 				},
 			},
 		})

internal/meta/meta.go

@@ -28,6 +28,8 @@ var (
 	//
 	// ❗main 上此值始终是**下一个未发布中版本**，不随 patch 发布变动
 	//（见 docs/git-branching.md §2.1）；已发布的版本号看对应的 release/vX.Y.x 与 tag。
+	// 1.3.10：去掉提示词里"每轮只能发一次 output_send"的凭空限制；type 缺省即 text。
+	// 1.3.9：驻留子的「轮次」不再是恒 0（info() 此前没填 Rounds）。
 	// 1.3.8：inputch 划给子后输入只流向子（补上"进内核之前"的输入路由）。
 	// 1.3.7：驻留子继承父的输出通道（此前子侧 childIO 空壳 ⇒ 子不会发消息）。
 	// 1.3.6：人格文本不再在播种时固化版本 + 存量实例一次性去版本化（生产实例
@@ -35,7 +37,7 @@ var (
 	// 1.3.5：系统提示词（人格卡）支持版本占位符 —— 人格卡是配置项，写死版本号
 	//        会随发版说谎（线上写 v1.0.3、内核 1.3.x，agent 就自报 1.0.3）。
 	//        支持 {{kernel_version}} / {{kernel_commit}} / {{sdk_version}}。
-	Version = "1.3.8"
+	Version = "1.3.10"
 
 	// Commit 是构建时的 Git commit hash。
 	Commit = "unknown"