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.7 KB
Raw Blame
use super::*;
use crate::compiler::test_fixtures::compilation_facts;

fn change() -> PlanContentChangeV2 {
    PlanContentChangeV2 {

        schema: PLAN_CONTENT_CHANGE_SCHEMA_V2.into(), target: PlanContentTargetV2::Create { creation_key: "editor-one".into() },
        editor: serde_json::from_value(serde_json::json!({
            "schema": PLAN_EDITOR_SCHEMA_V2, "display_name": "日常编码", "purpose": "辅助日常编码",
            "mode":"fixed_model", "candidates":[{"binding_id":"binding/free-b"}],
            "smart":{"economy":[],"primary":[],"judgment":hiroute_domain::JudgmentSettingsV1::default(),"reselect_on_user_message":false,"classifier":{"kind":"local_rules"},"complex_keywords":[]},
            "free":{"candidates":[],"primary":[],"primary_fallback":false},
            "delegation_enabled": false,
            "requirements":{},"limits":{"maximum_attempts":6,"request_timeout_ms":60000,"attempt_timeout_ms":30000}
        })).unwrap(), consumed_draft: None,
    }
}
fn state() -> PlanAuthoringSnapshotV2 {
    PlanAuthoringSnapshotV2 {
        workspace: WorkspaceId::default(),
        aliases: AliasRegistryV1::default(),
        active_publication: None,
        plan_heads: vec![],
        current_head: None,
        legacy_source: None,
        draft: None,
        facts: compilation_facts(),
        decision_service: None,
        expected_revisions: RevisionSetV1 {
            target: 1,
            dependencies: Default::default(),
        },
    }
}

