Index 17: Autonomous Agents — 空闲循环 / 自动认领

$ cat-code
> /task add t3 跑基准测试
> 派生一个研究员和审查员
🤖 spawn teammate 'researcher' ...
🤖 spawn teammate 'reviewer' ...
# ── 用户走开 30 秒，IdleLoop 后台自动认领 ──
# 回来输入任意字符，回合间 drain：
🔔 auto - task t1 claimed by researcher
🔔 auto - task t3 claimed by reviewer
🔔 auto - task t1 completed by researcher
> /task list
Tasks (3):
  t1  [COMPLETED] 调研符号表缓存      ← 研究员空闲时自动做完
  t2  [PENDING]   实现哈希索引        ← 等更多空闲队友或主智能体继续
  t3  [COMPLETED] 跑基准测试
> /auto
Autonomous agents: ON (tick every 10s)
  claimed: 2 completed: 2
> /auto off
Autonomous agents: OFF

s05 TodoWrite -> s12 TaskSystem -> s13 BackgroundTasks -> s14 CronScheduler
                              ↘ s17 AutonomousAgents
s06 Subagent ──→ s15 AgentTeams ──→ s16 TeamProtocols ──→ s17 AutonomousAgents

                         ┌─────────────────────────────────────────────┐
                         │               ReplLoop (主)                  │
                         │  ┌──────────────┐   ┌────────────────────┐  │
                         │  │  IdleLoop    │   │  TaskStore (s12)   │  │
                         │  │  (后台协程)   │──▶│  (磁盘持久化)        │  │
                         │  └──────┬───────┘   └─────────▲──────────┘  │
                         │   仅主空闲时 tick              │ update 状态   │
                         │   通知 → s13 Queue             │              │
                         └─────────┼─────────────────────┼──────────────┘
                                   │  AutoClaimer.tick()   │
                                   │  ①完成检测  ②就绪认领   │
        ┌──────────────────────────┼─────────────────────┼──────────┐
        │                    ┌─────▼─────┐          ┌─────▼─────┐    │
        │                    │ TeamStore │          │ MessageBus│    │
        │                    │ (s15 IDLE │          │ (s15 路由) │    │
        │                    │  成员查询) │          └─────┬─────┘    │
        │                    └─────┬─────┘                │ send      │
        │                          │ status              │ task 消息  │
        │                 ┌────────▼────────┐             │            │
        │                 │  researcher(IDLE)│◄────────────┘            │
        │                 │  消费协程 resume  │  "Autonomous task t1: …"  │
        │                 └─────────────────┘   RUNNING→IDLE            │
        └───────────────────────────────────────────────────────────────┘

// AutoClaimer.kt（节选）
class AutoClaimer(
    private val taskStore: TaskStore,      // s12
    private val teamStore: TeamStore,      // s15
    private val messageBus: MessageBus,    // s15
    private val tracker: ClaimTracker = ClaimTracker(),
    private val config: AutonomousConfig = AutonomousConfig()
) {
    fun tick(): ClaimResult {
        val completed = mutableListOf<String>()
        val claimed = mutableListOf<String>()

        // ① 完成检测（先于②，避免本 tick 新建认领被误判完成）
        for ((taskId, teammate) in tracker.snapshot()) {
            when (teamStore.get(teammate)?.status) {
                TeamStatus.IDLE -> {
                    taskStore.findById(taskId)?.let { task ->
                        taskStore.update(task.copy(status = TaskStatus.COMPLETED))
                        completed.add(taskId)
                    }
                    tracker.release(taskId)
                }
                TeamStatus.RUNNING -> {}          // 仍在处理
                else -> {                         // 队友被停/失败 -> 任务回 PENDING 可重认领
                    taskStore.findById(taskId)?.let {
                        taskStore.update(it.copy(status = TaskStatus.PENDING))
                    }
                    tracker.release(taskId)
                }
            }
        }

        // ② 就绪认领：就绪 PENDING 任务 → 空闲且无认领的队友
        val ready = TaskScheduler.readyTasks(taskStore.loadAll())
            .filter { it.status == TaskStatus.PENDING }
            .take(config.maxTasksPerTick)
        val idle = teamStore.all().filter {
            it.status == TeamStatus.IDLE && !tracker.hasPendingAssignment(it.name)
        }
        for ((task, teammate) in ready.zip(idle)) {
            tracker.assign(task.id, teammate.name)
            taskStore.update(task.copy(status = TaskStatus.IN_PROGRESS))
            messageBus.send(TeamMessage("main", teammate.name, formatTask(task), "task ${task.id}"))
            claimed.add(task.id)
        }
        return ClaimResult(claimed, completed)
    }
}

