Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

23.9 KB
Raw Blame
use super::*;
use hiroute_integrations::model_feed::FeedPayload;

fn payload(sequence: u64) -> Vec<u8> {
    let mut snapshot = crate::release_catalog::current_fixture_catalog().official_snapshot();
    snapshot.data_revision = sequence.max(1);
    publication_bytes(&FeedPayload::from_snapshot(
        snapshot,
        sequence,
        "2026-10-18T00:00:00Z".into(),
        "0123456789abcdef0123456789abcdef01234567".into(),
        vec![],
    ))
}
fn publication_bytes(payload: &FeedPayload) -> Vec<u8> {
    serde_json::to_vec(payload).unwrap()
}

#[test]
fn model_feed_restart_and_removal_preserve_captured_catalog_without_authorizing_new_use() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    let bytes = publication_bytes(&super::fixtures::publication(17));
    service
        .refresh_using(
            |_| {
                Ok(FeedDownload::Content {
                    bytes: bytes.clone(),
                    etag: None,
                })
            },
            |_, _| Ok(()),
        )
        .unwrap();
    let captured = service.current();
    assert!(
        captured
            .model_data()
            .model(super::fixtures::MODEL)
            .is_some()
    );
    drop(service);
    let restarted = open(root.path(), captured.generation);
    assert_eq!(
        restarted.current().model_data_provenance(),
        captured.model_data_provenance()
    );
    restarted
        .remove(&restarted.removal_digest().unwrap(), true, |_, _| Ok(()))
        .unwrap();
    assert!(
        restarted
            .current()
            .model_data()
            .model(super::fixtures::MODEL)
            .is_none()
    );
    assert!(
        captured
            .model_data()
            .model(super::fixtures::MODEL)
            .is_some()
    );
    let generation = restarted.current().generation;
    drop(restarted);
    let restarted = open(root.path(), generation);
    assert!(
        restarted
            .current()
            .model_data()
            .model(super::fixtures::MODEL)
            .is_none()
    );
    assert_eq!(
        restarted.status().unwrap().highest_accepted_sequence,
        Some(17)
    );
    restarted
        .refresh_using(
            |_| {
                Ok(FeedDownload::Content {
                    bytes: bytes.clone(),
                    etag: None,
                })
            },
            |_, _| Ok(()),
        )
        .unwrap();
    assert!(
        restarted
            .current()
            .model_data()
            .model(super::fixtures::MODEL)
            .is_some()
    );
}
fn open(path: &Path, min: u64) -> ModelFeedService {
    ModelFeedService::open(
        path,
        crate::release_catalog::current_fixture_catalog(),
        min,
        0,
    )
    .unwrap()
}
fn fetch(service: &ModelFeedService, sequence: u64) -> Result<(), String> {
    service.refresh_using(
        |_| {
            Ok(FeedDownload::Content {
                bytes: payload(sequence),
                etag: Some("test-etag".into()),
            })
        },
        |_, _| Ok(()),
    )
}

#[test]
fn model_feed_delete_preserves_high_water_and_identical_publication_restores_after_restart() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 10).unwrap();
    let old = service.current();
    service
        .remove(&service.removal_digest().unwrap(), true, |_, _| Ok(()))
        .unwrap();
    assert!(!service.status().unwrap().retrieval_enabled);
    assert!(service.status().unwrap().held.is_none());
    assert_eq!(old.generation, 1);
    assert_eq!(old.accepted_sequence, 10);
    assert_eq!(service.current().accepted_sequence, 10);
    let restarted = open(root.path(), 2);
    assert_eq!(
        restarted.status().unwrap().highest_accepted_sequence,
        Some(10)
    );
    assert!(fetch(&restarted, 9).is_err());
    assert_eq!(
        restarted.status().unwrap().last_attempt.unwrap().result,
        "older_sequence"
    );
    fetch(&restarted, 10).unwrap();
    assert_eq!(restarted.status().unwrap().held.unwrap().sequence, 10);
    assert_eq!(restarted.current().generation, 3);
}

#[test]
fn model_feed_cacheless_304_retries_without_conditional_header() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 10).unwrap();
    service
        .remove(&service.removal_digest().unwrap(), false, |_, _| Ok(()))
        .unwrap();
    let mut calls = 0;
    service
        .refresh_using(
            |etag| {
                assert!(etag.is_none());
                calls += 1;
                if calls == 1 {
                    Ok(FeedDownload::NotModified)
                } else {
                    Ok(FeedDownload::Content {
                        bytes: payload(10),
                        etag: None,
                    })
                }
            },
            |_, _| Ok(()),
        )
        .unwrap();
    assert_eq!(calls, 2);
    assert!(service.status().unwrap().held.is_some());
}