#[test]
fn publication_requires_the_exact_saved_decision_revision_for_both_modes() {
    let service = DecisionServiceV1 {
        id: "decision/authoring".into(),
        revision: 1,
        name: "Saved extension".into(),
        connection: DecisionConnectionV1::Custom {
            endpoint: "https://extension.example/v1/decisions".into(),
            timeout_ms: 3000,
            auth_header: None,
        },
    };
    for mode in [PlanEditorMode::SmartSaving, PlanEditorMode::CustomBranches] {
        let mut change = change();
        let mut state = state();
        let classifier = ComplexityClassifierModeV1::DecisionService {
            service: Box::new(service.clone()),
        };
        change.editor.mode = mode;
        change.editor.smart.economy = change.editor.candidates.clone();
        change.editor.smart.primary = change.editor.candidates.clone();
        change.editor.smart.classifier = classifier.clone();
        change.editor.branch_routing = Some(BranchRoutingEditorV1 {
            classifier,
            branches: ["writing", "review"]
                .map(|id| RouteBranchV1 {
                    id: id.into(),
                    name: id.into(),
                    condition: format!("Handle {id}"),
                    candidates: change.editor.candidates.clone(),
                    primary_candidates: vec![],
                    judgment: None,
                })
                .into(),
            default_branch_id: "review".into(),
            judgment: Default::default(),
            reselect_on_user_message: false,
        });
        assert_eq!(
            preview_plan_content(&change, &state),
            Err(PlanPreviewError::InvalidDecisionService)
        );
        state.decision_service = Some(service.clone());
        let preview = preview_plan_content(&change, &state).unwrap();
        assert_eq!(
            preview.plan_version.configuration.decision_service(),
            Some(&service)
        );
        // Matching identity is insufficient: every frozen field must match its saved revision.
        state.decision_service.as_mut().unwrap().name = "Different saved content".into();
        assert_eq!(
            preview_plan_content(&change, &state),
            Err(PlanPreviewError::InvalidDecisionService)
        );
        state.decision_service = Some(service.clone());
        state.decision_service.as_mut().unwrap().revision = 2;
        assert_eq!(
            preview_plan_content(&change, &state),
            Err(PlanPreviewError::InvalidDecisionService)
        );
    }
}
#[test]
fn preview_is_read_only_and_seals_proposed_alias_and_registry() {
    let change = change();
    let mut state = state();
    let before = state.aliases.clone();
    let first = preview_plan_content(&change, &state).unwrap();
    assert_eq!(
        first.plan_head.model_alias.as_str(),
        "hiroute-richangbianma"
    );
    assert_eq!(before, state.aliases);
    assert_eq!(first, preview_plan_content(&change, &state).unwrap());
    state
        .aliases
        .allocate_custom(
            AgentPlanId::parse("plan/competitor").unwrap(),
            first.plan_head.model_alias.clone(),
        )
        .unwrap();
    let second = preview_plan_content(&change, &state).unwrap();
    assert_eq!(
        second.plan_head.model_alias.as_str(),
        "hiroute-richangbianma-2"
    );
    // Ordinary Publish confirms the exact edit and database revisions. Allocating another
    // alias through a real writer advances the target revision; model the same boundary here.
    assert_eq!(first.change_digest, second.change_digest);
    assert_ne!(first.alias_registry_digest, second.alias_registry_digest);
    state.expected_revisions.target += 1;
    let after_commit = preview_plan_content(&change, &state).unwrap();
    assert_ne!(first.change_digest, after_commit.change_digest);
    assert_eq!(second.plan_head, after_commit.plan_head);
}
#[test]
fn manual_alias_survives_name_changes_and_published_alias_cannot_change() {
    let mut change = change();
    let mut state = state();
    change.editor.custom_alias = Some("my-coding".into());
    let first = preview_plan_content(&change, &state).unwrap();
    change.editor.display_name = "资料整理".into();
    assert_eq!(
        preview_plan_content(&change, &state)
            .unwrap()
            .plan_head
            .model_alias
            .as_str(),
        "my-coding"
    );
    state
        .aliases
        .allocate_custom(
            first.plan_head.reference.plan_id.clone(),
            first.plan_head.model_alias.clone(),
        )
        .unwrap();
    state.current_head = Some(first.plan_head.clone());
    change.target = PlanContentTargetV2::Update {
        plan_id: first.plan_head.reference.plan_id,
        expected_head_revision: 1,
    };
    let updated = preview_plan_content(&change, &state).unwrap();
    assert_eq!(updated.plan_head.model_alias.as_str(), "my-coding");
    assert_eq!(updated.plan_head.reference.content_revision, 2);
    change.editor.custom_alias = Some("different".into());
    assert_eq!(
        preview_plan_content(&change, &state),
        Err(PlanPreviewError::AliasImmutable)
    );
}

#[test]
fn current_unversioned_publication_source_can_be_adopted_on_first_update() {
    let mut change = change();
    let mut state = state();
    let existing = preview_plan_content(&change, &state).unwrap();
    state
        .aliases
        .allocate_custom(
            existing.plan_head.reference.plan_id.clone(),
            existing.plan_head.model_alias.clone(),
        )
        .unwrap();
    state.current_head = Some(existing.plan_head.clone());
    state.plan_heads = vec![existing.plan_head.clone()];
    state.legacy_source = Some(existing.plan_version.clone());
    change.target = PlanContentTargetV2::Update {
        plan_id: existing.plan_head.reference.plan_id.clone(),
        expected_head_revision: existing.plan_head.head_revision,
    };

    let updated = preview_plan_content(&change, &state).unwrap();
    assert_eq!(updated.legacy_source, Some(existing.plan_version));
    assert_eq!(updated.plan_head.reference.content_revision, 2);
    assert_eq!(updated.plan_head.head_revision, 2);
}

