lernie 0.0.11

A git-backed agent harness
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

//! The retarget mark is consumed **by the agent's own executor, at a step
//! boundary** (ARCH §2.2, §2.3) — the claim the whole design rests on,
//! proven here against a real workspace by driving one `lernie advance`
//! hop over a marked branch.
//!
//! Nothing about the hop is special-cased for it: the branch has an empty
//! transcript, so the hop's warrant is `NothingDue` and it exits without a
//! model call (the injected resolver is a tripwire that must never run).
//! The retarget still landed, because the boundary consumes the mark
//! *before* anything resolves config — which is what makes the next step
//! the first the target governs.

use super::advance::no_resolve;
use super::fixtures::{FixedClock, FixedIdGen, never_stopped, no_launch};
use super::stubs::{StubSleeper, unreachable_adapter};
use super::tool_stub::StubToolExecutor;
use crate::prompt::Deps;
use crate::prompt::dispatch::advance::{AdvanceOutcome, run};
use crate::template::{GitRunner, RealGit};
use crate::workspace::{self, DEFAULT_CONFIG_NAME, agent_ref, fixture, repo_git};
use std::path::Path;

#[test]
fn the_executor_lands_a_marked_retarget_at_its_next_step_boundary() {
    let (_h, ws, wt) = crate::prompt::retarget::tests::agent();
    let git = RealGit::new();
    fixture::amend_config(&ws, &[("souls/worker.md", "the newer soul\n")]);
    let target = git
        .run_capture(
            &repo_git(&ws),
            &["rev-parse", &workspace::config_ref(DEFAULT_CONFIG_NAME)],
        )
        .unwrap()
        .trim()
        .to_string();
    let before = workspace::governing_config(&ws, &agent_ref("a"), &git).unwrap();
    assert_ne!(before.trim(), target, "the freeze is real before the mark");
    workspace::retarget::write(&ws, "a", &target, &git).unwrap();

    let adapter = unreachable_adapter();
    let tools = StubToolExecutor::ok();
    let sleeper = StubSleeper::default();
    let clock = FixedClock::default();
    let id_gen = FixedIdGen;
    let deps = Deps {
        adapter: &adapter,
        sleeper: &sleeper,
        git: &git,
        clock: &clock,
        id_gen: &id_gen,
        tool_executor: &tools,
        config_root: Path::new("/nonexistent"),
        adapter_target: None,
        stop: never_stopped(),
        launcher: no_launch(),
        rng: crate::workspace::agent_name::mint::test_rng(),
    };
    let outcome = run(&ws, "a", None, &deps, &mut no_resolve).unwrap();

    // The hop itself was an ordinary no-op — no model call, no resolve.
    assert!(
        matches!(outcome, AdvanceOutcome::NothingToDo),
        "{outcome:?}"
    );
    // …and the branch is now governed by the target, with its own
    // dispatch commit re-derived on top of it and the mark consumed.
    assert_eq!(
        workspace::governing_config(&ws, &agent_ref("a"), &git)
            .unwrap()
            .trim(),
        target,
    );
    assert_eq!(workspace::retarget::read(&ws, "a", &git), None);
    assert_eq!(
        std::fs::read_to_string(wt.join("soul.md")).unwrap(),
        "the newer soul",
    );
}