#[test]
fn model_feed_corrupt_state_is_preserved_and_mutations_are_refused() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    drop(service);
    let path = root.path().join("model-feed/state.json");
    std::fs::write(&path, b"future schema").unwrap();
    let reopened = open(root.path(), 1);
    assert!(reopened.status().unwrap().held.is_none());
    assert!(reopened.settings(Some(true), None).is_err());
    assert!(fetch(&reopened, 6).is_err());
    assert_eq!(std::fs::read(path).unwrap(), b"future schema");
}

#[test]
fn model_feed_crash_before_state_commit_does_not_adopt_unreferenced_blob() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    let bytes = payload(6);
    service
        .store
        .persist_blob(&bytes, &CanonicalDigest::of_bytes(&bytes))
        .unwrap();
    drop(service);
    let reopened = open(root.path(), 1);
    assert_eq!(reopened.status().unwrap().held.unwrap().sequence, 5);
}

#[test]
fn model_feed_crash_after_commit_recovers_catalog_and_generation() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    assert!(
        service
            .refresh_using(
                |_| Ok(FeedDownload::Content {
                    bytes: payload(6),
                    etag: None
                }),
                |_, _| Err("injected activation interruption".into())
            )
            .is_err()
    );
    assert_eq!(service.available_catalog().unwrap().generation, 1);
    assert!(service.settings(Some(true), None).is_err());
    assert!(fetch(&service, 7).is_err());
    drop(service);
    let reopened = open(root.path(), 1);
    assert_eq!(reopened.current().generation, 2);
    assert_eq!(reopened.status().unwrap().held.unwrap().sequence, 6);
}

#[test]
fn model_feed_generation_is_captured_with_catalog_before_dependency_activation() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    let before = service.current();
    service
        .refresh_using(
            |_| {
                Ok(FeedDownload::Content {
                    bytes: payload(2),
                    etag: None,
                })
            },
            |generation, sequence| {
                assert_eq!(sequence, 2);
                assert_eq!(generation, 1);
                assert_eq!(service.current().generation, 0);
                assert!(service.available_catalog().is_none());
                Ok(())
            },
        )
        .unwrap();
    assert_eq!(before.generation, 0);
    assert_eq!(service.current().generation, 1);
}

#[test]
fn model_feed_disabling_then_reenabling_invalidates_in_flight_retrieval() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    let result = service.refresh_using(
        |_| {
            service.settings(Some(false), None).unwrap();
            service.settings(Some(true), None).unwrap();
            Ok(FeedDownload::Content {
                bytes: payload(1),
                etag: None,
            })
        },
        |_, _| panic!("superseded retrieval cannot activate"),
    );
    assert!(result.is_err());
    assert!(service.status().unwrap().held.is_none());
}

#[test]
fn model_feed_invalid_cache_retains_high_water_on_reopen() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    let held = service.status().unwrap().held.unwrap();
    std::fs::remove_file(
        root.path()
            .join("model-feed/publications")
            .join(format!("{}.json", &held.payload_digest.as_str()[7..])),
    )
    .unwrap();
    drop(service);
    let reopened = open(root.path(), 1);
    assert!(reopened.status().unwrap().held.is_none());
    assert_eq!(
        reopened.status().unwrap().highest_accepted_sequence,
        Some(5)
    );
    assert!(fetch(&reopened, 4).is_err());
    fetch(&reopened, 5).unwrap();
}

#[test]
fn model_feed_missing_state_recovers_floor_from_independent_checkpoint() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 17).unwrap();
    drop(service);
    std::fs::remove_dir_all(root.path().join("model-feed")).unwrap();
    let reopened = open(root.path(), 0);
    assert_eq!(
        reopened.status().unwrap().highest_accepted_sequence,
        Some(17)
    );
    assert!(reopened.status().unwrap().held.is_none());
    assert!(!reopened.status().unwrap().retrieval_enabled);
    assert_eq!(fetch(&reopened, 16).unwrap_err(), "older_sequence");
    fetch(&reopened, 17).unwrap();
}