#[test]
fn consumed_draft_binds_identity_and_revision_but_publishes_the_submitted_editor() {
    let mut change = change();
    let mut state = state();
    change.consumed_draft = Some(PlanDraftRefV1 {
        draft_id: "draft/one".into(),
        revision: 1,
    });
    assert_eq!(
        preview_plan_content(&change, &state),
        Err(PlanPreviewError::Stale)
    );
    state.draft = Some(PlanDraftV1 {
        schema: PLAN_DRAFT_SCHEMA_V1.into(),
        workspace_id: state.workspace.clone(),
        draft_id: "draft/one".into(),
        revision: 1,
        plan_id: None,
        base_head_revision: None,
        editor: change.editor.clone(),
    });
    let before = preview_plan_content(&change, &state).unwrap();
    change.editor.purpose = "Edited after saving the draft".into();
    let edited = preview_plan_content(&change, &state).unwrap();
    assert_eq!(
        edited.plan_version.configuration.purpose.as_str(),
        change.editor.purpose
    );
    assert_ne!(before.change_digest, edited.change_digest);
    assert_eq!(edited.consumed_draft, change.consumed_draft);
    let original = state.draft.as_ref().unwrap().clone();
    for mismatch in ["identity", "plan"] {
        let draft = state.draft.as_mut().unwrap();
        *draft = original.clone();
        match mismatch {
            "identity" => draft.draft_id = "draft/other".into(),
            "plan" => {
                draft.plan_id = Some(AgentPlanId::parse("plan/other").unwrap());
                draft.base_head_revision = Some(1);
            }
            _ => unreachable!(),
        }
        assert_eq!(
            preview_plan_content(&change, &state),
            Err(PlanPreviewError::Stale)
        );
    }
    state.draft = Some(original);
    state.draft.as_mut().unwrap().revision = 2;
    assert_eq!(
        preview_plan_content(&change, &state),
        Err(PlanPreviewError::Stale)
    );

    state
        .aliases
        .allocate_custom(
            before.plan_head.reference.plan_id.clone(),
            before.plan_head.model_alias.clone(),
        )
        .unwrap();
    state.current_head = Some(before.plan_head.clone());
    change.target = PlanContentTargetV2::Update {
        plan_id: before.plan_head.reference.plan_id.clone(),
        expected_head_revision: before.plan_head.head_revision,
    };
    let draft = state.draft.as_mut().unwrap();
    draft.revision = 1;
    draft.plan_id = Some(before.plan_head.reference.plan_id.clone());
    draft.base_head_revision = Some(before.plan_head.head_revision);
    preview_plan_content(&change, &state).unwrap();
    state.draft.as_mut().unwrap().base_head_revision = Some(before.plan_head.head_revision + 1);
    assert_eq!(
        preview_plan_content(&change, &state),
        Err(PlanPreviewError::Stale)
    );
}

#[test]
fn complete_content_operation_binds_the_version_head_and_publication() {
    assert_complete_content_operation(false, None);
}

#[test]
fn retained_native_operation_uses_frozen_semantics_and_still_rejects_tampering() {
    assert_complete_content_operation(true, None);
}

#[test]
fn current_custom_operations_preserve_parked_source_and_reject_sealed_input_tampering() {
    for mode in [PlanEditorMode::SmartSaving, PlanEditorMode::CustomBranches] {
        assert_complete_content_operation(false, Some(mode));
    }
}

