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.

6.9 KB
Raw Blame
//! Real native Session -> protected Application -> daemon/store publication path.
use super::*;

fn editor_input(
    action: &str,
    plan: &AgentPlanStatusV2,
    editor: &hiroute_domain::PlanEditorStateV2,
    draft_revision: Option<u64>,
) -> crate::session::EditorInput {
    serde_json::from_value(serde_json::json!({
        "action": action,
        "plan_id": plan.agent_plan_id,
        "draft_id": "draft/native-publication",
        "expected_head_revision": plan.head.head_revision,
        "expected_draft_revision": draft_revision,
        "editor": editor,
        "language": "en"
    }))
    .unwrap()
}

#[tokio::test]
async fn edited_draft_publish_uses_submitted_content_and_consumes_the_exact_draft() {
    let root = prepare();
    let mut session = open(root.path());
    let original = plan(&mut session).await;
    let mut editor = original
        .desired
        .editor(Some(original.model_alias.as_str().into()))
        .unwrap();
    editor.purpose = "saved draft before the final edit".into();
    let draft = session
        .preview_editor(editor_input("save_draft", &original, &editor, None))
        .await
        .unwrap();
    assert!(!draft.requires_confirmation());
    session
        .finish_native_confirmation(draft, true)
        .await
        .unwrap();
    let snapshot = session.snapshot().await.unwrap();
    let draft_revision = snapshot
        .catalog
        .drafts
        .iter()
        .find(|draft| draft.draft_id == "draft/native-publication")
        .unwrap()
        .revision;

    editor.purpose = "content edited immediately before ordinary Publish".into();
    let publication = session
        .preview_editor(editor_input(
            "publish",
            &original,
            &editor,
            Some(draft_revision),
        ))
        .await
        .unwrap();
    assert!(
        !publication.requires_confirmation(),
        "ordinary Publish has no hidden confirmation dialog"
    );
    let outcome = session
        .finish_native_confirmation(publication, true)
        .await
        .unwrap();
    assert_eq!(outcome.operation.unwrap().state, "succeeded");
    let current = plan(&mut session).await;
    assert_eq!(current.desired.purpose.as_str(), editor.purpose);
    assert_eq!(current.desired.strategy, original.desired.strategy);
    assert_eq!(current.model_alias, original.model_alias);
    assert!(
        session
            .snapshot()
            .await
            .unwrap()
            .catalog
            .drafts
            .iter()
            .all(|draft| draft.draft_id != "draft/native-publication")
    );
    drop(session);
    let mut restarted = open(root.path());
    assert_eq!(
        plan(&mut restarted).await.desired.purpose.as_str(),
        editor.purpose
    );
    assert!(
        restarted
            .snapshot()
            .await
            .unwrap()
            .catalog
            .drafts
            .iter()
            .all(|draft| draft.draft_id != "draft/native-publication")
    );
}
#[tokio::test]
async fn native_default_preserves_custom_text_across_publication_and_restart() {
    use hiroute_domain::*;
    let root = prepare();
    let mut session = open(root.path());
    let original = plan(&mut session).await;
    let service: DecisionServiceV1 = serde_json::from_value(serde_json::json!({
        "id":"native-transition", "revision":1, "name":"Native transition fixture", "connection": {
            "kind":"system_one", "provider":"compatible", "model":"fixture", "endpoint":"https://decision.example/systemone",
            "timeout_ms":3000, "auth_header":{"name":"Authorization","value_secret_ref":"placeholder"}
        }
    })).unwrap();
    session
        .save_decision_service(
            DecisionServiceChangeV1 {
                id: service.id.clone(),
                expected_revision: 0,
                service: Some(service),
                input_slot: None,
            },
            Some(zeroize::Zeroizing::new("native-fixture".into())),
        )
        .await
        .unwrap();
    let service = session
        .decision_services()
        .await
        .unwrap()
        .services
        .remove(0);
    let mut editor = original
        .desired
        .editor(Some(original.model_alias.as_str().into()))
        .unwrap();
    editor.mode = PlanEditorMode::SmartSaving;
    editor.smart.economy = editor.candidates.clone();
    editor.smart.primary = editor.candidates.clone();
    editor.smart.classifier = ComplexityClassifierModeV1::DecisionService {
        service: Box::new(service),
    };
    let mut current = original.clone();
    for iteration in 0..2 {
        editor.purpose = format!("Native default publication {iteration}");
        let confirmation = session
            .preview_editor(editor_input("publish", &current, &editor, None))
            .await
            .unwrap();
        assert!(
            !confirmation.requires_confirmation(),
            "ordinary publish gained an extra review dialog"
        );
        session
            .finish_native_confirmation(confirmation, true)
            .await
            .unwrap();
        current = plan(&mut session).await;
        let scope = current.desired.assessment_scopes()[SMART_SAVING_SCOPE_ID];
        assert_eq!(
            scope.competence.standard,
            Some(AssessmentStandardV1::Default)
        );
        assert_eq!(
            scope.competence.criteria,
            stock_c_questions()["q1"]["criteria"]
                .as_array()
                .unwrap()
                .iter()
                .map(|v| v.as_str().unwrap().to_owned())
                .collect::<Vec<_>>()
                .as_slice()
        );
        editor = current.desired.editor(None).unwrap();
    }
    editor.smart.judgment.competence.standard = Some(AssessmentStandardV1::Custom);
    editor.smart.judgment.competence.instructions =
        "  Preserve custom text.\nSecond line.  ".into();
    editor.smart.judgment.competence.criteria[1].push_str("  ");
    let custom = editor.smart.judgment.competence.clone();
    for iteration in 0..2 {
        editor.purpose = format!("Native custom publication {iteration}");
        let confirmation = session
            .preview_editor(editor_input("publish", &current, &editor, None))
            .await
            .unwrap();
        session
            .finish_native_confirmation(confirmation, true)
            .await
            .unwrap();
        current = plan(&mut session).await;
        assert_eq!(
            current.desired.assessment_scopes()[SMART_SAVING_SCOPE_ID].competence,
            custom
        );
        editor = current.desired.editor(None).unwrap();
    }
    let before = current.head.reference.clone();
    drop(session);
    let mut restarted = open(root.path());
    let reopened = plan(&mut restarted).await;
    assert_eq!(reopened.head.reference, before);
    assert_eq!(
        reopened.desired.assessment_scopes()[SMART_SAVING_SCOPE_ID].competence,
        custom
    );
}