feat(resident): N3–N7 驻留式子 agent 全量落地（生命周期/双向投递/处理表/contextfull/e2e+压力）

设计：docs/zh/resident-subagent-design.md §6/§7/§8/§9/§10。

## N3 生命周期（resident.go）

- `SpawnResident`：主库**受限句柄** + 自己的 temp 实例（`LightMemory`）⇒ 子的轻量内核；
  划入 inputch（登记归属）、授权输出通道、注入任务提示词；为父登记 `child/<id>` 入站 inputch；
  建独立 `IOManager`（共享通道登记表）；启动子。
- `DestroyResident`：停子内核、归还划入的 inputch（回到未分配）、丢弃 temp 目录、出登记表。
- `Stop()` → `StopResidents()`：**父退出必须销毁全部子、不留孤儿**（设计 §10 硬约束）。
- `Residents()` 登记表快照；`ResidentTable(id)` 父 pull 子的处理表（不打断）。

## N4 跨 agent 投递

- 子→父：`notify_parent` → 投进父的 `child/<id>` inputch，优先级 **L3**。
- 父→子：`SendToResident` → 投进子的 inputch，优先级 **L4**；
  `isKernelLevelSource` 泛化为"该 agent 的上级"（`AgentConfig.KernelSource`）⇒
  只有父能在子的阶梯上产生 L4（子内部一律 ≤L3）。
- 子的 contextfull → 父侧 `raiseKernelInterrupt`（内核级事件，带子标识，父侧 L4）。

## N5 inputch 处理表

- 子持有；`inputch_note` 主动写**优先**，轮末 `autoRecordInputch` 兜底 ⇒ 每轮必有记录。
- 压缩时清表（表记的是被压掉那段窗口的逐轮处理）。

## N6 contextfull（判据修正）

❗初版判据是"拼好的 `f.Msgs` 估算 > 90% 窗口"，**结构上永不成立**：
`buildMessages` 拿到的 `budget.ContextTokens` 由 `targetUsage = 0.8 × 窗口` 推出，
时间线**在拼进消息之前就被预算裁过**，`f.Msgs` 封顶在 ~80% 窗口。
（初版测试用一个比系统提示词还小的窗口才勉强越线 —— 那等于什么都没测。）
现判据 = **未裁剪的积累上下文**（`a.context.Recent(0)`）超过窗口 90%：
它超过就说明下一轮必须丢事件，这正是"上下文满"。

三处置：`CompressResident`（保留语义：`TrimKeepRecent` 保留最近 N 条 + 清表）/
`ReclaimResident`（取消语义：`ExportTriples` 读 temp → 父选出要保留的 → `Commit` 进 main → 取消该子）/
`DestroyResident`（立刻销毁并移除）。

## 工具面

`resident_agents`（父，单工具多动作：list/create/send/inspect/compress/reclaim/destroy）、
`notify_parent` + `inputch_note`（子）。声明条件式：父才有前者，子才有后两者。

## 验收

`resident_test.go` 五项：生命周期与不留孤儿、双向投递（含"子的主动消息不得以 L4 出现"）、
处理表（自动写 vs 主动写优先）、contextfull + 三处置、
**压力 8 子 × 12 轮（父→子 L4 与普通输入各半）+ 双向汇报 + 父退出清理**。
全仓 go test ./... 37 包 ok / 0 FAIL；`-race`（agent/memory/plugin）干净；
压力 `-race -count=3` 通过。

internal/agent/core/resident_tools.go

