Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Keep rollout trace terminal sessions distinct when process IDs are reused (#56011)

cassirer-openaideede7201da2
diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rs
index 37a4759b82..5c4a429b3f 100644
--- a/codex-rs/core/src/unified_exec/process_manager.rs
+++ b/codex-rs/core/src/unified_exec/process_manager.rs
@@ -996,6 +996,15 @@ impl UnifiedExecProcessManager {
} = self
.prepare_process_handles(process_id, &locked_process)
.await?;
+ context
+ .session
+ .services
+ .rollout_thread_trace
+ .record_stdin_target(
+ &context.step_context.turn.sub_id,
+ &context.call_id,
+ &call_id,
+ );
let remote_exited =
process.has_exited() && output.drain_policy == OutputDrainPolicy::WaitForOutputClosure;
// A write racing with remote exit still collects the final output.
diff --git a/codex-rs/rollout-trace/src/model/runtime.rs b/codex-rs/rollout-trace/src/model/runtime.rs
index 297166e5b7..36b399ac47 100644
--- a/codex-rs/rollout-trace/src/model/runtime.rs
+++ b/codex-rs/rollout-trace/src/model/runtime.rs
@@ -215,7 +215,7 @@ pub enum ToolCallSummary {
},
}
-/// Reusable terminal process/session returned by the runtime.
+/// One terminal process lifetime, including its command and subsequent polls.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TerminalSession {
pub terminal_id: TerminalId,
@@ -230,7 +230,7 @@ pub struct TerminalSession {
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TerminalOperation {
pub operation_id: TerminalOperationId,
- /// Runtime terminal/process ID. `None` is legal only while the operation that creates it is starting.
+ /// Reduced session identity, distinct from the recyclable runtime process ID.
pub terminal_id: Option<TerminalId>,
pub tool_call_id: ToolCallId,
pub kind: TerminalOperationKind,
diff --git a/codex-rs/rollout-trace/src/raw_event.rs b/codex-rs/rollout-trace/src/raw_event.rs
index bd9010d7bb..b8ec8f315e 100644
--- a/codex-rs/rollout-trace/src/raw_event.rs
+++ b/codex-rs/rollout-trace/src/raw_event.rs
@@ -144,6 +144,11 @@ pub enum RawTraceEventPayload {
tool_call_id: ToolCallId,
mcp_call_id: McpCallId,
},
+ /// Exec selected by the runtime after resolving a recyclable process handle.
+ StdinTargetResolved {
+ tool_call_id: ToolCallId,
+ exec_tool_call_id: ToolCallId,
+ },
ToolCallRuntimeStarted {
tool_call_id: ToolCallId,
/// Runtime/protocol observation for how Codex began executing the tool.
@@ -243,6 +248,7 @@ impl RawTraceEventPayload {
| RawTraceEventPayload::CompactionRequestFailed { .. }
| RawTraceEventPayload::CodeCellStarted { .. }
| RawTraceEventPayload::McpToolCallCorrelationAssigned { .. }
+ | RawTraceEventPayload::StdinTargetResolved { .. }
| RawTraceEventPayload::AgentResultObserved {
carried_payload: None,
..
diff --git a/codex-rs/rollout-trace/src/reducer/mod.rs b/codex-rs/rollout-trace/src/reducer/mod.rs
index 91eeba55d4..123c0cbff6 100644
--- a/codex-rs/rollout-trace/src/reducer/mod.rs
+++ b/codex-rs/rollout-trace/src/reducer/mod.rs
@@ -57,6 +57,8 @@ pub fn replay_bundle(bundle_dir: impl AsRef<Path>) -> Result<RolloutTrace> {
bundle_dir: bundle_dir.to_path_buf(),
next_conversation_item_ordinal: 1,
next_terminal_operation_ordinal: 1,
+ terminal_ids_by_process: BTreeMap::new(),
+ process_ids_by_terminal: BTreeMap::new(),
thread_conversation_snapshots: BTreeMap::new(),
pending_compaction_replacement_item_ids: BTreeMap::new(),
code_cell_ids_by_runtime: BTreeMap::new(),
@@ -90,6 +92,10 @@ struct TraceReducer {
bundle_dir: PathBuf,
next_conversation_item_ordinal: u64,
next_terminal_operation_ordinal: u64,
+ /// Latest session for each thread-local runtime handle; each exec replaces it.
+ terminal_ids_by_process: BTreeMap<(String, String), String>,
+ /// Retains the begin/end consistency check when a handle is later reused.
+ process_ids_by_terminal: BTreeMap<String, String>,
/// Last model-visible conversation snapshot per thread.
///
/// Requests and responses both advance this sequence because both are
@@ -267,6 +273,12 @@ impl TraceReducer {
} => {
self.assign_mcp_tool_call_correlation(tool_call_id, mcp_call_id)?;
}
+ RawTraceEventPayload::StdinTargetResolved {
+ tool_call_id,
+ exec_tool_call_id,
+ } => {
+ self.resolve_stdin_target(&tool_call_id, &exec_tool_call_id)?;
+ }
RawTraceEventPayload::ToolCallRuntimeStarted {
tool_call_id,
runtime_payload,
diff --git a/codex-rs/rollout-trace/src/reducer/tool.rs b/codex-rs/rollout-trace/src/reducer/tool.rs
index 20e1e2af47..45913b0a2b 100644
--- a/codex-rs/rollout-trace/src/reducer/tool.rs
+++ b/codex-rs/rollout-trace/src/reducer/tool.rs
@@ -101,9 +101,8 @@ impl TraceReducer {
self.thread_mut(&thread_id)?;
- // Some terminal-like tools, notably write_stdin, do not emit a richer
- // runtime begin event. For those tools the canonical invocation is the
- // only place to recover the terminal/session join key.
+ // write_stdin has no protocol runtime-begin event, so its request comes
+ // from the canonical invocation. Runtime resolution can refine its session link.
let terminal_operation_id = self.start_terminal_operation_from_invocation(
seq,
wall_time_unix_ms,
diff --git a/codex-rs/rollout-trace/src/reducer/tool/terminal.rs b/codex-rs/rollout-trace/src/reducer/tool/terminal.rs
index f9c6bc3788..13f56d7461 100644
--- a/codex-rs/rollout-trace/src/reducer/tool/terminal.rs
+++ b/codex-rs/rollout-trace/src/reducer/tool/terminal.rs
@@ -5,6 +5,9 @@
//! runtime details. Direct tools without protocol observations, such as
//! `write_stdin`, can still form a terminal row from the canonical dispatch
//! invocation/result payloads when those payloads carry the session join key.
+//! Runtime process handles are recyclable and thread-local. Each exec creates a
+//! distinct reduced session; stdin uses the runtime's resolved exec when recorded,
+//! falling back to the latest session for its handle in older traces.
use anyhow::Context;
use anyhow::Result;
@@ -114,7 +117,7 @@ impl TraceReducer {
) -> Result<Option<TerminalOperationId>> {
let operation_id = self.next_terminal_operation_id();
let ParsedTerminalRequest {
- terminal_id,
+ process_id,
request,
} = start.request;
@@ -122,7 +125,7 @@ impl TraceReducer {
operation_id.clone(),
TerminalOperation {
operation_id: operation_id.clone(),
- terminal_id: terminal_id.clone(),
+ terminal_id: None,
tool_call_id: start.tool_call_id.to_string(),
kind: start.operation_kind,
execution: ExecutionWindow {
@@ -139,14 +142,8 @@ impl TraceReducer {
},
);
- if let Some(terminal_id) = terminal_id {
- self.ensure_terminal_session(
- start.thread_id,
- &terminal_id,
- &operation_id,
- start.wall_time_unix_ms,
- start.seq,
- )?;
+ if let Some(process_id) = process_id {
+ self.attach_terminal_session(start.thread_id, &process_id, &operation_id)?;
}
Ok(Some(operation_id))
@@ -185,7 +182,7 @@ impl TraceReducer {
})
.transpose()?;
- let (terminal_id, started_at_unix_ms, started_seq) = {
+ let process_id = {
let Some(operation) = self.rollout.terminal_operations.get_mut(operation_id) else {
bail!("terminal end referenced unknown operation {operation_id}");
};
@@ -195,84 +192,128 @@ impl TraceReducer {
if let Some((raw_payload_id, response)) = response {
push_unique(&mut operation.raw_payload_ids, &raw_payload_id);
- // If begin and end both report a process id they must name the
- // same terminal. If begin omitted it, the end event completes
- // the session join key for this operation.
- match (&operation.terminal_id, response.terminal_id.as_deref()) {
- (Some(existing), Some(process_id)) if existing != process_id => {
- bail!(
- "terminal operation {operation_id} changed process id from \
- {existing} to {process_id}"
- );
- }
- (None, Some(process_id)) => {
- operation.terminal_id = Some(process_id.to_string());
- }
- (Some(_), Some(_)) | (Some(_), None) | (None, None) => {}
- }
operation.result = Some(response.result);
+ response.process_id
+ } else {
+ None
}
-
- (
- operation.terminal_id.clone(),
- operation.execution.started_at_unix_ms,
- operation.execution.started_seq,
- )
};
- if let Some(terminal_id) = terminal_id {
- self.ensure_terminal_session(
- thread_id,
- &terminal_id,
- operation_id,
- started_at_unix_ms,
- started_seq,
- )?;
+ if let Some(process_id) = process_id {
+ self.attach_terminal_session(thread_id, &process_id, operation_id)?;
}
Ok(())
}
- fn ensure_terminal_session(
+ fn attach_terminal_session(
&mut self,
thread_id: &str,
- terminal_id: &str,
+ process_id: &str,
operation_id: &str,
- started_at_unix_ms: i64,
- started_seq: RawEventSeq,
) -> Result<()> {
- if !self.rollout.terminal_sessions.contains_key(terminal_id) {
- self.rollout.terminal_sessions.insert(
- terminal_id.to_string(),
- TerminalSession {
- terminal_id: terminal_id.to_string(),
- thread_id: thread_id.to_string(),
- created_by_operation_id: operation_id.to_string(),
- operation_ids: Vec::new(),
- execution: ExecutionWindow {
- started_at_unix_ms,
- started_seq,
- // Current raw events do not report a terminal/session
- // shutdown boundary, so the session remains open even
- // after individual operations complete.
- ended_at_unix_ms: None,
- ended_seq: None,
- status: ExecutionStatus::Running,
- },
- },
- );
+ let Some(operation) = self.rollout.terminal_operations.get_mut(operation_id) else {
+ bail!("terminal session referenced unknown operation {operation_id}");
+ };
+ if let Some(terminal_id) = &operation.terminal_id {
+ let existing = &self.process_ids_by_terminal[terminal_id];
+ if existing != process_id {
+ bail!(
+ "terminal operation {operation_id} changed process id from {existing} to {process_id}"
+ );
+ }
+ return Ok(());
}
- let Some(session) = self.rollout.terminal_sessions.get_mut(terminal_id) else {
- bail!("terminal session {terminal_id} disappeared during reduction");
+ let key = (thread_id.to_string(), process_id.to_string());
+ let existing = match operation.kind {
+ TerminalOperationKind::ExecCommand => None,
+ TerminalOperationKind::WriteStdin => self.terminal_ids_by_process.get(&key).cloned(),
};
- if session.thread_id != thread_id {
- bail!(
- "terminal session {terminal_id} belongs to thread {}, not {thread_id}",
- session.thread_id
- );
- }
+ let terminal_id = existing.unwrap_or_else(|| format!("terminal_session:{operation_id}"));
+ let session = self
+ .rollout
+ .terminal_sessions
+ .entry(terminal_id.clone())
+ .or_insert_with(|| TerminalSession {
+ terminal_id: terminal_id.clone(),
+ thread_id: thread_id.to_string(),
+ created_by_operation_id: operation_id.to_string(),
+ operation_ids: Vec::new(),
+ execution: ExecutionWindow {
+ started_at_unix_ms: operation.execution.started_at_unix_ms,
+ started_seq: operation.execution.started_seq,
+ // Raw events do not report session release: buffered output
+ // can still be collected after the process exits.
+ ended_at_unix_ms: None,
+ ended_seq: None,
+ status: ExecutionStatus::Running,
+ },
+ });
push_unique(&mut session.operation_ids, operation_id);
+ operation.terminal_id = Some(terminal_id.clone());
+ self.process_ids_by_terminal
+ .insert(terminal_id.clone(), process_id.to_string());
+ self.terminal_ids_by_process.insert(key, terminal_id);
+ Ok(())
+ }
+
+ /// Replaces the provisional handle-based join with the runtime's actual target.
+ pub(in crate::reducer) fn resolve_stdin_target(
+ &mut self,
+ tool_call_id: &str,
+ exec_tool_call_id: &str,
+ ) -> Result<()> {
+ let stdin = self
+ .rollout
+ .tool_calls
+ .get(tool_call_id)
+ .with_context(|| format!("stdin target referenced unknown call {tool_call_id}"))?;
+ let exec = self
+ .rollout
+ .tool_calls
+ .get(exec_tool_call_id)
+ .with_context(|| format!("stdin target referenced unknown exec {exec_tool_call_id}"))?;
+ let (Some(operation_id), Some(exec_operation_id)) =
+ (&stdin.terminal_operation_id, &exec.terminal_operation_id)
+ else {
+ // A failed payload write can leave either call without a terminal projection.
+ return Ok(());
+ };
+ let Some(terminal_id) = self.rollout.terminal_operations[exec_operation_id]
+ .terminal_id
+ .clone()
+ else {
+ return Ok(());
+ };
+ let operation = self
+ .rollout
+ .terminal_operations
+ .get_mut(operation_id)
+ .with_context(|| format!("stdin target referenced unknown operation {operation_id}"))?;
+ if operation.terminal_id.as_ref() == Some(&terminal_id) {
+ return Ok(());
+ }
+ // Move this operation without rewinding the handle lookup: a newer exec
+ // may already own that handle by the time resolution is recorded.
+ if let Some(previous) = operation.terminal_id.replace(terminal_id.clone()) {
+ let session = self
+ .rollout
+ .terminal_sessions
+ .get_mut(&previous)
+ .with_context(|| format!("stdin target referenced unknown session {previous}"))?;
+ session.operation_ids.retain(|id| id != operation_id);
+ if session.operation_ids.is_empty() {
+ self.rollout.terminal_sessions.remove(&previous);
+ self.process_ids_by_terminal.remove(&previous);
+ }
+ }
+ self.rollout
+ .terminal_sessions
+ .get_mut(&terminal_id)
+ .with_context(|| format!("stdin target referenced unknown session {terminal_id}"))?
+ .operation_ids
+ .push(operation_id.clone());
Ok(())
}
@@ -354,12 +395,12 @@ struct TerminalOperationStart<'a> {
}
struct ParsedTerminalRequest {
- terminal_id: Option<String>,
+ process_id: Option<String>,
request: TerminalRequest,
}
struct ParsedTerminalResponse {
- terminal_id: Option<String>,
+ process_id: Option<String>,
result: TerminalResult,
}
@@ -369,7 +410,7 @@ fn parse_protocol_terminal_request(
) -> ParsedTerminalRequest {
// Startup/poll paths usually include a process id at begin time, but plain
// exec starts may only learn it in the matching end event.
- let terminal_id = payload.process_id.clone();
+ let process_id = payload.process_id.clone();
let request = match operation_kind {
TerminalOperationKind::ExecCommand => TerminalRequest::ExecCommand {
display_command: payload.command.join(" "),
@@ -385,7 +426,7 @@ fn parse_protocol_terminal_request(
},
};
ParsedTerminalRequest {
- terminal_id,
+ process_id,
request,
}
}
@@ -416,11 +457,11 @@ fn parse_dispatch_terminal_request(value: JsonValue) -> Result<Option<ParsedTerm
.context("write_stdin dispatch payload omitted function arguments")?;
let args: DispatchedWriteStdinArgs = serde_json::from_str(&arguments)
.context("parse write_stdin dispatch function arguments")?;
- let terminal_id = terminal_id_from_json(&args.session_id)
+ let process_id = process_id_from_json(&args.session_id)
.context("write_stdin dispatch payload omitted session_id")?;
Ok(Some(ParsedTerminalRequest {
- terminal_id: Some(terminal_id),
+ process_id: Some(process_id),
request: TerminalRequest::WriteStdin {
stdin: args.chars,
yield_time_ms: args.yield_time_ms,
@@ -456,7 +497,7 @@ fn parse_terminal_response_payload(
fn parse_protocol_terminal_response(payload: ExecCommandEndPayload) -> ParsedTerminalResponse {
ParsedTerminalResponse {
- terminal_id: payload.process_id,
+ process_id: payload.process_id,
result: TerminalResult {
exit_code: Some(payload.exit_code),
stdout: payload.aggregated_output,
@@ -502,7 +543,7 @@ fn parse_dispatch_terminal_response(value: JsonValue) -> Result<ParsedTerminalRe
},
};
Ok(ParsedTerminalResponse {
- terminal_id: None,
+ process_id: None,
result,
})
}
@@ -547,7 +588,7 @@ fn json_text_content(value: &JsonValue) -> Option<String> {
}
}
-fn terminal_id_from_json(value: &JsonValue) -> Option<String> {
+fn process_id_from_json(value: &JsonValue) -> Option<String> {
match value {
JsonValue::String(value) if !value.is_empty() => Some(value.clone()),
JsonValue::Number(value) => Some(value.to_string()),
diff --git a/codex-rs/rollout-trace/src/reducer/tool/terminal_tests.rs b/codex-rs/rollout-trace/src/reducer/tool/terminal_tests.rs
index a42f3bbd0d..cd7ac59146 100644
--- a/codex-rs/rollout-trace/src/reducer/tool/terminal_tests.rs
+++ b/codex-rs/rollout-trace/src/reducer/tool/terminal_tests.rs
@@ -18,8 +18,11 @@ use crate::raw_event::RawTraceEventPayload;
use crate::reducer::test_support::create_started_writer;
use crate::reducer::test_support::generic_summary;
use crate::reducer::test_support::message;
+use crate::reducer::test_support::start_thread;
use crate::reducer::test_support::start_turn;
+use crate::reducer::test_support::start_turn_for_thread;
use crate::reducer::test_support::trace_context;
+use crate::reducer::test_support::trace_context_for_thread;
use crate::replay_bundle;
use crate::writer::TraceWriter;
@@ -157,7 +160,7 @@ fn exec_tool_reduces_to_terminal_operation_and_session() -> anyhow::Result<()> {
rollout.terminal_operations[&operation_id],
TerminalOperation {
operation_id: operation_id.clone(),
- terminal_id: Some("pty-1".to_string()),
+ terminal_id: Some("terminal_session:terminal_operation:1".to_string()),
tool_call_id: "tool-1".to_string(),
kind: TerminalOperationKind::ExecCommand,
execution: ExecutionWindow {
@@ -193,9 +196,9 @@ fn exec_tool_reduces_to_terminal_operation_and_session() -> anyhow::Result<()> {
},
);
assert_eq!(
- rollout.terminal_sessions["pty-1"],
+ rollout.terminal_sessions["terminal_session:terminal_operation:1"],
TerminalSession {
- terminal_id: "pty-1".to_string(),
+ terminal_id: "terminal_session:terminal_operation:1".to_string(),
thread_id: "thread-root".to_string(),
created_by_operation_id: operation_id.clone(),
operation_ids: vec![operation_id],
@@ -213,90 +216,113 @@ fn exec_tool_reduces_to_terminal_operation_and_session() -> anyhow::Result<()> {
}
#[test]
-fn write_stdin_operation_reuses_existing_terminal_session() -> anyhow::Result<()> {
+fn reused_process_ids_keep_sessions_and_stdin_joins_distinct() -> anyhow::Result<()> {
let temp = TempDir::new()?;
let writer = create_started_writer(&temp)?;
start_turn(&writer, "turn-1")?;
+ start_thread(&writer, "child", "/root/child")?;
+ start_turn_for_thread(&writer, "child", "child-turn")?;
+ let mut reused_stdin = None;
- let startup_payload = writer.write_json_payload(
- RawPayloadKind::ToolRuntimeEvent,
- &json!({
- "call_id": "tool-start",
- "process_id": "pty-1",
- "turn_id": "turn-1",
- "command": ["bash"],
- "cwd": "/repo"
- }),
- )?;
- writer.append_with_context(
- trace_context("turn-1"),
- RawTraceEventPayload::ToolCallStarted {
- tool_call_id: "tool-start".to_string(),
- model_visible_call_id: None,
- code_mode_runtime_tool_id: None,
- requester: crate::raw_event::RawToolCallRequester::Model,
- kind: ToolCallKind::ExecCommand,
- summary: generic_summary("exec_command"),
- invocation_payload: None,
- },
- )?;
- writer.append_with_context(
- trace_context("turn-1"),
- RawTraceEventPayload::ToolCallRuntimeStarted {
- tool_call_id: "tool-start".to_string(),
- runtime_payload: startup_payload,
- },
- )?;
-
- let stdin_payload = writer.write_json_payload(
- RawPayloadKind::ToolRuntimeEvent,
- &json!({
- "call_id": "tool-stdin",
- "process_id": "pty-1",
- "turn_id": "turn-1",
- "command": ["bash"],
- "cwd": "/repo",
- "interaction_input": "echo hi\n"
- }),
- )?;
- let _stdin_start = writer.append_with_context(
- trace_context("turn-1"),
- RawTraceEventPayload::ToolCallStarted {
- tool_call_id: "tool-stdin".to_string(),
- model_visible_call_id: None,
- code_mode_runtime_tool_id: None,
- requester: crate::raw_event::RawToolCallRequester::Model,
- kind: ToolCallKind::WriteStdin,
- summary: generic_summary("write_stdin"),
- invocation_payload: None,
- },
- )?;
- let stdin_runtime_start = writer.append_with_context(
- trace_context("turn-1"),
- RawTraceEventPayload::ToolCallRuntimeStarted {
- tool_call_id: "tool-stdin".to_string(),
- runtime_payload: stdin_payload,
- },
- )?;
+ // Real rollouts reuse process IDs both across threads and after an exec
+ // finishes. Polls must stay with the corresponding exec, not the last
+ // occurrence of the process number anywhere in the rollout.
+ for (index, (thread, turn, kind)) in [
+ ("thread-root", "turn-1", ToolCallKind::ExecCommand),
+ ("child", "child-turn", ToolCallKind::ExecCommand),
+ ("thread-root", "turn-1", ToolCallKind::WriteStdin),
+ ("child", "child-turn", ToolCallKind::WriteStdin),
+ ("thread-root", "turn-1", ToolCallKind::ExecCommand),
+ ("thread-root", "turn-1", ToolCallKind::WriteStdin),
+ ]
+ .into_iter()
+ .enumerate()
+ {
+ if index == 4 {
+ let response = writer.write_json_payload(
+ RawPayloadKind::ToolRuntimeEvent,
+ &json!({"process_id": "123", "exit_code": 0}),
+ )?;
+ writer.append_with_context(
+ trace_context("turn-1"),
+ RawTraceEventPayload::ToolCallRuntimeEnded {
+ tool_call_id: "tool-0".to_string(),
+ status: ExecutionStatus::Completed,
+ runtime_payload: response,
+ },
+ )?;
+ }
+ let tool_call_id = format!("tool-{index}");
+ writer.append_with_context(
+ trace_context_for_thread(thread, turn),
+ RawTraceEventPayload::ToolCallStarted {
+ tool_call_id: tool_call_id.clone(),
+ model_visible_call_id: None,
+ code_mode_runtime_tool_id: None,
+ requester: crate::raw_event::RawToolCallRequester::Model,
+ kind,
+ summary: generic_summary("terminal"),
+ invocation_payload: None,
+ },
+ )?;
+ let request = writer.write_json_payload(
+ RawPayloadKind::ToolRuntimeEvent,
+ &json!({
+ "process_id": "123",
+ "command": ["bash"],
+ "cwd": "/repo",
+ "interaction_input": (index == 5).then_some("echo hi\n"),
+ }),
+ )?;
+ let request_id = request.raw_payload_id.clone();
+ let runtime_start = writer.append_with_context(
+ trace_context_for_thread(thread, turn),
+ RawTraceEventPayload::ToolCallRuntimeStarted {
+ tool_call_id,
+ runtime_payload: request,
+ },
+ )?;
+ if index == 5 {
+ reused_stdin = Some((runtime_start, request_id));
+ }
+ }
let rollout = replay_bundle(temp.path())?;
- let startup_operation_id = "terminal_operation:1".to_string();
- let stdin_operation_id = "terminal_operation:2".to_string();
-
+ let groups = rollout
+ .terminal_sessions
+ .values()
+ .map(|session| {
+ let calls = session
+ .operation_ids
+ .iter()
+ .map(|id| {
+ let operation = &rollout.terminal_operations[id];
+ assert_eq!(operation.terminal_id.as_ref(), Some(&session.terminal_id));
+ operation.tool_call_id.as_str()
+ })
+ .collect::<Vec<_>>();
+ (session.thread_id.as_str(), calls)
+ })
+ .collect::<Vec<_>>();
assert_eq!(
- rollout.terminal_sessions["pty-1"].operation_ids,
- vec![startup_operation_id, stdin_operation_id.clone()],
+ groups,
+ vec![
+ ("thread-root", vec!["tool-0", "tool-2"]),
+ ("child", vec!["tool-1", "tool-3"]),
+ ("thread-root", vec!["tool-4", "tool-5"]),
+ ],
);
+ let (runtime_start, request_id) = reused_stdin.unwrap();
assert_eq!(
- rollout.terminal_operations[&stdin_operation_id],
+ rollout.terminal_operations["terminal_operation:6"],
TerminalOperation {
- operation_id: stdin_operation_id.clone(),
- terminal_id: Some("pty-1".to_string()),
- tool_call_id: "tool-stdin".to_string(),
+ operation_id: "terminal_operation:6".to_string(),
+ terminal_id: Some("terminal_session:terminal_operation:5".to_string()),
+ tool_call_id: "tool-5".to_string(),
kind: TerminalOperationKind::WriteStdin,
execution: ExecutionWindow {
- started_at_unix_ms: stdin_runtime_start.wall_time_unix_ms,
- started_seq: stdin_runtime_start.seq,
+ started_at_unix_ms: runtime_start.wall_time_unix_ms,
+ started_seq: runtime_start.seq,
ended_at_unix_ms: None,
ended_seq: None,
status: ExecutionStatus::Running,
@@ -308,10 +334,39 @@ fn write_stdin_operation_reuses_existing_terminal_session() -> anyhow::Result<()
},
result: None,
model_observations: Vec::new(),
- raw_payload_ids: vec!["raw_payload:2".to_string()],
+ raw_payload_ids: vec![request_id],
},
);
+ // Stdin started while tool-0 owned the handle, but dispatch was delayed
+ // until tool-4 replaced it. Only its session membership should change.
+ writer.append_with_context(
+ trace_context("turn-1"),
+ RawTraceEventPayload::StdinTargetResolved {
+ tool_call_id: "tool-2".to_string(),
+ exec_tool_call_id: "tool-4".to_string(),
+ },
+ )?;
+ let mut expected = rollout;
+ let previous = "terminal_session:terminal_operation:1";
+ let resolved = "terminal_session:terminal_operation:5";
+ expected
+ .terminal_sessions
+ .get_mut(previous)
+ .unwrap()
+ .operation_ids = vec!["terminal_operation:1".to_string()];
+ expected
+ .terminal_sessions
+ .get_mut(resolved)
+ .unwrap()
+ .operation_ids
+ .push("terminal_operation:3".to_string());
+ expected
+ .terminal_operations
+ .get_mut("terminal_operation:3")
+ .unwrap()
+ .terminal_id = Some(resolved.to_string());
+ assert_eq!(replay_bundle(temp.path())?, expected);
Ok(())
}
@@ -389,7 +444,7 @@ fn dispatch_write_stdin_payload_reduces_to_terminal_operation() -> anyhow::Resul
rollout.terminal_operations[&operation_id],
TerminalOperation {
operation_id: operation_id.clone(),
- terminal_id: Some("123".to_string()),
+ terminal_id: Some("terminal_session:terminal_operation:1".to_string()),
tool_call_id: "tool-stdin".to_string(),
kind: TerminalOperationKind::WriteStdin,
execution: ExecutionWindow {
@@ -417,9 +472,9 @@ fn dispatch_write_stdin_payload_reduces_to_terminal_operation() -> anyhow::Resul
},
);
assert_eq!(
- rollout.terminal_sessions["123"],
+ rollout.terminal_sessions["terminal_session:terminal_operation:1"],
TerminalSession {
- terminal_id: "123".to_string(),
+ terminal_id: "terminal_session:terminal_operation:1".to_string(),
thread_id: "thread-root".to_string(),
created_by_operation_id: operation_id.clone(),
operation_ids: vec![operation_id],
diff --git a/codex-rs/rollout-trace/src/thread.rs b/codex-rs/rollout-trace/src/thread.rs
index 514b8d382b..4a38bacaff 100644
--- a/codex-rs/rollout-trace/src/thread.rs
+++ b/codex-rs/rollout-trace/src/thread.rs
@@ -247,6 +247,25 @@ impl ThreadTraceContext {
context.append_with_context_best_effort(codex_turn_id.into(), payload);
}
+ /// Records the exec actually selected by stdin, since its process handle can be reused.
+ pub fn record_stdin_target(
+ &self,
+ codex_turn_id: &str,
+ tool_call_id: &str,
+ exec_tool_call_id: &str,
+ ) {
+ let ThreadTraceContextState::Enabled(context) = &self.state else {
+ return;
+ };
+ context.append_with_context_best_effort(
+ codex_turn_id.to_string(),
+ RawTraceEventPayload::StdinTargetResolved {
+ tool_call_id: tool_call_id.to_string(),
+ exec_tool_call_id: exec_tool_call_id.to_string(),
+ },
+ );
+ }
+
/// Emits the v2 child-to-parent completion message as an explicit graph edge.
///
/// The notification is runtime delivery from a completed child turn into