fix(render): show reasoning before answer on session resume

Providers persist an assistant turn as [Text, ReasoningTrace, ToolUse],
so the resume/re-render path appended reasoning markup into the message
text in stored block order, displaying the thinking *after* the answer.
Live streaming shows reasoning before the answer, so resumed sessions
looked wrong. Accumulate reasoning separately and prepend it to the
answer text at each flush point to match live ordering. Adds a
regression test using the real stored block order.

Author: 1jehuang

crates/jcode-base/src/session/render.rs

@@ -381,6 +381,12 @@ pub fn render_messages_and_images_with_compacted_history(
         };
         let message_role = msg.role.clone();
         let mut text = String::new();
+        // Reasoning is accumulated separately so it can be rendered *before* the
+        // answer text, matching the live streaming order. Providers persist the
+        // assistant turn as `[Text, ReasoningTrace, ToolUse]`, so appending
+        // reasoning into `text` in block order would otherwise show the thinking
+        // *after* the answer on resume/re-render.
+        let mut reasoning = String::new();
         let mut tool_calls: Vec<String> = Vec::new();
         let mut current_tool: Option<ToolCall> = None;
         let mut last_image_idx: Option<usize> = None;
@@ -421,13 +427,16 @@ pub fn render_messages_and_images_with_compacted_history(
                     content,
                     ..
                 } => {
-                    if !text.is_empty() {
+                    let combined = format!("{}{}", reasoning, text);
+                    if !combined.is_empty() {
                         if role == "user" && !is_attached_image_label_text(&text) {
                             user_prompt_count += 1;
                         }
+                        text.clear();
+                        reasoning.clear();
                         rendered.push(RenderedMessage {
                             role: role.to_string(),
-                            content: std::mem::take(&mut text),
+                            content: combined,
                             tool_calls: tool_calls.clone(),
                             tool_data: None,
                         });
@@ -452,7 +461,7 @@ pub fn render_messages_and_images_with_compacted_history(
                     });
                 }
                 ContentBlock::Reasoning { text: t } | ContentBlock::ReasoningTrace { text: t } => {
-                    text.push_str(&format_reasoning_markup(t));
+                    reasoning.push_str(&format_reasoning_markup(t));
                 }
                 ContentBlock::AnthropicThinking { .. } | ContentBlock::OpenAIReasoning { .. } => {}
                 ContentBlock::Image { media_type, data } => {
@@ -480,13 +489,14 @@ pub fn render_messages_and_images_with_compacted_history(
             }
         }
 
-        if !text.is_empty() {
+        let combined = format!("{}{}", reasoning, text);
+        if !combined.is_empty() {
             if role == "user" && !is_attached_image_label_text(&text) {
                 user_prompt_count += 1;
             }
             rendered.push(RenderedMessage {
                 role: role.to_string(),
-                content: text,
+                content: combined,
                 tool_calls,
                 tool_data: None,
             });

crates/jcode-base/src/session_tests/cases.rs

@@ -1066,6 +1066,53 @@ fn test_render_messages_honors_system_display_role_override() {
     assert!(rendered[0].content.contains("Background Task Completed"));
 }
 
+#[test]
+fn test_render_messages_renders_reasoning_before_answer_in_stored_order() {
+    // Regression: providers persist the assistant turn as `[Text, ReasoningTrace,
+    // ToolUse]` (see agent/turn_loops.rs push order). On resume/re-render the
+    // reasoning must still appear *before* the answer text to match the live
+    // streaming order, even though the Text block is stored first.
+    use jcode_render_core::REASONING_SENTINEL;
+
+    let _env_lock = lock_env();
+    let _mode = EnvVarGuard::set("JCODE_REASONING_DISPLAY", "full");
+    crate::config::invalidate_config_cache();
+
+    let mut session = Session::create_with_id(
+        "session_render_reasoning_order_test".to_string(),
+        None,
+        Some("render reasoning order test".to_string()),
+    );
+
+    session.add_message(
+        Role::Assistant,
+        vec![
+            ContentBlock::Text {
+                text: "Here is the answer.".to_string(),
+                cache_control: None,
+            },
+            ContentBlock::ReasoningTrace {
+                text: "step one\nstep two".to_string(),
+            },
+        ],
+    );
+
+    let rendered = render_messages(&session);
+    assert_eq!(rendered.len(), 1);
+    let content = &rendered[0].content;
+    assert!(
+        content.contains(&format!("*{0}step one{0}*", REASONING_SENTINEL)),
+        "expected reasoning markup, got: {content:?}"
+    );
+    assert!(content.contains("Here is the answer."));
+    let reasoning_pos = content.find("step two").unwrap();
+    let answer_pos = content.find("Here is the answer.").unwrap();
+    assert!(
+        reasoning_pos < answer_pos,
+        "reasoning should precede the answer text even when stored after it: {content:?}"
+    );
+}
+
 #[test]
 fn test_render_messages_renders_persisted_reasoning() {
     use jcode_render_core::REASONING_SENTINEL;