fn assert_complete_content_operation(legacy_native: bool, custom_mode: Option<PlanEditorMode>) {
    let mut change = change();
    let mut state = state();
    if legacy_native {
        let service = DecisionServiceV1 {
            id: "decision/retained-operation".into(),
            revision: 1,
            name: "Retained native".into(),
            connection: DecisionConnectionV1::SystemOne {
                provider: "compatible".into(),
                model: "synthetic".into(),
                endpoint: "https://decision.example/systemone".into(),
                timeout_ms: 3000,
                auth_header: ClassifierAuthHeaderV1 {
                    name: "Authorization".into(),
                    value_secret_ref: "fixture".into(),
                },
            },
        };
        change.editor.mode = PlanEditorMode::SmartSaving;
        change.editor.smart.economy = change.editor.candidates.clone();
        change.editor.smart.primary = change.editor.candidates.clone();
        change.editor.smart.classifier = ComplexityClassifierModeV1::DecisionService {
            service: Box::new(service.clone()),
        };
        state.decision_service = Some(service);
    }
    if let Some(mode) = custom_mode {
        let service = DecisionServiceV1 {
            id: "decision/current-operation".into(),
            revision: 1,
            name: "Current extension".into(),
            connection: DecisionConnectionV1::Custom {
                endpoint: "https://decision.example/choose".into(),
                timeout_ms: 3000,
                auth_header: None,
            },
        };
        let classifier = ComplexityClassifierModeV1::DecisionService {
            service: Box::new(service.clone()),
        };
        change.editor.mode = mode;
        change.editor.smart.classifier = classifier.clone();
        change.editor.smart.economy = change.editor.candidates.clone();
        change.editor.smart.primary = change.editor.candidates.clone();
        change.editor.smart.judgment.degree.instructions = "   ".into();
        change.editor.smart.judgment.competence.instructions = "  parked assessment  ".into();
        change.editor.smart.judgment.competence.floor_millis = 730;
        change.editor.branch_routing = Some(BranchRoutingEditorV1 {
            classifier,
            branches: ["code", "docs"]
                .map(|id| RouteBranchV1 {
                    id: id.into(),
                    name: id.into(),
                    condition: format!("Handle {id}"),
                    candidates: change.editor.candidates.clone(),
                    primary_candidates: if id == "code" {
                        change.editor.candidates.clone()
                    } else {
                        vec![]
                    },
                    judgment: Some(change.editor.smart.judgment.clone()),
                })
                .into(),
            default_branch_id: "docs".into(),
            judgment: change.editor.smart.judgment.clone(),
            reselect_on_user_message: false,
        });
        state.decision_service = Some(service);
    }
    let mut preview = preview_plan_content(&change, &state).unwrap();
    if custom_mode.is_some() {
        assert_eq!(
            preview.plan_version.configuration,
            change.editor.effective().unwrap()
        );
        let mut invalid = preview.plan_version.compiled.body.materialized.clone();
        match &mut invalid.request_owned {
            RequestOwnedRouteV1::Classified { judgment, .. } => {
                assert!(judgment.is_none());
                *judgment = Some(JudgmentSettingsV1::default());
            }
            RequestOwnedRouteV1::Branches { branches, .. } => {
                assert!(branches.iter().all(|b| b.judgment.is_none()));
                branches[0].judgment = Some(JudgmentSettingsV1::default());
            }
            _ => unreachable!(),
        }
        assert_eq!(invalid.validate(), Err(CompiledPlanError::InvalidGroups));
    }
    if legacy_native {
        // Construct the supported sealed legacy shape. The real released-producer
        // acceptance additionally authenticates actual v0.3.1 Operations on reopen.
        let mut configuration = preview.plan_version.configuration.clone();
        let AgentPlanStrategyV2::SmartSaving {
            native_protocol,
            judgment,
            ..
        } = &mut configuration.strategy
        else {
            unreachable!()
        };
        *native_protocol = None;
        *judgment = change.editor.smart.judgment.clone();
        let compiled = crate::compiler::compile_agent_plan_v2(
            preview.plan_version.compiled.body.identity.clone(),
            preview.plan_version.reference.content_revision,
            &configuration,
            &state.facts,
        )
        .unwrap();
        preview.plan_version =
            PlanVersionV1::new(state.workspace.clone(), configuration, compiled).unwrap();
        preview.plan_head.reference = preview.plan_version.reference.clone();
        assert!(
            change
                .editor
                .effective()
                .unwrap()
                .native_protocol()
                .is_some()
        );
        assert!(
            preview
                .plan_version
                .configuration
                .native_protocol()
                .is_none()
        );
    }
    let mut aliases = state.aliases.clone();
    aliases
        .allocate_custom(
            preview.plan_head.reference.plan_id.clone(),
            preview.plan_head.model_alias.clone(),
        )
        .unwrap();
    let revision = GatewayPublicationRevision::new(1).unwrap();
    let publication = GatewayPublicationV1::new(
        state.workspace.clone(),
        revision,
        AliasRegistryV1::default(),
        vec![],
    )
    .unwrap()
    .next_with_plan_content(
        revision,
        aliases,
        preview.plan_version.compiled.clone(),
        vec![preview.plan_head.clone()],
    )
    .unwrap();
    let record =
        PublicationRecordV1::from_publication(state.workspace.clone(), &publication).unwrap();
    let spec = ChangeSpecV1 {
        schema_version: hiroute_domain::CHANGE_SPEC_SCHEMA_V1,
        command_id: "routing.apply".into(),
        resource_id: Some(format!(
            "agent-plan/{}",
            preview.plan_head.reference.plan_id.as_str()
        )),
        desired_state: serde_json::to_value(&change).unwrap(),
    };
    let plan = TransactionPlanV1::from_plan_content_planner(
        spec,
        preview.plan_version.clone(),
        preview.plan_head.clone(),
        None,
        None,
        record.clone(),
        None,
    )
    .unwrap();
    let content = plan.plan_content_control().unwrap().unwrap();
    assert_eq!(content.plan_version, preview.plan_version);
    assert_eq!(
        routing_publication_record(&plan.external()[0]).unwrap(),
        Some(record)
    );
    let roundtrip = TransactionPlanV1::from_registered_typed_planner(
        plan.spec().clone(),
        plan.control().clone(),
        None,
        vec![],
        vec![],
        plan.external().to_vec(),
    )
    .unwrap();
    assert_eq!(roundtrip.plan_content_control().unwrap().unwrap(), content);
    // Alter both envelope copies and the change digest consistently: rejection must
    // still come from the editor-to-sealed-configuration check.
    let mut tampered = plan.spec().clone();
    tampered.desired_state["editor"]["purpose"] = serde_json::json!("Changed after sealing");
    let mut control = plan.control().clone();
    control["change_spec_digest"] =
        serde_json::to_value(CanonicalDigest::of(&tampered).unwrap()).unwrap();
    let mut effect = serde_json::to_value(&plan.external()[0]).unwrap();
    effect["desired"]["change_spec"] = serde_json::to_value(&tampered).unwrap();
    effect["desired"]["control"] = control;
    assert!(
        ExternalEffectIntentV1::from_registered_adapter(
            effect["effect_id"].as_str().unwrap(),
            serde_json::from_value(effect["kind"].clone()).unwrap(),
            effect["target"].as_str().unwrap(),
            serde_json::from_value(effect["before_fingerprint"].clone()).unwrap(),
            effect["desired"].clone(),
            effect["desired_mode"].as_u64().unwrap() as u32,
            effect["sensitive"].as_bool().unwrap(),
        )
        .is_err()
    );
    let mut changed = plan.control().clone();
    changed["plan_head"]["head_revision"] = serde_json::json!(99);
    assert!(
        TransactionPlanV1::from_registered_typed_planner(
            plan.spec().clone(),
            changed,
            None,
            vec![],
            vec![],
            plan.external().to_vec(),
        )
        .is_err()
    );
}

