yardlet 0.7.0

Yardlet: a local AI workbench. Plan, queue, route, validate, and hand off long-running work using your already-installed Codex and Claude Code CLIs as hidden workers.
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

//! Compact checkpoint + handoff writers.
//!
//! Yardlet must not rely on chat history as memory. At task/cycle boundaries it
//! compacts into durable artifacts that the next run can start from.

use std::path::Path;

use anyhow::Result;

use crate::evaluator::Evaluation;
use crate::schemas::{RunResult, Task};
use crate::state::write_str;

/// Write `checkpoint.md` for a run: short enough to feed into the next cycle.
pub fn write_checkpoint(
    run_dir: &Path,
    task: &Task,
    eval: &Evaluation,
    result: Option<&RunResult>,
    intent_summary: &str,
) -> Result<()> {
    let mut md = String::new();
    md.push_str("# Checkpoint\n\n");
    md.push_str(&format!(
        "- Intent: {}\n",
        non_empty(intent_summary, "(none yet)")
    ));
    md.push_str(&format!("- Task: {} {}\n", task.id, task.title));
    md.push_str(&format!("- Run: {}\n", eval.run_id));
    md.push_str(&format!("- Result status: {}\n", eval.status));
    md.push_str(&format!("- Next task state: {:?}\n", eval.next_task_state));

    if let Some(r) = result {
        let changed = r.changes.files_modified.len()
            + r.changes.files_created.len()
            + r.changes.files_deleted.len();
        md.push_str(&format!("- Changed files: {changed}\n"));
        md.push_str(&format!(
            "- Validation: {}\n",
            if r.validation.passed {
                "passed"
            } else {
                "not passed / not run"
            }
        ));
        md.push_str(&format!(
            "- Completed: {}\n",
            non_empty(&r.compact_summary, "(no summary)")
        ));
        if let Some(q) = &r.question_for_user {
            md.push_str(&format!("- Blockers / question: {q}\n"));
        }
    }

    md.push_str("- Must-read anchors:\n");
    md.push_str("  - .agents/intent-contract.yaml\n");
    md.push_str("  - .agents/work-queue.yaml\n");
    md.push_str(&format!("  - {}/result.json\n", run_dir.display()));

    write_str(&run_dir.join("checkpoint.md"), &md)?;
    Ok(())
}

/// Write `handoff.md` for humans and future workers.
pub fn write_handoff(
    run_dir: &Path,
    task: &Task,
    eval: &Evaluation,
    result: Option<&RunResult>,
) -> Result<()> {
    let mut md = String::new();
    md.push_str(&format!("# Handoff: {} {}\n\n", task.id, task.title));
    md.push_str(&format!(
        "Run `{}` finished with status **{}**.\n\n",
        eval.run_id, eval.status
    ));

    md.push_str("## Evaluator checks\n\n");
    for c in &eval.checks {
        md.push_str(&format!(
            "- [{}] {} — {}\n",
            if c.passed { "x" } else { " " },
            c.name,
            c.note
        ));
    }
    md.push('\n');

    if let Some(r) = result {
        md.push_str("## What changed\n\n");
        for f in &r.changes.files_created {
            md.push_str(&format!("- created `{f}`\n"));
        }
        for f in &r.changes.files_modified {
            md.push_str(&format!("- modified `{f}`\n"));
        }
        for f in &r.changes.files_deleted {
            md.push_str(&format!("- deleted `{f}`\n"));
        }
        md.push('\n');
        if !r.compact_summary.is_empty() {
            md.push_str(&format!("## Summary\n\n{}\n\n", r.compact_summary));
        }
        if let Some(q) = &r.question_for_user {
            md.push_str(&format!("## Needs user input\n\n{q}\n\n"));
        }
    }

    md.push_str(&format!(
        "## Next task state\n\n{:?}\n",
        eval.next_task_state
    ));

    write_str(&run_dir.join("handoff.md"), &md)?;
    Ok(())
}

fn non_empty<'a>(s: &'a str, fallback: &'a str) -> &'a str {
    if s.trim().is_empty() {
        fallback
    } else {
        s
    }
}