fix(plugin): advertise codex experimental api

Send `capabilities.experimentalApi = true` during Codex app-server
initialization so `thread/start` accepts `runtimeWorkspaceRoots` for the
workspace-scoped chat session.

Extend the live app-server smoke to start a thread with
`runtimeWorkspaceRoots` without starting a model turn, covering the protocol
path that the chat pane uses on submit.

Author: fcoury

docs/codex-integration-plan.md

@@ -168,7 +168,8 @@ Acceptance checks:
 - Terminal smoke coverage can open the Codex Chat Window, submit a prompt to a
   fake app-server, and verify streamed assistant text is rendered.
 - Opt-in live app-server smoke coverage can initialize the installed Codex CLI
-  over stdio and list project sessions without starting a model turn.
+  over stdio, list project sessions, and start a thread with
+  `runtimeWorkspaceRoots` without starting a model turn.
 
 ## Deferred Work
 

scripts/smoke-test-codex-live-app-server.sh

@@ -79,6 +79,9 @@ try:
                 "title": "Red Live Smoke",
                 "version": "0",
             },
+            "capabilities": {
+                "experimentalApi": True,
+            },
         },
     })
     initialize_result = read_response(0)
@@ -101,6 +104,21 @@ try:
         fail("codex app-server thread/list response was not an object")
     if "data" in list_result and not isinstance(list_result["data"], list):
         fail("codex app-server thread/list `data` field was not a list")
+    send({
+        "method": "thread/start",
+        "id": 2,
+        "params": {
+            "cwd": cwd,
+            "runtimeWorkspaceRoots": [cwd],
+        },
+    })
+    start_result = read_response(2)
+    thread = start_result.get("thread") if isinstance(start_result, dict) else None
+    if not isinstance(thread, dict) or not isinstance(thread.get("id"), str):
+        fail("codex app-server thread/start response did not include `thread.id`")
+    roots = start_result.get("runtimeWorkspaceRoots") if isinstance(start_result, dict) else None
+    if roots is not None and roots != [cwd]:
+        fail("codex app-server thread/start returned unexpected `runtimeWorkspaceRoots`")
     print("Codex live app-server smoke passed.")
 finally:
     process.kill()

src/plugin/runtime.rs

@@ -641,17 +641,7 @@ async fn op_codex_app_server_request(
     let endpoint = take_codex_app_server_endpoint(&mut params);
     let mut client = open_codex_app_server_client(endpoint.as_deref()).await?;
 
-    let initialize = json!({
-        "method": "initialize",
-        "id": 0,
-        "params": {
-            "clientInfo": {
-                "name": "red_codex_plugin",
-                "title": "Red Codex Plugin",
-                "version": env!("CARGO_PKG_VERSION")
-            }
-        }
-    });
+    let initialize = codex_initialize_request();
     client.send(initialize).await?;
 
     timeout(
@@ -703,19 +693,7 @@ async fn run_codex_turn_inner(
 
     let mut client = open_codex_app_server_client(endpoint.as_deref()).await?;
 
-    client
-        .send(json!({
-            "method": "initialize",
-            "id": 0,
-            "params": {
-                "clientInfo": {
-                    "name": "red_codex_plugin",
-                    "title": "Red Codex Plugin",
-                    "version": env!("CARGO_PKG_VERSION")
-                }
-            }
-        }))
-        .await?;
+    client.send(codex_initialize_request()).await?;
     timeout(
         Duration::from_secs(30),
         read_app_server_response(&mut client, 0),
@@ -941,6 +919,23 @@ fn is_app_server_request(value: &serde_json::Value) -> bool {
         && value.get("error").is_none()
 }
 
+fn codex_initialize_request() -> serde_json::Value {
+    json!({
+        "method": "initialize",
+        "id": 0,
+        "params": {
+            "clientInfo": {
+                "name": "red_codex_plugin",
+                "title": "Red Codex Plugin",
+                "version": env!("CARGO_PKG_VERSION")
+            },
+            "capabilities": {
+                "experimentalApi": true
+            }
+        }
+    })
+}
+
 fn is_interactive_app_server_request_method(method: &str) -> bool {
     matches!(
         method,
@@ -1537,6 +1532,20 @@ mod tests {
     use super::*;
     use tokio::net::TcpListener;
 
+    fn assert_codex_initialize_request(initialize: &Value) {
+        assert_eq!(
+            initialize.get("method").and_then(Value::as_str),
+            Some("initialize")
+        );
+        assert_eq!(initialize.get("id").and_then(Value::as_i64), Some(0));
+        assert_eq!(
+            initialize
+                .pointer("/params/capabilities/experimentalApi")
+                .and_then(Value::as_bool),
+            Some(true)
+        );
+    }
+
     #[tokio::test]
     async fn test_runtime_plugin() {
         let mut runtime = Runtime::new();
@@ -1672,11 +1681,7 @@ mod tests {
             let mut stream = tokio_tungstenite::accept_async(socket).await.unwrap();
 
             let initialize = read_fake_app_server_message(&mut stream).await;
-            assert_eq!(
-                initialize.get("method").and_then(Value::as_str),
-                Some("initialize")
-            );
-            assert_eq!(initialize.get("id").and_then(Value::as_i64), Some(0));
+            assert_codex_initialize_request(&initialize);
             write_fake_app_server_message(
                 &mut stream,
                 json!({
@@ -1844,10 +1849,7 @@ mod tests {
             let mut stream = tokio_tungstenite::accept_async(socket).await.unwrap();
 
             let initialize = read_fake_app_server_message(&mut stream).await;
-            assert_eq!(
-                initialize.get("method").and_then(Value::as_str),
-                Some("initialize")
-            );
+            assert_codex_initialize_request(&initialize);
             write_fake_app_server_message(&mut stream, json!({ "id": 0, "result": {} })).await;
 
             let initialized = read_fake_app_server_message(&mut stream).await;
@@ -1981,10 +1983,7 @@ mod tests {
             let mut stream = tokio_tungstenite::accept_async(socket).await.unwrap();
 
             let initialize = read_fake_app_server_message(&mut stream).await;
-            assert_eq!(
-                initialize.get("method").and_then(Value::as_str),
-                Some("initialize")
-            );
+            assert_codex_initialize_request(&initialize);
             write_fake_app_server_message(&mut stream, json!({ "id": 0, "result": {} })).await;
 
             let initialized = read_fake_app_server_message(&mut stream).await;