@@ -0,0 +1,168 @@
+package core
+
+// 驻留子的**工具面**（对照设计 §7 控制面与 §8 处理表）。
+//
+// 单工具多动作：父侧一个 `resident_agents`（list/create/send/inspect/compress/reclaim/destroy），
+// 子侧两个小工具：`notify_parent`（L3 主动汇报）与 `inputch_note`（主动写处理表）。
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
+	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/memory"
+)
+
+func strArg(tc agentAPI.ToolCall, key string) string {
+	s, _ := tc.Arguments[key].(string)
+	return strings.TrimSpace(s)
+}
+
+func splitArg(s string) []string {
+	if strings.TrimSpace(s) == "" {
+		return nil
+	}
+	parts := strings.Split(s, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if p = strings.TrimSpace(p); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// executeResidentAgents 是父的驻留子控制面（单工具多动作）。
+func (a *Agent) executeResidentAgents(tc agentAPI.ToolCall) string {
+	switch action := strArg(tc, "action"); action {
+	case "", "list":
+		list := a.Residents()
+		if len(list) == 0 {
+			return "当前没有驻留子 agent。"
+		}
+		var b strings.Builder
+		fmt.Fprintf(&b, "驻留子 agent（%d 个）:", len(list))
+		for _, r := range list {
+			fmt.Fprintf(&b, "\n  - %s [%s] inputch=%v 轮次=%d 处理表=%d",
+				r.ID, r.State, r.InputChs, r.Rounds, r.TableSize)
+			if r.ContextFull {
+				b.WriteString("  ⚠️ contextfull")
+			}
+		}
+		return b.String()
+
+	case "create":
+		id := strArg(tc, "id")
+		tempPath := strArg(tc, "temp_path")
+		if tempPath == "" {
+			if a.dataDir == "" {
+				return "创建驻留子需要 data_dir 或显式 temp_path"
+			}
+			tempPath = filepath.Join(a.dataDir, "residents", id, "graph.db")
+		}
+		info, err := a.SpawnResident(ResidentOptions{
+			ID:             id,
+			TaskPrompt:     strArg(tc, "task_prompt"),
+			InputChs:       splitArg(strArg(tc, "input_chs")),
+			AllowedOutputs: splitArg(strArg(tc, "allowed_outputs")),
+			Capacity:       intArg(tc, "capacity"),
+			TempPath:       tempPath,
+		})
+		if err != nil {
+			return fmt.Sprintf("创建驻留子失败: %v", err)
+		}
+		return "已创建驻留子: " + MarshalResidentInfo(info)
+
+	case "send":
+		if err := a.SendToResident(strArg(tc, "id"), strArg(tc, "text")); err != nil {
+			return fmt.Sprintf("发送失败: %v", err)
+		}
+		return "已发送（对子而言是 L4 中断）"
+
+	case "inspect":
+		id := strArg(tc, "id")
+		if id == "" {
+			return "inspect 需要 id（或先用 action=list）"
+		}
+		table, err := a.ResidentTable(id)
+		if err != nil {
+			return fmt.Sprintf("查看失败: %v", err)
+		}
+		var b strings.Builder
+		fmt.Fprintf(&b, "驻留子 %s 的 inputch 处理表（%d 条）:", id, len(table))
+		for _, r := range table {
+			kind := "系统写"
+			if r.Proactive {
+				kind = "主动写"
+			}
+			fmt.Fprintf(&b, "\n  - [%s][%s] %s", r.InputCh, kind, r.Text)
+		}
+		if len(table) == 0 {
+			b.WriteString("\n  （尚无记录）")
+		}
+		return b.String()
+
+	case "compress":
+		n, err := a.CompressResident(strArg(tc, "id"))
+		if err != nil {
+			return fmt.Sprintf("压缩失败: %v", err)
+		}
+		return fmt.Sprintf("已压缩子 agent 上下文（丢弃 %d 条旧事件，并发清理其 inputch 处理表）；子继续存在", n)
+
+	case "reclaim":
+		info, err := a.ReclaimResident(strArg(tc, "id"), reclaimKeepAll)
+		if err != nil {
+			return fmt.Sprintf("回收失败: %v", err)
+		}
+		return "已回收（temp 中选中的记录已合入主记忆，该驻留子已取消）: " + MarshalResidentInfo(info)
+
+	case "destroy":
+		if err := a.DestroyResident(strArg(tc, "id")); err != nil {
+			return fmt.Sprintf("销毁失败: %v", err)
+		}
+		return "已销毁并移除该驻留子"
+
+	default:
+		return fmt.Sprintf("未知 action=%q；可用：list | create | send | inspect | compress | reclaim | destroy", action)
+	}
+}
+
+// reclaimKeepAll 是回收时的默认策略：把子 temp 的活跃记录全部纳入主记忆
+// （"哪些纳入"由父的模型决定——这里给的是"全要"这一档）。
+func reclaimKeepAll(_ []InputchRecord, triples []memory.Triple) []memory.Triple { return triples }
+
+func intArg(tc agentAPI.ToolCall, key string) int {
+	switch v := tc.Arguments[key].(type) {
+	case float64:
+		return int(v)
+	case int:
+		return v
+	}
+	return 0
+}
+
+// executeNotifyParent 是子的"主动向父发消息"（父侧阶梯 = **L3 中断**）。
+func (a *Agent) executeNotifyParent(tc agentAPI.ToolCall) string {
+	return a.notifyParentFrom(strArg(tc, "text"))
+}
+
+// executeInputchNote 是子"主动写入本轮 inputch 的处理信息"。
+// 主动写过 ⇒ 本轮系统不再自动写（见 autoRecordInputch）。
+func (a *Agent) executeInputchNote(tc agentAPI.ToolCall) string {
+	text := strArg(tc, "text")
+	if text == "" {
+		return "text 不能为空"
+	}
+	a.recordInputchNote(text)
+	return "已记录本轮 inputch 处理信息（本轮系统不会再自动写）"
+}
+
+// childInboundChannelHint 是给子看的"父会怎么把消息投给你"的提示（不参与调度）。
+func childInboundChannelHint(a *Agent) string { return "sub/" + string(a.id) }
+
+// residentTempDir 返回某个驻留子 temp 存储所在目录（销毁时连同目录丢弃）。
+func residentTempDir(tempPath string) string { return filepath.Dir(tempPath) }
+
+var _ = agentIO.InputChannel{} // 保持 agentIO 依赖（工具面未来会用通道登记）