#[test]
fn model_feed_corrupt_state_can_be_explicitly_quarantined_without_resetting_acceptance() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 18).unwrap();
    drop(service);
    let path = root.path().join("model-feed/state.json");
    std::fs::write(&path, b"broken owned state").unwrap();
    let reopened = open(root.path(), 1);
    assert!(reopened.status().unwrap().recovery_available);
    assert_eq!(
        reopened.status().unwrap().highest_accepted_sequence,
        Some(18)
    );
    reopened
        .remove(&reopened.removal_digest().unwrap(), true, |_, sequence| {
            assert_eq!(sequence, 18);
            Ok(())
        })
        .unwrap();
    assert!(!reopened.status().unwrap().recovery_available);
    let saved = std::fs::read_dir(path.parent().unwrap())
        .unwrap()
        .flatten()
        .find(|entry| {
            entry
                .file_name()
                .to_string_lossy()
                .starts_with("state.quarantined-")
        })
        .unwrap();
    assert_eq!(std::fs::read(saved.path()).unwrap(), b"broken owned state");
    assert_eq!(fetch(&reopened, 17).unwrap_err(), "older_sequence");
    fetch(&reopened, 18).unwrap();
}

#[test]
fn model_feed_newer_schema_and_corruption_without_checkpoint_cannot_be_reset() {
    for (contents, checkpoint) in [
        (
            br#"{"schema":"hiroute.model-feed.state/v99"}"#.as_slice(),
            true,
        ),
        (b"broken".as_slice(), false),
    ] {
        let root = tempfile::tempdir().unwrap();
        let service = open(root.path(), 0);
        if checkpoint {
            fetch(&service, 19).unwrap();
        }
        drop(service);
        let path = root.path().join("model-feed/state.json");
        std::fs::write(&path, contents).unwrap();
        let reopened = open(root.path(), 0);
        assert!(!reopened.status().unwrap().recovery_available);
        assert!(
            reopened
                .remove(&reopened.removal_digest().unwrap(), true, |_, _| Ok(()))
                .is_err()
        );
        assert_eq!(std::fs::read(path).unwrap(), contents);
    }
}

#[test]
fn model_feed_acceptance_commit_precedes_state_and_never_adopts_orphan_blob() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    let bytes = payload(20);
    let validated = parse_feed(&bytes).unwrap();
    service
        .store
        .persist_blob(&bytes, &validated.payload_digest)
        .unwrap();
    // Crash after high-water commit but before the state/activation commit.
    service
        .store
        .retain_acceptance(&HighestAccepted {
            sequence: 20,
            payload_digest: validated.payload_digest,
        })
        .unwrap();
    drop(service);
    let reopened = open(root.path(), 1);
    assert_eq!(
        reopened.status().unwrap().highest_accepted_sequence,
        Some(20)
    );
    assert!(reopened.status().unwrap().held.is_none());
    assert_eq!(fetch(&reopened, 19).unwrap_err(), "older_sequence");
    fetch(&reopened, 20).unwrap();
}

#[test]
fn model_feed_unknown_digest_floor_requires_a_strictly_higher_sequence() {
    let root = tempfile::tempdir().unwrap();
    let service = ModelFeedService::open(
        root.path(),
        crate::release_catalog::current_fixture_catalog(),
        4,
        11,
    )
    .unwrap();
    assert_eq!(
        service.status().unwrap().highest_accepted_sequence,
        Some(11)
    );
    assert!(!service.status().unwrap().retrieval_enabled);
    assert_eq!(fetch(&service, 11).unwrap_err(), "older_sequence");
    fetch(&service, 12).unwrap();
}

#[test]
fn model_feed_invalid_refresh_keeps_the_last_good_catalog_and_private_cache() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    let bytes = publication_bytes(&super::fixtures::publication(17));
    service
        .refresh_using(
            |_| {
                Ok(FeedDownload::Content {
                    bytes: bytes.clone(),
                    etag: None,
                })
            },
            |_, _| Ok(()),
        )
        .unwrap();
    let captured = service.current();
    let held = service.status().unwrap().held.unwrap();
    for invalid in [b"invalid JSON".to_vec(), b"null".to_vec(), payload(16)] {
        assert!(
            service
                .refresh_using(
                    |_| Ok(FeedDownload::Content {
                        bytes: invalid.clone(),
                        etag: None
                    }),
                    |_, _| panic!("invalid or older publication cannot activate"),
                )
                .is_err()
        );
        assert_eq!(service.current().generation, captured.generation);
        assert!(
            service
                .current()
                .model_data()
                .model(super::fixtures::MODEL)
                .is_some()
        );
        assert_eq!(service.store.blob(&held).unwrap(), bytes);
    }
    drop(service);
    let reopened = open(root.path(), captured.generation);
    assert!(
        reopened
            .current()
            .model_data()
            .model(super::fixtures::MODEL)
            .is_some()
    );
    assert_eq!(reopened.status().unwrap().verification, "validated");
}

