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

use crate::runtime::goal::agent::types::{
    GoalAgentDispatchPlan, GoalAgentTaskProposal, GoalAgentWaveKind,
};
use crate::runtime::goal::state::{
    GoalState, GOAL_AGENT_EXECUTE_TASK_ID, GOAL_AGENT_FOLLOWUPS_RUN_ID, GOAL_AGENT_VERIFY_TASK_ID,
};
use crate::runtime::goal::task_graph::{
    goal_task_done, pending_goal_agent_followup_proposals, GoalTaskGraph, GoalTaskStatus,
};

pub(crate) fn goal_agent_dispatch_plan(
    state: &GoalState,
    task_graph: &GoalTaskGraph,
) -> Option<GoalAgentDispatchPlan> {
    if state.slice_execution {
        return goal_agent_slice_dispatch_plan(state, task_graph, "");
    }
    goal_agent_dispatch_plan_with_run_key(state, task_graph, GOAL_AGENT_EXECUTE_TASK_ID)
}

/// Build a dispatch plan for a specific slice, using a slice-specific run key
/// so concurrent slice waves do not collide on worker directories.
///
/// When `slice_task_id` is empty, this finds the first not-done implement task
/// (or verify task if all implements are done) for serial dispatch.
pub(crate) fn goal_agent_slice_dispatch_plan(
    state: &GoalState,
    task_graph: &GoalTaskGraph,
    slice_task_id: &str,
) -> Option<GoalAgentDispatchPlan> {
    // If a specific slice task id is provided, return its proposal directly.
    if !slice_task_id.is_empty() {
        let task = task_graph.tasks.iter().find(|t| t.id == slice_task_id)?;
        let run_key = if slice_task_id.starts_with("goal-agent-implement-") {
            slice_task_id.to_string()
        } else {
            format!("{}-{}", GOAL_AGENT_EXECUTE_TASK_ID, slice_task_id)
        };
        return Some(GoalAgentDispatchPlan {
            run_key,
            kind: GoalAgentWaveKind::Initial,
            proposals: vec![super::proposal_from_task(state, task)],
            allow_existing_task_ids: true,
        });
    }

    // Serial slice dispatch: find first not-done implement task.
    for task in &task_graph.tasks {
        if task.id.starts_with("goal-agent-implement-") && task.status != GoalTaskStatus::Done {
            return Some(GoalAgentDispatchPlan {
                run_key: task.id.clone(),
                kind: GoalAgentWaveKind::Initial,
                proposals: vec![super::proposal_from_task(state, task)],
                allow_existing_task_ids: true,
            });
        }
    }

    // All implements done — dispatch verify if not done.
    if let Some(verify_task) = task_graph
        .tasks
        .iter()
        .find(|t| t.id == GOAL_AGENT_VERIFY_TASK_ID && t.status != GoalTaskStatus::Done)
    {
        return Some(GoalAgentDispatchPlan {
            run_key: GOAL_AGENT_VERIFY_TASK_ID.to_string(),
            kind: GoalAgentWaveKind::Initial,
            proposals: vec![super::proposal_from_task(state, verify_task)],
            allow_existing_task_ids: true,
        });
    }

    // Follow-ups
    let proposals = pending_goal_agent_followup_proposals(task_graph);
    (!proposals.is_empty()).then(|| GoalAgentDispatchPlan {
        run_key: GOAL_AGENT_FOLLOWUPS_RUN_ID.to_string(),
        kind: GoalAgentWaveKind::FollowUp,
        proposals,
        allow_existing_task_ids: true,
    })
}

fn goal_agent_dispatch_plan_with_run_key(
    state: &GoalState,
    task_graph: &GoalTaskGraph,
    run_key: &str,
) -> Option<GoalAgentDispatchPlan> {
    if !goal_task_done(task_graph, GOAL_AGENT_EXECUTE_TASK_ID) {
        return Some(GoalAgentDispatchPlan {
            run_key: run_key.to_string(),
            kind: GoalAgentWaveKind::Initial,
            proposals: super::propose_goal_agent_tasks(state),
            allow_existing_task_ids: false,
        });
    }

    let proposals = pending_goal_agent_followup_proposals(task_graph);
    (!proposals.is_empty()).then(|| GoalAgentDispatchPlan {
        // Use the original follow-up run key when this is the default plan;
        // only suffix for slice-specific plans so worker directories stay
        // predictable for existing tests and non-slice callers.
        run_key: if run_key == GOAL_AGENT_EXECUTE_TASK_ID {
            GOAL_AGENT_FOLLOWUPS_RUN_ID.to_string()
        } else {
            format!("{}-{}", GOAL_AGENT_FOLLOWUPS_RUN_ID, run_key)
        },
        kind: GoalAgentWaveKind::FollowUp,
        proposals,
        allow_existing_task_ids: true,
    })
}

pub(crate) fn proposal_from_task(
    state: &GoalState,
    task: &crate::runtime::goal::task_graph::GoalTask,
) -> GoalAgentTaskProposal {
    GoalAgentTaskProposal {
        id: task.id.clone(),
        title: task.title.clone(),
        description: task.description.clone(),
        dependencies: task.dependencies.clone(),
        read_set: task.read_set.clone(),
        write_set: task.write_set.clone(),
        risk: task.risk.clone(),
        acceptance: task.acceptance.clone(),
        budget_secs: crate::runtime::goal::state::goal_agent_task_budget_secs(state, 900),
        priority: if task.id.starts_with("goal-agent-implement-") {
            20
        } else {
            10
        },
    }
}