// ClaimTracker.kt —— 线程安全（ConcurrentHashMap）
class ClaimTracker {
    private val assignments = ConcurrentHashMap<String, String>()
    fun assign(taskId: String, teammate: String)
    fun release(taskId: String)
    fun teammateFor(taskId: String): String?
    fun hasPendingAssignment(teammate: String): Boolean   // 防重复派发
    fun snapshot(): Map<String, String>                    // 遍历用拷贝
}

// IdleLoop.kt（节选）
class IdleLoop(
    private val autoClaimer: AutoClaimer,
    private val notifications: NotificationQueue,      // s13
    private val config: AutonomousConfig = AutonomousConfig(),
    private val delayMillis: Long = config.tickIntervalMillis,
    private val shouldRun: () -> Boolean = { true }    // 主 REPL 空闲门控
) {
    fun start(scope: CoroutineScope) {
        if (job?.isActive == true) return
        job = scope.launch {
            while (isActive) {
                if (enabled.get() && shouldRun()) {
                    val result = autoClaimer.tick()
                    result.claimed.forEach { id ->
                        claimedCount.incrementAndGet()
                        notifications.push(BackgroundNotification(id, BackgroundStatus.RUNNING, "autonomous task $id claimed"))
                    }
                    result.completed.forEach { id ->
                        completedCount.incrementAndGet()
                        notifications.push(BackgroundNotification(id, BackgroundStatus.COMPLETED, "autonomous task $id completed"))
                    }
                }
                delay(delayMillis)
            }
        }
    }
    fun setEnabled(enabled: Boolean)   // /auto on|off
    fun isEnabled(): Boolean
    fun stop() / isRunning() / claimedCount() / completedCount() / tickIntervalMillis()
}

// AutoCommand.kt（节选）
override suspend fun execute(args: String, ctx: ReplContext): ReplCommandResult {
    return when (args.trim()) {
        "", "status" -> status(ctx)
        "on" -> { ctx.idleLoop.setEnabled(true); println("Autonomous agents: ON"); Continue }
        "off" -> { ctx.idleLoop.setEnabled(false); println("Autonomous agents: OFF"); Continue }
        "tasks" -> tasks(ctx)
        else -> { println("Unknown subcommand"); println(USAGE); Continue }
    }
}

private fun status(ctx: ReplContext): ReplCommandResult {
    val state = if (ctx.idleLoop.isEnabled()) "ON" else "OFF"
    println("Autonomous agents: $state (tick every ${ctx.idleLoop.tickIntervalMillis() / 1000}s)")
    println("  claimed: ${ctx.idleLoop.claimedCount()}  completed: ${ctx.idleLoop.completedCount()}")
    val ready = TaskScheduler.readyTasks(ctx.taskStore.loadAll()).filter { it.status == TaskStatus.PENDING }
    if (ready.isNotEmpty()) println("  ${ready.size} ready task(s) awaiting claim -- /auto tasks")
    return ReplCommandResult.Continue
}

private fun tasks(ctx: ReplContext): ReplCommandResult {
    val ready = TaskScheduler.readyTasks(ctx.taskStore.loadAll()).filter { it.status == TaskStatus.PENDING }
    val claims = ctx.autoClaimer.claims()
    if (ready.isEmpty() && claims.isEmpty()) { println("No ready tasks or active claims."); return Continue }
    ready.forEach { println("  ${it.id}  ${it.title}") }
    claims.forEach { (taskId, teammate) -> println("  $taskId -> $teammate") }
    return ReplCommandResult.Continue
}

// ReplLoop.kt
private val busy = AtomicBoolean(false)   // s17: 主 REPL 忙态门控
private lateinit var autoClaimer: AutoClaimer
private lateinit var idleLoop: IdleLoop
private lateinit var autoScope: CoroutineScope

// ReplLoop.start() 内，s15 team 设置之后：
autoScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
autoClaimer = AutoClaimer(taskStore, teamStore, messageBus)   // 复用 s12/s15 的 store
idleLoop = IdleLoop(
    autoClaimer = autoClaimer,
    notifications = notificationQueue,       // s13 通知队列
    shouldRun = { !busy.get() }              // 主 REPL 空闲门控
)
idleLoop.start(autoScope)

busy.set(true)
try {
    when {
        input.startsWith(COMMAND_PREFIX) -> { val c = handleCommand(input); if (!c) break }
        else -> handleChat(input)
    }
} finally {
    busy.set(false)
}

