omk 0.5.0

A Rust runtime for Kimi CLI. Turns prompts into proof-backed engineering runs with gates, worktrees, and replay.
Documentation 
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
138

use std::sync::Arc;
use tokio::sync::broadcast;

pub use crate::runtime::classifier::Intent;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ActiveMode {
    Idle,
    DirectLlm,
    WireWorker,
    PlannerWorkers,
    GoalRun,
}

#[derive(Debug, Clone)]
pub struct Preflight {
    pub kind: PreflightKind,
    pub headline: String,
    pub timeout_ms: u32,
    pub ticket_id: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PreflightKind {
    LargeEscalation,
    MediumLowConfidence,
    SmallOverProtectedPath,
    SmallOverManyFiles,
    QueueLargeOnActiveLarge,
    QueueMediumAtConcurrencyCap,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PreflightAction {
    Accept,
    Explain,
    Downgrade,
    Cancel,
    Timeout,
}

#[derive(Debug, Clone)]
pub enum BusEvent {
    ClassifierDecided {
        intent: Intent,
        confidence: f32,
        latency_ms: u32,
        reasoning: String,
        cached: bool,
        fallback: bool,
    },
    RouterEscalating {
        intent: Intent,
        target_mode: ActiveMode,
        preflight: bool,
    },
    WorkerStarted {
        worker_id: String,
        kind: String,
        task: String,
    },
    WorkerProgress {
        worker_id: String,
        percent: Option<f32>,
        message: Option<String>,
    },
    WorkerCompleted {
        worker_id: String,
        files_touched: u32,
        ok: bool,
    },
    ChildGoalCreated {
        goal_id: String,
        parent_conv_id: String,
        plan: Vec<String>,
    },
    ChildGoalEvent {
        goal_id: String,
        event: crate::runtime::goal::chat_api::ChildGoalEvent,
    },
    CostDelta {
        source: String,
        tokens_in: u32,
        tokens_out: u32,
        usd: f32,
    },
    PreflightRequest(Preflight),
    PreflightResponse(PreflightAction),
    /// Router would have prompted user (preflight kind matched)
    /// but is operating in autonomous mode. The dispatch proceeds
    /// as if Accept was received. Emitted for observability and
    /// session escalation log; UI/listeners can render a marker.
    AutonomousProceed {
        kind: PreflightKind,
        intent: Intent,
        confidence: f32,
        reasoning: String,
    },
    DisclosureLine(String),
    Refused {
        reason: String,
        intent: Intent,
    },
    CostSoftCapWarning {
        current_usd: f32,
        soft_cap_usd: f32,
    },
}

#[derive(Debug)]
pub struct EventBus {
    tx: broadcast::Sender<BusEvent>,
}

impl EventBus {
    pub fn new() -> Self {
        let (tx, _rx) = broadcast::channel(1024);
        Self { tx }
    }

    pub fn subscribe(&self) -> broadcast::Receiver<BusEvent> {
        self.tx.subscribe()
    }

    pub fn publish(&self, ev: BusEvent) {
        let _ = self.tx.send(ev);
    }

    pub fn arc(self) -> Arc<Self> {
        Arc::new(self)
    }
}

impl Default for EventBus {
    fn default() -> Self {
        Self::new()
    }
}