Refs answers carry the transparency log (step A3) e5b97ac399e7

    fn add_log(&self, name: &str, refs: &mut oxy_core::protocol::RefsResponse) {

        let Some(app) = self.app_hint.lock().unwrap().as_ref().and_then(|w| w.upgrade()) else { return };

        let row = RepoName::parse(name).and_then(|p| self.row(&crate::wiki::parent_of(&p).0).ok()).map(|r| r.id);

        let backfill = crate::tlog::add_log(&app, row, refs);

        if !backfill.is_empty() {

            self.block(crate::tlog::log(&app, backfill));

        }

    }

    /// Entry `n`'s bytes.

    pub fn entry(&self, n: u64) -> anyhow::Result<Vec<u8>> {

        let f = self.files.lock().unwrap();

        anyhow::ensure!(n < f.size, "entry {n} is not in the log");

        Self::entry_bytes(&f, n)

    }

}

/// Add the log to a refs answer (Oxygen spec §14.8): the latest

/// checkpoint, and for each bookmark's attestation its entry and inclusion

/// proof against it. An attestation the hub serves but never logged (one

/// pushed before the log began) is logged now, and proved on a later fetch.

pub fn add_log(app: &Shared, row: Option<i64>, refs: &mut oxy_core::protocol::RefsResponse) -> Vec<Pending> {

    let mut backfill = Vec::new();

    let Some(note) = app.tlog.checkpoint() else { return backfill };

    let Some(size) = tlog::Note::parse(&note).ok().and_then(|n| Checkpoint::parse(&n.text).ok()).map(|c| c.size) else {

        return backfill;

    };

    refs.log = Some(note);

    for r in refs.refs.iter_mut() {

        let Some(a) = &r.attestation else { continue };

        let object = a.attest.hash();

        let idx = tokio::task::block_in_place(|| {

            tokio::runtime::Handle::current().block_on(db::tlog::entry_of(&app.db, &object.to_hex(), "ref"))

        });

        match idx {

            Ok(Some(i)) if (i as u64) < size => {

                let (Ok(entry), Ok(proof)) = (app.tlog.entry(i as u64), app.tlog.prove_inclusion(size, i as u64)) else { continue };

                r.logged = Some(oxy_core::protocol::Logged { index: i as u64, entry, proof });

            }

            Ok(Some(_)) => {}

            Ok(None) => backfill.push(Pending { kind: "ref", repo: a.attest.repo, repo_row: row, object, signers: sig_keys(&a.sigs) }),

            Err(e) => eprintln!("tlog: looking up {}: {e}", &object.to_hex()[..12]),

        }

    }

    backfill

/// Fetching checks the hub's log (oxygenhub#238, step A3): the checkpoint

/// comes with the refs, each attestation with its entry and inclusion

/// proof; a later checkpoint is proved to extend the one seen before, from

/// the hub's tiles; an attestation not in a checkpoint yet is a note; and a

/// log that does not extend what this user saw fails the fetch.

#[tokio::test(flavor = "multi_thread")]

async fn a_fetch_checks_the_hub_s_log_and_refuses_a_fork() {

    use oxy_core::tlog::{Checkpoint, Note};

    let h = hub().await;

    create(&h.app, "andy", "demo").await;

    let url = format!("{}/andy/demo", h.base);

    let work = tempfile::tempdir().unwrap();

    let mut a = client(&url, &work.path().join("a"));

    a.create_identity("Andy", "[email protected]", oxy_core::repo::IdentityScope::Repo).unwrap();

    let (_, sk) = oxygenhub::keys::load_secret(&h.app.config.keys_dir()).unwrap();

    let hub_id = h.app.hub_key.identity.clone();

    let checkpoint = || h.app.tlog.refresh_checkpoint(&hub_id, &sk).unwrap();

    let mut n = 0;

    let mut push = |a: &Repo| {

        n += 1;

        write(&work.path().join("a"), "a.txt", &format!("{n}\n"));

        a.commit(&format!("change {n}"), &[]).unwrap();

        assert!(a.push("origin", false).unwrap().iter().all(|r| r.ok));

    };

    push(&a);

    checkpoint();

    let home = work.path().join("home-b");

    let b = Repo::clone(&url, &work.path().join("b")).unwrap().with_home(home.clone());

    let report = b.fetch("origin").unwrap();

    assert!(report.log_notes.is_empty(), "{:?}", report.log_notes);

    let pin = std::fs::read_dir(home.join("tlog")).unwrap().next().unwrap().unwrap().path();

    let seen = |p: &std::path::Path| {

        let t = std::fs::read_to_string(p).unwrap();

        Checkpoint::parse(&Note::parse(t.split_once('\n').unwrap().1).unwrap().text).unwrap()

    };

    let first = seen(&pin);

    // A later checkpoint: proved to extend the first from the tiles.

    push(&a);

    checkpoint();

    let report = b.fetch("origin").unwrap();

    assert!(report.log_notes.is_empty(), "{:?}", report.log_notes);

    assert!(seen(&pin).size > first.size);

    // Pushed after the last checkpoint: not provable yet, only a note.

    push(&a);

    let report = b.fetch("origin").unwrap();

    assert!(report.log_notes.iter().any(|n| n.contains("not in its transparency log yet")), "{:?}", report.log_notes);

    // What this user saw replaced by another log of the same size, signed

    // by the hub's own key: the hub's real log does not extend it.

    let size = seen(&pin).size;

    let forged = Checkpoint { origin: oxygenhub::tlog::origin_of(h.app.config.base_url()), size, root: [7; 32], extensions: vec![] };

    let text = std::fs::read_to_string(&pin).unwrap();

    let key = text.split_once('\n').unwrap().0;

    std::fs::write(&pin, format!("{key}\n{}", forged.sign(&hub_id, &sk).unwrap().encode())).unwrap();

    checkpoint();

    let err = b.fetch("origin").unwrap_err().to_string();

    assert!(err.contains("showed two histories") && err.contains("does not extend"), "{err}");

}

- **Refs answers** carry the latest checkpoint and, for each bookmark's attestation, its entry and inclusion proof (Oxygen spec §16; step A3, 2026-10-18). An attestation served but never logged (pushed before the log began) is logged then, and proved on a later fetch. oxy pins the log's key per hub, requires each checkpoint to extend the last it saw (proved from the tiles), and fails a fetch whose hub showed two histories.

- **Not yet:** proofs in push responses, `oxy tlog verify`, witnesses and trusted time (docs/transparency.md). Backups do not copy the log yet.