sprawling 0.0.12

A local multi-agent harness for persistent agent teams: long-running project work, agent communication, and experiments in coordination and social simulation.
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
// Copyright (c) 2026 2youg1 and the sprawling contributors

use std::path::Path;

use kernel::{Address, AxCode, Seq};

use super::*;
use crate::assembly::{hands, init_city};
use accounting::worker::RunWorker;

/// Changes one digit of the first line's timestamp in place, so the
/// line still parses and only the chain can tell.
fn break_the_first_line(city_root: &Path) {
    let first = storage::ledger_segments_at(&kernel::layout::CityLayout::new(city_root).ledger())
        .unwrap()
        .remove(0);
    let mut bytes = std::fs::read(&first).unwrap();
    let at = bytes
        .windows(4)
        .position(|held| held == b"\"t\":")
        .and_then(|key| key.checked_add(4))
        .unwrap();
    bytes[at] = if bytes[at] == b'1' { b'2' } else { b'1' };
    std::fs::write(&first, bytes).unwrap();
}

#[test]
fn a_chain_broken_under_a_served_city_refuses_the_next_command_with_the_audits_reason() {
    let dir = tempfile::tempdir().unwrap();
    init_city(dir.path()).unwrap();
    let mut worker = RunWorker::new(
        dir.path(),
        Diagnostics::off(),
        hands(gateway::Custodian::in_memory()),
    )
    .unwrap();
    break_the_first_line(dir.path());
    let storage::ChainAudit::Broken(reason) =
        storage::audit_chain(&kernel::layout::CityLayout::new(dir.path()).ledger()).unwrap()
    else {
        panic!("the tampered ledger still audits whole");
    };

    audit_in_background(
        worker.chain_under_audit(storage::ChainHalt::awaiting_proof()),
        Diagnostics::off(),
        monotonic_now(),
    )
    .unwrap()
    .join()
    .unwrap();
    let refused = worker
        .handle(wire::Command::CreateBuilding {
            addr: Address::parse("lab").unwrap(),
            template: wire::TemplateName::parse("minimal").unwrap(),
            idem: kernel::IdemKey::derive(&RunId::CITY, Seq::FIRST, b"create"),
        })
        .err();

    assert_eq!(refused, Some(reason));
}

/// An audit that did not finish proved nothing whole, and a view that
/// resumed from a snapshot has only this audit looking at the lines
/// before it.
#[test]
fn an_audit_that_cannot_read_the_ledger_trips_the_halt() {
    let dir = tempfile::tempdir().unwrap();
    let missing = dir.path().join("no-ledger-here");
    let reason = storage::audit_chain(&missing).unwrap_err().into_ax();
    let halt = storage::ChainHalt::awaiting_proof();

    report_proof(
        ChainUnderAudit {
            halt: halt.clone(),
            ledger_dir: missing.clone(),
            at: Seq::FIRST,
            records: storage::ProofRecords::read_only(&dir.path().join("records")),
        },
        Diagnostics::off(),
        monotonic_now(),
    );

    assert_eq!(halt.reason(), Some(reason));
}

/// A served worker answers a command that arrives before the proof of its
/// history with `E_HISTORY_UNPROVEN` and writes nothing, and takes the
/// same command once the proof is whole (`crates/sprawling/spec/Assembly/Listening.lean` ยง8-90).
#[test]
fn a_served_worker_takes_commands_once_its_history_is_proved() {
    let dir = tempfile::tempdir().unwrap();
    init_city(dir.path()).unwrap();
    let mut worker = RunWorker::new(
        dir.path(),
        Diagnostics::off(),
        hands(gateway::Custodian::in_memory()),
    )
    .unwrap();
    let create = |name: &str| wire::Command::CreateBuilding {
        addr: Address::parse(name).unwrap(),
        template: wire::TemplateName::parse("minimal").unwrap(),
        idem: kernel::IdemKey::derive(&RunId::CITY, Seq::FIRST, name.as_bytes()),
    };
    let watch = worker.chain_under_audit(storage::ChainHalt::awaiting_proof());

    let before = worker
        .handle(create("lab"))
        .map_err(|refused| *refused.code());
    audit_in_background(watch, Diagnostics::off(), monotonic_now())
        .unwrap()
        .join()
        .unwrap();
    let after = worker.handle(create("lab")).map(|_| ());

    assert_eq!(
        (before.err(), after),
        (Some(AxCode::HistoryUnproven), Ok(()))
    );
}