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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use serde::{Deserialize, Serialize};

/// A curated role pack defines agent behavior, default tools, and skill bundles.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RolePack {
    pub id: String,
    pub name: String,
    pub description: String,
    pub system_prompt: String,
    pub tools: Vec<String>,
    pub default_skills: Vec<String>,
    pub suggested_worker_count: usize,
}

impl RolePack {
    /// All built-in role packs.
    pub fn all() -> Vec<Self> {
        vec![
            Self::architect(),
            Self::executor(),
            Self::verifier(),
            Self::reviewer(),
            Self::integrator(),
        ]
    }

    pub fn architect() -> Self {
        Self {
            id: "architect".to_string(),
            name: "Architect".to_string(),
            description: "Kimi-native architecture role for boundaries, APIs, and ADR-quality design decisions."
                .to_string(),
            system_prompt: include_str!("../../.kimi/agents/architect/system.md").to_string(),
            tools: vec!["read".to_string(), "write".to_string(), "ask".to_string()],
            default_skills: vec!["architect".to_string()],
            suggested_worker_count: 1,
        }
    }

    pub fn executor() -> Self {
        Self {
            id: "executor".to_string(),
            name: "Executor".to_string(),
            description: "Kimi-native implementation role for focused delivery with tests and anti-slop discipline."
                .to_string(),
            system_prompt: include_str!("../../.kimi/agents/executor/system.md").to_string(),
            tools: vec!["read".to_string(), "write".to_string(), "shell".to_string(), "test".to_string()],
            default_skills: vec!["backend".to_string(), "qa".to_string()],
            suggested_worker_count: 2,
        }
    }

    pub fn verifier() -> Self {
        Self {
            id: "verifier".to_string(),
            name: "Verifier".to_string(),
            description: "Kimi-native verification role for evidence-first gates, regression checks, and proof quality."
                .to_string(),
            system_prompt: include_str!("../../.kimi/agents/verifier/system.md").to_string(),
            tools: vec!["read".to_string(), "shell".to_string(), "test".to_string()],
            default_skills: vec!["qa".to_string()],
            suggested_worker_count: 1,
        }
    }

    pub fn reviewer() -> Self {
        Self {
            id: "reviewer".to_string(),
            name: "Reviewer".to_string(),
            description: "Kimi-native review role for correctness, risk discovery, and actionable feedback before merge."
                .to_string(),
            system_prompt: include_str!("../../.kimi/agents/reviewer/system.md").to_string(),
            tools: vec!["read".to_string(), "ask".to_string()],
            default_skills: vec!["security-review".to_string()],
            suggested_worker_count: 1,
        }
    }

    pub fn integrator() -> Self {
        Self {
            id: "integrator".to_string(),
            name: "Integrator".to_string(),
            description: "Kimi-native release role for safe integration, CI gates, and release readiness checks."
                .to_string(),
            system_prompt: include_str!("../../.kimi/agents/integrator/system.md").to_string(),
            tools: vec!["shell".to_string(), "read".to_string(), "write".to_string()],
            default_skills: vec!["devops".to_string()],
            suggested_worker_count: 1,
        }
    }

    pub fn find(id: &str) -> Option<Self> {
        Self::all().into_iter().find(|r| r.id == id)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_role_pack_all_has_5_roles() {
        let roles = RolePack::all();
        assert_eq!(roles.len(), 5);
    }

    #[test]
    fn test_role_pack_find_architect() {
        let pack = RolePack::find("architect");
        assert!(pack.is_some());
        let pack = pack.unwrap();
        assert_eq!(pack.id, "architect");
        assert_eq!(pack.name, "Architect");
        assert_eq!(pack.suggested_worker_count, 1);
    }

    #[test]
    fn test_role_pack_find_unknown_returns_none() {
        let pack = RolePack::find("nonexistent");
        assert!(pack.is_none());
    }

    #[test]
    fn test_executor_has_test_tool() {
        let pack = RolePack::find("executor").unwrap();
        assert!(pack.tools.contains(&"test".to_string()));
    }

    #[test]
    fn test_every_role_prompt_includes_hierarchy_and_anti_slop_guards() {
        let roles = RolePack::all();
        for role in roles {
            assert!(
                role.system_prompt.contains("Instruction Hierarchy"),
                "{} prompt must define instruction hierarchy",
                role.id
            );
            assert!(
                role.system_prompt.contains("AGENTS.md"),
                "{} prompt must mention AGENTS.md hierarchy",
                role.id
            );
            assert!(
                role.system_prompt.contains("Anti-Slop"),
                "{} prompt must include anti-slop discipline",
                role.id
            );
            assert!(
                role.system_prompt.contains("Review Discipline"),
                "{} prompt must include review discipline",
                role.id
            );
        }
    }
}