yog 0.0.57

//! Goal composition (§3.3): the per-rung prefills and typed target bindings,
//! the ball header and its inverse, and [`compose_prepared`] (whose workspace
//! name is a query over the target path, §3.1). The mint's own tables are
//! [`super::identity`].

use crate::binding::{work_worktree_path, workspace_path};
use crate::projects::join::JoinState;
use crate::start::goal::{compose_prepared, prefill, target_binding};
use crate::start::{BallSpec, Payload, StartInputs, parse_ball_stamp, strip_path_preamble};
use std::path::{Path, PathBuf};

const YOG: &str = "/yog";
const BALLS: &str = "/balls";
const HOME: &str = "/home/op";
const PROJ: &str = "/proj";

fn existing_ball() -> Payload {
    Payload::Ball {
        project: "proj".to_owned(),
        ball: BallSpec::Existing {
            id: "bl-1".to_owned(),
            title: "T".to_owned(),
            body: "B".to_owned(),
            join: JoinState::ReadyStartable,
            tags: Vec::new(),
        },
    }
}
fn new_ball() -> Payload {
    Payload::Ball {
        project: "proj".to_owned(),
        ball: BallSpec::New {
            title: "Fresh".to_owned(),
            body: "do".to_owned(),
        },
    }
}

#[test]
fn prefill_is_empty_for_bare() {
    assert_eq!(prefill(&Payload::Bare), "");
}

/// The path rung leads with its headline (§3.3): the directory is on line one,
/// verbatim, because the derived conversation display name is the goal's first
/// payload line. Line two states the binding the fire also passes typed
/// (bl-fea6) — it may restate that channel, never contradict it.
#[test]
fn prefill_names_the_path_verbatim_on_line_one() {
    let g = prefill(&Payload::Path {
        dir: PathBuf::from("/work/here"),
    });
    assert_eq!(
        g,
        "Working directory: /work/here\nThis is already your current directory: every tool call starts there and relative paths resolve there. Keep the work inside it.",
    );
    assert_eq!(g.lines().next(), Some("Working directory: /work/here"));
    assert!(!g.contains("workspace"));
}

/// **THE BALL** (bl-e2ad): compose and parse, in one beat, in the module that
/// owns both. The seat joins the operator's words after the prefill it was
/// handed — `lernie start`'s `{prefill}\n\n{typed}` — and the §3.3 display
/// ladder must read the operator's half, not yog's. Written as a round trip so
/// a reworded preamble cannot leave the inverse expecting a sentence nobody
/// composes: it reddens here, at the compose.
#[test]
fn the_path_preamble_comes_back_off_the_goal_the_seat_fires() {
    let prefill = prefill(&Payload::Path {
        dir: PathBuf::from("/work/here"),
    });
    let typed = "The test suite in this project fails: fix it.\n\nCommit the fix.";
    assert_eq!(
        strip_path_preamble(&format!("{prefill}\n\n{typed}")),
        typed,
        "the operator's goal, whole"
    );
    // Nothing follows it: the fire had no words of the operator's own, and the
    // directory line is all there is to show. Verbatim, never empty.
    assert_eq!(strip_path_preamble(&prefill), prefill);
    // No preamble at all — every bare and ball rung, every foreign root — is
    // the general path with nothing to strip.
    for goal in [
        "",
        "Ball bl-1: T\n\nB",
        "Working directory: /w/x\nnot the sentence",
    ] {
        assert_eq!(strip_path_preamble(goal), goal, "{goal:?}");
    }
}

/// The ball rung's prefill is **payload and nothing else** (§3.3, bl-6654): the
/// `Ball <id>: <title>` header — the §3.2 conversation→ball join — and the body
/// verbatim. The worktree paragraph that used to trail it is retired; location
/// is the typed `--cwd` binding now, so no absolute path and no
/// do-the-work-there instruction may reappear in the goal text.
#[test]
fn prefill_for_a_ball_is_the_header_and_body_with_no_location_prose() {
    let wt = work_worktree_path(Path::new(BALLS), Path::new(PROJ), "bl-1", None);
    let g = prefill(&existing_ball());
    assert_eq!(g, "Ball bl-1: T\n\nB");
    assert!(!g.contains(&wt.display().to_string()));
    assert!(!g.contains(PROJ));
    assert!(!g.contains("worktree"));
    assert!(!g.contains("absolute path"));
}

