cueloop 0.4.1

A Rust CLI for managing AI agent loops with a structured JSON task queue
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

//! Regression coverage for machine task command parsing helpers.
//!
//! Purpose:
//! - Regression coverage for machine task command parsing helpers.
//!
//! Responsibilities:
//! - Validate supported status parsing.
//! - Validate supported child-policy parsing.
//!
//! Not handled here:
//! - Machine task write workflows.
//! - Queue mutation/decomposition integration.
//!
//!
//! Usage:
//! - Used through the crate module tree or integration test harness.
//!
//! Invariants/assumptions:
//! - Parsing remains case-insensitive for supported values.
//! - Unsupported values continue to fail fast.

use super::{build_decompose_document, parse_child_policy, parse_task_status};
use crate::commands::task::{
    DecompositionChildPolicy, DecompositionPlan, DecompositionPreview,
    DecompositionPreviewCheckpointRef, DecompositionSource, PlannedNode,
};
use crate::contracts::{BlockingReason, TaskStatus};

#[test]
fn parse_task_status_accepts_supported_values_case_insensitively() {
    assert_eq!(
        parse_task_status("ToDo").expect("todo status"),
        TaskStatus::Todo
    );
    assert_eq!(
        parse_task_status("done").expect("done status"),
        TaskStatus::Done
    );
}

#[test]
fn parse_task_status_rejects_unknown_values() {
    assert!(parse_task_status("later").is_err());
}

#[test]
fn parse_child_policy_accepts_supported_values_case_insensitively() {
    assert_eq!(
        parse_child_policy("Append").expect("append child policy"),
        DecompositionChildPolicy::Append
    );
}

#[test]
fn parse_child_policy_rejects_unknown_values() {
    assert!(parse_child_policy("merge").is_err());
}

#[test]
fn preview_continuation_uses_exact_checkpoint_command_without_ellipsis() {
    let preview = test_preview(Vec::new());
    let checkpoint = test_checkpoint();
    let document = build_decompose_document(&preview, None, Some(&checkpoint));
    let commands = document
        .continuation
        .next_steps
        .iter()
        .map(|step| step.command.as_str())
        .collect::<Vec<_>>();
    assert_eq!(
        commands,
        vec!["cueloop machine task decompose --write --from-preview dp-test-123"]
    );
    assert!(commands.iter().all(|command| !command.contains("...")));
}

#[test]
fn blocked_preview_continuation_has_no_placeholder_ellipsis() {
    let preview = test_preview(vec!["Parent already has children".to_string()]);
    let checkpoint = test_checkpoint();
    let document = build_decompose_document(&preview, None, Some(&checkpoint));
    let commands = document
        .continuation
        .next_steps
        .iter()
        .map(|step| step.command.as_str())
        .collect::<Vec<_>>();
    assert!(
        commands.contains(&"cueloop machine task decompose --write --from-preview dp-test-123")
    );
    assert!(commands.iter().all(|command| !command.contains("...")));
    let suggested = match &document.blocking.as_ref().expect("blocking state").reason {
        BlockingReason::OperatorRecovery {
            suggested_command, ..
        } => suggested_command.as_deref().expect("suggested command"),
        other => panic!("unexpected blocking reason: {other:?}"),
    };
    assert!(!suggested.contains("..."));
}

fn test_checkpoint() -> DecompositionPreviewCheckpointRef {
    DecompositionPreviewCheckpointRef {
        id: "dp-test-123".to_string(),
        path: ".cueloop/cache/decompose-previews/dp-test-123.json".to_string(),
        created_at: "2026-04-30T00:00:00Z".to_string(),
        expires_at: "2026-05-07T00:00:00Z".to_string(),
    }
}

fn test_preview(write_blockers: Vec<String>) -> DecompositionPreview {
    DecompositionPreview {
        source: DecompositionSource::Freeform {
            request: "Ship auth".to_string(),
        },
        attach_target: None,
        plan: DecompositionPlan {
            root: PlannedNode {
                planner_key: "root".to_string(),
                title: "Ship auth".to_string(),
                description: None,
                plan: vec![],
                tags: vec![],
                scope: vec![],
                depends_on_keys: vec![],
                children: vec![PlannedNode {
                    planner_key: "leaf".to_string(),
                    title: "Wire login".to_string(),
                    description: None,
                    plan: vec![],
                    tags: vec![],
                    scope: vec![],
                    depends_on_keys: vec![],
                    children: vec![],
                    dependency_refs: vec![],
                }],
                dependency_refs: vec![],
            },
            warnings: vec![],
            total_nodes: 2,
            leaf_nodes: 1,
            dependency_edges: vec![],
        },
        write_blockers,
        child_status: TaskStatus::Draft,
        parent_status: TaskStatus::Draft,
        leaf_status: TaskStatus::Draft,
        child_policy: DecompositionChildPolicy::Fail,
        with_dependencies: false,
    }
}