Step 1  用户 /task add t1 "调研符号表缓存" + /team spawn 研究员
        │ TaskStore.save(t1) → PENDING；teammate 消费协程跑完初始 prompt → IDLE
        ▼
Step 2  IdleLoop 后台 tick（主 REPL 空闲，busy=false，enabled=true）
        │ AutoClaimer.tick()（AutoClaimer.kt:52）
        │   ① 完成检测：无认领 → 跳过
        │   ② 就绪认领：t1(PENDING) → researcher(IDLE)
        │     ├─ tracker.assign("t1", "researcher")（ClaimTracker.kt:28）
        │     ├─ taskStore.update(t1 → IN_PROGRESS)
        │     └─ messageBus.send(TeamMessage("main", "researcher", "Autonomous task t1: …"))
        │   通知：🔔 auto - task t1 claimed
        ▼
Step 3  researcher 消费协程收到任务消息（resume）
        │   markRunning → loop.run("Autonomous task t1: 调研符号表缓存…") → markIdle
        │   researcher 处理完回到 IDLE
        ▼
Step 4  下一次 IdleLoop tick
        │ AutoClaimer.tick()
        │   ① 完成检测：t1→researcher，researcher 现在 IDLE → t1 COMPLETED
        │     ├─ taskStore.update(t1 → COMPLETED)
        │     └─ tracker.release("t1")
        │   通知：🔔 auto - task t1 completed
        ▼
Step 5  用户回来输入任意字符 → 回合间 drainNotifications()
        │   🔔 auto - task t1 claimed by researcher
        │   🔔 auto - task t1 completed by researcher
        ▼
Step 6  用户 /task list → t1 [COMPLETED]；/auto → ON, claimed: 1 completed: 1

# ── 用户离开前：建任务 + 派生队友 ──
> /task add t1 调研符号表缓存
Task created: t1
> /task add t2 实现哈希索引
Task created: t2
> /task add t3 跑基准测试
Task created: t3          ← t2 阻塞于 t1，t3 阻塞于 t2（依赖链）
> 派生一个研究员和一个审查员
🤖 spawn teammate 'researcher' ...
🤖 spawn teammate 'reviewer' ...
> /team
Team members (2):
  researcher  [IDLE]
  reviewer    [IDLE]
> /task list
Tasks (3):
  t1  [PENDING]   调研符号表缓存        ← 就绪
  t2  [PENDING]   实现哈希索引          ← BLOCKED by t1
  t3  [PENDING]   跑基准测试            ← BLOCKED by t2

# ── 用户走开。IdleLoop 每 10s tick 一次 ──
#    tick1: 就绪 t1 → researcher(IDLE) 认领
#    tick2: researcher 已 IDLE（处理完 t1）→ t1 COMPLETED；t2 就绪 → reviewer 认领
#    tick3: reviewer 完成 t2 → t2 COMPLETED；t3 就绪 → researcher 认领
#    tick4: researcher 完成 t3 → t3 COMPLETED

# ── 用户回来，输入任意字符，回合间 drain ──
> 今天进展如何？
🔔 auto - task t1 claimed by researcher
🔔 auto - task t1 completed by researcher
🔔 auto - task t2 claimed by reviewer
🔔 auto - task t2 completed by reviewer
🔔 auto - task t3 claimed by researcher
🔔 auto - task t3 completed by researcher
[Agent] 三号任务全部完成。依赖链 t1→t2→t3 已按顺序自动执行。

# ── 用户验收 ──
> /task list
Tasks (3):
  t1  [COMPLETED] 调研符号表缓存
  t2  [COMPLETED] 实现哈希索引
  t3  [COMPLETED] 跑基准测试
> /auto
Autonomous agents: ON (tick every 10s)
  claimed: 3 completed: 3
> /auto off
Autonomous agents: OFF

autonomous/                     （4 个新文件）
├── AutonomousConfig.kt         # tick 间隔/上限配置
├── ClaimTracker.kt             # 认领映射（taskId→teammate）
├── AutoClaimer.kt              # tick()：完成检测 + 就绪认领
└── IdleLoop.kt                 # 后台周期 tick + 开关 + 通知
repl/commands/AutoCommand.kt    # /auto 控制命令

main: ReplLoop.kt（busy 门控/autoScope/启动清理）、ReplCommand.kt（ReplContext +2）
test: AutoClaimerTest（+9）、IdleLoopTest（+5）、AutoCommandTest（+6）、
      ClaimTrackerTest（+7）、AutonomousConfigTest（+2）、
      TestTeamSupport（+2 字段）、6 个命令测试 ReplContext 补字段