#[test]
fn model_feed_valid_json_with_changed_cached_bytes_is_discarded_without_lowering_acceptance() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 17).unwrap();
    let held = service.status().unwrap().held.unwrap();
    let file = root
        .path()
        .join("model-feed/publications")
        .join(format!("{}.json", &held.payload_digest.as_str()[7..]));
    let mut changed = payload(17);
    changed.push(b'\n');
    std::fs::write(&file, changed).unwrap();
    drop(service);
    let reopened = open(root.path(), 1);
    assert!(reopened.status().unwrap().held.is_none());
    assert_eq!(
        reopened.status().unwrap().highest_accepted_sequence,
        Some(17)
    );
    assert_eq!(fetch(&reopened, 16).unwrap_err(), "older_sequence");
    fetch(&reopened, 17).unwrap();
}

#[test]
fn announcement_only_publication_preserves_semantic_generation_and_confirmation_dependencies() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    let before = service.current();
    let mut publication: FeedPayload = serde_json::from_slice(&payload(5)).unwrap();
    publication.sequence = 6;
    publication.issued_at = "2026-10-19T00:00:00Z".into();
    service
        .refresh_using(
            |_| {
                Ok(FeedDownload::Content {
                    bytes: publication_bytes(&publication),
                    etag: None,
                })
            },
            |_, _| panic!("editorial-only updates cannot activate a semantic/price generation"),
        )
        .unwrap();
    assert_eq!(service.current().generation, before.generation);
    assert_eq!(
        service.current().official_snapshot(),
        before.official_snapshot()
    );
    assert_eq!(service.status().unwrap().highest_accepted_sequence, Some(6));
}

#[test]
fn higher_publication_sequence_cannot_lower_semantic_data_even_after_removal() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    service
        .remove(&service.removal_digest().unwrap(), false, |_, _| Ok(()))
        .unwrap();
    let mut publication: FeedPayload = serde_json::from_slice(&payload(4)).unwrap();
    publication.sequence = 100;
    let bytes = publication_bytes(&publication);
    assert_eq!(
        service
            .refresh_using(
                |_| Ok(FeedDownload::Content {
                    bytes: bytes.clone(),
                    etag: None
                }),
                |_, _| Ok(())
            )
            .unwrap_err(),
        "older_data_revision"
    );
    drop(service);
    let restarted = open(root.path(), 0);
    assert_eq!(
        restarted.status().unwrap().highest_accepted_sequence,
        Some(5)
    );
    assert_eq!(
        restarted.store.read_data_floor().unwrap().unwrap().revision,
        5
    );
}

#[test]
fn retained_v1_choices_and_floor_do_not_poison_v2_acceptance() {
    let root = tempfile::tempdir().unwrap();
    let _store = FeedStore::open(root.path()).unwrap();
    let legacy = serde_json::json!({
        "schema":"hiroute.model-feed.state/v1", "retrieval_enabled":false,
        "disclosure_acknowledged":true, "generation":7, "sequence_floor":99,
        "highest_accepted":{"sequence":99,"payload_digest":CanonicalDigest::of_bytes(b"legacy")},
        "held":null, "last_attempt":null,"last_success_at_ms":null,"etag":null
    });
    let bytes = serde_json::to_vec(&legacy).unwrap();
    std::fs::write(root.path().join("model-feed/state.json"), &bytes).unwrap();
    let service = open(root.path(), 7);
    assert!(!service.status().unwrap().retrieval_enabled);
    assert!(service.status().unwrap().disclosure_acknowledged);
    assert_eq!(service.status().unwrap().highest_accepted_sequence, None);
    assert_eq!(
        std::fs::read(root.path().join("model-feed/retained-v1-state.json")).unwrap(),
        bytes
    );
    fetch(&service, 2).unwrap();
    let generation = service.current().generation;
    drop(service);
    let restarted = open(root.path(), generation);
    assert_eq!(
        restarted.status().unwrap().highest_accepted_sequence,
        Some(2)
    );
    restarted
        .remove(&restarted.removal_digest().unwrap(), true, |_, _| Ok(()))
        .unwrap();
    drop(restarted);
    let restarted = open(root.path(), generation + 1);
    assert_eq!(fetch(&restarted, 1).unwrap_err(), "older_sequence");
    assert!(restarted.status().unwrap().disclosure_acknowledged);
}