#[test]
fn ordinary_publication_confirmation_binds_edit_target_versions_and_draft_intent() {
    let original = change();
    let revisions = state().expected_revisions;
    let digest = plan_content_confirmation_digest(&original, &revisions).unwrap();
    let mut edited = original.clone();
    edited.editor.purpose = "another purpose".into();
    assert_ne!(
        digest,
        plan_content_confirmation_digest(&edited, &revisions).unwrap()
    );
    edited = original.clone();
    edited.target = PlanContentTargetV2::Create {
        creation_key: "another-plan".into(),
    };
    assert_ne!(
        digest,
        plan_content_confirmation_digest(&edited, &revisions).unwrap()
    );
    let mut new_revisions = revisions.clone();
    new_revisions.target += 1;
    assert_ne!(
        digest,
        plan_content_confirmation_digest(&original, &new_revisions).unwrap()
    );
    // Every wire field is part of the confirmation, including optional draft ownership.
    let mut json = serde_json::to_value(&original).unwrap();
    json["consumed_draft"] = serde_json::json!({"draft_id":"draft/confirmation", "revision":3});
    let with_draft: PlanContentChangeV2 = serde_json::from_value(json).unwrap();
    assert_ne!(
        digest,
        plan_content_confirmation_digest(&with_draft, &revisions).unwrap()
    );
}

