dpc-tau 0.2.0

A minimal Unix-first coding agent.
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
151
152
153
154
155

//! Process-level regressions for tracing journals whose writer remains loaded.

mod support;

use std::path::PathBuf;
use std::process::Command;

use tau_core::AgentStore;
use tau_proto::{AgentCreator, AgentId, AgentStarted, Event};

/// Returns the bundled Tau binary under Cargo's integration-test contract.
fn tau_bin() -> PathBuf {
    std::env::var_os("CARGO_BIN_EXE_tau")
        .map(PathBuf::from)
        .expect("CARGO_BIN_EXE_tau")
}

/// Appends one durable creation fact while retaining the store's writer lease.
fn start_agent(
    store: &mut AgentStore,
    agent_id: &AgentId,
    creator: AgentCreator,
    parent_agent: Option<AgentId>,
) {
    store
        .append_agent_event(
            agent_id.as_str(),
            None,
            Event::AgentStarted(AgentStarted {
                agent_id: agent_id.clone(),
                creator: Some(creator),
                parent_agent,
                role: "trace-cli-test".to_owned(),
                display_name: None,
                metadata: Vec::new(),
                ephemeral: false,
            }),
        )
        .expect("agent start");
}

/// Runs the real CLI trace command against an externally held writer lock.
fn trace(root: &std::path::Path, agents_dir: &std::path::Path, agent_id: &AgentId) -> Vec<u8> {
    let output = support::isolated_tau_command(tau_bin(), root)
        .args([
            "agent",
            "trace",
            agent_id.as_str(),
            "--agents-dir",
            agents_dir.to_str().expect("UTF-8 fixture path"),
            "--format",
            "agent-performance-jsonl",
        ])
        .output()
        .expect("run tau agent trace");
    assert!(
        output.status.success(),
        "trace failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    output.stdout
}

/// A running target traces through its finite checkpoint and accepts later
/// work.
#[test]
fn cli_traces_running_agent_without_invalidating_writer() {
    let temp = tempfile::tempdir().expect("tempdir");
    let agents_dir = temp.path().join("agents");
    let agent_id = AgentId::parse("agent-running").expect("agent id");
    let mut store = AgentStore::open_fixture(&agents_dir).expect("store");
    start_agent(&mut store, &agent_id, AgentCreator::User, None);

    let output = trace(temp.path(), &agents_dir, &agent_id);
    let rows = String::from_utf8(output).expect("JSONL");
    assert_eq!(rows.lines().count(), 2, "finite header and summary");

    store
        .append_agent_event(
            agent_id.as_str(),
            None,
            Event::AgentDisplayNameSet(tau_proto::AgentDisplayNameSet {
                agent_id: agent_id.clone(),
                display_name: "later-work".to_owned(),
            }),
        )
        .expect("later routing/write survives");
}

/// A completed delegated worker remains traceable while both loaded leases and
/// descendant routing continue to work.
#[test]
fn cli_traces_completed_loaded_descendant_without_disrupting_parent() {
    let temp = tempfile::tempdir().expect("tempdir");
    let agents_dir = temp.path().join("agents");
    let parent = AgentId::parse("agent-parent").expect("parent id");
    let child = AgentId::parse("agent-completed-child").expect("child id");
    let session_id = tau_proto::SessionId::parse("trace-cli-session").expect("session id");
    let mut store = AgentStore::open_fixture(&agents_dir).expect("store");
    start_agent(&mut store, &parent, AgentCreator::User, None);
    start_agent(
        &mut store,
        &child,
        AgentCreator::Agent {
            agent_id: parent.clone(),
            session_id,
        },
        Some(parent.clone()),
    );
    store
        .append_agent_event(
            child.as_str(),
            None,
            Event::AgentDisplayNameSet(tau_proto::AgentDisplayNameSet {
                agent_id: child.clone(),
                display_name: "completed delegated worker".to_owned(),
            }),
        )
        .expect("completed worker's final durable fact");

    let output = Command::new(tau_bin())
        .args([
            "agent",
            "trace",
            parent.as_str(),
            "--include-descendants",
            "--agents-dir",
            agents_dir.to_str().expect("UTF-8 fixture path"),
            "--format",
            "tau-jsonl",
        ])
        .env_clear()
        .env("HOME", temp.path())
        .output()
        .expect("run descendant trace");
    assert!(
        output.status.success(),
        "trace failed: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    let rows = String::from_utf8(output.stdout).expect("JSONL");
    assert!(rows.contains(parent.as_str()));
    assert!(rows.contains(child.as_str()));

    store
        .append_agent_event(
            parent.as_str(),
            None,
            Event::AgentDisplayNameSet(tau_proto::AgentDisplayNameSet {
                agent_id: parent.clone(),
                display_name: "parent-still-routable".to_owned(),
            }),
        )
        .expect("parent later routing/write survives");
}