#[test]
fn prefill_for_a_new_ball_is_title_and_body_only() {
    // Pre-create the id is unknown, so the header cannot carry it; the real
    // `Ball <id>:` header joins on the re-plan once `bl create` mints the id
    // (§8.1), and the binding joins with the claim that follows it.
    assert_eq!(prefill(&new_ball()), "Ball (new): Fresh\n\ndo");
}

#[test]
fn parse_ball_stamp_is_the_inverse_of_the_composed_header() {
    // A modern goal.md is the prefill verbatim (bl-6920: nothing prepended); a
    // pre-0.0.4 root carries the legacy identity stamp above the header. The
    // parse reads the id back off the `Ball <id>:` line regardless.
    let modern = prefill(&existing_ball());
    assert_eq!(parse_ball_stamp(&modern).as_deref(), Some("bl-1"));
    let legacy = format!("You are cobalt-gecko.\n\n{modern}");
    assert_eq!(parse_ball_stamp(&legacy).as_deref(), Some("bl-1"));
}

#[test]
fn parse_ball_stamp_rejects_non_ball_goals_and_malformed_headers() {
    // A bare/path conversation has no header.
    assert_eq!(parse_ball_stamp("You are x.\n\nfree prose"), None);
    // The word "Ball" opening a prose line is not a header: an empty id and a
    // multi-word id are both rejected (a real id is one token).
    assert_eq!(parse_ball_stamp("Ball : no id"), None);
    assert_eq!(parse_ball_stamp("Ball two words: nope"), None);
    // A header buried after the preamble still parses (line-wise scan) — and the
    // scan is preamble-agnostic, so a pre-bl-df65 goal (whose `<y>` was a
    // *workspace*, still on disk until litany's 30-day retention ages it out,
    // §3.3) reads its ball back unchanged.
    assert_eq!(
        parse_ball_stamp("You are y.\n\nBall bz-9: T\n\nbody").as_deref(),
        Some("bz-9"),
    );
}

/// The typed work target, per rung (§3.3, bl-6654 / VISION §4.10 item 2) — the
/// value the fire passes as litany's `--cwd`.
#[test]
fn target_binding_is_the_per_rung_work_target() {
    let wt = work_worktree_path(Path::new(BALLS), Path::new(PROJ), "bl-1", None);
    // The bare rung binds nothing: litany's own default (the agent worktree)
    // stands, which is what "no work target" means.
    assert_eq!(target_binding(&Payload::Bare, None), None);
    // The path rung binds the directory box's value.
    assert_eq!(
        target_binding(
            &Payload::Path {
                dir: PathBuf::from("/d")
            },
            None,
        ),
        Some(PathBuf::from("/d")),
    );
    // The ball rung binds the claim's cross-checked work worktree, never the
    // project root it lives beside.
    assert_eq!(target_binding(&existing_ball(), Some(&wt)), Some(wt));
    // A not-yet-created ball has no claim yet, so it binds nothing; the re-plan
    // after `bl create` binds the worktree the claim mints (§8.1).
    assert_eq!(target_binding(&new_ball(), None), None);
}

#[test]
fn compose_prepared_derives_the_fire_params() {
    let inputs = StartInputs {
        workspace: workspace_path(Path::new(YOG), "cobalt-gecko"),
        repo: Some(PathBuf::from(PROJ)),
        payload: Payload::Bare,
        home: PathBuf::from(HOME),
        yog_data_root: PathBuf::from(YOG),
        balls_state_root: PathBuf::from(BALLS),
        conversation_names: Vec::new(),
    };
    let p = compose_prepared(&inputs, None);
    // §3.1: the name IS the address — one string, one fact (bl-f5f6).
    assert_eq!(p.workspace, "cobalt-gecko");
    assert_eq!(p.binding, None, "the bare rung binds no work target");
    assert_eq!(p.goal, "");
    // **The work target is the binding and nothing else** (bl-6654): there is no
    // per-rung driver cwd field left to disagree with it.
    let wt = work_worktree_path(Path::new(BALLS), Path::new(PROJ), "bl-1", None);
    let ball = StartInputs {
        payload: existing_ball(),
        ..inputs.clone()
    };
    let bound = compose_prepared(&ball, Some(&wt));
    assert_eq!(bound.binding, Some(wt));
    // **The workspace name is a query, not a field** (§3.1, bl-d942): it is the
    // target path's leaf, for a foreign workspace outside the names root exactly
    // as for one of yog's own — nothing carries a second copy of it.
    let foreign = StartInputs {
        workspace: PathBuf::from("/litany/workspaces/20260101T-aa"),
        ..inputs
    };
    assert_eq!(compose_prepared(&foreign, None).workspace, "20260101T-aa");
}