#[test]
fn ordinary_preview_resolves_defaults_and_seals_concrete_contents_without_review() {
    let mut change = change();
    let mut state = state();
    let service = DecisionServiceV1 {
        id: "decision/preview".into(),
        revision: 1,
        name: "Fixture".into(),
        connection: DecisionConnectionV1::SystemOne {
            provider: "compatible".into(),
            model: "fixture".into(),
            endpoint: "https://decision.example/systemone".into(),
            timeout_ms: 3000,
            auth_header: ClassifierAuthHeaderV1 {
                name: "Authorization".into(),
                value_secret_ref: "fixture".into(),
            },
        },
    };
    change.editor.mode = PlanEditorMode::SmartSaving;
    change.editor.smart.classifier = ComplexityClassifierModeV1::DecisionService {
        service: Box::new(service.clone()),
    };
    change.editor.smart.economy = change.editor.candidates.clone();
    change.editor.smart.primary = change.editor.candidates.clone();
    state.decision_service = Some(service);
    let legacy = preview_plan_content(&change, &state).unwrap();
    let old_bytes = serde_json::to_vec(&legacy.plan_version).unwrap();
    assert_eq!(
        legacy.change_digest,
        plan_content_confirmation_digest(&change, &state.expected_revisions).unwrap()
    );
    let enabled = preview_plan_content(&change, &state).unwrap();
    enabled.plan_version.validate().unwrap();
    let encoded = serde_json::to_value(&enabled).unwrap();
    assert!(encoded.get("assessment_transition").is_none());
    assert!(
        encoded["plan_version"]
            .get("assessment_transition")
            .is_none()
    );
    assert_eq!(
        enabled.change_digest,
        plan_content_confirmation_digest(&change, &state.expected_revisions).unwrap()
    );
    let route = &enabled
        .plan_version
        .compiled
        .body
        .materialized
        .request_owned;
    let RequestOwnedRouteV1::Classified {
        native_protocol: Some(frozen),
        ..
    } = route
    else {
        panic!("native execution missing")
    };
    assert_eq!(frozen.scopes[SMART_SAVING_SCOPE_ID].standard, "default");
    assert_eq!(
        frozen.scopes[SMART_SAVING_SCOPE_ID].assessment,
        stock_c_questions()["q1"]
    );
    assert_eq!(frozen.protocol.fixed, NativeFixedContentV1::c_v1());
    let reopened = enabled.plan_version.configuration.editor(None).unwrap();
    change.editor = reopened;
    let off = preview_plan_content(&change, &state).unwrap();
    off.plan_version.validate().unwrap();
    assert_eq!(
        off.plan_version.configuration.assessment_scopes()[SMART_SAVING_SCOPE_ID]
            .competence
            .instructions,
        stock_c_questions()["q1"]["instructions"]
            .as_str()
            .unwrap()
            .strip_prefix(&(NativeFixedContentV1::c_v1().assessment_wrapper + " "))
            .unwrap()
    );
    assert_eq!(serde_json::to_vec(&legacy.plan_version).unwrap(), old_bytes);
}