Summary: 2344 instances, 1312 unique

Text	Count
.unwrap_or_else(|_| panic!("protected create monitor thread panicked"));	1
panic!("expected UserInputAnswer");	10
other => panic!("expected incoming message, got {other:?}"),	2
serde_json::to_value(interface).unwrap(),	1
panic!("expected item started event");	2
other => panic!("unexpected notification: {other:?}"),	3
panic!("expected legacy response item");	1
panic!("expected initialized notification");	1
fs::create_dir_all(path.parent().expect("file should have a parent")).unwrap();	1
Err(error) => panic!("remote MCP should resolve: {error}"),	1
let newest_pinned = ThreadId::from_string("00000000-0000-0000-0000-000000000043").unwrap();	1
assert!(is_loopback_host(&Host::parse("LOCALHOST").unwrap()));	1
mitm_hooks: crate::mitm_hook::compile_mitm_hooks(&config).unwrap(),	1
let http_addr = http_listener.local_addr().unwrap();	3
assert_eq!(head, vec![serde_json::to_value(response_item).unwrap()]);	1
fs::write(dir.path().join("target.txt"), "target\n").unwrap();	1
panic!("expected raw response item event");	1
panic!("guardian error should deny the approval");	1
other => panic!("expected initialize incoming message, got {other:?}"),	2
let cwd_dir = tempfile::tempdir().unwrap();	1
let socks_addr = occupied_socks.local_addr().unwrap();	1
panic!("expected to find row containing {needle:?}, have rows: {rows:?}")	1
toml::from_str(config).unwrap(),	2
let http_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();	3
panic!("expected start hook event, got {event_name:?}")	1
_ => panic!("unexpected remaining event: {event:?}"),	1
panic!("failed to create stderr pipe for bubblewrap: {err}");	1
panic!("stopped goal should be updated for in-flight accounting");	1
.unwrap_or_else(|| panic!("managed proxy mode requires a proxy route spec"));	1
let set = compile_denylist_globset(&["*.Example.COM.".to_string()]).unwrap();	1
unreachable!("imagegen root schema must be an object");	1
other => panic!("expected process start request, got {other:?}"),	1
let codex_home = TempDir::new().unwrap();	4
state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),	1
let link_s = link.to_str().unwrap().to_string();	1
Some(&HeaderValue::from_str(&format!("Bearer {dummy_token}")).unwrap())	1
headers.insert(ETAG, etag.parse().unwrap());	1
other => panic!("unexpected lower-watermark phase2 claim outcome: {other:?}"),	1
GuardianAssessmentAction::Command { .. } => unreachable!(),	1
panic!("expected stop hook event, got {event_name:?}");	1
panic!("test process should be running");	2
source.read_exact(&mut expected[..chunk.len()]).unwrap();	1
_ => panic!("expected ImageGenerationBegin event"),	1
EventBrokerState::Paused | EventBrokerState::Start => unreachable!(),	1
_ => panic!("expected targeted server notification"),	1
let template = Template::parse("Hello, {{ name }}.").unwrap();	3
fs::write(&path, "foo\nbar\nbaz\n").unwrap();	2
std::fs::write(&file, "{}").unwrap();	1
.unwrap()	13
None => panic!("failed to resolve current process argv[0]"),	1
let absolute_dir = tempfile::tempdir().unwrap();	1
command.write_ansi(&mut out).unwrap();	1
fs::write(&path, "foo\nbar\n").unwrap();	1
other => panic!("expected InsertHistoryCell event, got {other:?}"),	11
other => panic!("expected initialize request, got {other:?}"),	5
let occupied_socks = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();	2
unreachable!("recovered turn submission cannot steer")	1
let logs = String::from_utf8(fb.snapshot(/*session_id*/ None).bytes).unwrap();	1
let cmds = parse_seq("rg -n \"foo\" -g\"*.py\"").unwrap();	1
let mut completed = mutex.lock().unwrap();	2
panic!("expected stdio transport");	2
dunce::canonicalize(&temp_dir).unwrap(),	1
fs::read_to_string(&absolute_update).unwrap(),	1
panic!("expected history batch response");	1
Err(err) => panic!("client notification should serialize: {err}"),	1
*self.sign_in_state.write().unwrap() = SignInState::PickMode;	1
other => panic!("expected resize frame, got {other:?}"),	1
let upgrade_all = UpgradeMarketplaceArgs::try_parse_from(["upgrade"]).unwrap();	1
unreachable!("ready turn environments always carry resolved configuration")	2
assert_eq!(fs::read_to_string(system_file).unwrap(), config);	1
assert_eq!(harness.initial_event_rx.await.unwrap(), terminated);	1
panic!("expected invalid image error");	1
other => panic!("unexpected third event: {other:?}"),	1
let writable_root = AbsolutePathBuf::try_from(root).unwrap();	1
record_added_marketplace_entry(codex_home.path(), "debug", &install_metadata).unwrap();	1
Poll::Ready(Ok(_)) => panic!("execution completed before the registry lock was released"),	1
let mut sign_in_state = self.sign_in_state.write().unwrap();	1
Ok(_) => panic!("stalled connect response should time out"),	1
std::fs::create_dir(&themes_dir).unwrap();	6
panic!("expected execution response after termination");	1
fs::rename(&pending_path, &ready_path).unwrap();	1
_ => panic!("unexpected histogram data type"),	1
let runtime = tokio::runtime::Runtime::new().unwrap();	4
fs::write(&absolute_update, "absolute old\n").unwrap();	1
event.lines().next().unwrap().as_bytes()	1
std::fs::write(root.join("file.txt"), "orig\n").unwrap();	2
symlink(&real, &link).unwrap();	1
*error.write().unwrap() = None;	3
fs::write(path, format!("contents {i}")).unwrap();	1
assert!(is_loopback_host(&Host::parse("localhost").unwrap()));	1
panic!("expected native, WSL, and OSC 52 errors");	1
unreachable!("root tool schema must be an object");	2
panic!("expected app link request");	1
panic!("expected targeted server notification envelope");	1
unreachable!(	1
.unwrap_or_else(|| panic!("cwd must be valid UTF-8"))	2
let first = ThreadId::from_string("00000000-0000-0000-0000-000000000061").unwrap();	1
other => panic!("expected connection opened, got {other:?}"),	9
Ok(_) => panic!("non-loopback ws should be rejected before connect"),	1
unreachable!("{BEDROCK_API_KEY_UNSUPPORTED_MESSAGE}")	1
assert!(transport.last_request.lock().unwrap().is_none());	1
assert!(is_non_public_ip("100.64.0.1".parse().unwrap()));	1
serde_json::from_value::<CodexUserSettingsResponse>(serde_json::json!({})).unwrap(),	1
let cmds = parse_seq("echo \"hello world\"").unwrap();	1
.unwrap() // Unwrap is safe thanks to the tests.	1
fs::write(&installed_root, "corrupt install root").unwrap();	1
panic!("expected initialized notification");	2
unreachable!("app server should be initialized for --fork --last");	1
write_session_file_with_meta_payload(home, ts, uuid, payload).unwrap();	2
state.auth_dot_json.lock().unwrap().clone()	1
assert!(is_non_public_ip("192.0.2.1".parse().unwrap()));	1
let (x, y) = t.cursor_pos_with_state(area, state).unwrap();	4
w.write_all(b"abcdefgh").unwrap();	1
persist_managed_ca_certificate(dir.path(), &certificate).unwrap();	1
assert_eq!(v.get("output").unwrap().as_str().unwrap(), "ok");	1
assert!(is_non_public_ip("192.168.0.1".parse().unwrap()));	1
(Some(_), Some(_)) => unreachable!("fork boundaries are mutually exclusive"),	2
Ok(_) => panic!("http error response should fail the websocket connect"),	1
.unwrap_or_else(|err| panic!("base branch backup review prompt must parse: {err}"))	1
let expected_page2_first = *page1.last().unwrap() + 1;	1
panic!("expected fallback remoteControl/enable request");	1
panic!("expected permissions approval request");	1
unreachable!("server message variant checked above");	1
let upgrade_one = UpgradeMarketplaceArgs::try_parse_from(["upgrade", "debug"]).unwrap();	1
Err(error) => panic!("route-aware client cache lock should not be poisoned: {error}"),	2
unreachable!("app server should be initialized for --resume <id>");	1
Err(err) => panic!("provider auth cwd must resolve: {err}"),	1
fs::write(path, TEST_SPRITESHEET.as_slice()).unwrap();	1
panic!("--verify-fd-mount is only supported in the inner sandbox stage");	1
.unwrap_or_else(|err| panic!("review prompt template must render: {err}"))	1
assert_eq!(tbl.get("a").unwrap().as_integer(), Some(1));	1
unimplemented!()	1
*error.write().unwrap() = Some(message);	1
panic!("error applying Linux sandbox restrictions: {e:?}");	2
let url = reqwest::Url::parse("https://chatgpt.com/a").unwrap();	1
parse_seq(r#"echo '/usr'"/"'local'/bin"#).unwrap(),	1
_ => panic!("unexpected fixture name: {name}"),	1
panic!("imagegen should advertise a namespace tool");	1
let contents = fs::read_to_string(&dest).unwrap();	1
panic!("expected message response");	1
let header = std::str::from_utf8(parts.next().unwrap()).unwrap();	1
assert_eq!(http_addr, "0.0.0.0:3128".parse::<SocketAddr>().unwrap());	1
fs::write(parent.join(".gitignore"), "*\n!.gitignore\n").unwrap();	2
let mut parser = PowershellParserProcess::spawn(powershell).unwrap();	6
.unwrap_or_else(|_| panic!("timed out waiting for exit\n{}", sandbox_log(codex_home)))	1
fs::write(&trust_bundle_path, "stale managed bundle\n").unwrap();	1
parse_host_port("127.0.0.1:8080", /*default_port*/ 3128).unwrap(),	1
let (_x, y) = t.cursor_pos_with_state(small_area, state).unwrap();	2
let mut complete_times = self.complete_times.lock().unwrap();	1
*widget.sign_in_state.write().unwrap() =	5
fs::create_dir_all(installed_root.parent().unwrap()).unwrap();	1
unreachable!("service operation retry loop should return on success or final error")	1
panic!("expected legacy compacted item");	1
std::fs::write(themes_dir.join("my-fancy.tmTheme"), "placeholder").unwrap();	1
fs::write(&system_file, config).unwrap();	1
Ok(other) => panic!("unexpected app event: {other:?}"),	9
serde_json::to_value(PluginSource::Local { path: local_path }).unwrap(),	1
.unwrap_or_else(|err| panic!("sandbox template must render: {err}"))	1
Ok(other) => panic!("expected OpenApprovalsPopup cancel event, got {other:?}"),	1
panic!("metric {name} missing");	1
unreachable!("compaction output must exist when count is exactly one");	1
panic!("unexpected error: {err:?}");	2
let path = entry.path().unwrap().to_string_lossy().into_owned();	1
AuthMode::BedrockApiKey => unreachable!("bedrock api key mode is handled above"),	1
unreachable!("prepared MCP calls retain their immutable permission authority");	1
completed = cv.wait(completed).unwrap();	1
assert!(state.is_unix_socket_allowed(&socket_path).await.unwrap());	1
panic!("completed goal should be updated for final accounting");	1
panic!("execution failed before the registry lock was released: {error}")	1
panic!("rule should match so heuristic should not be called");	1
let beta_start = t.text().find("beta").unwrap();	1
unreachable!("initialize retry loop should return on success or final error")	1
let path = path.canonicalize().unwrap();	1
"auto".parse::<ProtocolSelection>().unwrap(),	1
fs::create_dir(&config_path).unwrap();	1
panic!("failed to set bubblewrap child parent-death signal: {err}");	1
unreachable!("app server should exist when auth is required");	1
let mut mac = HmacSha256::new_from_slice(shared_secret).unwrap();	1
panic!("expected RGB color {expected:?}, got {color:?}");	1
other => panic!("expected placeholder text but found {other:?}"),	3
fs::write(&path, "foo\nbar\nbaz\nqux\n").unwrap();	1
other => panic!("expected feedback error history cell, saw {other:?}"),	1
panic!("meta must be an object");	1
resolve_addr("http://example.com:5555", /*default_port*/ 3128).unwrap(),	1
panic!("theme {theme_name} produced RGB foreground: {span:?}")	1
let socks_addr = socks_listener.local_addr().unwrap();	1
handle.join().unwrap();	1
other => panic!("unexpected banner action: {other:?}"),	1
let event = serde_json::from_value::<ItemCompletedEvent>(value).unwrap();	1
let url = builtin_pet_url(pet).unwrap();	1
&*widget.sign_in_state.read().unwrap(),	5
state.add_allowed_domain("user.example.com").await.unwrap();	1
Ok(out) => panic!("invalid byte should error, got output: {out:?}"),	1
fs::remove_file(binary_path).unwrap();	1
None => panic!("outbound notifications closed"),	1
other => panic!("expected queued follow-up submission, got {other:?}"),	2
other => panic!("expected recovery process/read request, got {other:?}"),	1
panic!("expected model command, got service tier {command:?}")	1
self.updates.lock().unwrap().clone()	1
.unwrap_or_else(|| panic!("expected url-like first row in screen rows: {rows:?}"));	1
panic!("write ide-context response failed: {err}");	1
panic!(	4
let fast = fast.unwrap_or_else(|err| panic!("fast request failed: {err:?}"));	1
panic!("expected agents subcommand");	1
fs::write(&path, "line1\nline2\nline3\n").unwrap();	1
.unwrap_or_else(|err| panic!("failed to serialize permission profile: {err}"));	2
Err(err) => panic!("read ide-context failed: {err}"),	1
fs::write(session_dir.path().join("binary.dat"), [0xff, 0xfe, 0xfd]).unwrap();	1
fs::copy(dir.path().join("pet.json"), avatar_dir.join("avatar.json")).unwrap();	1
std::fs::write(&sixel_frame, b"fake-sixel").unwrap();	2
panic!("initial yield delivery returned an actor error: {error:?}")	1
_ => panic!("Expected a single UpdateFile hunk"),	2
assert!(is_non_public_ip("0.1.2.3".parse().unwrap()));	1
let url = reqwest::Url::parse("wss://chatgpt.com/backend-api/codex/responses").unwrap();	1
let (x, y) = t.cursor_pos_with_state(small_area, state).unwrap();	1
panic!("expected server request event");	2
local_paths::load_plugin_share_local_paths(codex_home.path()).unwrap(),	2
fs::create_dir_all(&worktree_dir).unwrap();	1
_ => panic!("unexpected counter data type"),	1
panic!("expected proxy subcommand");	1
windows_managed_loopback_addr("[::]:8081".parse::<SocketAddr>().unwrap()),	1
.unwrap()	12
Err(err) => panic!("failed to resolve current executable path: {err}"),	1
let first = parser.parse("Get-Content 'foo bar'").unwrap();	1
other => panic!("expected connected event, got {other:?}"),	1
other => panic!("expected token activity refresh request, got {other:?}"),	1
serde_json::from_value::<MarketplaceUpgradeParams>(json!({})).unwrap(),	1
unreachable!("validated file URLs support hierarchical path segments");	1
let codex_home = tempfile::tempdir().unwrap();	8
other => panic!("expected server model event, got {other:?}"),	1
panic!("expected saved connection failures");	1
parse_seq(r#"echo "/usr"'/'"local"/bin"#).unwrap(),	1
resolve_addr("http://[::1]:8080", /*default_port*/ 3128).unwrap(),	1
Ok(out) => panic!("unfinished code point should error, got output: {out:?}"),	1
assert!(is_non_public_ip("::ffff:127.0.0.1".parse().unwrap()));	1
panic!("accept failed");	1
OtelExporter::Statsig => unreachable!("statsig exporter should be resolved"),	2
other => panic!("expected json-rpc websocket frame, got {other:?}"),	1
assert!(state.is_unix_socket_allowed(&link_s).await.unwrap());	1
response.headers().get("x-proxy-error").unwrap(),	1
Ok(_) => panic!("first lazy reconnect should fail"),	1
other => panic!("expected targeted error envelope, got: {other:?}"),	1
panic!("expected app-server notification");	1
fs::write(&script_path, "#!/bin/sh\nprintf \"edited\" > \"$1\"\n").unwrap();	1
SessionSource::from_startup_arg("vscode").unwrap(),	1
unreachable!("run() is not used by handle_escalate_session_with_policy() tests")	2
panic!("failed to restore bubblewrap forwarded signals: {err}");	1
None => panic!("empty needle should match"),	1
parse_host_port("2001:db8::1", /*default_port*/ 3128).unwrap(),	1
Ok(_) => panic!("buffered partial code point should be rejected"),	1
let codex_home = TempDir::new().unwrap();	20
fs::create_dir_all(&avatar_dir).unwrap();	2
std::fs::write(path, contents).unwrap();	1
panic!("failed to redirect stderr for bubblewrap: {err}");	1
panic!("Event must serialize");	1
Ok(_) => panic!("embedded startup should surface state db init failures"),	2
assert_eq!(config, toml::from_str::<TomlValue>(safe).unwrap());	1
std::fs::write(&path, original).unwrap();	1
fs::set_permissions(&source_dir, fs::Permissions::from_mode(0o555)).unwrap();	1
Err(error) => panic!("failed to create test CODEX_HOME: {error}"),	1
unreachable!("realtime v2 does not send conversation handoff output")	1
panic!("expected ApiError::Transport(Http)");	2
assert!(state.is_unix_socket_allowed("/tmp/any.sock").await.unwrap());	1
assert!(is_non_public_ip("240.0.0.1".parse().unwrap()));	1
std::fs::write(root.join("file.txt"), "line1\nline2\nline3\n").unwrap();	1
let url = reqwest::Url::parse("https://chatgpt.com/backend-api/codex/responses").unwrap();	3
None => panic!("expected a selected command for exact match"),	1
fs::create_dir_all(repo.join(".git")).unwrap();	1
let (x0, y0) = t.cursor_pos_with_state(area, state).unwrap();	1
panic!("WineTestProcess dropped without async teardown");	1
*sign_in_state.write().unwrap() = SignInState::PickMode;	2
*widget.error.write().unwrap() = Some("still logging in".to_string());	2
unreachable!("required stdin prompt should produce content");	1
let (directory_ca_cert, _) = generate_ca().unwrap();	1
other => panic!("expected connection close event, got {other:?}"),	2
other => panic!("unexpected initial claim outcome: {other:?}"),	1
Err(err) => panic!("failed to convert argv to CString: {err}"),	1
store.remote_plugin_id(&result.plugin_id).unwrap(),	1
parse_marketplace_source("owner/repo@main", /*explicit_ref*/ None).unwrap(),	1
assert_eq!(span_context.span_id(), SpanId::from_hex(span_id).unwrap());	1
panic!("expected input text content, got {item:?}")	1
assert_eq!(desktop_update_note(update).unwrap().summary, expected);	1
other => panic!("expected developer message, got {other:?}"),	1
panic!("expected a tool-call response");	1
"kitty".parse::<ProtocolSelection>().unwrap(),	1
.contains(&dunce::canonicalize(&temp_dir).unwrap())	1
assert!(!is_loopback_host(&Host::parse("1.2.3.4").unwrap()));	1
"1.2.3.4:80".parse::<SocketAddr>().unwrap()	1
super::save_oauth_tokens_to_file(&tokens).unwrap();	1
let (managed_ca_cert, _) = generate_ca().unwrap();	2
let mut terminal = Terminal::new(TestBackend::new(/*width*/ 8, area.height)).unwrap();	1
let temp_dir = TempDir::new().unwrap();	5
None => unreachable!("expiration wait only resolves while expiration is active"),	1
panic!("expected remote-control subcommand");	2
*error.write().unwrap() = Some(err.to_string());	1
fs::write(&relative_update, "relative old\n").unwrap();	1
let occupied = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();	2
other => panic!("unexpected stage1 claim outcome: {other:?}"),	9
Err(err) => panic!("search command schema should parse: {err}"),	1
panic!("expected hidden side boundary prompt text");	1
toml::from_str(&fs::read_to_string(codex_home.join(CONFIG_TOML_FILE)).unwrap()).unwrap()	1
other => panic!("expected JSON-RPC response, got {other:?}"),	1
assert_eq!(tbl.get("b").unwrap().as_integer(), Some(2));	1
panic!("expected remoteControl/disable request");	1
let proc = self.proc.lock().unwrap().try_clone()?;	1
panic!("codex-linux-sandbox is only supported on Linux");	1
fs::create_dir(dir.path().join("guides")).unwrap();	1
None => panic!("expected a match"),	8
_ => panic!("expected McpToolCallBegin event"),	1
toml::from_str(&fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap())	3
panic!("write cert fixture failed for {}: {error}", path.display())	1
let dir = tempfile::tempdir().unwrap();	25
let remove = RemoveMarketplaceArgs::try_parse_from(["remove", "debug"]).unwrap();	1
assert!(is_non_public_ip("fc00::1".parse().unwrap()));	1
Ok(_) => panic!("local stdio MCP should require a local environment"),	1
.unwrap_or_else(|err| panic!("login error page template must render: {err}"))	1
panic!("expected debug models subcommand");	1
fs::write(&marker, "installed").unwrap();	1
panic!("an omitted legacy elicitation mode must default to form");	1
self.updates.lock().unwrap().clear();	1
let mut terminal = Terminal::new(TestBackend::new(/*width*/ 100, /*height*/ 1)).unwrap();	1
let claims_segment = URL_SAFE_NO_PAD.encode(serde_json::to_vec(&claims).unwrap());	1
|_host, _port| async { Ok(vec!["127.0.0.1:80".parse().unwrap()]) },	1
fs::create_dir_all(&installed_root).unwrap();	4
occupied_socks.local_addr().unwrap(),	1
fs::create_dir_all(dir.path().join("docs/guides")).unwrap();	1
.unwrap_or_else(|err| panic!("generated input schema for {name} should parse: {err}")),	2
let mut latest_query = self.shared.latest_query.lock().unwrap();	1
assert!(is_non_public_ip("fe80::1".parse().unwrap()));	1
let last = ThreadId::from_string("00000000-0000-0000-0000-000000000063").unwrap();	1
panic!("Wine process stdout has already been taken");	1
panic!("paused goal should not be updated by active-only accounting");	1
unreachable!("lock holder cannot observe starting")	1
unreachable!("only world-state replay items are collected")	1
Err(err) => unreachable!("CODEX_AUTH should be a valid secret name: {err}"),	1
Err(Err(error)) => panic!("cell event delivery returned an actor error: {error:?}"),	1
let url = reqwest::Url::parse("http://chatgpt.com/backend-api/codex/responses").unwrap();	1
panic!("failed to build managed proxy: {err:#}");	2
file.write_all(block.as_bytes()).unwrap();	1
self.shared.latest_query.lock().unwrap().clone()	1
.unwrap_or_else(|err| panic!("collaboration mode default template must parse: {err}"))	1
self.complete_times.lock().unwrap().clear();	1
build_config_state(config.clone(), NetworkProxyConstraints::default()).unwrap();	1
let dir = tempfile::tempdir().unwrap();	1
unreachable!("executor-scoped hooks do not produce public hook summaries");	2
let occupied_addr = occupied.local_addr().unwrap();	1
panic!("aws-lc-rs rustls crypto provider should be installed");	1
panic!("expected tmux and OSC 52 errors");	1
fs::write(dir.path().join("docs/guides/intro.md"), "intro").unwrap();	1
panic!("initial yield delivery returned an unexpected event: {event:?}")	1
cwd.join("relative-delete.py").unwrap(),	1
format!("{}\n", serde_json::to_string(&line).unwrap()),	1
panic!("expected account/read request");	4
assert_eq!(managed_proxy_ports(&config).unwrap(), vec![3128]);	1
panic!("expected text event, got {message:?}");	1
keymap_with_replacement(&TuiKeymap::default(), &context, &action, &key).unwrap();	1
panic!("expected local path source");	1
_ => panic!("expected McpToolCallEnd event"),	1
"127.0.0.1:8081".parse::<SocketAddr>().unwrap()	1
std::fs::create_dir(&sixel_dir).unwrap();	2
let cursor = t.cursor_pos(terminal.backend().buffer().area).unwrap();	1
unreachable!("validated file URLs can remove a localhost authority");	1
let TurnInput::ResponseItem(envelope) = serde_json::from_value(forged).unwrap() else {	1
let received_payload = receive_task.await.unwrap()?;	1
unreachable!("header auth cannot be loaded from auth storage")	1
Err(err) => panic!("test provider with local should create valid environments: {err}"),	1
.unwrap_or_else(|err| panic!("review exit success template must parse: {err}"))	1
_ => panic!("expected turn_aborted event"),	1
panic!("expected command/exec response");	2
panic!("multipart body should be raw");	2
let (next_state, wait_result) = cv.wait_timeout(state, remaining).unwrap();	1
Ok(_) => panic!("missing executable should fail"),	1
assert_eq!(requests.lock().unwrap().len(), 2);	1
fs::create_dir_all(repo.join(".vscode")).unwrap();	2
.unwrap_or_else(|err| panic!("review exit success template must render: {err}"))	1
other => panic!("unexpected stage1 claim outcome for a: {other:?}"),	1
AuthMode::ApiKey => unreachable!("api key mode is handled above"),	1
Err(err) => panic!(	3
let url = reqwest::Url::parse("https://api.openai.com/v1/responses").unwrap();	1
unreachable!("queue change-version connection was initialized");	1
panic!("expected item completed event");	1
panic!("completion delivery unexpectedly carried an actor error: {error:?}")	1
Err(err) => panic!("request transport should work: {err}"),	1
SessionSource::from_startup_arg(" Atlas ").unwrap(),	1
state.add_allowed_domain("ExAmPlE.CoM").await.unwrap();	1
other => panic!("expected update change, got {other:?}"),	1
let sixel = String::from_utf8(sixel).unwrap();	4
fs::write(path, contents).unwrap();	1
panic!("expected environment info request");	1
panic!("failed to reap sandboxed child: {err}");	1
panic!("budget-limited goal should not be updated");	1
panic!("expected error message");	1
self.state.auth_dot_json.lock().unwrap().clone()	1
unreachable!("new thread manager state should not be shared");	1
let cell = screen.cell(row_idx as u16, c).unwrap();	1
GuardianAssessmentAction::Command { .. } => unreachable!(),	1
other => panic!("unexpected stage1 claim outcome for thread a: {other:?}"),	1
panic!("failed to read fd flags for preserved bubblewrap file descriptor {fd}: {err}");	1
Some(AbsolutePathBuf::try_from(installed_root.clone()).unwrap())	2
let payload = parts.next().unwrap().strip_suffix(b"\n").unwrap();	1
panic!("legacy elicitation/create must dispatch to the typed handler");	1
unreachable!("permission requests are routed directly to Guardian")	1
panic!("failed to install bubblewrap signal forwarder for {signal}: {err}");	1
assert_eq!(params.unwrap(), expected_params);	2
unreachable!("stdio helper should build stdio transport");	2
panic!("embedded goals/objective_updated.md template failed to render: {err}")	1
assert!(!is_non_public_ip("::ffff:8.8.8.8".parse().unwrap()));	1
RequestCompression::None => unreachable!("guarded by compression != None"),	1
Ok(out) => panic!("invalid continuation byte should error, got output: {out:?}"),	1
regex_lite::Regex::new(r"(?i)try again in\s*(\d+(?:\.\d+)?)\s*(s|ms|seconds?)").unwrap()	1
| ThreadGoalStatus::BudgetLimited => unreachable!("status validated above"),	1
panic!("failed to read bubblewrap stderr: {err}");	1
write_spans(&mut actual, spans.iter()).unwrap();	1
_ => panic!("expected WebSearchBegin event"),	1
panic!("expected start hook event, got {event_name:?}")	1
panic!("expected command execution approval response");	1
let contents = fs::read_to_string(&path).unwrap();	3
other => panic!("expected buffered hook notification, saw: {other:?}"),	1
assert_eq!(v.get("output").unwrap().as_str().unwrap(), "bad");	1
let previewed = result.unwrap();	1
FileSystemSandboxKind::ExternalSandbox => unreachable!(	1
fs::write(&managed_ca_cert_path, &managed_ca_cert).unwrap();	2
unreachable!("loop exits only after returning payload")	1
require_single_current_time_connection(&[ConnectionId(7)]).unwrap(),	1
assert_eq!(format_json_compact("null").unwrap(), "null");	1
.unwrap();	1
Err(event) => panic!("yield delivery returned an unexpected event: {event:?}"),	1
fs::rename(reverted_source, reverted_path.as_path()).unwrap();	1
_ => unreachable!("unsupported item event"),	1
std::fs::write(&real, b"not a socket").unwrap();	1
other => panic!("expected initialized notification, got {other:?}"),	1
let image_start = message.find("[Image #1]").unwrap();	1
rgba.save(&frame_path).unwrap();	1
_ => unreachable!("unsupported target_format should have been handled earlier"),	1
let cmds = parse_seq("git commit -m \"line1\nline2\"").unwrap();	1
_ => panic!("expected completed client message"),	1
panic!("expected broadcast notification");	1
assert_eq!(serde_json::from_value::<TurnInput>(value).unwrap(), input);	1
let temp_dir = tempdir().unwrap();	1
Err(err) => panic!("client request should encode as JSON-RPC request: {err}"),	1
file.write_all(b"{\"message\":\"").unwrap();	1
assert!(!state.is_unix_socket_allowed("relative.sock").await.unwrap());	1
other => panic!("expected function payload, got {other:?}"),	1
RealtimeWireAdapter::FramelessBidi => unreachable!(),	1
.unwrap_or_else(|_| unreachable!("thread settings persistence semaphore is never closed"))	1
StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();	1
*sign_in_state.write().unwrap() = SignInState::ApiKeyEntry(ApiKeyInputState {	2
other => panic!("unknown fixture {other}"),	1
None => panic!("heading present"),	1
&*widget.sign_in_state.read().unwrap(),	1
let destination = TempDir::new().unwrap();	1
lock.acquire().await.unwrap_or_else(|_| unreachable!())	1
symlink(dir.path().join("target.txt"), dir.path().join("link.txt")).unwrap();	1
panic!("expected native and OSC 52 errors");	1
render_ambient_pet_image(&mut output, &mut state, Some(request)).unwrap();	5
panic!("expected features subcommand");	2
let writable_roots = vec![AbsolutePathBuf::try_from(extra_root.as_path()).unwrap()];	1
other => panic!("expected fast service tier to be selected, got {other:?}"),	1
request_sink.lock().unwrap().push(req);	11
panic!("pending delivery returned an unexpected event: {event:?}")	1
harness.event_tx.send(RuntimeEvent::Pending).unwrap();	1
let requested_socks_addr = requested_socks.local_addr().unwrap();	1
state.host_blocked("localhost", /*port*/ 80).await.unwrap(),	2
panic!("expected connection-targeted warning notification");	3
let socks_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();	1
fs::write(&session_file_path, "session directory content\n").unwrap();	1
ContentItem::InputImage { .. } => unreachable!("images are handled atomically above"),	1
JSONRPCMessage::Error(error) => panic!("unexpected JSON-RPC error: {error:?}"),	1
other => panic!("expected one buffered MCP notification, saw: {other:?}"),	1
let guard = self.sign_in_state.read().unwrap();	1
*self.sign_in_state.write().unwrap() = SignInState::ChatGptSuccessMessage;	1
panic!("configured cwd should not prompt during startup")	1
state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),	3
std::fs::write(secret_file.path(), "ghp-file-secret\n").unwrap();	1
ThreadId::from_string("00000000-0000-0000-0000-000000000042").unwrap();	1
let mut guard = self.sign_in_state.write().unwrap();	1
fs::write(&trust_bundle_path, "tampered roots").unwrap();	1
_ => unreachable!(),	1
panic!("expected session failure after disconnect, got {event:?}");	1
panic!("expected outbound network policy request");	1
CheckStatus::Fail => unreachable!(),	1
windows_store_update(&serde_json::to_vec(&manifest).unwrap(), "26.803.5235.1"),	1
panic!("expected policy request");	1
panic!("waitpid failed for bubblewrap child: {err}");	1
other => panic!("expected patch preview history cell, saw {other:?}"),	1
let set = compile_denylist_globset(&["[fe80::1%25lo0]".to_string()]).unwrap();	1
panic!("Expected exactly one call in a command display cell");	1
panic!("expected SubmitThreadOp");	4
let result = format_json_compact(json).unwrap();	7
let proc = self.proc.lock().unwrap();	1
let stderr_str = String::from_utf8(stderr).unwrap();	6
other => panic!("unexpected initial phase2 claim outcome: {other:?}"),	1
let real_s = real.to_str().unwrap().to_string();	1
panic!("expected personality command, got service tier {command:?}")	1
.unwrap_or_else(|err| panic!("failed to prepare host proxy routing bridge: {err}"));	1
let mut state = mutex.lock().unwrap();	1
AbsolutePathBuf::try_from(if cfg!(windows) { "C:\\repo" } else { "/repo" }).unwrap();	1
.unwrap_or_else(|| panic!("bundled models.json should include {slug}"))	1
panic!("thread settings applied item");	1
fs::read(managed_ca_certificate_lock_path(ca.certificate_path()).unwrap()).unwrap(),	1
assert_eq!(http_addr, "127.0.0.1:3128".parse::<SocketAddr>().unwrap());	2
let dir = tempdir().unwrap();	25
Ok(_) => panic!("remote HTTP helper should be rejected"),	1
None => unreachable!("unrestricted login methods accept every auth mode"),	1
let set = compile_allowlist_globset(&patterns).unwrap();	1
Message::Close(_) => panic!("unexpected close frame"),	1
std::fs::create_dir_all(policy_path.parent().unwrap()).expect("create policy dir");	2
let mut guard = self.snapshot.write().unwrap();	1
*widget.sign_in_state.write().unwrap() = SignInState::ChatGptDeviceCode(	1
.unwrap_or_else(|| panic!("command cwd must be valid UTF-8"))	2
panic!("failed to create bubblewrap exec start pipe: {err}");	1
assert_eq!(recorded_requests.lock().unwrap().len(), 1);	2
pretty_assertions::assert_eq!(std::str::from_utf8(&snap.bytes).unwrap(), "cdefghij");	1
unreachable!("bedrock access keys mode is handled above")	1
let availability: PluginAvailability = serde_json::from_value(json!("ENABLED")).unwrap();	1
.unwrap_or_else(|| panic!("expected built-in theme {theme_name} to resolve"));	1
let fallback_addr = listener.local_addr().unwrap();	1
.unwrap_or_else(|err| panic!("generated skill tool schema should serialize: {err}"));	1
let newline = text.find('\n').unwrap();	1
other => panic!("unexpected phase2 claim after no-output deletion: {other:?}"),	1
.unwrap_or_else(|| unreachable!("validated file URLs have path segments"))	1
|_host, _port| async { Ok(vec!["8.8.8.8:80".parse().unwrap()]) },	1
other => panic!("unexpected event: {other:?}"),	1
_ => panic!("expected PatchApplyEnd event"),	1
.unwrap_or_else(|| panic!("snapshot file has no parent: {}", snapshot_file.display()))	1
fs::write(&relative_delete, "delete relative\n").unwrap();	1
let contents = fs::read_to_string(path).unwrap();	2
let first_key = pet.frame_cache_key().unwrap();	1
let mut st = self.state.lock().unwrap();	2
assert_eq!(fs::read_to_string(user_file).unwrap(), config);	1
cwd.join("relative-add.py").unwrap(),	1
.map(|entry| entry.unwrap().path())	1
fs::write(dir.path().join("alpha.txt"), "alpha").unwrap();	2
| ConsumeAccountRateLimitResetCreditOutcome::AlreadyRedeemed => unreachable!(),	1
panic!("expected at least one wrapped line");	1
let outcome = remove_user_marketplace_config(codex_home.path(), "debug").unwrap();	1
*self.sign_in_state.write().unwrap() = SignInState::ChatGptSuccess;	1
let installed_root = AbsolutePathBuf::try_from(PathBuf::from(installed_root)).unwrap();	1
panic!("expected KeymapCaptured event");	1
panic!("unexpected websocket close frame: {frame:?}");	1
panic!("expected a matching hook");	1
panic!("expected thread-routed history response");	1
unreachable!("URL-safe base64 always produces a valid fallback path URI");	1
panic!("sandbox cwd should be rejected after resolving runtime paths");	1
.unwrap_or_else(|error| panic!("invalid legacy bubblewrap fd mount: {error}"));	1
.unwrap_or_else(|| panic!("bubblewrap argv is missing command separator '--'"));	1
append_download_chunk(&mut bytes, b"1234", /*max_bytes*/ 8, url).unwrap();	1
unreachable!("app server should be initialized for --resume --last");	1
panic!("failed to restore bubblewrap signal handler for {signal}: {err}");	1
let plugin_path = AbsolutePathBuf::try_from(PathBuf::from(plugin_path)).unwrap();	2
assert!(store.cookies(&first_url).unwrap().is_sensitive());	1
let cmds = parse_seq("grep -n 'pattern' -g'*.txt'").unwrap();	1
limit: NonZero::new(20).unwrap(),	6
other => panic!("unexpected phase2 claim after initial output: {other:?}"),	1
Err(err) => panic!("failed to serialize permission profile: {err}"),	1
None => panic!("expected Some(selected_idx) after wrap"),	1
fs::create_dir_all(source_root.join(".agents/plugins")).unwrap();	1
unreachable!("thread ID generator must be set before thread manager is shared");	1
"0.0.0.0:8765".parse().unwrap(),	2
panic!("expected ready primary environment");	1
panic!("expected an inbound client request");	1
let io_error = err.downcast_ref::<io::Error>().unwrap();	1
Err(err) => panic!("failed to parse JSON-RPC line: {err}"),	1
other => panic!("unexpected claim outcome: {other:?}"),	5
let shorthand = parse_marketplace_source("owner/repo", /*explicit_ref*/ None).unwrap();	1
panic!("expected warning listener command");	1
panic!("expected ApiError::Retryable");	1
panic!("by construction Constrained<WebSearchMode> must always support Disabled: {err}");	1
let (startup_ca_cert, startup_ca_key) = generate_ca().unwrap();	1
other => panic!("expected CodexOp event, got {other:?}"),	1
unreachable!("steer-only submission cannot start a turn")	1
let set = compile_denylist_globset(&["Example.COM.".to_string()]).unwrap();	1
panic!("process should be running");	1
panic!("backend request body should be JSON");	1
panic!(	8
let fallback_port = reserved.http_listener.local_addr().unwrap().port();	1
other => panic!("unexpected stage1 claim outcome: {other:?}"),	10
let expected_allow: HashSet<PathBuf> = [dunce::canonicalize(&command_cwd).unwrap()]	4
_ => panic!("expected queued incoming message"),	2
.unwrap_or_else(|err| panic!("cli session source should deserialize: {err}")),	1
harness.task.await.unwrap();	5
let patch = parse_patch(&patch).unwrap();	2
TranscriptEntryKind::User => unreachable!("user entries were selected separately"),	5
result = &mut archive => panic!("archive completed while the source was reserved: {result:?}"),	1
persist_managed_ca_trust_bundle(&managed_ca_cert_path, "trusted roots").unwrap();	1
screen.cell(row as u16, /*col*/ 0).unwrap().bgcolor(),	1
_ => panic!("unexpected listener command"),	1
let mut entry = entry.unwrap();	1
panic!("budget crossing should update the goal");	2
entry.read_to_end(&mut contents).unwrap();	1
_ => panic!("unexpected histogram aggregation"),	1
panic!("pid file {} should be written", path.display());	1
panic!("imagegen output should contain generated image bytes");	2
let _permit = WINDOWS_INGRESS_TEST_LOCK.acquire().await.unwrap();	4
let slow = slow.unwrap_or_else(|err| panic!("slow request failed: {err:?}"));	1
windows_store_update(&serde_json::to_vec(&manifest).unwrap(), "26.803.5235.0").is_err()	1
other => panic!("unexpected phase2 lock claim outcome: {other:?}"),	1
error.read().unwrap().as_deref(),	1
fs::set_permissions(&locked_dir, fs::Permissions::from_mode(0o555)).unwrap();	1
unreachable!("HTTP helper should build streamable HTTP transport");	1
panic!("expected execution failure to be reported as an error");	1
let upgraded_root = AbsolutePathBuf::try_from(PathBuf::from(upgraded_root)).unwrap();	1
let set = compile_denylist_globset(&["[::1]".to_string()]).unwrap();	1
limit: NonZero::new(20).unwrap(),	2
Ok(_) => panic!("path-like filename should be rejected"),	1
regex_lite::Regex::new(r"^Sandbox:\s*(.+?)\((\d+)\)\s+deny\(.*?\)\s*(.+)$").unwrap()	1
panic!("unexpected message");	1
unreachable!("app server should be initialized for --fork <id>");	1
panic!("process {pid} should exit");	1
.unwrap_or_else(|err| panic!("workspace-write sandbox template must parse: {err}"))	1
fs::set_permissions(&locked_dir, fs::Permissions::from_mode(0o755)).unwrap();	1
serde_json::to_value(value).unwrap(),	2
fs::write(&managed_ca_cert_path, "managed ca\n").unwrap();	1
result => panic!("expected MaybeApplyPatch::Body got {result:?}"),	4
panic!("stale goal version should not be updated");	1
other => panic!("unexpected phase2 claim outcome: {other:?}"),	9
let expected_cursor1: Cursor = serde_json::from_str(&format!("\"{ts}\"")).unwrap();	1
other => panic!("expected stdin frame, got {other:?}"),	1
assert_eq!(managed_proxy_ports(&config).unwrap(), vec![3128, 48081]);	1
toml::from_str::<toml::Value>(&fs::read_to_string(target_path).unwrap()).unwrap();	1
let local_path = AbsolutePathBuf::try_from(PathBuf::from(local_path)).unwrap();	1
.unwrap_or_else(|err| panic!("read generated schema {fixture}: {err}"));	1
let (x1, y1) = t.cursor_pos(area).unwrap();	1
assert_eq!(fs::read_to_string(src).unwrap(), "line\n");	1
.unwrap_or_else(|err| panic!("invalid CODEX_BWRAP_SHA256 value: {err}"));	1
let set = compile_denylist_globset(&["region*.v2.argotunnel.com".to_string()]).unwrap();	1
payload["source"] = serde_json::to_value(source).unwrap();	1
let (allowed, denied) = state.current_patterns().await.unwrap();	4
panic!("expected ThreadSettingsUpdated for thread {thread_id}");	1
panic!("expected first guardian assessment");	2
response.headers().get("x-proxy-error").unwrap(),	4
panic!("tried to execute ResetScrollRegion command using WinAPI, use ANSI instead");	1
unreachable!("unconditional settings updates must commit");	1
let sixel = encode_rgba(&rgba, /*width*/ 4, /*height*/ 1).unwrap();	1
managed_ca_trust_bundle_for_cert_path(&managed_ca_cert_path, &env).unwrap();	2
custom_pet.frame_cache_key().unwrap(),	1
None => panic!("{field_name} must be non-zero"),	1
panic!("error activating Linux proxy routing bridge: {err}");	1
Err(err) => panic!("valid UTF-8 stream should parse: {err}"),	1
let sign_in_state = self.sign_in_state.read().unwrap();	4
.unwrap(),	42
(None, None) => unreachable!("removable evidence was counted before eviction"),	1
other => panic!("expected connection open after reconnect, got {other:?}"),	1
let (_x, y) = t.cursor_pos_with_state(area, state).unwrap();	1
other => panic!("expected incoming message, got {other:?}"),	1
unreachable!("typed extension data stored an incompatible value");	1
panic!("expected second guardian assessment");	2
assert!(is_non_public_ip("203.0.113.1".parse().unwrap()));	1
symlink(dir.path().join("guides"), dir.path().join("guides-link")).unwrap();	1
Err(err) => panic!(	5
&*sign_in_state.read().unwrap(),	4
let (x2, y2) = t.cursor_pos_with_state(area, bad_state).unwrap();	1
GuardianAssessmentAction::Execve { .. } => unreachable!(),	1
parse_exec_source("text('hi')").unwrap(),	1
unreachable!("exec_command has a function schema");	1
let mut perms = fs::metadata(&script_path).unwrap().permissions();	1
panic!("expected plan command, got service tier {command:?}")	1
Ok(_) => panic!("legacy query field should be rejected"),	1
Ok(_) => panic!("burned environment should stay failed"),	1
panic!("expected Notification for first message");	3
let a = load_tasks(&backend, Some("env-A")).await.unwrap();	1
let hooks = compile_mitm_hooks(&config).unwrap();	1
Err(err) => panic!(	3
assert_eq!(format_json_compact(r#""string""#).unwrap(), r#""string""#);	1
Err(err) => panic!("invalid regex pattern `{pattern}`: {err}"),	1
other => panic!("unexpected event: {other:?}"),	5
let original_bytes = source.metadata().unwrap().len() as usize;	1
panic!("expected content items");	4
unreachable!("invalid plugin ids are handled above");	1
let temp = tempfile::tempdir().unwrap();	2
symlink(&target_path, codex_home.path().join(CONFIG_TOML_FILE)).unwrap();	1
fs::read_to_string(&relative_update).unwrap(),	1
assert_eq!(reserved.http_listener.local_addr().unwrap(), http_addr);	1
panic!("expected an encoded JSON body");	1
.unwrap();	103
let next = stream.next().await.unwrap();	1
Ok(_) => panic!("startup failure should be returned"),	1
let first_url = reqwest::Url::parse("https://cookies.chatgpt.com/a").unwrap();	1
unreachable!("personal access token mode is handled above")	1
panic!("expected exec subcommand");	3
let pet = catalog::builtin_pet("dewey").unwrap();	1
Err(error) => panic!("failed to finish gzip test data: {error}"),	1
other => panic!("expected connection open event, got {other:?}"),	2
let mut inner = self.inner.lock().unwrap();	1
unreachable!()	4
panic!("error applying legacy Linux sandbox restrictions: {e:?}");	1
managed_ca_certificate_lock_path(ca.certificate_path()).unwrap(),	1
assert_ne!(pet.frame_cache_key().unwrap(), first_key);	1
let second = parser.parse("Write-Output foo | Measure-Object").unwrap();	1
.unwrap_or_else(|err| panic!("generated tool schema should serialize: {err}"));	1
String::from_utf8(expected).unwrap()	1
fs::read_to_string(destination.path().join(".codex-plugin/plugin.json")).unwrap(),	1
fs::write(&src, "line\n").unwrap();	2
Err(error) => panic!("failed to finish tar test data: {error}"),	1
let value = serde_json::to_value(&config).unwrap();	1
.unwrap_or_else(|err| panic!("failed to serialize env: {err}"));	1
let _g = env_lock().lock().unwrap();	6
panic!("expected image response decode error");	1
Err(err) => panic!("client request should serialize: {err}"),	1
*cancellation_sink.lock().unwrap() = Some(cancellation);	1
assert!(is_non_public_ip("::1".parse().unwrap()));	1
ThreadSortKey::SectionPosition => unreachable!("section order uses the state database"),	1
w.write_all(b"ij").unwrap();	1
fs::create_dir(&source_dir).unwrap();	1
unreachable!("explicit user input can enter Plan mode");	1
unreachable!("start-if-idle submission cannot steer")	1
panic!("expected to find the third-level ordered list line; got: {streamed_strs:?}")	1
let outcome = remove_user_marketplace_config(codex_home.path(), "Debug").unwrap();	1
fs::remove_file(first_path).unwrap();	1
panic!("bubblewrap argv is missing inner command after '--'");	1
panic!("expected server request response");	2
Some(event) => panic!("completion commit rejected an unexpected event: {event:?}"),	1
Err(err) => panic!("claim stage1 should not fail: {err}"),	1
panic!("expected execution response after cancellation");	1
panic!("expected sandboxed filesystem error");	1
assert!(is_non_public_ip("127.0.0.1".parse().unwrap()));	1
_ => unreachable!("reset confirmation only renders two rows"),	1
unreachable!("unsupported plugin sources should be filtered before resolution")	1
let sixel = encode_rgba(&[255, 0, 0, 0], /*width*/ 1, /*height*/ 1).unwrap();	1
panic!("omitted legacy elicitation mode must default to form");	1
String::from_utf8(stdout).unwrap(),	1
_ => unreachable!("Codex Apps fetch ticket requires cache context"),	1
unreachable!("allowlisted executor handler must be an MCP tool");	1
let mut updates = self.updates.lock().unwrap();	1
Err(err) => panic!("state should still allow a valid continuation: {err}"),	1
let (received_payload, received_fds) = receive_task.await.unwrap()?;	1
other => panic!("unexpected event for {code}: {other:?}"),	1
AbsolutePathBuf::try_from(installed_root.clone()).unwrap()	1
panic!("tried to execute SetScrollRegion command using WinAPI, use ANSI instead");	1
other => panic!("expected hook trust event, got {other:?}"),	3
let sign_in_state = { (*self.sign_in_state.read().unwrap()).clone() };	1
fs::create_dir_all(&pet_dir).unwrap();	3
other => panic!("expected retried process/write request, got {other:?}"),	1
other => panic!("expected freeform payload, got {other:?}"),	1
panic!("expected initialize request");	2
panic!("failed to write JSON-RPC line: {err}");	1
assert!(is_loopback_host(&Host::parse("::1").unwrap()));	1
Err(err) => panic!("missing app event: {err}"),	9
let request = transport.last_request.lock().unwrap().clone().unwrap();	7
.unwrap_or_else(|err| panic!("cwd root must be an absolute path: {err}"))	1
.unwrap_or_else(|err| panic!("failed to convert argv to CString: {err}"))	1
let ca = ManagedMitmCa::create(dir.path()).unwrap();	1
_ => unreachable!("advanced choices are limited to Max and Ultra"),	1
other => panic!("expected key event, got {other:?}"),	3
"127.0.0.1:8765".parse().unwrap(),	1
.unwrap_or_else(|err| panic!("login error page template must parse: {err}"))	1
other => panic!("expected first process/write request, got {other:?}"),	1
let url = reqwest::Url::parse(url).unwrap();	1
panic!("expected extension web search item");	1
resolve_addr("1.2.3.4", /*default_port*/ 80).unwrap(),	1
other => panic!("unexpected selection: {other:?}"),	1
panic!("shutdown failed before acquiring the registry lock: {error}")	1
unreachable!();	1
let composer_icon = AbsolutePathBuf::try_from(PathBuf::from(composer_icon)).unwrap();	1
std::fs::write(themes_dir.join("broken-custom.tmTheme"), "not a plist").unwrap();	1
serde_json::to_value(&event).unwrap(),	1
_ => panic!("unexpected remaining event: {event:?}"),	1
panic!(	6
let content = tokio::fs::read_to_string(path).await.unwrap();	1
let cwd = AbsolutePathBuf::try_from(std::env::current_dir().unwrap())	1
panic!("active goal should account usage");	1
None => panic!("expected at least one match for '/mo'"),	1
panic!("unexpected binary websocket frame");	1
row.strip_prefix("› ").unwrap().trim()	1
let res = unsafe { GetProcessId(self.proc.lock().unwrap().as_raw_handle() as _) };	1
.unwrap_or_else(|_| panic!("timed out waiting for exit\n{}", sandbox_log(codex_home.path())))	1
let third_line_start = t.text().find("mid").unwrap();	1
panic!("expected debug prompt-input subcommand");	1
let sixel = fs::read_to_string(sixel_path).unwrap();	1
Pet::load_with_codex_home("dewey", /*codex_home*/ Some(codex_home.path())).unwrap();	1
assert!(is_non_public_ip("198.18.0.1".parse().unwrap()));	1
let cmds = parse_seq("ls -1").unwrap();	1
parse_rfc3339_non_optional("2025-01-03T12:00:00Z").unwrap()	1
let mut source = fs::File::open(source_path).unwrap();	1
state.add_denied_domain("EXAMPLE.COM").await.unwrap();	1
serde_json::to_value(PluginSource::Remote).unwrap(),	1
let sixel = encode_rgba(&[255, 0, 0, 255], /*width*/ 1, /*height*/ 1).unwrap();	1
AbsolutePathBuf::try_from(write_test_plugin(temp_dir.path(), "demo-plugin")).unwrap();	2
panic!(	1
Err(err) => panic!("stream should finish: {err}"),	1
(_, Some(source)) => unreachable!("validated env_vars source `{source}`"),	1
&["remote", "add", "origin", remote.to_str().unwrap()],	1
.contains(&dunce::canonicalize(&workspace_root).unwrap())	1
other => panic!("unexpected global consolidation claim outcome: {other:?}"),	1
unreachable!("namespace index must point to a namespace spec");	1
panic!("expected extension item");	2
.unwrap_or_else(|err| panic!("cli session source should deserialize: {err}")),	1
.unwrap();	47
MarketplaceSource::Local { .. } => unreachable!(	1
let guard = recorded_requests.lock().unwrap();	7
.unwrap_or_else(|| panic!("expected built-in theme {theme_name} to resolve"));	1
panic!("expected OpenKeymapCapture event");	1
action.cwd.to_abs_path().unwrap().as_path(),	1
panic!("{}", message.to_string());	1
other => panic!("unexpected seed claim outcome: {other:?}"),	1
let output = child.wait_with_output().unwrap().stdout;	1
*error.write().unwrap() = Some(format!(	2
None => unreachable!("AgentIdentityAuth should only be constructed with a task_id"),	1
other => panic!("expected draw or key event, got {other:?}"),	1
build_config_state(config, constraints).unwrap(),	3
let api_url = reqwest::Url::parse("https://api.openai.com/v1/responses").unwrap();	1
Err(err) => panic!("client notification should encode as JSON-RPC notification: {err}"),	1
panic!("expected updated keymap");	5
other => panic!("expected followup incoming message, got {other:?}"),	1
let db_request = requests.lock().unwrap()[0].clone();	3
panic!("failed to read fd flags for test fd {fd}: {err}");	1
let sixel = encode_rgba(&rgba, /*width*/ 1, /*height*/ 7).unwrap();	1
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();	2
request_sink.lock().unwrap().push(thread_id);	3
let oldest_pinned = ThreadId::from_string("00000000-0000-0000-0000-000000000041").unwrap();	1
let expected = dir.path().join("spritesheet.webp").canonicalize().unwrap();	1
parts.next().unwrap(),	1
Err(err) => panic!("failed to encode JSON-RPC message: {err}"),	1
panic!("expected guardian assessment");	4
file.write_all(&record_block).unwrap();	1
unreachable!("the final open attempt returns its error")	1
panic!("trust step should remain present");	3
let compiled = hooks.get("api.github.com").unwrap();	2
threads: NonZero::new(2).unwrap(),	2
panic!("expected thread/status/changed notification");	2
panic!("imagegen should advertise a function tool");	1
panic!("expected KeymapCleared event");	1
fs::create_dir(&locked_dir).unwrap();	1
other => panic!("unexpected initial stage1 claim outcome: {other:?}"),	1
fs::write(&absolute_delete, "delete absolute\n").unwrap();	1
.unwrap_or_else(|_| unreachable!());	1
unreachable!("server message variant checked above");	1
let body = serde_json::to_vec(&*self.body).unwrap();	1
parse_exec_source("// @exec: {\"yield_time_ms\": 10}\ntext('hi')").unwrap(),	1
_ => panic!("unexpected counter aggregation"),	1
other => panic!("unexpected rate-limit event: {other:?}"),	1
fs::create_dir_all(&assets_dir).unwrap();	1
.unwrap_or_else(|| unreachable!("missing FeatureSpec for {self:?}"))	1
SessionSource::from_startup_arg("app-server").unwrap(),	1
store.values_mut().next().unwrap().access_token = "new".to_string();	1
panic!("Initialize should be handled before initialized request dispatch");	1
panic!("parent environment should be ready");	1
assert!(is_loopback_host(&Host::parse("localhost.").unwrap()));	1
*self.last_request.lock().unwrap() = Some(req);	2
value.as_object_mut().unwrap().remove("completed_at_ms");	1
.unwrap_or_else(|err| panic!("invalid system bubblewrap path: {err}"));	1
assert_eq!(fs::read_to_string(dest).unwrap(), "line2\n");	1
panic!("process should be running");	1
let root = load_tasks(&backend, /*env*/ None).await.unwrap();	1
let contents = fs::read_to_string(&path).unwrap();	1
other => panic!("expected verified body, got {other:?}"),	1
panic!("failed to verify descriptor-backed bubblewrap mount: {err}");	1
exit_info.exit_reason = ExitReason::Archived(exit_info.thread_id.unwrap());	1
panic!("expected remoteControl/enable request");	1
let world_start = t.text().find("world").unwrap();	1
unreachable!("response id must exist after response.completed");	1
recorded_requests.lock().unwrap().clear();	3
panic!("claim stage1 should have returned within retry budget")	1
panic!("git cloner should not be called for local marketplace sources")	4
self.snapshot.read().unwrap().clone()	1
.unwrap_or_else(|_| panic!("invalid static internal context source: {source}"))	1
assert!(!store.cookies(&url).unwrap().is_sensitive());	1
let result = outgoing_rx.recv().await.unwrap();	3
assert_eq!(*recorded_requests.lock().unwrap(), vec![thread_id]);	3
panic!("expected tool search spec");	2
fs::write(&source_path, "before\n").unwrap();	1
let start_word2 = t.text().find("word2").unwrap();	1
unreachable!("workspace-write profiles use restricted managed permissions");	1
panic!("expected features disable");	1
let lease = lock_managed_ca_certificate(&certificate_path).unwrap();	1
let later_db_request = requests.lock().unwrap()[1].clone();	1
panic!("failed to place bubblewrap child in its own process group: {err}");	1
let cmds = parse_seq("echo 123 456").unwrap();	1
unreachable!("only MCP actions can request MCP tool approval");	1
panic!("embedded goals/budget_limit.md template failed to render: {err}")	1
spritesheet.save(&spritesheet_path).unwrap();	1
let http_addr = "0.0.0.0:3128".parse::<SocketAddr>().unwrap();	3
panic!("expected UserTurn op, saw: {seen:?}");	1
row.strip_prefix("› ").unwrap().trim()	1
panic!("expected runtime result after termination");	1
let expected_deny: HashSet<PathBuf> = [dunce::canonicalize(&git_file).unwrap()]	1
let busy_port = occupied.local_addr().unwrap().port();	1
let mut guard = sign_in_state.write().unwrap();	2
panic!("Linux sandbox retained effective or permitted capabilities");	1
record_user_marketplace(codex_home.path(), "other", &update).unwrap();	1
"127.0.0.1:48081".parse::<SocketAddr>().unwrap()	1
fs::write(&path, [0xff, 0xfe, 0xfd]).unwrap();	1
other => panic!("expected personality to be selected for exact match, got {other:?}"),	1
let (_x, y) = t.cursor_pos(area).unwrap();	1
assert!(!is_loopback_host(&Host::parse("notlocalhost").unwrap()));	1
Err(err) => panic!("parser should recover after rollback: {err}"),	1
let cwd = PathUri::from_host_native_path(cwd_dir.path()).unwrap();	1
runtime.shutdown().await.unwrap();	1
let second_url = reqwest::Url::parse("https://cookies.chatgpt.com/b").unwrap();	1
panic!("expected session metadata");	4
panic!("expected apply-patch approval request");	1
panic!("failed to append tar test data: {error}");	1
serde_json::from_value::<PluginShareListParams>(json!({})).unwrap(),	1
fs::create_dir(&dest_dir).unwrap();	1
panic!("expected response item");	1
unreachable!("code-mode session provider must be set before thread manager is shared");	1
panic!("completed goal should not be updated by active-only accounting");	1
state.host_blocked("127.0.0.1", /*port*/ 80).await.unwrap(),	2
unreachable!("protected create removal retry loop should return or panic")	1
other => panic!("expected initialized notification, got {other:?}"),	5
fs::write(dir.path().join("docs/readme.md"), "readme").unwrap();	1
display_path_for(changes.first().unwrap(), cwd)	1
unreachable!("externally provided auth is never loaded from auth storage")	1
panic!("expected OSC 52 error");	1
unreachable!("current turn must exist after initialization");	1
let json = serde_json::to_string(file_match).unwrap();	1
file.write_all(b"\"}\n").unwrap();	1
let runtime = RuntimeKeymap::from_config(&keymap).unwrap();	4
LogDbCommand::Flush(_) => panic!("expected queued entry"),	2
unreachable!("Windows sandbox should have been handled above");	1
.unwrap_or_else(|err| panic!("imagegen schema should serialize: {err}"));	1
unreachable!("header loop always returns")	1
*self.sign_in_state.write().unwrap() = SignInState::ChatGptSuccess;	1
panic!("imagegen should return function tool output");	2
record_user_marketplace(codex_home.path(), "debug", &update).unwrap();	3
ShellType::PowerShell | ShellType::Cmd => unreachable!(),	1
.unwrap()	20
other => panic!("expected targeted response envelope, got: {other:?}"),	1
value.as_object_mut().unwrap().remove("started_at_ms");	1
panic!("expected warning notification");	3
panic!("expected local audio error placeholder");	1
Poll::Ready(Ok(())) => panic!("shutdown completed before acquiring the registry lock"),	1
*sign_in_state.write().unwrap() = SignInState::ApiKeyConfigured;	1
cwd.join("relative-update.py").unwrap(),	1
other => panic!("unexpected stage1 claim outcome for b: {other:?}"),	1
panic!("expected initialize request");	1
Err(err) => panic!("failed to read JSON-RPC line: {err}"),	1
let removed = remove_user_marketplace(codex_home.path(), "debug").unwrap();	2
panic!("stopped goal should account final usage");	1
assert!(is_non_public_ip("10.0.0.1".parse().unwrap()));	1
None => panic!("failed to configure arg0 dispatch aliases for test binary"),	1
Ok(_) => panic!("listener should not receive a connection"),	1
assert_eq!(socks_addr, "0.0.0.0:8081".parse::<SocketAddr>().unwrap());	1
default_pet.frame_cache_key().unwrap()	1
.unwrap_or_else(|| panic!("expected URL first row in screen rows: {rows:?}"));	1
AppLinkSuggestionType::Auth => unreachable!(	1
state.host_blocked("127.0.0.1", /*port*/ 80).await.unwrap(),	1
panic!("expected app-server exit before ready");	1
panic!("primary environment should be ready");	3
panic!(	4
let parsed = parse_shell_lc_plain_commands(&command).unwrap();	1
let template = Template::parse("{{ b }} {{ a }} {{ b }}").unwrap();	1
sixel_frame(&frame_path, &dir.path().join("sixel"), /*height_px*/ 1).unwrap();	1
other => panic!("expected item completed notification, got {other:?}"),	1
let blocked = state.drain_blocked().await.unwrap();	1
Err(err) => panic!("expected cancel callback event, got {err}"),	1
panic!("failed to exec system bubblewrap {program_path}: {err}");	1
let powershell = powershell.as_path().to_str().unwrap();	6
panic!("canonical session meta");	1
let head = read_head_for_summary(&rollout_path).await.unwrap();	1
.unwrap_or_else(|| panic!("expected continuation row in screen rows: {rows:?}"));	2
unreachable!("plugin json should be an object");	2
Err(error) => panic!("system proxy cache lock should not be poisoned: {error}"),	1
unreachable!("every turn has a host skills snapshot");	1
let inner = self.inner.lock().unwrap();	2
_ => panic!("expected forwarded response message"),	1
other => panic!("expected initialize request, got {other:?}"),	1
.unwrap_or_else(|err| panic!("invalid generated hooks schema {name}: {err}"))	1
unreachable!("namespace index must point to a namespace");	1
let thread_id = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap();	4
let cell = screen.cell(row, col).unwrap();	2
*broker.state.lock().unwrap() = EventBrokerState::Running(source);	1
unreachable!("expected a command approval request");	1
thread_id: Some(ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap()),	1
let st = self.state.lock().unwrap();	1
serde_json::to_value(availability).unwrap(),	1
other => panic!("expected plan to be selected for exact match, got {other:?}"),	1
let socks_addr = "0.0.0.0:8081".parse::<SocketAddr>().unwrap();	3
*self.sign_in_state.write().unwrap() = SignInState::PickMode;	1
panic!("expected initialize params");	1
let second_line_start = t.text().find("two").unwrap();	1
payload => panic!("expected function payload, got {payload:?}"),	1
let mut file = fs::File::create(&binary_path).unwrap();	1
StoreThreadSortKey::SectionPosition => unreachable!("section positions use rank cursors"),	1
fs::write(&unrelated_path, "user managed").unwrap();	1
let (received_bytes, received_fds) = receive_task.await.unwrap()?;	1
let expected_cursor2: Cursor = serde_json::from_str("\"2025-03-02T09-00-00\"").unwrap();	1
_ => panic!("expected ImageGenerationEnd event"),	1
_ => panic!("unexpected events for {code}: {events:?}"),	1
state.add_denied_domain("8.8.8.8").await.unwrap();	1
panic!("expected remoteControl/pairing/start request");	1
assert!(is_non_public_ip("::ffff:10.0.0.1".parse().unwrap()));	1
Err(error) => panic!("invalid hash location regex: {error}"),	1
parse_host_port("http://[::1]:9999", /*default_port*/ 3128).unwrap(),	1
Err(()) => unreachable!("validated file URLs support hierarchical path segments"),	1
assert!(!is_non_public_ip("8.8.8.8".parse().unwrap()));	1
Ok(_) => panic!("unknown MCP environment should fail"),	1
other => panic!("expected initialize incoming message, got {other:?}"),	1
dunce::canonicalize(&codex_dir).unwrap(),	1
assert!(super::fallback_file_path().unwrap().exists());	1
fs::set_permissions(&source_dir, fs::Permissions::from_mode(0o755)).unwrap();	1
panic!("{context}: {err}");	1
assert!(recorded_requests.lock().unwrap().is_empty());	2
let (x1, y1) = t.cursor_pos_with_state(area, state).unwrap();	1
*self.error.write().unwrap() = message;	1
panic!("non-native cwd should be rejected");	1
_ => panic!("unexpected test proxy policy: {policy_name}"),	1
panic!("expected UserInputAnswer event");	2
std::fs::write(&frame, b"png").unwrap();	5
let session_dir = tempdir().unwrap();	4
panic!("expected connection-scoped outgoing message");	3
parse_marketplace_source(file.to_str().unwrap(), /*explicit_ref*/ None).unwrap_err();	1
state.host_blocked(host, /*port*/ 80).await.unwrap(),	1
other => panic!("expected JSON-RPC request, got {other:?}"),	1
Err(err) => panic!("leading byte may be buffered until next chunk: {err}"),	1
None => panic!("para present"),	1
request_sink.lock().unwrap().push(request);	1
let tempdir = TempDir::new().unwrap();	1
let source = parse_marketplace_source(".", /*explicit_ref*/ None).unwrap();	1
let end_second_nl = t.text().find("\nthree").unwrap();	1
HookSource::Plugin => unreachable!("plugin hooks are handled by summary_source"),	1
actions: hooks.get("api.github.com").unwrap()[0].actions.clone(),	4
panic!("Failed to execvp {}: {err}", command[0].as_str());	1
Ok(runtime) => panic!(	1
.unwrap();	116
fs::write(&user_file, config).unwrap();	1
panic!("expected unsupported detail error");	1
unreachable!("errored and disabled statuses are rejected before formatting")	1
validate_absolute_form_host_header(&req, &RequestContext::try_from(&req).unwrap(),),	3
"127.0.0.1:5555".parse::<SocketAddr>().unwrap()	1
self.error.read().unwrap().clone()	1
fs::set_permissions(&script_path, perms).unwrap();	1
let guard = recorded_requests.lock().unwrap();	7
other => panic!("unexpected first phase2 claim outcome: {other:?}"),	1
panic!(	1
build_config_state(reloaded_config, NetworkProxyConstraints::default()).unwrap();	1
LogDbCommand::Entry(_) => panic!("expected flush command"),	1
let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();	1
GuardianAssessmentAction::Execve { .. } => unreachable!(),	1
let base = PathUri::parse("file:///root/%FE/admin").unwrap();	1
panic!("failed to clear CLOEXEC for preserved bubblewrap file descriptor {fd}: {err}");	1
.unwrap(),	10
fs::remove_file(second_path).unwrap();	1
dunce::canonicalize(&agents_dir).unwrap(),	1
fs::write(repo.join(".vscode/settings.json"), "{ \"editor\": true }\n").unwrap();	2
other => panic!("expected JSON-RPC message, got {other:?}"),	1
assert!(is_loopback_host(&Host::parse("127.0.0.1").unwrap()));	1
harness.event_tx.send(RuntimeEvent::YieldRequested).unwrap();	5
ca.tls_acceptor_data_for_host("example.com").unwrap();	1
let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();	10
unreachable!("app server should be initialized for --fork picker");	1
assert_eq!(fs::read_to_string(marker).unwrap(), "installed");	1
render_ambient_pet_image(&mut output, &mut state, /*request*/ None).unwrap();	2
let archive_bytes = archive_plugin_for_upload(&plugin_path).unwrap();	2
assert_eq!(response.unwrap().status(), StatusCode::BAD_REQUEST);	1
.unwrap_or_else(|err| panic!("read-only sandbox template must parse: {err}"))	1
other => panic!("expected message response but got {other:?}"),	7
Box::pin(async { unreachable!("prepare_escalated_exec() is not used by exec() tests") })	1
other => panic!("expected connection open event, got {other:?}"),	1
fs::write(&target, "bundle").unwrap();	1
panic!("expected command hook");	1
Err(_) => unreachable!("a generated code-mode session ID is nonempty"),	1
panic!("expected resumed runtime output");	1
fs::write(dir.path().join("pet.json"), manifest).unwrap();	1
let limit = NonZero::new(1).unwrap();	1
windows_store_update(&serde_json::to_vec(&manifest).unwrap(), "26.803.5235.0"),	1
let _mitm_config_state_guard = config.mitm.then(|| MITM_CONFIG_STATE_LOCK.lock().unwrap());	1
history.local_history.last().unwrap(),	2
panic!();	2
let set = compile_denylist_globset(&["**.Example.COM.".to_string()]).unwrap();	1
.unwrap_or_else(|err| panic!("commit review prompt with title must parse: {err}"))	1
panic!("expected websocket transport");	1
fs::read_to_string(codex_home.path().join(codex_config::CONFIG_TOML_FILE)).unwrap();	4
other => panic!("unexpected stage1 claim outcome for thread b: {other:?}"),	1
unreachable!("position matched a text item");	1
panic!("expected thread-routed history batch response");	1
assert!(!state.is_unix_socket_allowed(&socket_path).await.unwrap());	1
panic!("expected CodexOp");	1
other => panic!("unexpected message: {other:?}"),	1
fs::create_dir(&startup_ca_dir).unwrap();	1
panic!("set listener nonblocking failed: {err}");	1
unreachable!("search commands schema must be an object");	1
other => panic!("expected incoming initialize, got {other:?}"),	1
None => panic!("AWS auth refresh timeout must be non-zero"),	1
let state = build_config_state(config, NetworkProxyConstraints::default()).unwrap();	2
let contents = std::fs::read_to_string(&path).unwrap();	1
let requests = server.received_requests().await.unwrap();	2
Err(error) => panic!("local HTTP MCP should resolve: {error}"),	1
other => panic!("expected restored draft submission, got {other:?}"),	1
Err(_) => unreachable!("remote control enrollment lock should stay open"),	1
fs::write(repo.join("package.json"), "{ \"name\": \"demo\" }\n").unwrap();	2
reqwest::Url::parse("https://chatgpt.com/backend-api/codex/responses").unwrap();	1
panic!("--apply-seccomp-then-exec is incompatible with --use-legacy-landlock");	1
unreachable!("realtime v2 does not send standalone handoff output")	1
panic!("failed to block bubblewrap forwarded signals: {err}");	1
std::fs::write(root.join("file.txt"), "line1\nlocal2\nline3\n").unwrap();	1
let path = std::env::current_dir().unwrap();	1
Ok(Box::new(self.inner.lock().unwrap().readable.try_clone()?))	1
unreachable!("normalized hook identity should serialize to TOML");	1
validate_cached_spritesheet(&path).unwrap();	1
let first = stream.next().await.unwrap();	1
.unwrap_or_else(|| panic!("{tool_name} tool should be registered"))	1
.unwrap_or_else(|err| panic!("danger-full-access sandbox template must parse: {err}"))	1
panic!("finished process metric should be a u64 sum");	1
let b = load_tasks(&backend, Some("env-B")).await.unwrap();	1
.map(|cert| CertificateDer::from_pem_slice(cert.as_bytes()).unwrap());	1
panic!("expected exec resume");	2
*error.write().unwrap() = Some(format!("Failed to save API key: {err}"));	1
unreachable!("unconditional turn construction must accept valid settings");	1
AppLinkSuggestionType::ExternalAction => unreachable!(	1
runtime.upsert_thread(&metadata).await.unwrap();	2
Err(error) => panic!("invalid location suffix regex: {error}"),	1
.unwrap_or_else(|| panic!("cwd must have a filesystem root"));	1
fs::write(dir.path().join("source.txt"), "before\n").unwrap();	1
unreachable!("checked end < text.len()");	1
other => panic!("unexpected no-output stage1 claim outcome: {other:?}"),	1
"127.0.0.1:43128".parse::<SocketAddr>().unwrap()	1
.unwrap_or_else(|err| panic!("commit review prompt must parse: {err}"))	1
panic!("failed to reset bubblewrap signal handler for {signal}: {err}");	1
request.headers.get(CONTENT_TYPE).unwrap(),	2
other => panic!("unexpected refreshed stage1 claim outcome: {other:?}"),	1
.unwrap_or_else(|| panic!("missing fake response for {:?}", command.argv));	1
metadata.recency_at = DateTime::<Utc>::from_timestamp(recency_at, 0).unwrap();	1
assert_eq!(format_json_compact("false").unwrap(), "false");	1
_ => unreachable!("Codex Apps fetch ticket requires cache context"),	1
panic!("Wine process guard is missing");	2
assert_eq!(serde_json::to_value(&input).unwrap(), value);	1
fs::write(&path, "x").unwrap();	1
other => panic!("unexpected second phase2 claim outcome: {other:?}"),	1
panic!("server task failed: {err}");	2
fs::write(&db_rollout_path, "").unwrap();	1
assert_eq!(*error.read().unwrap(), None);	1
.unwrap_or_else(|err| panic!("plugin cache root should be absolute: {err}"))	1
None => unreachable!("pending namespace ancestor was not probed"),	1
.unwrap_or_else(|err| panic!("collaboration mode default template must render: {err}"))	1
other => panic!("expected restored paste submission, got {other:?}"),	1
let tied = ThreadId::from_string("00000000-0000-0000-0000-000000000062").unwrap();	1
Err(_) => unreachable!("fail-closed glob handling does not return errors"),	1
.contains(&dunce::canonicalize(&extra_root).unwrap())	1
assert!(harness.initial_event_rx.await.unwrap().is_ok());	3
let expected_cursor1: Cursor = serde_json::from_str("\"2025-03-04T09-00-00\"").unwrap();	1
panic!("expected response message");	1
String::from_utf8(actual).unwrap(),	1
assert!(is_non_public_ip("198.51.100.1".parse().unwrap()));	1
.unwrap(),	25
ThreadId::from_string("00000000-0000-0000-0000-000000000044").unwrap();	1
Err(err) => panic!("partial code point should be buffered: {err}"),	3
panic!("failed to fork sandboxed command: {err}");	1
let mut file = fs::File::create(path).unwrap();	1
panic!("expected third guardian assessment");	1
fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap(),	1
|| panic!("runtime thread panic probe"),	2
.unwrap();	13
panic!("pending delivery returned an unexpected event: {event:?}")	1
let temp = TempDir::new().unwrap();	20
parse_host_port("example.com:notaport", /*default_port*/ 3128).unwrap(),	1
let template = Template::parse("{{greeting}}, {{ name }}!").unwrap();	1
*sign_in_state.write().unwrap() =	1
panic!("expected fourth guardian assessment");	1
panic!("expected fallback remoteControl/disable request");	1
assert!(is_non_public_ip("192.0.0.1".parse().unwrap()));	1
let json = serde_json::to_string(&value).unwrap();	1
image.save(&spritesheet_path).unwrap();	1
fs::copy(dir.path().join("pet.json"), pet_dir.join("pet.json")).unwrap();	1
panic!("unexpected event variant");	6
Pet::load_with_codex_home(dir.path().to_str().unwrap(), /*codex_home*/ None).unwrap_err()	1
TraceId::from_hex(trace_id).unwrap()	1
panic!("expected exec approval request");	4
serde_json::to_value(CodexErrorInfo::from(core)).unwrap(),	1
assert_eq!(socks_addr, "127.0.0.1:8081".parse::<SocketAddr>().unwrap());	2
fs::write(session_dir.path().join("source.txt"), "before\n").unwrap();	1
_ => unreachable!("json literal must be an object"),	1
unreachable!("app server should be initialized for --resume picker");	1
let col_start = rows[row_idx].find(needle).unwrap() as u16; // column where '1' starts	1
*widget.sign_in_state.write().unwrap() =	1
let stdout_str = String::from_utf8(stdout).unwrap();	7
keymap_with_replacement(&TuiKeymap::default(), "global", "copy", "ctrl-x").unwrap();	1
panic!("active goal should be updated");	1
let set = compile_denylist_globset(&patterns).unwrap();	4
dir.path().join("pet.json").to_str().unwrap(),	1
fs::create_dir_all(installed_root.join(".agents/plugins")).unwrap();	1
harness.event_tx.send(RuntimeEvent::Started).unwrap();	1
other => panic!("expected queued key event, got {other:?}"),	1
other => panic!("unexpected status: {other:?}"),	2
fs::write(dir.path().join("beta.txt"), "beta").unwrap();	2
let cmds2 = parse_seq("echo 'hi there'").unwrap();	1
.unwrap_or_else(|err| panic!("imagegen input schema should parse: {err}")),	1
AbsolutePathBuf::try_from(codex_home.path().join("local-plugin")).unwrap();	2
symlink(&target, &link).unwrap();	1
Err(err) => panic!("search commands schema should serialize: {err}"),	1
Err(err) => panic!("root path must be absolute: {err}"),	1
.unwrap_or_else(|err| panic!("base branch review prompt must parse: {err}"))	1
SessionSource::from_startup_arg("atlas").unwrap(),	1
other => panic!(	2
panic!("expected image-generation item");	3
let secret_file = NamedTempFile::new().unwrap();	1
assert_eq!(base.join_native_bytes(path).unwrap().to_string(), expected);	1
Err(err) => panic!("embedded template {template_name} is invalid: {err}"),	3
let expected_deny: HashSet<PathBuf> = [dunce::canonicalize(&git_dir).unwrap()]	1
let start_word3 = t.text().find("word3").unwrap();	1
let config: NetworkProxyConfig = serde_json::from_str(r#"{ "enabled": true }"#).unwrap();	1
.unwrap_or_else(|err| panic!("failed to serialize {flag}: {err}")),	1
panic!("expected resume subcommand");	1
other => panic!("expected item started notification, got {other:?}"),	1
fs::write(&path, b"png").unwrap();	2
Err(err) => panic!("timed out waiting for JSON-RPC line: {err}"),	1
let output = String::from_utf8(output).unwrap();	5
fs::write(session_dir.path().join("target.txt"), "target\n").unwrap();	1
let baseline_bundle = fs::read_to_string(&trust_bundle.path).unwrap();	2
Some(other) => unreachable!("unexpected reset confirmation row: {other}"),	1
state.host_blocked("10.0.0.1", /*port*/ 80).await.unwrap(),	2
fs::create_dir_all(db_rollout_path.parent().expect("rollout parent")).unwrap();	1
Err(err) => panic!("test codex_home should be absolute: {err}"),	1
panic!("ide-context request did not include a request id");	1
.contains(&dunce::canonicalize(&command_cwd).unwrap())	3
fs::write(startup_ca_dir.join("directory-ca.pem"), &directory_ca_cert).unwrap();	1
&*self.sign_in_state.read().unwrap(),	1
panic!("expected invalid request error");	3
panic!("No command specified to execute.");	1
details => panic!("unexpected auth error: {details:?}"),	1
windows_managed_loopback_addr("0.0.0.0:3128".parse::<SocketAddr>().unwrap()),	1
panic!("expected app-server warning notification");	3
panic!("failed to fork for bubblewrap: {err}");	2
let cmds = parse_seq(src).unwrap();	1
panic!("expected JSON-RPC error response");	1
state.host_blocked("openai.com", /*port*/ 80).await.unwrap(),	1
ResolveCwdOutcome::Exit => panic!("configured cwd should not exit startup"),	1
let updated_hunks = parser.push_delta(&ch.to_string()).unwrap();	1
.unwrap_or_else(|err| panic!("temp codex home dir create failed: {err}"));	1
let mut guard = self.sign_in_state.write().unwrap();	2
harness.initial_event_rx.await.unwrap(),	1
McpProtocolMode::Legacy.stdio_mode(modern_version).unwrap(),	1
.map(|part| part.split("\x1b]8;;\x07").next().unwrap())	1
let version = windows_build_number().unwrap();	1
other => panic!("expected hook toggle event, got {other:?}"),	1
other => panic!("unexpected second event: {other:?}"),	1
Box::pin(async move { unimplemented!("test filesystem only supports reads") })	5
panic!("failed to set CLOEXEC for test fd {fd}: {err}");	1
panic!("embedded goals/continuation.md template failed to render: {err}")	1
response_headers.insert(LOCATION, HeaderValue::from_str(location).unwrap());	1
None => panic!("server connection closed before JSON-RPC line arrived"),	1
Ok(_) => panic!("stalled connect response body should time out"),	1
_ => unreachable!("unsupported user input variant"),	1
AuthMode::AgentIdentity => unreachable!("agent identity mode is handled above"),	1
_ => panic!("expected slow and fast requests"),	1
"sixel".parse::<ProtocolSelection>().unwrap(),	1
panic!("expected hidden side boundary prompt to be a user message");	1
let second = stream.next().await.unwrap();	1
Regex::new(&format!("(?i){pat}")).unwrap_or_else(|e| panic!("invalid regex: {e}"))	1
Some(&HeaderValue::from_str(&format!("Bearer {real_token}")).unwrap())	1
"[::1]:8080".parse::<SocketAddr>().unwrap()	1
let (x, y) = t.cursor_pos(area).unwrap();	1
_ => panic!("expected in-process shutdown request"),	1
assert_eq!(format_json_compact("true").unwrap(), "true");	1
let proc = self.proc.lock().unwrap().try_clone().unwrap();	2
unimplemented!("unsupported architecture for seccomp filter");	1
panic!("budget-limited goal should still account in-flight active usage");	1
|| panic!("tmux info should not be queried when forwarding is disabled"),	1
panic!("failed to compile bubblewrap for Linux target: {err}");	1
dunce::canonicalize(&command_cwd).unwrap(),	1
"127.0.0.1:3128".parse::<SocketAddr>().unwrap()	2
Ok(_) => panic!("Bedrock API key auth should be rejected"),	1
let logo_dark = AbsolutePathBuf::try_from(PathBuf::from(logo_dark)).unwrap();	1
resolve_addr("localhost", /*default_port*/ 3128).unwrap(),	1
other => panic!("expected command execution output delta, got {other:?}"),	1
.unwrap_or_else(|err| panic!("invalid bundled bubblewrap fd path: {err}"));	1
panic!("expected response item");	3
_ => unreachable!("we just sent a ServerRequest variant"),	1
let msg = warning.unwrap();	1
} = resolve_permission_profile(permission_profile).unwrap_or_else(|err| panic!("{err}"));	1
let mut config = toml::from_str(&format!("{safe}{key} = 'page-down'")).unwrap();	1
_ => panic!("tool schema should serialize to a JSON object"),	1
Pet::load_with_codex_home(dir.path().to_str().unwrap(), /*codex_home*/ None).unwrap()	1
panic!("expected user message event");	1
assert_eq!(String::from_utf8(stderr).unwrap(), "");	2
Ok(_) => panic!("initial connection should fail"),	1
other => panic!("expected connection closed, got {other:?}"),	4
let text = std::str::from_utf8(payload).unwrap();	1
Err(error) => panic!("foreign cwd should resolve: {error}"),	1
unreachable!("turn event params require a fully populated turn state");	1
panic!("builtin-like MCP tool should stay function-shaped");	1
let marketplace_path = AbsolutePathBuf::try_from(PathBuf::from(marketplace_path)).unwrap();	3
other => panic!("expected close-stdin frame, got {other:?}"),	1
assert_eq!(fs::read_to_string(&relative_add).unwrap(), "relative add\n");	1
.unwrap_or_else(|| panic!("managed proxy mode requires --proxy-route-spec"));	1
.unwrap()	4
panic!("expected remaining queued user input");	1
Err(err) => panic!("default provider should create valid environments: {err}"),	1
other => panic!("unexpected takeover claim outcome: {other:?}"),	1
assert_eq!(fs::read_to_string(&absolute_add).unwrap(), "absolute add\n");	1
panic!("built-in keymap defaults must be valid: {error}")	1
state.set_network_mode(NetworkMode::Limited).await.unwrap();	1
parse_marketplace_source("owner/repo@main", Some("release".to_string())).unwrap(),	1
assert_eq!(format_json_compact("42").unwrap(), "42");	1
let cmd = resolve_editor_command().unwrap();	1
.map(|k| parse_theme_name(k).unwrap_or_else(|| panic!("unmapped kebab name: {k}")))	1
panic!("expected hook prompt message");	1
.unwrap_or_else(|_| unreachable!());	4
fs::read_to_string(destination.path().join(long_skill_path)).unwrap(),	1
threads: NonZero::new(2).unwrap(),	6
_ => unreachable!("validated stop hook event"),	2
.unwrap_or_else(|err| panic!("bundled models.json should parse: {err}"))	1
_ => panic!("expected PatchApplyBegin event"),	1
panic!("cell close panic probe");	1
fs::write(&path, "a\nb\nc\nd\ne\nf\n").unwrap();	1
panic!("completion delivery unexpectedly carried an actor error: {error:?}")	1
(true, true, _) => unreachable!("direct and deferred exposure are mutually exclusive"),	1
panic!("expected warning event");	2
Err(error) => panic!("local stdio MCP should resolve: {error}"),	1
_ => panic!("expected shutdown command"),	1
_ => unreachable!("validated stop hook event"),	1
let after_alpha = t.text().find("alpha").unwrap() + "alpha".len();	1
panic!("bwrap is only supported on Linux");	1
serde_json::from_str(lines.next().expect("canonical session meta")).unwrap();	1
.unwrap_or_else(|| panic!("expected prompt row in screen rows: {rows:?}"));	1
other => panic!("expected JSON-RPC request, got {other:?}"),	1
Ref::map(cache, |c| &c.as_ref().unwrap().lines)	1
panic!("expected features enable");	1
panic!("expected init command, got service tier {command:?}")	1
let fallback_request = requests.lock().unwrap()[1].clone();	1
panic!("expected sandbox command");	4
other => panic!("expected timeout-or-cancellation expiration, got {other:?}"),	1
