adding tests

codex-rs/core/src/codex.rs

@@ -793,13 +793,21 @@ async fn submission_loop(
                 };
 
                 // Create a summarization request as user input
+                const SUMMARIZATION_PROMPT: &str = concat!(
+                    "Please provide a summary of our conversation so far, highlighting key points, ",
+                    "decisions made, and any important context that would be useful for future reference. ",
+                    "This summary will be used to replace our conversation history with a more concise ",
+                    "version so choose what details you will need to continue your work. ",
+                    "Provide the summary directly without main title."
+                );
+
                 let summarization_prompt = vec![InputItem::Text {
-                    text: "Please provide a summary of our conversation so far, highlighting key points, decisions made, and any important context that would be useful for future reference. This summary will be used to replace our conversation history with a more concise version so choose what details you will need to continue your work.".to_string(),
+                    text: SUMMARIZATION_PROMPT.to_string(),
                 }];
 
-                // attempt to inject input into current task
+                // Attempt to inject input into current task
                 if let Err(items) = sess.inject_input(summarization_prompt) {
-                    // no current task, spawn a new one
+                    // No current task, spawn a new one
                     let task = AgentTask::spawn(Arc::clone(sess), sub.id, items);
                     sess.set_task(task);
                 }

codex-rs/core/tests/summarize_context.rs

@@ -0,0 +1,109 @@
+#![expect(clippy::unwrap_used, clippy::expect_used)]
+
+//! Tests for the `Op::SummarizeContext` operation added to verify that
+//! summarization requests are properly handled and injected as user input.
+
+use std::time::Duration;
+
+use codex_core::Codex;
+use codex_core::protocol::EventMsg;
+use codex_core::protocol::InputItem;
+use codex_core::protocol::Op;
+mod test_support;
+use tempfile::TempDir;
+use test_support::load_default_config_for_test;
+use tokio::sync::Notify;
+use tokio::time::timeout;
+
+/// Helper function to set up a codex session and wait for it to be configured
+async fn setup_configured_codex_session() -> Codex {
+    let codex_home = TempDir::new().unwrap();
+    let config = load_default_config_for_test(&codex_home);
+    let (codex, _init_id) = Codex::spawn(config, std::sync::Arc::new(Notify::new()))
+        .await
+        .unwrap();
+
+    // Wait for session configured
+    loop {
+        let event = timeout(Duration::from_secs(5), codex.next_event())
+            .await
+            .expect("timeout waiting for session configured")
+            .expect("codex closed");
+
+        if matches!(event.msg, EventMsg::SessionConfigured(_)) {
+            break;
+        }
+    }
+
+    codex
+}
+
+#[tokio::test]
+async fn test_summarize_context_spawns_new_agent_task() {
+    // Test the specific behavior: when there's no current task,
+    // SummarizeContext should spawn a new AgentTask with the summarization prompt
+    let codex = setup_configured_codex_session().await;
+
+    // At this point, there should be no current task running
+    // Submit SummarizeContext operation - this should trigger:
+    // if let Err(items) = sess.inject_input(summarization_prompt) {
+    //     let task = AgentTask::spawn(Arc::clone(sess), sub.id, items);
+    //     sess.set_task(task);
+    // }
+    let _sub_id = codex.submit(Op::SummarizeContext).await.unwrap();
+
+    // Should receive a TaskStarted event indicating a new AgentTask was spawned
+    let event = timeout(Duration::from_secs(5), codex.next_event())
+        .await
+        .expect("timeout waiting for task started event")
+        .expect("codex closed");
+
+    assert!(
+        matches!(event.msg, EventMsg::TaskStarted),
+        "Expected TaskStarted when no current task exists - should spawn new AgentTask"
+    );
+}
+
+#[tokio::test]
+async fn test_summarize_context_injects_into_running_task() {
+    // Test that when a task IS running, SummarizeContext injects into the existing task
+    let codex = setup_configured_codex_session().await;
+
+    // First, start a task by submitting user input
+    let _input_sub_id = codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text {
+                text: "Hello, this should start a task".to_string(),
+            }],
+        })
+        .await
+        .unwrap();
+
+    // Wait for the task to start
+    let event = timeout(Duration::from_secs(5), codex.next_event())
+        .await
+        .expect("timeout waiting for task started")
+        .expect("codex closed");
+
+    assert!(
+        matches!(event.msg, EventMsg::TaskStarted),
+        "First task should start"
+    );
+
+    // Now submit SummarizeContext while a task is running
+    // This should test the inject_input SUCCESS path (not the spawn new task path)
+    let _summary_sub_id = codex.submit(Op::SummarizeContext).await.unwrap();
+
+    // The summarization prompt should be injected into the existing task
+    // rather than spawning a new one. We shouldn't get another TaskStarted event
+    let result = timeout(Duration::from_millis(500), codex.next_event()).await;
+
+    // If we get an event, it should NOT be TaskStarted (since we're injecting into existing task)
+    if let Ok(Ok(event)) = result {
+        assert!(
+            !matches!(event.msg, EventMsg::TaskStarted),
+            "Should not spawn new task when one is already running - should inject instead"
+        );
+    }
+    // If we timeout, that's expected - no immediate event for successful injection
+}