Use prior-turn personality for model-switch compaction base instructions

Author: charley-oai

codex-rs/core/src/codex.rs

@@ -1432,11 +1432,12 @@ impl Session {
         &self,
         previous_turn_context: &TurnContext,
         turn_context: &TurnContext,
+        previous_turn_personality: Option<Personality>,
     ) {
         let mut state = self.state.lock().await;
         let previous_model_default = previous_turn_context
             .model_info
-            .get_model_instructions(previous_turn_context.personality);
+            .get_model_instructions(previous_turn_personality);
         if state.session_configuration.base_instructions == previous_model_default {
             state.session_configuration.base_instructions = turn_context
                 .model_info
@@ -1492,18 +1493,21 @@ impl Session {
                     state.initial_context_seeded = true;
                 }
                 self.set_previous_model(None).await;
+                self.set_previous_personality(None).await;
                 // Ensure initial items are visible to immediate readers (e.g., tests, forks).
                 self.flush_rollout().await;
             }
             InitialHistory::Resumed(resumed_history) => {
                 let rollout_items = resumed_history.history;
                 let previous_model = Self::last_rollout_model_name(&rollout_items)
                     .map(std::string::ToString::to_string);
+                let previous_personality = Self::last_rollout_personality(&rollout_items);
                 {
                     let mut state = self.state.lock().await;
                     state.initial_context_seeded = false;
                 }
                 self.set_previous_model(previous_model).await;
+                self.set_previous_personality(previous_personality).await;
 
                 // If resuming, warn when the last recorded model differs from the current one.
                 let curr = turn_context.model_info.slug.as_str();
@@ -1546,7 +1550,9 @@ impl Session {
             InitialHistory::Forked(rollout_items) => {
                 let previous_model = Self::last_rollout_model_name(&rollout_items)
                     .map(std::string::ToString::to_string);
+                let previous_personality = Self::last_rollout_personality(&rollout_items);
                 self.set_previous_model(previous_model).await;
+                self.set_previous_personality(previous_personality).await;
 
                 // Always add response items to conversation history
                 let reconstructed_history = self
@@ -1597,6 +1603,16 @@ impl Session {
         })
     }
 
+    fn last_rollout_personality(rollout_items: &[RolloutItem]) -> Option<Personality> {
+        rollout_items.iter().rev().find_map(|it| {
+            if let RolloutItem::TurnContext(ctx) = it {
+                ctx.personality
+            } else {
+                None
+            }
+        })
+    }
+
     fn last_token_info_from_rollout(rollout_items: &[RolloutItem]) -> Option<TokenUsageInfo> {
         rollout_items.iter().rev().find_map(|item| match item {
             RolloutItem::EventMsg(EventMsg::TokenCount(ev)) => ev.info.clone(),
@@ -1609,11 +1625,21 @@ impl Session {
         state.previous_model()
     }
 
+    async fn previous_personality(&self) -> Option<Personality> {
+        let state = self.state.lock().await;
+        state.previous_personality()
+    }
+
     pub(crate) async fn set_previous_model(&self, previous_model: Option<String>) {
         let mut state = self.state.lock().await;
         state.set_previous_model(previous_model);
     }
 
+    pub(crate) async fn set_previous_personality(&self, previous_personality: Option<Personality>) {
+        let mut state = self.state.lock().await;
+        state.set_previous_personality(previous_personality);
+    }
+
     fn maybe_refresh_shell_snapshot_for_cwd(
         &self,
         previous_cwd: &Path,
@@ -3764,6 +3790,8 @@ mod handlers {
         let turn_context = sess.new_default_turn_with_sub_id(sub_id).await;
         sess.set_previous_model(Some(turn_context.model_info.slug.clone()))
             .await;
+        sess.set_previous_personality(turn_context.personality)
+            .await;
 
         let mut history = sess.clone_history().await;
         history.drop_last_n_user_turns(num_turns);
@@ -4388,6 +4416,7 @@ async fn run_pre_sampling_compact(
 ) -> CodexResult<()> {
     let total_usage_tokens_before_compaction = sess.get_total_token_usage().await;
     let previous_model = sess.previous_model().await;
+    let previous_personality = sess.previous_personality().await;
     let previous_turn_context = match maybe_run_previous_model_inline_compact(
         sess,
         turn_context,
@@ -4417,6 +4446,7 @@ async fn run_pre_sampling_compact(
         sess.set_base_instructions_for_turn_model(
             previous_turn_context.as_ref(),
             turn_context.as_ref(),
+            previous_personality,
         )
         .await;
     }

codex-rs/core/src/state/session.rs

@@ -1,5 +1,6 @@
 //! Session-wide mutable state.
 
+use codex_protocol::config_types::Personality;
 use codex_protocol::models::ResponseItem;
 use std::collections::HashMap;
 use std::collections::HashSet;
@@ -27,6 +28,8 @@ pub(crate) struct SessionState {
     pub(crate) initial_context_seeded: bool,
     /// Previous model seen by the session, used for model-switch handling on task start.
     previous_model: Option<String>,
+    /// Previous personality seen by the session, used for model-switch compaction handling.
+    previous_personality: Option<Personality>,
     /// Startup regular task pre-created during session initialization.
     pub(crate) startup_regular_task: Option<RegularTask>,
     pub(crate) active_mcp_tool_selection: Option<Vec<String>>,
@@ -46,6 +49,7 @@ impl SessionState {
             mcp_dependency_prompted: HashSet::new(),
             initial_context_seeded: false,
             previous_model: None,
+            previous_personality: None,
             startup_regular_task: None,
             active_mcp_tool_selection: None,
             active_connector_selection: HashSet::new(),
@@ -67,6 +71,12 @@ impl SessionState {
     pub(crate) fn set_previous_model(&mut self, previous_model: Option<String>) {
         self.previous_model = previous_model;
     }
+    pub(crate) fn previous_personality(&self) -> Option<Personality> {
+        self.previous_personality
+    }
+    pub(crate) fn set_previous_personality(&mut self, previous_personality: Option<Personality>) {
+        self.previous_personality = previous_personality;
+    }
 
     pub(crate) fn clone_history(&self) -> ContextManager {
         self.history.clone()

codex-rs/core/src/tasks/mod.rs

@@ -155,6 +155,8 @@ impl Session {
                     // Update previous model before TurnComplete is emitted so
                     // immediately following turns observe the correct switch state.
                     sess.set_previous_model(Some(model_slug)).await;
+                    sess.set_previous_personality(ctx_for_finish.personality)
+                        .await;
                     if !task_cancellation_token.is_cancelled() {
                         // Emit completion uniformly from spawn site so all tasks share the same lifecycle.
                         sess.on_task_finished(Arc::clone(&ctx_for_finish), last_agent_message)
@@ -275,6 +277,8 @@ impl Session {
         // Set previous model even when interrupted so model-switch handling stays correct.
         self.set_previous_model(Some(task.turn_context.model_info.slug.clone()))
             .await;
+        self.set_previous_personality(task.turn_context.personality)
+            .await;
 
         let session_ctx = Arc::new(SessionTaskContext::new(Arc::clone(self)));
         session_task

codex-rs/core/tests/suite/compact.rs

@@ -5,6 +5,7 @@ use codex_core::built_in_model_providers;
 use codex_core::compact::SUMMARIZATION_PROMPT;
 use codex_core::compact::SUMMARY_PREFIX;
 use codex_core::config::Config;
+use codex_core::config::types::Personality;
 use codex_core::features::Feature;
 use codex_core::protocol::AskForApproval;
 use codex_core::protocol::EventMsg;
@@ -2155,6 +2156,127 @@ async fn pre_sampling_compact_model_switch_preserves_base_instructions_override(
     assert_eq!(requests[2].instructions_text(), base_instructions_override);
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn pre_sampling_compact_model_switch_with_personality_updates_base_instructions() {
+    skip_if_no_network!();
+
+    let server = MockServer::start().await;
+    let previous_model = "gpt-5.2-codex";
+    let next_model = "gpt-5.1-codex-max";
+
+    let previous_model_info = model_info_with_context_window(previous_model, 273_000);
+    let next_model_info = model_info_with_context_window(next_model, 125_000);
+    let previous_default_instructions = previous_model_info.get_model_instructions(None);
+    let next_pragmatic_instructions =
+        next_model_info.get_model_instructions(Some(Personality::Pragmatic));
+    assert_ne!(
+        previous_default_instructions, next_pragmatic_instructions,
+        "test requires personality-specific instructions to differ from previous model default"
+    );
+
+    let models_mock = mount_models_once(
+        &server,
+        ModelsResponse {
+            models: vec![previous_model_info, next_model_info],
+        },
+    )
+    .await;
+
+    let request_log = mount_sse_sequence(
+        &server,
+        vec![
+            sse(vec![
+                ev_assistant_message("m1", "before switch"),
+                ev_completed_with_tokens("r1", 120_000),
+            ]),
+            sse(vec![
+                ev_assistant_message("m2", "PRE_SAMPLING_SUMMARY"),
+                ev_completed_with_tokens("r2", 10),
+            ]),
+            sse(vec![
+                ev_assistant_message("m3", "after switch with personality"),
+                ev_completed_with_tokens("r3", 100),
+            ]),
+        ],
+    )
+    .await;
+
+    let model_provider = non_openai_model_provider(&server);
+    let mut builder = test_codex()
+        .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
+        .with_model(previous_model)
+        .with_config(move |config| {
+            config.model_provider = model_provider;
+            set_test_compact_prompt(config);
+            config.features.enable(Feature::RemoteModels);
+            config.features.enable(Feature::Personality);
+        });
+    let test = builder.build(&server).await.expect("build test codex");
+
+    test.codex
+        .submit(Op::UserTurn {
+            items: vec![UserInput::Text {
+                text: "before switch".into(),
+                text_elements: Vec::new(),
+            }],
+            final_output_json_schema: None,
+            cwd: test.cwd.path().to_path_buf(),
+            approval_policy: AskForApproval::Never,
+            sandbox_policy: SandboxPolicy::DangerFullAccess,
+            model: previous_model.to_string(),
+            effort: None,
+            summary: ReasoningSummary::Auto,
+            collaboration_mode: None,
+            personality: None,
+        })
+        .await
+        .expect("submit first user turn");
+    wait_for_event(&test.codex, |event| {
+        matches!(event, EventMsg::TurnComplete(_))
+    })
+    .await;
+
+    test.codex
+        .submit(Op::UserTurn {
+            items: vec![UserInput::Text {
+                text: "after switch".into(),
+                text_elements: Vec::new(),
+            }],
+            final_output_json_schema: None,
+            cwd: test.cwd.path().to_path_buf(),
+            approval_policy: AskForApproval::Never,
+            sandbox_policy: SandboxPolicy::DangerFullAccess,
+            model: next_model.to_string(),
+            effort: None,
+            summary: ReasoningSummary::Auto,
+            collaboration_mode: None,
+            personality: Some(Personality::Pragmatic),
+        })
+        .await
+        .expect("submit second user turn");
+    assert_compaction_uses_turn_lifecycle_id(&test.codex).await;
+
+    let requests = request_log.requests();
+    assert_eq!(models_mock.requests().len(), 1);
+    assert_eq!(
+        requests.len(),
+        3,
+        "expected user, compact, and follow-up requests"
+    );
+    assert_pre_sampling_switch_compaction_requests(
+        &requests[0],
+        &requests[1],
+        &requests[2],
+        previous_model,
+        next_model,
+    );
+    assert_eq!(
+        requests[2].instructions_text(),
+        next_pragmatic_instructions,
+        "follow-up request should use new model base instructions for prior-turn personality"
+    );
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn auto_compact_persists_rollout_entries() {
     skip_if_no_network!();