feat(scheduler): M7 可观测性 + 压力测试 + 端到端测试

设计依据 docs/zh/input-scheduler-design.md §11.5（O1/O2）、§11.6（E1/E2）。

- 可观测性：KernelStatus 新增 Scheduler 段（running/三集合深度/计数/
  深度上限），由 GetKernelStatus 从 DumpScheduler 原子快照填充；
  新增 events.EventScheduler，挂起/恢复各发一条（action/task/level）
- TaskKind.String() 便于日志与状态输出
- 新增 scheduler_e2e_test.go 3 项：
  · 压力：200 排队输入 + 50 中断全部经真实 loop 执行，结束时三集合排空、
    LLM 调用数精确等于输入数、无 Rejected
  · 可观测性：挂起/恢复事件齐备，状态快照计数一致
  · 端到端：完整启动 schedulerLoop+interceptLoop，经真实 channel 投递
    L1 任务与 L4 中断，验证「LLM 流式中断 → 挂起 → 中断先完成 → 原任务恢复」
    整条链路（LLM 调用数 = 丢弃1+中断1+恢复1+常规1）
- 验收：agent 全量 + -race；全仓 build/vet 通过

internal/agent/core/scheduler.go

@@ -25,6 +25,8 @@ import (
 
 	agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api"
 	agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io"
+	"gitcode.com/JianFeeeee/HomeAgent/internal/events"
+	sdk "gitcode.com/JianFeeeee/HomeAgent/internal/sdk"
 )
 
 // Level 是任务优先级，由内核预定义四级（设计文档 §3.1）。
@@ -73,6 +75,17 @@ const (
 	TaskKindSelf
 )
 
+func (k TaskKind) String() string {
+	switch k {
+	case TaskKindInput:
+		return "input"
+	case TaskKindSelf:
+		return "self"
+	default:
+		return "unknown"
+	}
+}
+
 // Task 是调度器的最小单位。
 //
 // M2 只承载"一份待处理的输入"；M3 起把 TaskFrame（现场）挂上来，
@@ -124,9 +137,11 @@ func effectiveLevel(t *Task) Level {
 type SchedulerStats struct {
 	Enqueued uint64
 	Executed uint64
-	// Rejected 是因队列满而未入队的次数。M2 由泵入侧节流，正常为 0；
-	// 出现非 0 说明消费端长期慢于生产端。
+	// Rejected 是因队列满（或深度超限）而未被接纳的次数。
 	Rejected uint64
+	// Suspended / Resumed 是挂起与恢复的次数。
+	Suspended uint64
+	Resumed   uint64
 }
 
 // SchedulerSnapshot 是调度器的原子快照。
@@ -136,6 +151,33 @@ type SchedulerSnapshot struct {
 	PendingInterrupts []*Task
 	SuspendPool       []*suspendedTask
 	Stats             SchedulerStats
+	MaxSuspendDepth   int
+}
+
+// schedulerStatus 把快照转成对外的状态 DTO（不暴露帧内容）。
+func (a *Agent) schedulerStatus() sdk.SchedulerStatus {
+	if a.sched == nil {
+		return sdk.SchedulerStatus{}
+	}
+	snap := a.DumpScheduler()
+	out := sdk.SchedulerStatus{
+		ReadyQueueDepth:   len(snap.Queue),
+		PendingInterrupts: len(snap.PendingInterrupts),
+		SuspendPool:       len(snap.SuspendPool),
+		MaxSuspendDepth:   snap.MaxSuspendDepth,
+		Enqueued:          snap.Stats.Enqueued,
+		Executed:          snap.Stats.Executed,
+		Rejected:          snap.Stats.Rejected,
+		Suspended:         snap.Stats.Suspended,
+		Resumed:           snap.Stats.Resumed,
+		Preempted:         snap.Stats.Suspended,
+	}
+	if snap.Running != nil {
+		out.Running = &sdk.SchedulerTask{
+			ID: snap.Running.ID, Level: int(snap.Running.Level), Kind: snap.Running.Kind.String(),
+		}
+	}
+	return out
 }
 
 type scheduler struct {
@@ -342,6 +384,7 @@ func (s *scheduler) suspend(t *Task, f *TaskFrame) {
 		s.stats.Rejected++
 	}
 	s.suspendPool = append(s.suspendPool, &suspendedTask{Task: t, Frame: f})
+	s.stats.Suspended++
 	// 饥饿防护：抢占计数 +1（提升有效级）并记录冷却起点。
 	t.PreemptCount++
 	t.LastPreemptAt = time.Now()
@@ -487,6 +530,7 @@ func (a *Agent) DumpScheduler() SchedulerSnapshot {
 	snap.Queue = append(snap.Queue, a.sched.queue...)
 	snap.PendingInterrupts = append(snap.PendingInterrupts, a.sched.pendingInterrupts...)
 	snap.SuspendPool = append(snap.SuspendPool, a.sched.suspendPool...)
+	snap.MaxSuspendDepth = a.sched.maxSuspendDepth
 	return snap
 }
 
@@ -576,6 +620,9 @@ func (a *Agent) executeNewTask(t *Task) {
 
 	if out == outcomeSuspended && f != nil {
 		a.sched.suspend(t, f)
+		a.publishEvent(events.EventScheduler, map[string]interface{}{
+			"action": "suspend", "task": t.ID, "level": int(t.Level),
+		})
 		return
 	}
 	a.sched.done(t)
@@ -585,6 +632,12 @@ func (a *Agent) executeNewTask(t *Task) {
 //
 // 关键：不重建帧、不重跑 prepare 段——否则会重复提交上下文与事件。
 func (a *Agent) resumeTask(t *Task, f *TaskFrame) {
+	a.sched.mu.Lock()
+	a.sched.stats.Resumed++
+	a.sched.mu.Unlock()
+	a.publishEvent(events.EventScheduler, map[string]interface{}{
+		"action": "resume", "task": t.ID, "level": int(t.Level),
+	})
 	defer func() {
 		if r := recover(); r != nil {
 			log.Printf("[agent] resume task#%d panic recovered: %v\n%s",