ai-dispatch 10.40.0

Multi-AI CLI team orchestrator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Pure demo tick logic — advances running missions, completes/loses on schedule.
// Exports: DemoTickEngine.

import Foundation

enum DemoTickEngine {
    static let completeInterval = 13
    static let failInterval = 29

    struct Result: Sendable {
        var snapshot: FleetSnapshot
        var toasts: [ToastEvent]
        var xpAwards: [(MissionDisplayState, Int)]
    }

    static func tick(_ snapshot: FleetSnapshot, xpPayload: Int = 140) -> Result {
        var sectors = snapshot.sectors
        var toasts: [ToastEvent] = []
        var xpAwards: [(MissionDisplayState, Int)] = []
        let tick = snapshot.tick + 1
        let medians = ProgressDeriver.medianDurations(from: sectors)

        for sIdx in sectors.indices {
            for mIdx in sectors[sIdx].missions.indices {
                var mission = sectors[sIdx].missions[mIdx]
                guard mission.state == .run else { continue }
                mission = advanceRunning(mission, medians: medians)
                sectors[sIdx].missions[mIdx] = mission
            }
        }

        if tick % completeInterval == 0, let loc = firstRunning(in: sectors) {
            sectors[loc.s].missions[loc.m] = finish(
                sectors[loc.s].missions[loc.m], state: .done
            )
            let mission = sectors[loc.s].missions[loc.m]
            toasts.append(toast(for: mission, xp: xpPayload))
            xpAwards.append((.done, xpPayload))
        }

        if tick % failInterval == 0, let loc = lastRunning(in: sectors) {
            sectors[loc.s].missions[loc.m] = finish(
                sectors[loc.s].missions[loc.m], state: .fail
            )
            let mission = sectors[loc.s].missions[loc.m]
            toasts.append(toast(for: mission, xp: 20))
            xpAwards.append((.fail, 20))
        }

        var summary = snapshot.summary
        summary.running = countState(.run, in: sectors)
        summary.done = countState(.done, in: sectors)
        summary.failed = countState(.fail, in: sectors)

        let updated = FleetSnapshot(
            sectors: sectors,
            summary: summary,
            serverVersion: snapshot.serverVersion,
            connection: snapshot.connection,
            agents: DemoAgents.roster(from: sectors),
            tick: tick
        )
        return Result(snapshot: updated, toasts: toasts, xpAwards: xpAwards)
    }

    private struct Loc: Equatable { let s: Int; let m: Int }

    private static func advanceRunning(_ mission: Mission, medians: [String: [Int]]) -> Mission {
        let elapsed = mission.elapsedSeconds + 1
        let progress = ProgressDeriver.progress(
            elapsedSeconds: elapsed,
            agent: mission.agent,
            completedDurations: medians
        )
        return Mission(
            id: mission.id,
            title: mission.title,
            agent: mission.agent,
            model: mission.model,
            state: mission.state,
            threat: mission.threat,
            progress: progress,
            elapsedSeconds: elapsed,
            startedAt: mission.startedAt ?? Date().addingTimeInterval(TimeInterval(-elapsed)),
            tokens: mission.tokens,
            cost: mission.cost,
            memoryMB: mission.memoryMB,
            verifyTag: mission.verifyTag,
            awaitingReason: mission.awaitingReason
        )
    }

    private static func finish(_ mission: Mission, state: MissionDisplayState) -> Mission {
        Mission(
            id: mission.id,
            title: mission.title,
            agent: mission.agent,
            model: mission.model,
            state: state,
            threat: mission.threat,
            progress: state == .done ? 1 : mission.progress,
            elapsedSeconds: mission.elapsedSeconds,
            startedAt: nil,
            tokens: mission.tokens,
            cost: mission.cost,
            memoryMB: mission.memoryMB,
            verifyTag: mission.verifyTag,
            awaitingReason: mission.awaitingReason
        )
    }

    private static func firstRunning(in sectors: [Sector]) -> Loc? {
        for (s, sector) in sectors.enumerated() {
            if let m = sector.missions.firstIndex(where: { $0.state == .run }) {
                return Loc(s: s, m: m)
            }
        }
        return nil
    }

    private static func lastRunning(in sectors: [Sector]) -> Loc? {
        for (s, sector) in sectors.enumerated().reversed() {
            if let m = sector.missions.lastIndex(where: { $0.state == .run }) {
                return Loc(s: s, m: m)
            }
        }
        return nil
    }

    private static func toast(for mission: Mission, xp: Int) -> ToastEvent {
        ToastEvent(id: UUID(), missionID: mission.id, title: mission.title, state: mission.state, xpAward: xp)
    }

    private static func countState(_ state: MissionDisplayState, in sectors: [Sector]) -> Int {
        sectors.flatMap(\.missions).filter { $0.state == state }.count
    }
}