ccsm 0.17.0

Context-managed session orchestration for AI coding agents — track, resume, and manage work across sessions
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

//! Integration tests: ccsm sequence (batch mutations).

mod common;
use common::*;

#[test]
fn sequence_new_start_complete() {
    ensure_built();
    let ws = TempWorkspace::new();

    let out = ws.run_ok(&[
        "sequence",
        "-q", "new", "seq-test", "batch goal",
        "-q", "start", "seq-test",
        "-q", "scope", "seq-test", "batch approach",
        "-q", "tag", "seq-test", "batch", "test",
        "-q", "complete", "seq-test",
    ]);
    assert!(out.contains("created"), "seq new: {}", out);
    assert!(out.contains("start"), "seq start: {}", out);
    assert!(out.contains("complete"), "seq complete: {}", out);

    let reg = ws.read_registry();
    let entry = reg["sessions"]
        .as_array()
        .unwrap()
        .iter()
        .find(|s| s["name"] == "seq-test")
        .unwrap();
    assert_eq!(entry["status"], "completed");
    assert_eq!(entry["goal"], "batch goal");
    assert_eq!(entry["scope"], "batch approach");
}

#[test]
fn sequence_trash_recover() {
    ensure_built();
    let ws = TempWorkspace::new();

    // New → Start → Trash → Recover in one sequence
    ws.run_ok(&[
        "sequence",
        "-q", "new", "seq-trash", "test",
        "-q", "start", "seq-trash",
        "-q", "trash", "seq-trash",
        "-q", "recover", "seq-trash",
    ]);

    let reg = ws.read_registry();
    let entry = reg["sessions"]
        .as_array()
        .unwrap()
        .iter()
        .find(|s| s["name"] == "seq-trash")
        .unwrap();
    assert_eq!(entry["status"], "in_progress");
}

#[test]
fn sequence_blocks_duplicate() {
    ensure_built();
    let ws = TempWorkspace::new();

    let err = ws.run_err(&[
        "sequence",
        "-q", "new", "dup", "first",
        "-q", "new", "dup", "second",
    ]);
    assert!(err.contains("already exists"), "duplicate: {}", err);
}

#[test]
fn sequence_empty_is_error() {
    ensure_built();
    let ws = TempWorkspace::new();

    // No args after subcommand — clap catches this as a required args error
    let out = ws.run(&["sequence"]);
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(stderr.contains("required"), "empty seq: {}", stderr);
}