carryctx 0.4.2

Local-first memory for coding agents — resume tasks, checkpoints, and context across windows, sessions, and worktrees.
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

mod common;

#[test]
fn test_checkpoint_create_and_list() {
    let (dir, bin) = common::setup_test_project("checkpoint_test");
    common::run_cmd(&dir, &bin, &["init", "--force", "--task-prefix", "CK"]);
    common::run_cmd(
        &dir,
        &bin,
        &[
            "agent",
            "register",
            "--name",
            "tester",
            "--provider",
            "test",
        ],
    );
    common::run_cmd(
        &dir,
        &bin,
        &["task", "create", "--title", "Checkpoint test task"],
    );

    // Create checkpoint
    let cp = common::run_cmd(
        &dir,
        &bin,
        &[
            "checkpoint",
            "--task",
            "CK-0001",
            "--done",
            "First item",
            "--remaining",
            "Second item",
            "--json",
        ],
    );
    assert!(cp.status.success(), "checkpoint create should succeed");
    let stdout = String::from_utf8_lossy(&cp.stdout);
    assert!(
        stdout.contains("First item"),
        "checkpoint should contain done items"
    );

    // List checkpoints
    let list = common::run_cmd(&dir, &bin, &["checkpoint", "list", "--json"]);
    assert!(list.status.success(), "checkpoint list should succeed");
    let stdout = String::from_utf8_lossy(&list.stdout);
    assert!(
        stdout.contains("First item"),
        "list should contain checkpoint"
    );
}

/// Requires the `jj` binary on PATH. Not run by default in `cargo test`
/// (no CI guarantee jj is installed); run explicitly with
/// `cargo test --test checkpoint_test -- --ignored`.
///
/// Verifies Phase 2 of carryctx-docs/plans/2026-07-25-jujutsu-compatibility.md:
/// under a jj-colocated repo, `checkpoint` reports `vcs_backend: "jj"`, the
/// staged/modified/untracked three-way split is empty (jj's auto-snapshotting
/// makes it meaningless), and `changed_files`/`dirty` stay accurate.
#[test]
#[ignore]
fn test_checkpoint_jj_colocation_reports_backend_and_changed_files() {
    let (dir, bin) = common::setup_test_project("checkpoint_jj_test");

    let jj_init = std::process::Command::new("jj")
        .args(["git", "init", "--colocate"])
        .current_dir(&dir)
        .output()
        .expect("jj binary must be on PATH to run this test");
    assert!(
        jj_init.status.success(),
        "jj git init --colocate failed: {}",
        String::from_utf8_lossy(&jj_init.stderr)
    );

    common::run_cmd(&dir, &bin, &["init", "--force", "--task-prefix", "JJ"]);
    common::run_cmd(
        &dir,
        &bin,
        &[
            "agent",
            "register",
            "--name",
            "tester",
            "--provider",
            "test",
        ],
    );
    common::run_cmd(&dir, &bin, &["task", "create", "--title", "jj test task"]);

    std::fs::write(dir.join("tracked.txt"), "hello\n").unwrap();

    let cp = common::run_cmd(
        &dir,
        &bin,
        &[
            "checkpoint",
            "--task",
            "JJ-0001",
            "--done",
            "wrote a file",
            "--json",
        ],
    );
    assert!(cp.status.success(), "checkpoint create should succeed");
    let stdout = String::from_utf8_lossy(&cp.stdout);
    let value: serde_json::Value = serde_json::from_str(&stdout).expect("valid JSON");
    let data = &value["data"];

    assert_eq!(data["vcs_backend"], "jj", "vcs_backend should report jj");
    assert_eq!(
        data["dirty"], true,
        "repo has an untracked file, dirty must be true"
    );
    assert_eq!(
        data["staged_files"].as_array().unwrap().len(),
        0,
        "staged_files must be empty under jj colocation"
    );
    assert_eq!(
        data["modified_files"].as_array().unwrap().len(),
        0,
        "modified_files must be empty under jj colocation"
    );
    assert_eq!(
        data["untracked_files"].as_array().unwrap().len(),
        0,
        "untracked_files must be empty under jj colocation"
    );
    let changed = data["changed_files"].as_array().unwrap();
    assert!(
        changed.iter().any(|f| f == "tracked.txt"),
        "changed_files must still list the new file: {changed:?}"
    );
}