amberfork-align 0.4.0

Move-typed alignment engine: cost model, affine-gap aligner, resync fork rule.
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

//! The canonical guard (CLAUDE.md, "Tests are part of done"): **a run aligned against itself
//! must be all-sync with no fork** — for *any* run, not just the ones we thought of. Property
//! violations here mean the aligner or cost model broke determinism or tie-breaking.

use amberfork_align::{AlignParams, DiffParams, ForkParams, LexicalCost, align, diff, find_fork};
use amberfork_model::{MoveKind, Payload, Run, SchemaVersion, Step, StepKind};
use proptest::prelude::*;
use serde_json::Map;

/// Arbitrary-ish steps: pooled names (realistic — agents reuse tool names), free-form unicode
/// outputs (stresses the tokenizer), and occasional content-less steps.
fn arb_step(idx: usize) -> impl Strategy<Value = Step> {
    let kind = prop_oneof![
        Just(StepKind::Llm),
        Just(StepKind::Tool),
        Just(StepKind::Agent),
        Just(StepKind::Other),
    ];
    let name = prop_oneof![
        Just("planner".to_string()),
        Just("web.search".to_string()),
        Just("web.fetch".to_string()),
        Just("reader".to_string()),
        "[a-z]{1,8}",
    ];
    let outputs = prop_oneof![
        1 => Just(None),
        4 => any::<String>().prop_map(|s| Some(Payload::Text(s))),
    ];
    (kind, name, outputs).prop_map(move |(kind, name, outputs)| Step {
        idx,
        kind,
        name,
        inputs: None,
        outputs,
        attrs: Map::new(),
        t_start: None,
        t_end: None,
        parent_idx: None,
    })
}

fn arb_run() -> impl Strategy<Value = Vec<Step>> {
    prop::collection::vec(any::<u8>(), 0..25).prop_flat_map(|shape| {
        shape
            .into_iter()
            .enumerate()
            .map(|(i, _)| arb_step(i))
            .collect::<Vec<_>>()
    })
}

proptest! {
    #[test]
    fn self_alignment_is_all_sync_with_no_fork(run in arb_run()) {
        let moves = align(&run, &run, &LexicalCost, &AlignParams::default());

        prop_assert_eq!(moves.len(), run.len());
        for (i, m) in moves.iter().enumerate() {
            prop_assert_eq!(m.kind, MoveKind::Sync);
            prop_assert_eq!((m.a_idx, m.b_idx), (Some(i), Some(i)));
            prop_assert_eq!(m.cost, 0.0);
        }

        // No fork at the default threshold — nor even at tau = 0, the strictest possible.
        prop_assert_eq!(find_fork(&moves, &ForkParams::default()), None);
        let strictest = ForkParams { tau: 0.0, ..ForkParams::default() };
        prop_assert_eq!(find_fork(&moves, &strictest), None);

        // The same invariant through the public seam: a self-diff has no fork and therefore
        // no regression to attribute — `None`, never a zero-confidence attribution.
        let this = Run {
            schema_version: SchemaVersion::current(),
            id: "self".to_string(),
            task: None,
            outcome: None,
            steps: run,
            edges: None,
        };
        let result = diff(&this, &this, &LexicalCost, &DiffParams::default());
        prop_assert_eq!(result.fork, None);
        prop_assert!(result.attribution.is_none());
    }
}