artifactize 0.10.1

The AI-native collaboration layer for one-of-a-kind teammates and their agents: split a project into Artifacts with their own evals, and reuse every review while it still holds.
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

//! Opt-in fixture driven by the scratch PTY harness, never a model or default state.
use super::*;
use crate::agent::session::{self as saved, Answer, Header, Kind, Recorder, Saving};
use serde_json::json;
use std::fs;

#[tokio::test]
#[ignore = "requires the external fixture PTY harness"]
async fn live_session_pty_fixture() {
    let Some(path) = crate::platform::environment::var("ARTIFACTIZE_LIVE_PTY_FIXTURE") else {
        return;
    };
    let root = std::path::PathBuf::from(path);
    let repo = root.join("repo");
    let state = root.join("state");
    fs::create_dir_all(&repo).unwrap();
    let receipts = store::Receipts::open(&state, &repo).await.unwrap();
    let run: store::Run = serde_json::from_value(json!({
        "id":"fixture-run",
        "repoPath":repo,
        "stateDir":state,
        "status":"RUNNING",
        "createdAt":"2026-01-01T00:00:00Z",
        "selection":{"kind":"all"},
        "validation":null,
        "definitions":{
            "artifacts":{"app":{"path":""}},
            "evals":[
                {
                    "id":"app/check",
                    "target":"app",
                    "deps":[],
                    "declaration":{
                        "title":"Fixture Agent",
                        "profile":{"kind":"agent","backend":"openai","model":"fixture"},
                        "payload":{"instruction":"fixture"},
                    },
                },
                {
                    "id":"app/runtime",
                    "target":"app",
                    "deps":[],
                    "declaration":{
                        "title":"Fixture Runtime",
                        "profile":{"kind":"runtime","command":crate::test_os::true_program(),"args":[]},
                        "payload":{"instruction":"fixture"},
                    },
                },
            ],
        },
    }))
    .unwrap();
    let mut view = tests::request(
        "app/check",
        "RUNNING",
        json!({
            "profile":{"kind":"agent","backend":"openai","model":"fixture"},
            "sessionId":"fixture-session",
        }),
    );
    view.request.run_id = run.id.clone();
    let mut runtime = tests::request(
        "app/runtime",
        "GREEN",
        json!({
            "completedAt":"2026-01-01T00:01:00Z",
            "result":{"verdict":"GREEN","exitCode":0,"stdout":"other modal unaffected","stderr":""},
        }),
    );
    runtime.request.run_id = run.id.clone();
    receipts
        .create_run(&run, &[view.request.clone(), runtime.request.clone()])
        .await
        .unwrap();
    let saving = Saving {
        state: state.clone(),
        state_id: receipts.state_id().await.unwrap(),
        producer: store::Producer::current().name.parse().unwrap(),
    };
    let mut recorder = Recorder::new(
        Some(&saving),
        &view.request,
        &"fixture-session".parse().unwrap(),
    );
    recorder.start(Header::default());
    for n in 0..80 {
        recorder.event(Kind::Answer(Answer::Completed(format!(
            "initial row {n} 한글 e\u{301}"
        ))));
    }
    view.request.session = recorder.reference().cloned();
    receipts.save_request(&view.request).await.unwrap();
    let cancellation = tokio_util::sync::CancellationToken::new();
    let control = root.clone();
    let token = cancellation.clone();
    let writer = tokio::spawn(async move {
        fs::write(control.join("ready"), "ready").unwrap();
        loop {
            if control.join("quit").exists() {
                token.cancel();
                break;
            }
            if let Ok(text) = fs::read_to_string(control.join("delivery")) {
                let _ = fs::remove_file(control.join("delivery"));
                let delivery: saved::Delivery = serde_json::from_str(&text).unwrap();
                recorder.event(Kind::Delivery(delivery));
                crate::changes::drain().await;
                fs::write(control.join("delivered"), "flushed and notified").unwrap();
            }
            if let Ok(text) = fs::read_to_string(control.join("append")) {
                let _ = fs::remove_file(control.join("append"));
                recorder.event(Kind::Answer(Answer::Completed(text)));
                crate::changes::drain().await;
                fs::write(control.join("appended"), "flushed and notified").unwrap();
            }
            tokio::time::sleep(std::time::Duration::from_millis(20)).await;
        }
    });
    terminal::run(state, None, cancellation).await.unwrap();
    fs::write(root.join("quit"), "quit").unwrap();
    writer.await.unwrap();
    assert!(
        saved::path(&saving.state, "fixture-session")
            .unwrap()
            .exists()
    );
}