#[test]
fn model_feed_failed_preparation_keeps_previous_catalog_and_durable_selection() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    let old = service.current();
    assert!(
        service
            .refresh_using_prepared(
                |_| Ok(FeedDownload::Content {
                    bytes: payload(2),
                    etag: None
                }),
                |_| Err::<(), _>("prices.candidate.unavailable".into()),
                |_, (), _| panic!("failed candidate must never activate"),
            )
            .is_err()
    );
    assert_eq!(service.current().generation, old.generation);
    assert!(service.status().unwrap().held.is_none());
    drop(service);
    assert_eq!(open(root.path(), 0).current().generation, old.generation);
}

#[test]
fn model_feed_slow_preparation_does_not_hold_feed_lock_and_superseded_candidate_never_installs() {
    let root = tempfile::tempdir().unwrap();
    let service = Arc::new(open(root.path(), 0));
    let (entered_tx, entered_rx) = std::sync::mpsc::channel();
    let (resume_tx, resume_rx) = std::sync::mpsc::channel();
    let worker = service.clone();
    let join = std::thread::spawn(move || {
        worker.refresh_using_prepared(
            |_| {
                Ok(FeedDownload::Content {
                    bytes: payload(2),
                    etag: None,
                })
            },
            |_| {
                entered_tx.send(()).unwrap();
                resume_rx.recv().unwrap();
                Ok(())
            },
            |_, (), _| panic!("superseded candidate must never activate"),
        )
    });
    entered_rx
        .recv_timeout(std::time::Duration::from_secs(5))
        .unwrap();
    assert!(service.available_catalog().is_some());
    service.settings(Some(false), None).unwrap();
    assert!(!service.status().unwrap().retrieval_enabled);
    resume_tx.send(()).unwrap();
    assert_eq!(
        join.join().unwrap().unwrap_err(),
        "feed_retrieval_superseded"
    );
    assert_eq!(service.current().generation, 0);
}

#[test]
fn model_feed_registry_qualification_changes_advance_once_without_changing_semantic_data_floor() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    let mut state = service.store.read_state().unwrap();
    let old_identity = state.selected_data.clone();
    let old_generation = state.generation;
    state.qualification_digest = Some(CanonicalDigest::of_bytes(b"previous installed registry"));
    service.store.commit(&state).unwrap();
    drop(service);
    let updated = open(root.path(), old_generation);
    assert_eq!(updated.current().generation, old_generation + 1);
    assert_eq!(
        updated.store.read_state().unwrap().selected_data,
        old_identity
    );
    drop(updated);
    assert_eq!(
        open(root.path(), old_generation).current().generation,
        old_generation + 1
    );
}

#[test]
fn embedded_v2_upgrade_preserves_choices_and_acceptance_without_network() {
    let root = tempfile::tempdir().unwrap();
    let service = open(root.path(), 0);
    fetch(&service, 5).unwrap();
    service.settings(Some(false), Some(true)).unwrap();
    let captured = service.current();
    let previous_state = service.store.read_state().unwrap();
    drop(service);
    let embedded = crate::release_catalog::current_fixture_catalog();
    let mut updated = captured.official_snapshot();
    updated.data.connection_hints[0]
        .description
        .insert("en".into(), "A reviewed metadata correction.".into());
    updated.data_revision += 1;
    updated.data_digest = CanonicalDigest::of(&updated.data).unwrap();
    let installed = embedded
        .with_embedded_official_data(updated.clone())
        .unwrap();
    for _ in 0..2 {
        let reopened = ModelFeedService::open(root.path(), installed.clone(), 0, 0).unwrap();
        let status = reopened.status().unwrap();
        assert!(!status.retrieval_enabled);
        assert!(status.disclosure_acknowledged);
        assert_eq!(status.highest_accepted_sequence, Some(5));
        assert_eq!(
            status.highest_accepted_data_revision,
            Some(updated.data_revision)
        );
        assert_eq!(reopened.current().official_snapshot(), updated);
        assert_eq!(
            reopened
                .store
                .read_state()
                .unwrap()
                .highest_accepted
                .unwrap()
                .payload_digest,
            previous_state
                .highest_accepted
                .as_ref()
                .unwrap()
                .payload_digest
        );
        assert_eq!(captured.official_snapshot().data_revision, 5);
    }
}