codex-rs/tui/src/resume_picker.rs (96 lines):
	- line 3522: request_sink.lock().unwrap().push(request);
	- line 3613: let db_request = requests.lock().unwrap()[0].clone();
	- line 3629: let later_db_request = requests.lock().unwrap()[1].clone();
	- line 3638: assert_eq!(requests.lock().unwrap().len(), 2);
	- line 3647: let db_request = requests.lock().unwrap()[0].clone();
	- line 3655: let fallback_request = requests.lock().unwrap()[1].clone();
	- line 3732: let db_request = requests.lock().unwrap()[0].clone();
	- line 4017: request_sink.lock().unwrap().push(req);
	- line 4034: let guard = recorded_requests.lock().unwrap();
	- line 4533: .unwrap();
	- line 4546: request_sink.lock().unwrap().push(thread_id);
	- line 4571: .unwrap();
	- line 4574: assert_eq!(*recorded_requests.lock().unwrap(), vec![thread_id]);
	- line 4621: .unwrap();
	- line 4630: .unwrap();
	- line 4643: *cancellation_sink.lock().unwrap() = Some(cancellation);
	- line 4664: .unwrap();
	- line 4670: .unwrap();
	- line 4677: .unwrap()
	- line 4687: .unwrap();
	- line 4707: .unwrap();
	- line 4783: request_sink.lock().unwrap().push(thread_id);
	- line 4808: .unwrap();
	- line 4810: assert_eq!(*recorded_requests.lock().unwrap(), vec![thread_id]);
	- line 4838: .unwrap();
	- line 4870: .unwrap();
	- line 4920: .unwrap();
	- line 4951: .unwrap();
	- line 4985: .unwrap();
	- line 5014: .unwrap();
	- line 5036: .unwrap();
	- line 5040: .unwrap();
	- line 5053: request_sink.lock().unwrap().push(thread_id);
	- line 5078: .unwrap();
	- line 5081: assert_eq!(*recorded_requests.lock().unwrap(), vec![thread_id]);
	- line 5086: .unwrap();
	- line 5117: .unwrap();
	- line 5715: request_sink.lock().unwrap().push(req);
	- line 5737: assert!(recorded_requests.lock().unwrap().is_empty());
	- line 5739: let guard = recorded_requests.lock().unwrap();
	- line 5749: request_sink.lock().unwrap().push(req);
	- line 5776: assert!(recorded_requests.lock().unwrap().is_empty());
	- line 5784: request_sink.lock().unwrap().push(req);
	- line 5810: let guard = recorded_requests.lock().unwrap();
	- line 5826: request_sink.lock().unwrap().push(req);
	- line 5840: let guard = recorded_requests.lock().unwrap();
	- line 5848: .unwrap();
	- line 5852: .unwrap();
	- line 5856: .unwrap();
	- line 5858: let guard = recorded_requests.lock().unwrap();
	- line 5868: request_sink.lock().unwrap().push(req);
	- line 5882: let guard = recorded_requests.lock().unwrap();
	- line 5890: .unwrap();
	- line 5892: let guard = recorded_requests.lock().unwrap();
	- line 5902: request_sink.lock().unwrap().push(req);
	- line 5916: let guard = recorded_requests.lock().unwrap();
	- line 5924: .unwrap();
	- line 5926: let guard = recorded_requests.lock().unwrap();
	- line 5936: request_sink.lock().unwrap().push(req);
	- line 5960: .unwrap();
	- line 5964: .unwrap();
	- line 5968: .unwrap();
	- line 5970: let guard = recorded_requests.lock().unwrap();
	- line 6009: .unwrap();
	- line 6015: .unwrap();
	- line 6021: .unwrap();
	- line 6027: .unwrap();
	- line 6033: .unwrap();
	- line 6071: .unwrap();
	- line 6077: .unwrap();
	- line 6083: .unwrap();
	- line 6089: .unwrap();
	- line 6095: .unwrap();
	- line 6115: .unwrap();
	- line 6125: request_sink.lock().unwrap().push(req);
	- line 6157: .unwrap();
	- line 6161: assert_eq!(recorded_requests.lock().unwrap().len(), 1);
	- line 6243: other => panic!("unexpected selection: {other:?}"),
	- line 6534: .unwrap();
	- line 6540: .unwrap();
	- line 6582: .unwrap();
	- line 6620: .unwrap();
	- line 6667: request_sink.lock().unwrap().push(req);
	- line 6689: recorded_requests.lock().unwrap().clear();
	- line 6693: let guard = recorded_requests.lock().unwrap();
	- line 6710: .unwrap();
	- line 6713: let guard = recorded_requests.lock().unwrap();
	- line 6736: .unwrap();
	- line 6741: recorded_requests.lock().unwrap().clear();
	- line 6744: let guard = recorded_requests.lock().unwrap();
	- line 6761: .unwrap();
	- line 6762: assert_eq!(recorded_requests.lock().unwrap().len(), 1);
	- line 6776: .unwrap();
	- line 6824: request_sink.lock().unwrap().push(req);
	- line 6846: recorded_requests.lock().unwrap().clear();
	- line 6850: let guard = recorded_requests.lock().unwrap();


codex-rs/rollout/src/tests.rs (82 lines):
	- line 130: let temp = TempDir::new().unwrap();
	- line 142: .unwrap();
	- line 165: let temp = TempDir::new().unwrap();
	- line 178: .unwrap();
	- line 186: .unwrap();
	- line 193: fs::rename(reverted_source, reverted_path.as_path()).unwrap();
	- line 198: .unwrap(),
	- line 204: .unwrap(),
	- line 211: let temp = TempDir::new().unwrap();
	- line 222: .unwrap();
	- line 224: let contents = fs::read_to_string(&path).unwrap();
	- line 227: serde_json::from_str(lines.next().expect("canonical session meta")).unwrap();
	- line 239: .unwrap();
	- line 246: let temp = TempDir::new().unwrap();
	- line 258: .unwrap();
	- line 270: .unwrap();
	- line 291: let temp = TempDir::new().unwrap();
	- line 303: .unwrap();
	- line 327: let temp = TempDir::new().unwrap();
	- line 332: fs::create_dir_all(db_rollout_path.parent().expect("rollout parent")).unwrap();
	- line 333: fs::write(&db_rollout_path, "").unwrap();
	- line 404: .unwrap()
	- line 428: payload["source"] = serde_json::to_value(source).unwrap();
	- line 475: .unwrap()
	- line 554: .unwrap()
	- line 613: .unwrap()
	- line 648: let temp = TempDir::new().unwrap();
	- line 664: .unwrap();
	- line 672: .unwrap();
	- line 680: .unwrap();
	- line 694: .unwrap();
	- line 798: let temp = TempDir::new().unwrap();
	- line 816: .unwrap();
	- line 824: .unwrap();
	- line 832: .unwrap();
	- line 840: .unwrap();
	- line 848: .unwrap();
	- line 862: .unwrap();
	- line 877: let expected_cursor1: Cursor = serde_json::from_str("\"2025-03-04T09-00-00\"").unwrap();
	- line 942: .unwrap();
	- line 957: let expected_cursor2: Cursor = serde_json::from_str("\"2025-03-02T09-00-00\"").unwrap();
	- line 1022: .unwrap();
	- line 1063: let temp = TempDir::new().unwrap();
	- line 1069: .unwrap();
	- line 1083: .unwrap();
	- line 1091: let temp = TempDir::new().unwrap();
	- line 1103: .unwrap();
	- line 1117: .unwrap();
	- line 1128: let temp = TempDir::new().unwrap();
	- line 1140: .unwrap();
	- line 1154: .unwrap();
	- line 1168: let temp = TempDir::new().unwrap();
	- line 1180: .unwrap();
	- line 1194: .unwrap();
	- line 1197: let content = tokio::fs::read_to_string(path).await.unwrap();
	- line 1264: let temp = TempDir::new().unwrap();
	- line 1278: write_session_file_with_meta_payload(home, ts, uuid, payload).unwrap();
	- line 1292: .unwrap();
	- line 1306: let temp = TempDir::new().unwrap();
	- line 1322: write_session_file_with_meta_payload(home, ts, uuid, payload).unwrap();
	- line 1336: .unwrap();
	- line 1351: let temp = TempDir::new().unwrap();
	- line 1372: format!("{}\n", serde_json::to_string(&line).unwrap()),
	- line 1374: .unwrap();
	- line 1376: let head = read_head_for_summary(&rollout_path).await.unwrap();
	- line 1378: assert_eq!(head, vec![serde_json::to_value(response_item).unwrap()]);
	- line 1384: let temp = TempDir::new().unwrap();
	- line 1396: .unwrap();
	- line 1438: let temp = TempDir::new().unwrap();
	- line 1546: let temp = TempDir::new().unwrap();
	- line 1561: .unwrap();
	- line 1569: .unwrap();
	- line 1577: .unwrap();
	- line 1591: .unwrap();
	- line 1607: let expected_cursor1: Cursor = serde_json::from_str(&format!("\"{ts}\"")).unwrap();
	- line 1672: .unwrap();
	- line 1686: let temp = TempDir::new().unwrap();
	- line 1699: .unwrap();
	- line 1707: .unwrap();
	- line 1721: .unwrap();
	- line 1744: .unwrap();
	- line 1761: let temp = TempDir::new().unwrap();


codex-rs/apply-patch/src/lib.rs (77 lines):
	- line 894: let dir = tempdir().unwrap();
	- line 913: .unwrap();
	- line 915: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 916: let stderr_str = String::from_utf8(stderr).unwrap();
	- line 923: let contents = fs::read_to_string(path).unwrap();
	- line 929: let dir = tempdir().unwrap();
	- line 937: fs::write(&relative_delete, "delete relative\n").unwrap();
	- line 938: fs::write(&absolute_delete, "delete absolute\n").unwrap();
	- line 939: fs::write(&relative_update, "relative old\n").unwrap();
	- line 940: fs::write(&absolute_update, "absolute old\n").unwrap();
	- line 973: .unwrap();
	- line 975: assert_eq!(fs::read_to_string(&relative_add).unwrap(), "relative add\n");
	- line 976: assert_eq!(fs::read_to_string(&absolute_add).unwrap(), "absolute add\n");
	- line 980: fs::read_to_string(&relative_update).unwrap(),
	- line 984: fs::read_to_string(&absolute_update).unwrap(),
	- line 987: assert_eq!(String::from_utf8(stderr).unwrap(), "");
	- line 989: String::from_utf8(stdout).unwrap(),
	- line 1001: let dir = tempdir().unwrap();
	- line 1003: fs::write(&path, "x").unwrap();
	- line 1016: .unwrap();
	- line 1017: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 1018: let stderr_str = String::from_utf8(stderr).unwrap();
	- line 1030: let dir = tempdir().unwrap();
	- line 1032: fs::write(&path, "foo\nbar\n").unwrap();
	- line 1052: .unwrap();
	- line 1054: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 1055: let stderr_str = String::from_utf8(stderr).unwrap();
	- line 1062: let contents = fs::read_to_string(&path).unwrap();
	- line 1068: let dir = tempdir().unwrap();
	- line 1071: fs::write(&src, "line\n").unwrap();
	- line 1092: .unwrap();
	- line 1094: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 1095: let stderr_str = String::from_utf8(stderr).unwrap();
	- line 1103: let contents = fs::read_to_string(&dest).unwrap();
	- line 1112: let dir = tempdir().unwrap();
	- line 1115: fs::create_dir(&source_dir).unwrap();
	- line 1116: fs::create_dir(&dest_dir).unwrap();
	- line 1119: fs::write(&src, "line\n").unwrap();
	- line 1120: fs::set_permissions(&source_dir, fs::Permissions::from_mode(0o555)).unwrap();
	- line 1138: fs::set_permissions(&source_dir, fs::Permissions::from_mode(0o755)).unwrap();
	- line 1142: .unwrap()
	- line 1158: assert_eq!(fs::read_to_string(src).unwrap(), "line\n");
	- line 1159: assert_eq!(fs::read_to_string(dest).unwrap(), "line2\n");
	- line 1167: let dir = tempdir().unwrap();
	- line 1169: fs::write(&path, "foo\nbar\nbaz\nqux\n").unwrap();
	- line 1196: .unwrap();
	- line 1197: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 1198: let stderr_str = String::from_utf8(stderr).unwrap();
	- line 1205: let contents = fs::read_to_string(&path).unwrap();
	- line 1215: let dir = tempdir().unwrap();
	- line 1219: fs::write(&path, "a\nb\nc\nd\ne\nf\n").unwrap();
	- line 1254: .unwrap();
	- line 1256: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 1257: let stderr_str = String::from_utf8(stderr).unwrap();
	- line 1266: let contents = fs::read_to_string(&path).unwrap();
	- line 1272: let dir = tempdir().unwrap();
	- line 1274: fs::write(&path, "line1\nline2\nline3\n").unwrap();
	- line 1298: .unwrap();
	- line 1299: let contents = fs::read_to_string(path).unwrap();
	- line 1314: let dir = tempdir().unwrap();
	- line 1319: std::fs::write(&path, original).unwrap();
	- line 1341: .unwrap();
	- line 1345: let contents = std::fs::read_to_string(&path).unwrap();
	- line 1349: let stdout_str = String::from_utf8(stdout).unwrap();
	- line 1357: assert_eq!(String::from_utf8(stderr).unwrap(), "");
	- line 1365: let dir = tempdir().unwrap();
	- line 1367: fs::create_dir(&locked_dir).unwrap();
	- line 1368: fs::set_permissions(&locked_dir, fs::Permissions::from_mode(0o555)).unwrap();
	- line 1385: fs::set_permissions(&locked_dir, fs::Permissions::from_mode(0o755)).unwrap();
	- line 1392: let dir = tempdir().unwrap();
	- line 1394: fs::write(dir.path().join("source.txt"), "before\n").unwrap();
	- line 1401: fs::write(&path, [0xff, 0xfe, 0xfd]).unwrap();
	- line 1413: .unwrap();
	- line 1424: let dir = tempdir().unwrap();
	- line 1425: fs::write(dir.path().join("target.txt"), "target\n").unwrap();
	- line 1426: symlink(dir.path().join("target.txt"), dir.path().join("link.txt")).unwrap();
	- line 1440: .unwrap();


codex-rs/app-server-protocol/src/protocol/v2/tests.rs (63 lines):
	- line 3587: .unwrap(),
	- line 3599: .unwrap(),
	- line 3610: .unwrap(),
	- line 3626: .unwrap(),
	- line 3635: .unwrap(),
	- line 3649: .unwrap(),
	- line 3671: let local_path = AbsolutePathBuf::try_from(PathBuf::from(local_path)).unwrap();
	- line 3675: serde_json::to_value(PluginSource::Local { path: local_path }).unwrap(),
	- line 3689: .unwrap(),
	- line 3705: .unwrap(),
	- line 3715: serde_json::to_value(PluginSource::Remote).unwrap(),
	- line 3730: .unwrap(),
	- line 3744: .unwrap(),
	- line 3759: .unwrap(),
	- line 3766: serde_json::from_value::<MarketplaceUpgradeParams>(json!({})).unwrap(),
	- line 3776: .unwrap(),
	- line 3792: .unwrap(),
	- line 3809: let composer_icon = AbsolutePathBuf::try_from(PathBuf::from(composer_icon)).unwrap();
	- line 3816: let logo_dark = AbsolutePathBuf::try_from(PathBuf::from(logo_dark)).unwrap();
	- line 3842: serde_json::to_value(interface).unwrap(),
	- line 3874: .unwrap(),
	- line 3889: .unwrap(),
	- line 3912: .unwrap(),
	- line 3936: .unwrap(),
	- line 3954: let marketplace_path = AbsolutePathBuf::try_from(PathBuf::from(marketplace_path)).unwrap();
	- line 3962: .unwrap(),
	- line 3976: .unwrap(),
	- line 3989: .unwrap(),
	- line 4005: let marketplace_path = AbsolutePathBuf::try_from(PathBuf::from(marketplace_path)).unwrap();
	- line 4014: .unwrap(),
	- line 4029: .unwrap(),
	- line 4044: .unwrap(),
	- line 4062: .unwrap(),
	- line 4078: let plugin_path = AbsolutePathBuf::try_from(PathBuf::from(plugin_path)).unwrap();
	- line 4088: .unwrap(),
	- line 4115: .unwrap(),
	- line 4141: .unwrap(),
	- line 4159: .unwrap(),
	- line 4181: .unwrap(),
	- line 4194: serde_json::from_value::<PluginShareListParams>(json!({})).unwrap(),
	- line 4202: .unwrap(),
	- line 4213: let plugin_path = AbsolutePathBuf::try_from(PathBuf::from(plugin_path)).unwrap();
	- line 4220: let marketplace_path = AbsolutePathBuf::try_from(PathBuf::from(marketplace_path)).unwrap();
	- line 4232: .unwrap(),
	- line 4248: .unwrap(),
	- line 4286: .unwrap(),
	- line 4328: .unwrap();
	- line 4377: let availability: PluginAvailability = serde_json::from_value(json!("ENABLED")).unwrap();
	- line 4381: serde_json::to_value(availability).unwrap(),
	- line 4392: .unwrap(),
	- line 4403: .unwrap(),
	- line 4413: .unwrap(),
	- line 4424: .unwrap(),
	- line 4438: let installed_root = AbsolutePathBuf::try_from(PathBuf::from(installed_root)).unwrap();
	- line 4445: .unwrap(),
	- line 4457: .unwrap(),
	- line 4472: let upgraded_root = AbsolutePathBuf::try_from(PathBuf::from(upgraded_root)).unwrap();
	- line 4484: .unwrap(),
	- line 4503: serde_json::to_value(value).unwrap(),
	- line 4522: serde_json::to_value(CodexErrorInfo::from(core)).unwrap(),
	- line 4535: serde_json::to_value(value).unwrap(),
	- line 4552: .unwrap();
	- line 4584: .unwrap();


codex-rs/network-proxy/src/runtime.rs (62 lines):
	- line 1076: .unwrap(),
	- line 1084: .unwrap(),
	- line 1086: mitm_hooks: crate::mitm_hook::compile_mitm_hooks(&config).unwrap(),
	- line 1178: build_config_state(config.clone(), NetworkProxyConstraints::default()).unwrap();
	- line 1182: build_config_state(reloaded_config, NetworkProxyConstraints::default()).unwrap();
	- line 1228: .unwrap(),
	- line 1241: .unwrap(),
	- line 1247: state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),
	- line 1262: state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),
	- line 1270: state.host_blocked("127.0.0.1", /*port*/ 80).await.unwrap(),
	- line 1280: state.add_allowed_domain("ExAmPlE.CoM").await.unwrap();
	- line 1282: let (allowed, denied) = state.current_patterns().await.unwrap();
	- line 1289: .unwrap(),
	- line 1298: state.add_denied_domain("EXAMPLE.COM").await.unwrap();
	- line 1300: let (allowed, denied) = state.current_patterns().await.unwrap();
	- line 1307: .unwrap(),
	- line 1318: state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),
	- line 1322: state.add_denied_domain("8.8.8.8").await.unwrap();
	- line 1324: let (allowed, denied) = state.current_patterns().await.unwrap();
	- line 1328: state.host_blocked("8.8.8.8", /*port*/ 80).await.unwrap(),
	- line 1343: build_config_state(config, constraints).unwrap(),
	- line 1347: state.add_allowed_domain("user.example.com").await.unwrap();
	- line 1349: let (allowed, denied) = state.current_patterns().await.unwrap();
	- line 1370: build_config_state(config, constraints).unwrap(),
	- line 1395: build_config_state(config, constraints).unwrap(),
	- line 1505: .unwrap(),
	- line 1509: state.host_blocked("openai.com", /*port*/ 80).await.unwrap(),
	- line 1522: .unwrap(),
	- line 1529: .unwrap(),
	- line 1536: .unwrap(),
	- line 1546: state.host_blocked("127.0.0.1", /*port*/ 80).await.unwrap(),
	- line 1550: state.host_blocked("localhost", /*port*/ 80).await.unwrap(),
	- line 1560: state.host_blocked("localhost", /*port*/ 80).await.unwrap(),
	- line 1570: state.host_blocked("10.0.0.1", /*port*/ 80).await.unwrap(),
	- line 1583: .unwrap(),
	- line 1596: .unwrap(),
	- line 1612: .unwrap(),
	- line 1619: .unwrap(),
	- line 1633: state.host_blocked(host, /*port*/ 80).await.unwrap(),
	- line 1651: .unwrap(),
	- line 1658: .unwrap(),
	- line 1668: state.host_blocked("10.0.0.1", /*port*/ 80).await.unwrap(),
	- line 1678: state.host_blocked("127.0.0.1", /*port*/ 80).await.unwrap(),
	- line 1693: .unwrap(),
	- line 1737: |_host, _port| async { Ok(vec!["127.0.0.1:80".parse().unwrap()]) },
	- line 1750: |_host, _port| async { Ok(vec!["8.8.8.8:80".parse().unwrap()]) },
	- line 1993: let set = compile_denylist_globset(&patterns).unwrap();
	- line 2001: let set = compile_denylist_globset(&patterns).unwrap();
	- line 2010: let set = compile_denylist_globset(&patterns).unwrap();
	- line 2025: let set = compile_allowlist_globset(&patterns).unwrap();
	- line 2046: let set = compile_denylist_globset(&patterns).unwrap();
	- line 2100: assert!(state.is_unix_socket_allowed(&socket_path).await.unwrap());
	- line 2105: .unwrap()
	- line 2115: let temp_dir = tempdir().unwrap();
	- line 2123: std::fs::write(&real, b"not a socket").unwrap();
	- line 2124: symlink(&real, &link).unwrap();
	- line 2126: let real_s = real.to_str().unwrap().to_string();
	- line 2127: let link_s = link.to_str().unwrap().to_string();
	- line 2135: assert!(state.is_unix_socket_allowed(&link_s).await.unwrap());
	- line 2147: assert!(state.is_unix_socket_allowed("/tmp/any.sock").await.unwrap());
	- line 2148: assert!(!state.is_unix_socket_allowed("relative.sock").await.unwrap());
	- line 2165: assert!(!state.is_unix_socket_allowed(&socket_path).await.unwrap());


codex-rs/linux-sandbox/src/linux_run_main.rs (61 lines):
	- line 174: panic!("No command specified to execute.");
	- line 177: panic!("--verify-fd-mount is only supported in the inner sandbox stage");
	- line 184: } = resolve_permission_profile(permission_profile).unwrap_or_else(|err| panic!("{err}"));
	- line 196: panic!("failed to verify descriptor-backed bubblewrap mount: {err}");
	- line 211: panic!(
	- line 220: panic!("Linux sandbox retained effective or permitted capabilities");
	- line 226: .unwrap_or_else(|| panic!("managed proxy mode requires --proxy-route-spec"));
	- line 228: panic!("error activating Linux proxy routing bridge: {err}");
	- line 239: panic!("error applying Linux sandbox restrictions: {e:?}");
	- line 246: panic!("failed to fork sandboxed command: {err}");
	- line 272: panic!("failed to reap sandboxed child: {err}");
	- line 285: panic!("error applying Linux sandbox restrictions: {e:?}");
	- line 296: .unwrap_or_else(|err| panic!("failed to prepare host proxy routing bridge: {err}"));
	- line 328: panic!("error applying legacy Linux sandbox restrictions: {e:?}");
	- line 373: panic!("--apply-seccomp-then-exec is incompatible with --use-legacy-landlock");
	- line 387: panic!(
	- line 491: .unwrap_or_else(|| panic!("bubblewrap argv is missing command separator '--'"));
	- line 503: panic!("bubblewrap argv is missing inner command after '--'");
	- line 511: None => panic!("failed to resolve current process argv[0]"),
	- line 580: panic!("failed to fork for bubblewrap: {err}");
	- line 589: panic!("failed to place bubblewrap child in its own process group: {err}");
	- line 654: .unwrap_or_else(|_| panic!("protected create monitor thread panicked"));
	- line 757: panic!("failed to create bubblewrap exec start pipe: {err}");
	- line 826: panic!("failed to block bubblewrap forwarded signals: {err}");
	- line 840: panic!("failed to restore bubblewrap forwarded signals: {err}");
	- line 850: panic!("failed to set bubblewrap child parent-death signal: {err}");
	- line 867: panic!("failed to restore bubblewrap signal handler for {signal}: {err}");
	- line 885: panic!("failed to install bubblewrap signal forwarder for {signal}: {err}");
	- line 921: panic!("failed to reset bubblewrap signal handler for {signal}: {err}");
	- line 938: panic!("waitpid failed for bubblewrap child: {err}");
	- line 951: panic!(
	- line 975: panic!(
	- line 1000: panic!(
	- line 1007: panic!(
	- line 1035: Err(err) => panic!(
	- line 1054: Err(err) => panic!(
	- line 1061: panic!(
	- line 1078: Err(err) => panic!(
	- line 1099: Err(err) => panic!(
	- line 1115: Err(err) => panic!(
	- line 1130: Err(err) => panic!(
	- line 1144: Err(err) => panic!(
	- line 1162: panic!(
	- line 1169: unreachable!("protected create removal retry loop should return or panic")
	- line 1252: Err(err) => panic!(
	- line 1264: Err(err) => panic!(
	- line 1273: Err(err) => panic!(
	- line 1293: panic!(
	- line 1306: panic!(
	- line 1313: panic!(
	- line 1321: panic!(
	- line 1341: panic!(
	- line 1426: panic!("failed to create stderr pipe for bubblewrap: {err}");
	- line 1434: panic!("failed to fork for bubblewrap: {err}");
	- line 1445: panic!("failed to redirect stderr for bubblewrap: {err}");
	- line 1463: panic!("failed to read bubblewrap stderr: {err}");
	- line 1489: panic!("{context}: {err}");
	- line 1522: Err(err) => panic!("failed to resolve current executable path: {err}"),
	- line 1526: Err(err) => panic!("failed to serialize permission profile: {err}"),
	- line 1546: .unwrap_or_else(|| panic!("managed proxy mode requires a proxy route spec"));
	- line 1575: panic!("Failed to execvp {}: {err}", command[0].as_str());


codex-rs/file-search/src/lib.rs (59 lines):
	- line 125: limit: NonZero::new(20).unwrap(),
	- line 128: threads: NonZero::new(2).unwrap(),
	- line 626: let mut guard = self.snapshot.write().unwrap();
	- line 633: let mut completed = mutex.lock().unwrap();
	- line 643: let mut completed = mutex.lock().unwrap();
	- line 647: completed = cv.wait(completed).unwrap();
	- line 651: self.snapshot.read().unwrap().clone()
	- line 732: let mut state = mutex.lock().unwrap();
	- line 741: let (next_state, wait_result) = cv.wait_timeout(state, remaining).unwrap();
	- line 758: self.updates.lock().unwrap().clear();
	- line 759: self.complete_times.lock().unwrap().clear();
	- line 763: self.updates.lock().unwrap().clone()
	- line 775: .unwrap()
	- line 784: let mut updates = self.updates.lock().unwrap();
	- line 791: let mut complete_times = self.complete_times.lock().unwrap();
	- line 799: let dir = tempfile::tempdir().unwrap();
	- line 802: fs::write(path, format!("contents {i}")).unwrap();
	- line 854: let dir = tempfile::tempdir().unwrap();
	- line 855: fs::write(dir.path().join("alpha.txt"), "alpha").unwrap();
	- line 856: fs::write(dir.path().join("beta.txt"), "beta").unwrap();
	- line 885: let dir = tempfile::tempdir().unwrap();
	- line 886: fs::write(dir.path().join("alpha.txt"), "alpha").unwrap();
	- line 887: fs::write(dir.path().join("beta.txt"), "beta").unwrap();
	- line 975: limit: NonZero::new(20).unwrap(),
	- line 977: threads: NonZero::new(2).unwrap(),
	- line 1001: let dir = tempfile::tempdir().unwrap();
	- line 1002: fs::create_dir_all(dir.path().join("docs/guides")).unwrap();
	- line 1003: fs::write(dir.path().join("docs/guides/intro.md"), "intro").unwrap();
	- line 1004: fs::write(dir.path().join("docs/readme.md"), "readme").unwrap();
	- line 1010: limit: NonZero::new(20).unwrap(),
	- line 1012: threads: NonZero::new(2).unwrap(),
	- line 1031: let dir = tempfile::tempdir().unwrap();
	- line 1032: fs::create_dir(dir.path().join("guides")).unwrap();
	- line 1033: symlink(dir.path().join("guides"), dir.path().join("guides-link")).unwrap();
	- line 1068: handle.join().unwrap();
	- line 1083: let temp = tempfile::tempdir().unwrap();
	- line 1086: fs::create_dir_all(repo.join(".vscode")).unwrap();
	- line 1088: fs::write(parent.join(".gitignore"), "*\n!.gitignore\n").unwrap();
	- line 1093: .unwrap();
	- line 1094: fs::write(repo.join("package.json"), "{ \"name\": \"demo\" }\n").unwrap();
	- line 1095: fs::write(repo.join(".vscode/settings.json"), "{ \"editor\": true }\n").unwrap();
	- line 1101: limit: NonZero::new(20).unwrap(),
	- line 1103: threads: NonZero::new(2).unwrap(),
	- line 1121: limit: NonZero::new(20).unwrap(),
	- line 1123: threads: NonZero::new(2).unwrap(),
	- line 1140: let temp = tempfile::tempdir().unwrap();
	- line 1143: fs::create_dir_all(repo.join(".vscode")).unwrap();
	- line 1145: fs::write(parent.join(".gitignore"), "*\n!.gitignore\n").unwrap();
	- line 1150: .unwrap();
	- line 1151: fs::write(repo.join("package.json"), "{ \"name\": \"demo\" }\n").unwrap();
	- line 1152: fs::write(repo.join(".vscode/settings.json"), "{ \"editor\": true }\n").unwrap();
	- line 1157: .unwrap();
	- line 1159: fs::create_dir_all(repo.join(".git")).unwrap();
	- line 1165: limit: NonZero::new(20).unwrap(),
	- line 1167: threads: NonZero::new(2).unwrap(),
	- line 1185: limit: NonZero::new(20).unwrap(),
	- line 1187: threads: NonZero::new(2).unwrap(),
	- line 1205: limit: NonZero::new(20).unwrap(),
	- line 1207: threads: NonZero::new(2).unwrap(),


codex-rs/state/src/runtime/memories.rs (55 lines):
	- line 1764: other => panic!("unexpected claim outcome: {other:?}"),
	- line 1905: Err(err) => panic!("claim stage1 should not fail: {err}"),
	- line 1908: panic!("claim stage1 should have returned within retry budget")
	- line 2154: other => panic!("unexpected seed claim outcome: {other:?}"),
	- line 2354: other => panic!("unexpected claim outcome: {other:?}"),
	- line 2675: other => panic!("unexpected claim outcome: {other:?}"),
	- line 2711: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 2807: other => panic!("unexpected claim outcome: {other:?}"),
	- line 2885: other => panic!("unexpected initial stage1 claim outcome: {other:?}"),
	- line 2911: other => panic!("unexpected phase2 claim after initial output: {other:?}"),
	- line 2935: other => panic!("unexpected no-output stage1 claim outcome: {other:?}"),
	- line 2965: other => panic!("unexpected phase2 claim after no-output deletion: {other:?}"),
	- line 3013: other => panic!(
	- line 3107: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 3171: other => panic!(
	- line 3260: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3289: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3434: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3511: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3538: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 3620: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3647: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 3711: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3737: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 3803: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3829: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 3901: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 3927: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 3954: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4040: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4067: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 4106: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4169: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4195: other => panic!("unexpected first phase2 claim outcome: {other:?}"),
	- line 4222: other => panic!("unexpected refreshed stage1 claim outcome: {other:?}"),
	- line 4249: other => panic!("unexpected second phase2 claim outcome: {other:?}"),
	- line 4322: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4348: other => panic!("unexpected phase2 claim outcome: {other:?}"),
	- line 4365: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4456: other => panic!("unexpected stage1 claim outcome for a: {other:?}"),
	- line 4481: other => panic!("unexpected stage1 claim outcome for b: {other:?}"),
	- line 4586: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4685: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4781: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 4893: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 5017: other => panic!("unexpected stage1 claim outcome: {other:?}"),
	- line 5090: other => panic!("unexpected stage1 claim outcome for thread a: {other:?}"),
	- line 5116: other => panic!("unexpected stage1 claim outcome for thread b: {other:?}"),
	- line 5141: other => panic!("unexpected global consolidation claim outcome: {other:?}"),
	- line 5209: other => panic!("unexpected phase2 lock claim outcome: {other:?}"),
	- line 5263: other => panic!("unexpected initial claim outcome: {other:?}"),
	- line 5283: other => panic!("unexpected takeover claim outcome: {other:?}"),
	- line 5342: other => panic!("unexpected initial phase2 claim outcome: {other:?}"),
	- line 5376: other => panic!("unexpected lower-watermark phase2 claim outcome: {other:?}"),
	- line 5406: other => panic!("unexpected claim outcome: {other:?}"),


codex-rs/tui/src/bottom_pane/textarea.rs (52 lines):
	- line 2028: Ref::map(cache, |c| &c.as_ref().unwrap().lines)
	- line 2368: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 2374: .unwrap();
	- line 3498: let third_line_start = t.text().find("mid").unwrap();
	- line 3511: let second_line_start = t.text().find("two").unwrap();
	- line 3528: let end_second_nl = t.text().find("\nthree").unwrap();
	- line 3553: let after_alpha = t.text().find("alpha").unwrap() + "alpha".len();
	- line 3558: let beta_start = t.text().find("beta").unwrap();
	- line 3649: let world_start = t.text().find("world").unwrap();
	- line 3651: let (_x, y) = t.cursor_pos(area).unwrap();
	- line 3658: let (_x, y) = t.cursor_pos_with_state(small_area, state).unwrap();
	- line 3686: let newline = text.find('\n').unwrap();
	- line 3703: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3709: .unwrap();
	- line 3722: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3728: .unwrap();
	- line 3742: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3748: .unwrap();
	- line 3771: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3777: .unwrap();
	- line 3816: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3822: .unwrap();
	- line 3855: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3861: .unwrap();
	- line 3874: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3880: .unwrap();
	- line 3906: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 3912: .unwrap();
	- line 3955: let mut terminal = Terminal::new(TestBackend::new(/*width*/ 8, area.height)).unwrap();
	- line 3973: .unwrap();
	- line 4045: let mut terminal = Terminal::new(TestBackend::new(/*width*/ 100, /*height*/ 1)).unwrap();
	- line 4050: .unwrap();
	- line 4052: let cursor = t.cursor_pos(terminal.backend().buffer().area).unwrap();
	- line 4099: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 4108: .unwrap();
	- line 4137: let mut terminal = Terminal::new(TestBackend::new(area.width, area.height)).unwrap();
	- line 4143: .unwrap();
	- line 4178: let (x1, y1) = t.cursor_pos(area).unwrap();
	- line 4179: let (x2, y2) = t.cursor_pos_with_state(area, bad_state).unwrap();
	- line 4192: let (_x, y) = t.cursor_pos_with_state(small_area, state).unwrap();
	- line 4206: let (_x, y) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4224: let (x, y) = t.cursor_pos(area).unwrap();
	- line 4230: let (x, y) = t.cursor_pos_with_state(small_area, state).unwrap();
	- line 4260: let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4266: let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4272: let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4278: let (x, y) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4284: let (x0, y0) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4288: let (x1, y1) = t.cursor_pos_with_state(area, state).unwrap();
	- line 4300: let start_word2 = t.text().find("word2").unwrap();
	- line 4313: let start_word3 = t.text().find("word3").unwrap();
	- line 4346: .unwrap()


codex-rs/tui/src/onboarding/auth.rs (51 lines):
	- line 217: let sign_in_state = { (*self.sign_in_state.read().unwrap()).clone() };
	- line 223: *self.sign_in_state.write().unwrap() = SignInState::ChatGptSuccess;
	- line 236: let sign_in_state = self.sign_in_state.read().unwrap();
	- line 273: &*self.sign_in_state.read().unwrap(),
	- line 279: let mut sign_in_state = self.sign_in_state.write().unwrap();
	- line 305: *self.error.write().unwrap() = message;
	- line 309: self.error.read().unwrap().clone()
	- line 434: *self.sign_in_state.write().unwrap() = SignInState::PickMode;
	- line 571: let sign_in_state = self.sign_in_state.read().unwrap();
	- line 755: let mut guard = self.sign_in_state.write().unwrap();
	- line 818: let mut guard = self.sign_in_state.write().unwrap();
	- line 843: let mut guard = self.sign_in_state.write().unwrap();
	- line 887: *error.write().unwrap() = None;
	- line 888: *sign_in_state.write().unwrap() = SignInState::ApiKeyConfigured;
	- line 891: *error.write().unwrap() = Some(format!(
	- line 894: *sign_in_state.write().unwrap() = SignInState::ApiKeyEntry(ApiKeyInputState {
	- line 900: *error.write().unwrap() = Some(format!("Failed to save API key: {err}"));
	- line 901: *sign_in_state.write().unwrap() = SignInState::ApiKeyEntry(ApiKeyInputState {
	- line 917: *self.sign_in_state.write().unwrap() = SignInState::ChatGptSuccess;
	- line 952: *error.write().unwrap() = None;
	- line 953: *sign_in_state.write().unwrap() =
	- line 960: *sign_in_state.write().unwrap() = SignInState::PickMode;
	- line 961: *error.write().unwrap() = Some(format!(
	- line 966: *sign_in_state.write().unwrap() = SignInState::PickMode;
	- line 967: *error.write().unwrap() = Some(err.to_string());
	- line 990: let guard = self.sign_in_state.read().unwrap();
	- line 1005: *self.sign_in_state.write().unwrap() = SignInState::ChatGptSuccessMessage;
	- line 1008: *self.sign_in_state.write().unwrap() = SignInState::PickMode;
	- line 1034: let sign_in_state = self.sign_in_state.read().unwrap();
	- line 1051: let sign_in_state = self.sign_in_state.read().unwrap();
	- line 1126: let codex_home = TempDir::new().unwrap();
	- line 1132: .unwrap();
	- line 1164: .unwrap();
	- line 1192: &*widget.sign_in_state.read().unwrap(),
	- line 1272: &*widget.sign_in_state.read().unwrap(),
	- line 1288: &*widget.sign_in_state.read().unwrap(),
	- line 1297: *widget.error.write().unwrap() = Some("still logging in".to_string());
	- line 1298: *widget.sign_in_state.write().unwrap() =
	- line 1308: &*widget.sign_in_state.read().unwrap(),
	- line 1316: *widget.error.write().unwrap() = Some("still logging in".to_string());
	- line 1317: *widget.sign_in_state.write().unwrap() =
	- line 1329: &*widget.sign_in_state.read().unwrap(),
	- line 1355: let runtime = tokio::runtime::Runtime::new().unwrap();
	- line 1358: *widget.sign_in_state.write().unwrap() =
	- line 1394: let runtime = tokio::runtime::Runtime::new().unwrap();
	- line 1457: let runtime = tokio::runtime::Runtime::new().unwrap();
	- line 1459: *widget.sign_in_state.write().unwrap() =
	- line 1472: let runtime = tokio::runtime::Runtime::new().unwrap();
	- line 1474: *widget.sign_in_state.write().unwrap() = SignInState::ChatGptDeviceCode(
	- line 1484: *widget.sign_in_state.write().unwrap() =
	- line 1500: &*widget.sign_in_state.read().unwrap(),


codex-rs/network-proxy/src/proxy.rs (40 lines):
	- line 1877: let _permit = WINDOWS_INGRESS_TEST_LOCK.acquire().await.unwrap();
	- line 1878: let http_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 1879: let http_addr = http_listener.local_addr().unwrap();
	- line 1880: let socks_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 1881: let socks_addr = socks_listener.local_addr().unwrap();
	- line 1900: panic!("failed to build managed proxy: {err:#}");
	- line 2008: .unwrap();
	- line 2012: "127.0.0.1:43128".parse::<SocketAddr>().unwrap()
	- line 2016: "127.0.0.1:48081".parse::<SocketAddr>().unwrap()
	- line 2023: let _permit = WINDOWS_INGRESS_TEST_LOCK.acquire().await.unwrap();
	- line 2098: let _permit = WINDOWS_INGRESS_TEST_LOCK.acquire().await.unwrap();
	- line 2196: let _permit = WINDOWS_INGRESS_TEST_LOCK.acquire().await.unwrap();
	- line 2197: let http_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2198: let http_addr = http_listener.local_addr().unwrap();
	- line 2200: let occupied_socks = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2201: let socks_addr = occupied_socks.local_addr().unwrap();
	- line 2219: panic!("failed to build managed proxy: {err:#}");
	- line 2267: StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2268: let requested_socks_addr = requested_socks.local_addr().unwrap();
	- line 2368: windows_managed_loopback_addr("0.0.0.0:3128".parse::<SocketAddr>().unwrap()),
	- line 2369: "127.0.0.1:3128".parse::<SocketAddr>().unwrap()
	- line 2372: windows_managed_loopback_addr("[::]:8081".parse::<SocketAddr>().unwrap()),
	- line 2373: "127.0.0.1:8081".parse::<SocketAddr>().unwrap()
	- line 2380: let occupied = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2381: let busy_port = occupied.local_addr().unwrap().port();
	- line 2388: .unwrap();
	- line 2395: .unwrap()
	- line 2399: let fallback_port = reserved.http_listener.local_addr().unwrap().port();
	- line 2407: let http_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2408: let http_addr = http_listener.local_addr().unwrap();
	- line 2410: let occupied_socks = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2414: occupied_socks.local_addr().unwrap(),
	- line 2417: .unwrap();
	- line 2419: assert_eq!(reserved.http_listener.local_addr().unwrap(), http_addr);
	- line 2424: .unwrap()
	- line 2426: .unwrap()
	- line 2435: let occupied = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
	- line 2436: let occupied_addr = occupied.local_addr().unwrap();
	- line 2441: .unwrap();
	- line 2443: let fallback_addr = listener.local_addr().unwrap();


codex-rs/network-proxy/src/certs.rs (40 lines):
	- line 816: let dir = tempdir().unwrap();
	- line 817: let ca = ManagedMitmCa::create(dir.path()).unwrap();
	- line 818: ca.tls_acceptor_data_for_host("example.com").unwrap();
	- line 820: .unwrap()
	- line 821: .map(|entry| entry.unwrap().path())
	- line 826: managed_ca_certificate_lock_path(ca.certificate_path()).unwrap(),
	- line 833: fs::read(managed_ca_certificate_lock_path(ca.certificate_path()).unwrap()).unwrap(),
	- line 840: let dir = tempdir().unwrap();
	- line 846: persist_managed_ca_certificate(dir.path(), &certificate).unwrap();
	- line 847: let lease = lock_managed_ca_certificate(&certificate_path).unwrap();
	- line 857: .unwrap();
	- line 861: fs::write(&unrelated_path, "user managed").unwrap();
	- line 888: let dir = tempdir().unwrap();
	- line 891: fs::write(&managed_ca_cert_path, "managed ca\n").unwrap();
	- line 892: fs::write(&trust_bundle_path, "stale managed bundle\n").unwrap();
	- line 901: let dir = tempdir().unwrap();
	- line 904: persist_managed_ca_trust_bundle(&managed_ca_cert_path, "trusted roots").unwrap();
	- line 910: fs::write(&trust_bundle_path, "tampered roots").unwrap();
	- line 919: let dir = tempdir().unwrap();
	- line 923: let (managed_ca_cert, _) = generate_ca().unwrap();
	- line 924: let (startup_ca_cert, startup_ca_key) = generate_ca().unwrap();
	- line 926: let (directory_ca_cert, _) = generate_ca().unwrap();
	- line 928: .unwrap()
	- line 935: fs::write(&managed_ca_cert_path, &managed_ca_cert).unwrap();
	- line 940: .unwrap();
	- line 941: fs::create_dir(&startup_ca_dir).unwrap();
	- line 942: fs::write(startup_ca_dir.join("directory-ca.pem"), &directory_ca_cert).unwrap();
	- line 950: managed_ca_trust_bundle_for_cert_path(&managed_ca_cert_path, &env).unwrap();
	- line 955: let baseline_bundle = fs::read_to_string(&trust_bundle.path).unwrap();
	- line 958: .unwrap();
	- line 960: .map(|cert| CertificateDer::from_pem_slice(cert.as_bytes()).unwrap());
	- line 973: let dir = tempdir().unwrap();
	- line 976: let (managed_ca_cert, _) = generate_ca().unwrap();
	- line 977: fs::write(&managed_ca_cert_path, &managed_ca_cert).unwrap();
	- line 982: .unwrap();
	- line 989: managed_ca_trust_bundle_for_cert_path(&managed_ca_cert_path, &env).unwrap();
	- line 990: let baseline_bundle = fs::read_to_string(&trust_bundle.path).unwrap();
	- line 1000: let dir = tempdir().unwrap();
	- line 1003: fs::write(&target, "bundle").unwrap();
	- line 1004: symlink(&target, &link).unwrap();


codex-rs/core-plugins/src/marketplace_remove.rs (39 lines):
	- line 151: let codex_home = TempDir::new().unwrap();
	- line 162: .unwrap();
	- line 164: fs::create_dir_all(installed_root.join(".agents/plugins")).unwrap();
	- line 169: .unwrap();
	- line 178: .unwrap();
	- line 183: Some(AbsolutePathBuf::try_from(installed_root.clone()).unwrap())
	- line 186: fs::read_to_string(codex_home.path().join(codex_config::CONFIG_TOML_FILE)).unwrap();
	- line 193: let codex_home = TempDir::new().unwrap();
	- line 212: let codex_home = TempDir::new().unwrap();
	- line 218: fs::write(&user_file, config).unwrap();
	- line 219: fs::write(&system_file, config).unwrap();
	- line 221: fs::create_dir_all(&installed_root).unwrap();
	- line 223: fs::write(&marker, "installed").unwrap();
	- line 230: toml::from_str(config).unwrap(),
	- line 237: toml::from_str(config).unwrap(),
	- line 243: .unwrap();
	- line 261: assert_eq!(fs::read_to_string(user_file).unwrap(), config);
	- line 262: assert_eq!(fs::read_to_string(system_file).unwrap(), config);
	- line 263: assert_eq!(fs::read_to_string(marker).unwrap(), "installed");
	- line 268: let codex_home = TempDir::new().unwrap();
	- line 279: .unwrap();
	- line 281: fs::create_dir_all(&installed_root).unwrap();
	- line 298: fs::read_to_string(codex_home.path().join(codex_config::CONFIG_TOML_FILE)).unwrap();
	- line 304: let codex_home = TempDir::new().unwrap();
	- line 309: .unwrap();
	- line 311: fs::create_dir_all(&installed_root).unwrap();
	- line 331: let codex_home = TempDir::new().unwrap();
	- line 342: .unwrap();
	- line 344: fs::create_dir_all(installed_root.parent().unwrap()).unwrap();
	- line 345: fs::write(&installed_root, "corrupt install root").unwrap();
	- line 354: .unwrap();
	- line 361: AbsolutePathBuf::try_from(installed_root.clone()).unwrap()
	- line 367: fs::read_to_string(codex_home.path().join(codex_config::CONFIG_TOML_FILE)).unwrap();
	- line 373: let codex_home = TempDir::new().unwrap();
	- line 380: .unwrap();
	- line 382: fs::create_dir_all(&installed_root).unwrap();
	- line 391: .unwrap();
	- line 396: Some(AbsolutePathBuf::try_from(installed_root.clone()).unwrap())
	- line 400: fs::read_to_string(codex_home.path().join(codex_config::CONFIG_TOML_FILE)).unwrap();


codex-rs/core-plugins/src/remote/share/tests.rs (37 lines):
	- line 39: fs::create_dir_all(path.parent().expect("file should have a parent")).unwrap();
	- line 40: fs::write(path, contents).unwrap();
	- line 70: .unwrap()
	- line 80: .unwrap()
	- line 82: let mut entry = entry.unwrap();
	- line 86: let path = entry.path().unwrap().to_string_lossy().into_owned();
	- line 88: entry.read_to_end(&mut contents).unwrap();
	- line 122: unreachable!("plugin json should be an object");
	- line 133: unreachable!("plugin json should be an object");
	- line 172: let codex_home = TempDir::new().unwrap();
	- line 173: let temp_dir = TempDir::new().unwrap();
	- line 175: AbsolutePathBuf::try_from(write_test_plugin(temp_dir.path(), "demo-plugin")).unwrap();
	- line 177: .unwrap()
	- line 255: .unwrap();
	- line 266: local_paths::load_plugin_share_local_paths(codex_home.path()).unwrap(),
	- line 285: .unwrap();
	- line 303: let temp_dir = TempDir::new().unwrap();
	- line 321: let temp_dir = TempDir::new().unwrap();
	- line 324: let archive_bytes = archive_plugin_for_upload(&plugin_path).unwrap();
	- line 350: let temp_dir = TempDir::new().unwrap();
	- line 357: let archive_bytes = archive_plugin_for_upload(&plugin_path).unwrap();
	- line 358: let destination = TempDir::new().unwrap();
	- line 367: fs::read_to_string(destination.path().join(".codex-plugin/plugin.json")).unwrap(),
	- line 371: fs::read_to_string(destination.path().join(long_skill_path)).unwrap(),
	- line 378: let codex_home = TempDir::new().unwrap();
	- line 379: let temp_dir = TempDir::new().unwrap();
	- line 381: AbsolutePathBuf::try_from(write_test_plugin(temp_dir.path(), "demo-plugin")).unwrap();
	- line 383: .unwrap()
	- line 433: .unwrap();
	- line 515: .unwrap();
	- line 541: let codex_home = TempDir::new().unwrap();
	- line 543: AbsolutePathBuf::try_from(codex_home.path().join("local-plugin")).unwrap();
	- line 630: .unwrap();
	- line 733: let codex_home = TempDir::new().unwrap();
	- line 735: AbsolutePathBuf::try_from(codex_home.path().join("local-plugin")).unwrap();
	- line 752: .unwrap();
	- line 754: local_paths::load_plugin_share_local_paths(codex_home.path()).unwrap(),


codex-rs/tui/src/app/tests.rs (32 lines):
	- line 257: panic!("expected ThreadSettingsUpdated for thread {thread_id}");
	- line 329: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 376: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 450: unreachable!("expected a command approval request");
	- line 697: panic!("expected thread-routed history response");
	- line 721: panic!("expected thread-routed history batch response");
	- line 916: panic!("expected history batch response");
	- line 1203: other => panic!("expected queued follow-up submission, got {other:?}"),
	- line 1448: other => panic!("expected queued follow-up submission, got {other:?}"),
	- line 1505: other => panic!("expected restored paste submission, got {other:?}"),
	- line 1589: other => panic!("expected restored draft submission, got {other:?}"),
	- line 2635: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 2823: other => panic!("expected CodexOp event, got {other:?}"),
	- line 2844: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 2938: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 3033: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 3498: panic!("expected exec approval request");
	- line 3525: panic!("expected exec approval request");
	- line 3577: panic!("expected exec approval request");
	- line 3587: panic!("expected exec approval request");
	- line 3643: panic!("expected apply-patch approval request");
	- line 3662: other => panic!("expected patch preview history cell, saw {other:?}"),
	- line 3822: panic!("expected permissions approval request");
	- line 3864: panic!("expected app link request");
	- line 6389: other => panic!("expected feedback error history cell, saw {other:?}"),
	- line 6472: panic!("expected UserTurn op, saw: {seen:?}");
	- line 6784: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 6824: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 6867: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 6906: other => panic!("expected InsertHistoryCell event, got {other:?}"),
	- line 7743: other => panic!("expected token activity refresh request, got {other:?}"),
	- line 8616: other => panic!("expected InsertHistoryCell event, got {other:?}"),


codex-rs/network-proxy/src/config.rs (31 lines):
	- line 688: assert_eq!(managed_proxy_ports(&config).unwrap(), vec![3128, 48081]);
	- line 697: assert_eq!(managed_proxy_ports(&config).unwrap(), vec![3128]);
	- line 702: let config: NetworkProxyConfig = serde_json::from_str(r#"{ "enabled": true }"#).unwrap();
	- line 732: let value = serde_json::to_value(&config).unwrap();
	- line 772: parse_host_port("127.0.0.1:8080", /*default_port*/ 3128).unwrap(),
	- line 787: .unwrap(),
	- line 802: .unwrap(),
	- line 813: parse_host_port("http://[::1]:9999", /*default_port*/ 3128).unwrap(),
	- line 824: parse_host_port("2001:db8::1", /*default_port*/ 3128).unwrap(),
	- line 835: parse_host_port("example.com:notaport", /*default_port*/ 3128).unwrap(),
	- line 862: resolve_addr("localhost", /*default_port*/ 3128).unwrap(),
	- line 863: "127.0.0.1:3128".parse::<SocketAddr>().unwrap()
	- line 870: resolve_addr("1.2.3.4", /*default_port*/ 80).unwrap(),
	- line 871: "1.2.3.4:80".parse::<SocketAddr>().unwrap()
	- line 878: resolve_addr("http://[::1]:8080", /*default_port*/ 3128).unwrap(),
	- line 879: "[::1]:8080".parse::<SocketAddr>().unwrap()
	- line 886: resolve_addr("http://example.com:5555", /*default_port*/ 3128).unwrap(),
	- line 887: "127.0.0.1:5555".parse::<SocketAddr>().unwrap()
	- line 897: let http_addr = "0.0.0.0:3128".parse::<SocketAddr>().unwrap();
	- line 898: let socks_addr = "0.0.0.0:8081".parse::<SocketAddr>().unwrap();
	- line 902: assert_eq!(http_addr, "0.0.0.0:3128".parse::<SocketAddr>().unwrap());
	- line 903: assert_eq!(socks_addr, "0.0.0.0:8081".parse::<SocketAddr>().unwrap());
	- line 913: let http_addr = "0.0.0.0:3128".parse::<SocketAddr>().unwrap();
	- line 914: let socks_addr = "0.0.0.0:8081".parse::<SocketAddr>().unwrap();
	- line 918: assert_eq!(http_addr, "127.0.0.1:3128".parse::<SocketAddr>().unwrap());
	- line 919: assert_eq!(socks_addr, "127.0.0.1:8081".parse::<SocketAddr>().unwrap());
	- line 929: let http_addr = "0.0.0.0:3128".parse::<SocketAddr>().unwrap();
	- line 930: let socks_addr = "0.0.0.0:8081".parse::<SocketAddr>().unwrap();
	- line 934: assert_eq!(http_addr, "127.0.0.1:3128".parse::<SocketAddr>().unwrap());
	- line 935: assert_eq!(socks_addr, "127.0.0.1:8081".parse::<SocketAddr>().unwrap());
	- line 943: Ok(runtime) => panic!(


codex-rs/network-proxy/src/policy.rs (31 lines):
	- line 380: let set = compile_denylist_globset(&["Example.COM.".to_string()]).unwrap();
	- line 388: let set = compile_denylist_globset(&["*.Example.COM.".to_string()]).unwrap();
	- line 396: let set = compile_denylist_globset(&["region*.v2.argotunnel.com".to_string()]).unwrap();
	- line 406: let set = compile_denylist_globset(&["**.Example.COM.".to_string()]).unwrap();
	- line 414: let set = compile_denylist_globset(&["[::1]".to_string()]).unwrap();
	- line 421: let set = compile_denylist_globset(&["[fe80::1%25lo0]".to_string()]).unwrap();
	- line 430: assert!(is_loopback_host(&Host::parse("localhost").unwrap()));
	- line 431: assert!(is_loopback_host(&Host::parse("localhost.").unwrap()));
	- line 432: assert!(is_loopback_host(&Host::parse("LOCALHOST").unwrap()));
	- line 433: assert!(!is_loopback_host(&Host::parse("notlocalhost").unwrap()));
	- line 438: assert!(is_loopback_host(&Host::parse("127.0.0.1").unwrap()));
	- line 439: assert!(is_loopback_host(&Host::parse("::1").unwrap()));
	- line 440: assert!(!is_loopback_host(&Host::parse("1.2.3.4").unwrap()));
	- line 445: assert!(is_non_public_ip("127.0.0.1".parse().unwrap()));
	- line 446: assert!(is_non_public_ip("10.0.0.1".parse().unwrap()));
	- line 447: assert!(is_non_public_ip("192.168.0.1".parse().unwrap()));
	- line 448: assert!(is_non_public_ip("100.64.0.1".parse().unwrap()));
	- line 449: assert!(is_non_public_ip("192.0.0.1".parse().unwrap()));
	- line 450: assert!(is_non_public_ip("192.0.2.1".parse().unwrap()));
	- line 451: assert!(is_non_public_ip("198.18.0.1".parse().unwrap()));
	- line 452: assert!(is_non_public_ip("198.51.100.1".parse().unwrap()));
	- line 453: assert!(is_non_public_ip("203.0.113.1".parse().unwrap()));
	- line 454: assert!(is_non_public_ip("240.0.0.1".parse().unwrap()));
	- line 455: assert!(is_non_public_ip("0.1.2.3".parse().unwrap()));
	- line 456: assert!(!is_non_public_ip("8.8.8.8".parse().unwrap()));
	- line 458: assert!(is_non_public_ip("::ffff:127.0.0.1".parse().unwrap()));
	- line 459: assert!(is_non_public_ip("::ffff:10.0.0.1".parse().unwrap()));
	- line 460: assert!(!is_non_public_ip("::ffff:8.8.8.8".parse().unwrap()));
	- line 462: assert!(is_non_public_ip("::1".parse().unwrap()));
	- line 463: assert!(is_non_public_ip("fe80::1".parse().unwrap()));
	- line 464: assert!(is_non_public_ip("fc00::1".parse().unwrap()));


codex-rs/network-proxy/src/mitm_hook.rs (30 lines):
	- line 750: .unwrap();
	- line 752: let compiled = hooks.get("api.github.com").unwrap();
	- line 766: let secret_file = NamedTempFile::new().unwrap();
	- line 767: std::fs::write(secret_file.path(), "ghp-file-secret\n").unwrap();
	- line 776: let hooks = compile_mitm_hooks(&config).unwrap();
	- line 777: let compiled = hooks.get("api.github.com").unwrap();
	- line 798: .unwrap();
	- line 804: .unwrap();
	- line 808: panic!("expected a matching hook");
	- line 836: .unwrap();
	- line 842: .unwrap();
	- line 847: actions: hooks.get("api.github.com").unwrap()[0].actions.clone(),
	- line 870: .unwrap();
	- line 876: .unwrap();
	- line 881: actions: hooks.get("api.github.com").unwrap()[0].actions.clone(),
	- line 909: .unwrap();
	- line 914: .unwrap();
	- line 935: .unwrap();
	- line 954: .unwrap();
	- line 979: .unwrap();
	- line 985: .unwrap();
	- line 991: .unwrap();
	- line 996: actions: hooks.get("api.github.com").unwrap()[0].actions.clone(),
	- line 1022: .unwrap();
	- line 1028: .unwrap();
	- line 1034: .unwrap();
	- line 1039: actions: hooks.get("api.github.com").unwrap()[0].actions.clone(),
	- line 1060: .unwrap();
	- line 1065: .unwrap();
	- line 1079: .unwrap();


codex-rs/apply-patch/src/invocation.rs (30 lines):
	- line 530: result => panic!("expected MaybeApplyPatch::Body got {result:?}"),
	- line 555: let dir = tempdir().unwrap();
	- line 572: let dir = tempdir().unwrap();
	- line 609: result => panic!("expected MaybeApplyPatch::Body got {result:?}"),
	- line 637: result => panic!("expected MaybeApplyPatch::Body got {result:?}"),
	- line 680: result => panic!("expected MaybeApplyPatch::Body got {result:?}"),
	- line 790: let dir = tempdir().unwrap();
	- line 792: fs::write(&path, "foo\nbar\nbaz\n").unwrap();
	- line 805: let patch = parse_patch(&patch).unwrap();
	- line 808: _ => panic!("Expected a single UpdateFile hunk"),
	- line 815: .unwrap();
	- line 832: let dir = tempdir().unwrap();
	- line 834: fs::write(&path, "foo\nbar\nbaz\n").unwrap();
	- line 845: let patch = parse_patch(&patch).unwrap();
	- line 848: _ => panic!("Expected a single UpdateFile hunk"),
	- line 855: .unwrap();
	- line 870: let session_dir = tempdir().unwrap();
	- line 876: fs::write(&session_file_path, "session directory content\n").unwrap();
	- line 925: let session_dir = tempdir().unwrap();
	- line 928: fs::create_dir_all(&worktree_dir).unwrap();
	- line 933: fs::write(&source_path, "before\n").unwrap();
	- line 955: other => panic!("expected verified body, got {other:?}"),
	- line 959: action.cwd.to_abs_path().unwrap().as_path(),
	- line 977: other => panic!("expected update change, got {other:?}"),
	- line 983: let session_dir = tempdir().unwrap();
	- line 984: fs::write(session_dir.path().join("binary.dat"), [0xff, 0xfe, 0xfd]).unwrap();
	- line 990: fs::write(session_dir.path().join("source.txt"), "before\n").unwrap();
	- line 1014: let session_dir = tempdir().unwrap();
	- line 1015: fs::write(session_dir.path().join("target.txt"), "target\n").unwrap();
	- line 1020: .unwrap();


codex-rs/network-proxy/src/http_proxy.rs (28 lines):
	- line 1187: state.set_network_mode(NetworkMode::Limited).await.unwrap();
	- line 1194: .unwrap();
	- line 1204: response.headers().get("x-proxy-error").unwrap(),
	- line 1226: .unwrap();
	- line 1233: .unwrap();
	- line 1256: .unwrap();
	- line 1262: .unwrap();
	- line 1291: .unwrap();
	- line 1334: Some(&HeaderValue::from_str(&format!("Bearer {dummy_token}")).unwrap())
	- line 1363: Some(&HeaderValue::from_str(&format!("Bearer {real_token}")).unwrap())
	- line 1390: .unwrap();
	- line 1400: response.headers().get("x-proxy-error").unwrap(),
	- line 1560: let blocked = state.drain_blocked().await.unwrap();
	- line 1589: .unwrap();
	- line 1593: response.headers().get("x-proxy-error").unwrap(),
	- line 1614: .unwrap();
	- line 1619: response.headers().get("x-proxy-error").unwrap(),
	- line 1648: .unwrap();
	- line 1667: .unwrap();
	- line 1677: response.headers().get("x-proxy-error").unwrap(),
	- line 1690: .unwrap();
	- line 1697: assert_eq!(response.unwrap().status(), StatusCode::BAD_REQUEST);
	- line 1707: .unwrap();
	- line 1710: validate_absolute_form_host_header(&req, &RequestContext::try_from(&req).unwrap(),),
	- line 1722: .unwrap();
	- line 1725: validate_absolute_form_host_header(&req, &RequestContext::try_from(&req).unwrap(),),
	- line 1737: .unwrap();
	- line 1740: validate_absolute_form_host_header(&req, &RequestContext::try_from(&req).unwrap(),),


codex-rs/tui/src/pets/model.rs (28 lines):
	- line 645: let dir = tempfile::tempdir().unwrap();
	- line 646: fs::write(dir.path().join("pet.json"), manifest).unwrap();
	- line 652: Pet::load_with_codex_home(dir.path().to_str().unwrap(), /*codex_home*/ None).unwrap()
	- line 656: Pet::load_with_codex_home(dir.path().to_str().unwrap(), /*codex_home*/ None).unwrap_err()
	- line 661: let codex_home = tempfile::tempdir().unwrap();
	- line 665: Pet::load_with_codex_home("dewey", /*codex_home*/ Some(codex_home.path())).unwrap();
	- line 742: .unwrap();
	- line 772: let first_key = pet.frame_cache_key().unwrap();
	- line 779: image.save(&spritesheet_path).unwrap();
	- line 782: assert_ne!(pet.frame_cache_key().unwrap(), first_key);
	- line 799: custom_pet.frame_cache_key().unwrap(),
	- line 800: default_pet.frame_cache_key().unwrap()
	- line 809: dir.path().join("pet.json").to_str().unwrap(),
	- line 812: .unwrap();
	- line 813: let expected = dir.path().join("spritesheet.webp").canonicalize().unwrap();
	- line 821: let codex_home = tempfile::tempdir().unwrap();
	- line 823: fs::create_dir_all(&pet_dir).unwrap();
	- line 824: fs::copy(dir.path().join("pet.json"), pet_dir.join("pet.json")).unwrap();
	- line 829: .unwrap();
	- line 835: .unwrap();
	- line 844: let codex_home = tempfile::tempdir().unwrap();
	- line 846: fs::create_dir_all(&avatar_dir).unwrap();
	- line 847: fs::copy(dir.path().join("pet.json"), avatar_dir.join("avatar.json")).unwrap();
	- line 852: .unwrap();
	- line 858: .unwrap();
	- line 866: let codex_home = tempfile::tempdir().unwrap();
	- line 868: fs::create_dir_all(&pet_dir).unwrap();
	- line 876: .unwrap();


codex-rs/feedback/src/lib.rs (28 lines):
	- line 876: w.write_all(b"abcdefgh").unwrap();
	- line 877: w.write_all(b"ij").unwrap();
	- line 881: pretty_assertions::assert_eq!(std::str::from_utf8(&snap.bytes).unwrap(), "cdefghij");
	- line 909: let logs = String::from_utf8(fb.snapshot(/*session_id*/ None).bytes).unwrap();
	- line 1011: let requests = server.received_requests().await.unwrap();
	- line 1022: .unwrap();
	- line 1037: let mut file = fs::File::create(path).unwrap();
	- line 1039: file.write_all(block.as_bytes()).unwrap();
	- line 1050: let mut file = fs::File::create(&binary_path).unwrap();
	- line 1054: file.write_all(b"{\"message\":\"").unwrap();
	- line 1056: file.write_all(&record_block).unwrap();
	- line 1058: file.write_all(b"\"}\n").unwrap();
	- line 1071: fs::rename(&pending_path, &ready_path).unwrap();
	- line 1115: .unwrap();
	- line 1116: let requests = server.received_requests().await.unwrap();
	- line 1121: .unwrap();
	- line 1141: .unwrap();
	- line 1145: parts.next().unwrap(),
	- line 1146: event.lines().next().unwrap().as_bytes()
	- line 1148: let header = std::str::from_utf8(parts.next().unwrap()).unwrap();
	- line 1150: let payload = parts.next().unwrap().strip_suffix(b"\n").unwrap();
	- line 1151: let mut source = fs::File::open(source_path).unwrap();
	- line 1152: let original_bytes = source.metadata().unwrap().len() as usize;
	- line 1159: let text = std::str::from_utf8(payload).unwrap();
	- line 1164: source.read_exact(&mut expected[..chunk.len()]).unwrap();
	- line 1168: fs::remove_file(first_path).unwrap();
	- line 1169: fs::remove_file(second_path).unwrap();
	- line 1170: fs::remove_file(binary_path).unwrap();


codex-rs/cli/src/main.rs (27 lines):
	- line 3036: unreachable!()
	- line 3072: unreachable!()
	- line 3085: panic!("expected exec subcommand");
	- line 3111: unreachable!()
	- line 3204: panic!("expected exec subcommand");
	- line 3207: panic!("expected exec resume");
	- line 3231: panic!("expected exec subcommand");
	- line 3234: panic!("expected exec resume");
	- line 3416: unreachable!()
	- line 3443: panic!("expected debug prompt-input subcommand");
	- line 3462: panic!("expected debug models subcommand");
	- line 3627: panic!("expected sandbox command");
	- line 3648: panic!("expected sandbox command");
	- line 3671: panic!("expected sandbox command");
	- line 3686: panic!("expected sandbox command");
	- line 3780: .unwrap();
	- line 3810: exit_info.exit_reason = ExitReason::Archived(exit_info.thread_id.unwrap());
	- line 3822: thread_id: Some(ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap()),
	- line 4327: panic!("expected remote-control subcommand");
	- line 4345: panic!("expected remote-control subcommand");
	- line 4381: panic!("expected resume subcommand");
	- line 4401: panic!("expected agents subcommand");
	- line 4699: panic!("expected proxy subcommand");
	- line 4806: panic!("expected features subcommand");
	- line 4809: panic!("expected features enable");
	- line 4819: panic!("expected features subcommand");
	- line 4822: panic!("expected features disable");


codex-rs/tui/src/pets/mod.rs (27 lines):
	- line 288: let dir = tempfile::tempdir().unwrap();
	- line 290: std::fs::write(&frame, b"png").unwrap();
	- line 305: render_ambient_pet_image(&mut output, &mut state, Some(request)).unwrap();
	- line 307: let output = String::from_utf8(output).unwrap();
	- line 319: let dir = tempfile::tempdir().unwrap();
	- line 321: std::fs::write(&frame, b"png").unwrap();
	- line 336: render_ambient_pet_image(&mut output, &mut state, Some(request)).unwrap();
	- line 338: render_ambient_pet_image(&mut output, &mut state, /*request*/ None).unwrap();
	- line 340: let output = String::from_utf8(output).unwrap();
	- line 349: let dir = tempfile::tempdir().unwrap();
	- line 351: std::fs::write(&frame, b"png").unwrap();
	- line 366: render_ambient_pet_image(&mut output, &mut state, Some(request)).unwrap();
	- line 368: let output = String::from_utf8(output).unwrap();
	- line 378: let dir = tempfile::tempdir().unwrap();
	- line 380: std::fs::write(&frame, b"png").unwrap();
	- line 382: std::fs::create_dir(&sixel_dir).unwrap();
	- line 384: std::fs::write(&sixel_frame, b"fake-sixel").unwrap();
	- line 399: render_ambient_pet_image(&mut output, &mut state, Some(request)).unwrap();
	- line 401: let output = String::from_utf8(output).unwrap();
	- line 409: let dir = tempfile::tempdir().unwrap();
	- line 411: std::fs::write(&frame, b"png").unwrap();
	- line 413: std::fs::create_dir(&sixel_dir).unwrap();
	- line 415: std::fs::write(&sixel_frame, b"fake-sixel").unwrap();
	- line 430: render_ambient_pet_image(&mut output, &mut state, Some(request)).unwrap();
	- line 432: render_ambient_pet_image(&mut output, &mut state, /*request*/ None).unwrap();
	- line 434: let output = String::from_utf8(output).unwrap();
	- line 444: let dir = tempfile::tempdir().unwrap();


codex-rs/exec-server/src/client.rs (26 lines):
	- line 1802: other => panic!("expected initialize request, got {other:?}"),
	- line 1820: other => panic!("expected initialized notification, got {other:?}"),
	- line 1825: other => panic!("expected process start request, got {other:?}"),
	- line 1937: other => panic!("expected json-rpc websocket frame, got {other:?}"),
	- line 1976: other => panic!("expected initialize request, got {other:?}"),
	- line 2002: other => panic!("expected initialized notification, got {other:?}"),
	- line 2168: panic!("pid file {} should be written", path.display());
	- line 2179: panic!("process {pid} should exit");
	- line 2207: other => panic!("expected initialize request, got {other:?}"),
	- line 2226: other => panic!("expected initialized notification, got {other:?}"),
	- line 2353: other => panic!("expected initialize request, got {other:?}"),
	- line 2372: other => panic!("expected initialized notification, got {other:?}"),
	- line 2404: panic!("expected session failure after disconnect, got {event:?}");
	- line 2454: panic!("expected environment info request");
	- line 2559: other => panic!("expected first process/write request, got {other:?}"),
	- line 2581: other => panic!("expected recovery process/read request, got {other:?}"),
	- line 2604: other => panic!("expected retried process/write request, got {other:?}"),
	- line 2672: other => panic!("expected initialize request, got {other:?}"),
	- line 2714: other => panic!("expected initialized notification, got {other:?}"),
	- line 2814: Ok(_) => panic!("missing executable should fail"),
	- line 2819: Ok(_) => panic!("burned environment should stay failed"),
	- line 2832: panic!("expected saved connection failures");
	- line 2878: Ok(_) => panic!("initial connection should fail"),
	- line 2977: Ok(_) => panic!("first lazy reconnect should fail"),
	- line 3013: other => panic!("expected initialize request, got {other:?}"),
	- line 3032: other => panic!("expected initialized notification, got {other:?}"),


codex-rs/code-mode-runtime/src/cell_actor/tests.rs (26 lines):
	- line 135: .unwrap();
	- line 227: harness.event_tx.send(RuntimeEvent::Started).unwrap();
	- line 235: .unwrap();
	- line 238: harness.initial_event_rx.await.unwrap(),
	- line 254: harness.task.await.unwrap();
	- line 266: .unwrap();
	- line 273: assert_eq!(harness.initial_event_rx.await.unwrap(), terminated);
	- line 274: harness.task.await.unwrap();
	- line 284: harness.event_tx.send(RuntimeEvent::YieldRequested).unwrap();
	- line 285: assert!(harness.initial_event_rx.await.unwrap().is_ok());
	- line 299: .unwrap();
	- line 300: harness.event_tx.send(RuntimeEvent::YieldRequested).unwrap();
	- line 307: .unwrap();
	- line 330: harness.task.await.unwrap();
	- line 340: harness.event_tx.send(RuntimeEvent::YieldRequested).unwrap();
	- line 341: assert!(harness.initial_event_rx.await.unwrap().is_ok());
	- line 361: .unwrap();
	- line 362: harness.event_tx.send(RuntimeEvent::YieldRequested).unwrap();
	- line 369: .unwrap();
	- line 392: harness.task.await.unwrap();
	- line 402: harness.event_tx.send(RuntimeEvent::YieldRequested).unwrap();
	- line 403: assert!(harness.initial_event_rx.await.unwrap().is_ok());
	- line 422: .unwrap();
	- line 423: harness.event_tx.send(RuntimeEvent::Pending).unwrap();
	- line 430: .unwrap();
	- line 453: harness.task.await.unwrap();


codex-rs/tui/src/render/highlight.rs (24 lines):
	- line 747: .unwrap();
	- line 784: std::fs::write(path, contents).unwrap();
	- line 803: .unwrap_or_else(|| panic!("expected built-in theme {theme_name} to resolve"));
	- line 847: panic!("expected RGB color {expected:?}, got {color:?}");
	- line 1081: .unwrap_or_else(|| panic!("expected built-in theme {theme_name} to resolve"));
	- line 1093: panic!("theme {theme_name} produced RGB foreground: {span:?}")
	- line 1340: let dir = tempfile::tempdir().unwrap();
	- line 1342: std::fs::create_dir(&themes_dir).unwrap();
	- line 1431: let dir = tempfile::tempdir().unwrap();
	- line 1433: std::fs::create_dir(&themes_dir).unwrap();
	- line 1441: let dir = tempfile::tempdir().unwrap();
	- line 1459: let dir = tempfile::tempdir().unwrap();
	- line 1462: let msg = warning.unwrap();
	- line 1471: let dir = tempfile::tempdir().unwrap();
	- line 1473: std::fs::create_dir(&themes_dir).unwrap();
	- line 1483: let dir = tempfile::tempdir().unwrap();
	- line 1485: std::fs::create_dir(&themes_dir).unwrap();
	- line 1486: std::fs::write(themes_dir.join("my-fancy.tmTheme"), "placeholder").unwrap();
	- line 1502: let dir = tempfile::tempdir().unwrap();
	- line 1504: std::fs::create_dir(&themes_dir).unwrap();
	- line 1506: std::fs::write(themes_dir.join("broken-custom.tmTheme"), "not a plist").unwrap();
	- line 1526: let dir = tempfile::tempdir().unwrap();
	- line 1528: std::fs::create_dir(&themes_dir).unwrap();
	- line 1599: .map(|k| parse_theme_name(k).unwrap_or_else(|| panic!("unmapped kebab name: {k}")))


codex-rs/code-mode-runtime/src/runtime/mod.rs (22 lines):
	- line 380: || panic!("runtime thread panic probe"),
	- line 398: || panic!("runtime thread panic probe"),
	- line 419: .unwrap();
	- line 423: .unwrap()
	- line 424: .unwrap();
	- line 431: .unwrap()
	- line 432: .unwrap();
	- line 434: panic!("expected runtime result after termination");
	- line 441: .unwrap()
	- line 462: .unwrap();
	- line 467: .unwrap()
	- line 468: .unwrap(),
	- line 474: .unwrap()
	- line 475: .unwrap(),
	- line 481: .unwrap();
	- line 490: .unwrap();
	- line 494: .unwrap()
	- line 495: .unwrap();
	- line 499: panic!("expected resumed runtime output");
	- line 505: .unwrap()
	- line 506: .unwrap(),
	- line 512: .unwrap();


codex-rs/config/src/marketplace_edit.rs (22 lines):
	- line 185: let codex_home = TempDir::new().unwrap();
	- line 193: record_user_marketplace(codex_home.path(), "debug", &update).unwrap();
	- line 196: toml::from_str(&fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap())
	- line 197: .unwrap();
	- line 220: let codex_home = TempDir::new().unwrap();
	- line 227: record_user_marketplace(codex_home.path(), "debug", &update).unwrap();
	- line 228: record_user_marketplace(codex_home.path(), "other", &update).unwrap();
	- line 230: let removed = remove_user_marketplace(codex_home.path(), "debug").unwrap();
	- line 234: toml::from_str(&fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap())
	- line 235: .unwrap();
	- line 239: .unwrap();
	- line 246: let codex_home = TempDir::new().unwrap();
	- line 248: let removed = remove_user_marketplace(codex_home.path(), "debug").unwrap();
	- line 255: let codex_home = TempDir::new().unwrap();
	- line 262: record_user_marketplace(codex_home.path(), "debug", &update).unwrap();
	- line 264: let outcome = remove_user_marketplace_config(codex_home.path(), "Debug").unwrap();
	- line 276: let codex_home = TempDir::new().unwrap();
	- line 286: .unwrap();
	- line 288: let outcome = remove_user_marketplace_config(codex_home.path(), "debug").unwrap();
	- line 292: toml::from_str(&fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap())
	- line 293: .unwrap();
	- line 297: .unwrap();


codex-rs/protocol/src/protocol.rs (21 lines):
	- line 4506: SessionSource::from_startup_arg("vscode").unwrap(),
	- line 4510: SessionSource::from_startup_arg("app-server").unwrap(),
	- line 4578: SessionSource::from_startup_arg("atlas").unwrap(),
	- line 4582: SessionSource::from_startup_arg(" Atlas ").unwrap(),
	- line 5128: _ => panic!("expected WebSearchBegin event"),
	- line 5167: _ => panic!("expected ImageGenerationBegin event"),
	- line 5203: _ => panic!("expected PatchApplyBegin event"),
	- line 5250: _ => panic!("expected McpToolCallBegin event"),
	- line 5283: _ => panic!("expected ImageGenerationEnd event"),
	- line 5322: _ => panic!("expected PatchApplyEnd event"),
	- line 5376: _ => panic!("expected McpToolCallEnd event"),
	- line 5597: .unwrap();
	- line 5598: value.as_object_mut().unwrap().remove("started_at_ms");
	- line 5612: .unwrap();
	- line 5613: value.as_object_mut().unwrap().remove("completed_at_ms");
	- line 5615: let event = serde_json::from_value::<ItemCompletedEvent>(value).unwrap();
	- line 5629: .unwrap();
	- line 5636: .unwrap();
	- line 5712: serde_json::to_value(&event).unwrap(),
	- line 5850: panic!("expected user message event");
	- line 5895: _ => panic!("expected turn_aborted event"),


codex-rs/tui/src/insert_history.rs (20 lines):
	- line 352: panic!("tried to execute SetScrollRegion command using WinAPI, use ANSI instead");
	- line 372: panic!("tried to execute ResetScrollRegion command using WinAPI, use ANSI instead");
	- line 508: write_spans(&mut actual, spans.iter()).unwrap();
	- line 521: .unwrap();
	- line 524: String::from_utf8(actual).unwrap(),
	- line 525: String::from_utf8(expected).unwrap()
	- line 579: .map(|part| part.split("\x1b]8;;\x07").next().unwrap())
	- line 730: let cell = screen.cell(row, col).unwrap();
	- line 738: let cell = screen.cell(row, col).unwrap();
	- line 776: panic!("expected to find row containing {needle:?}, have rows: {rows:?}")
	- line 778: let col_start = rows[row_idx].find(needle).unwrap() as u16; // column where '1' starts
	- line 783: let cell = screen.cell(row_idx as u16, c).unwrap();
	- line 920: row.strip_prefix("› ").unwrap().trim()
	- line 930: screen.cell(row as u16, /*col*/ 0).unwrap().bgcolor(),
	- line 937: .unwrap()
	- line 1000: .unwrap_or_else(|| panic!("expected continuation row in screen rows: {rows:?}"));
	- line 1032: .unwrap_or_else(|| panic!("expected continuation row in screen rows: {rows:?}"));
	- line 1168: .unwrap_or_else(|| panic!("expected url-like first row in screen rows: {rows:?}"));
	- line 1208: .unwrap_or_else(|| panic!("expected prompt row in screen rows: {rows:?}"));
	- line 1212: .unwrap_or_else(|| panic!("expected URL first row in screen rows: {rows:?}"));


codex-rs/shell-command/src/command_safety/powershell_parser.rs (19 lines):
	- line 280: let powershell = powershell.as_path().to_str().unwrap();
	- line 281: let mut parser = PowershellParserProcess::spawn(powershell).unwrap();
	- line 283: let first = parser.parse("Get-Content 'foo bar'").unwrap();
	- line 292: let second = parser.parse("Write-Output foo | Measure-Object").unwrap();
	- line 307: let powershell = powershell.as_path().to_str().unwrap();
	- line 308: let mut parser = PowershellParserProcess::spawn(powershell).unwrap();
	- line 312: .unwrap();
	- line 321: let powershell = powershell.as_path().to_str().unwrap();
	- line 322: let mut parser = PowershellParserProcess::spawn(powershell).unwrap();
	- line 326: .unwrap();
	- line 335: let powershell = powershell.as_path().to_str().unwrap();
	- line 336: let mut parser = PowershellParserProcess::spawn(powershell).unwrap();
	- line 340: .unwrap();
	- line 349: let powershell = powershell.as_path().to_str().unwrap();
	- line 350: let mut parser = PowershellParserProcess::spawn(powershell).unwrap();
	- line 354: .unwrap();
	- line 363: let powershell = powershell.as_path().to_str().unwrap();
	- line 364: let mut parser = PowershellParserProcess::spawn(powershell).unwrap();
	- line 370: .unwrap();


codex-rs/config/src/plugin_edit.rs (19 lines):
	- line 188: let codex_home = TempDir::new().unwrap();
	- line 196: .unwrap();
	- line 205: .unwrap();
	- line 211: let codex_home = TempDir::new().unwrap();
	- line 220: .unwrap();
	- line 228: .unwrap();
	- line 238: .unwrap();
	- line 244: let codex_home = TempDir::new().unwrap();
	- line 252: .unwrap();
	- line 256: .unwrap();
	- line 259: fs::read_to_string(codex_home.path().join(CONFIG_TOML_FILE)).unwrap(),
	- line 266: let codex_home = TempDir::new().unwrap();
	- line 270: .unwrap();
	- line 280: let codex_home = TempDir::new().unwrap();
	- line 282: symlink(&target_path, codex_home.path().join(CONFIG_TOML_FILE)).unwrap();
	- line 290: .unwrap();
	- line 293: toml::from_str::<toml::Value>(&fs::read_to_string(target_path).unwrap()).unwrap();
	- line 300: .unwrap();
	- line 305: toml::from_str(&fs::read_to_string(codex_home.join(CONFIG_TOML_FILE)).unwrap()).unwrap()


codex-rs/state/src/runtime/threads.rs (19 lines):
	- line 1656: let oldest_pinned = ThreadId::from_string("00000000-0000-0000-0000-000000000041").unwrap();
	- line 1658: ThreadId::from_string("00000000-0000-0000-0000-000000000042").unwrap();
	- line 1659: let newest_pinned = ThreadId::from_string("00000000-0000-0000-0000-000000000043").unwrap();
	- line 1661: ThreadId::from_string("00000000-0000-0000-0000-000000000044").unwrap();
	- line 1678: metadata.recency_at = DateTime::<Utc>::from_timestamp(recency_at, 0).unwrap();
	- line 1688: runtime.upsert_thread(&metadata).await.unwrap();
	- line 1709: .unwrap();
	- line 1729: .unwrap();
	- line 1737: .unwrap();
	- line 1750: .unwrap();
	- line 1771: .unwrap()
	- line 1804: let first = ThreadId::from_string("00000000-0000-0000-0000-000000000061").unwrap();
	- line 1805: let tied = ThreadId::from_string("00000000-0000-0000-0000-000000000062").unwrap();
	- line 1806: let last = ThreadId::from_string("00000000-0000-0000-0000-000000000063").unwrap();
	- line 1821: runtime.upsert_thread(&metadata).await.unwrap();
	- line 1839: .unwrap();
	- line 1846: .unwrap();
	- line 1853: .unwrap();
	- line 1875: .unwrap()


codex-rs/protocol/src/models.rs (19 lines):
	- line 380: FileSystemSandboxKind::ExternalSandbox => unreachable!(
	- line 3281: assert_eq!(v.get("output").unwrap().as_str().unwrap(), "ok");
	- line 3298: assert_eq!(v.get("output").unwrap().as_str().unwrap(), "bad");
	- line 3380: panic!("expected content items");
	- line 3524: panic!("expected content items");
	- line 3556: panic!("expected content items");
	- line 3588: panic!("expected content items");
	- line 3831: other => panic!("expected message response but got {other:?}"),
	- line 3947: panic!("expected message response");
	- line 3950: panic!("expected local audio error placeholder");
	- line 3977: other => panic!("expected message response but got {other:?}"),
	- line 4199: other => panic!("expected message response but got {other:?}"),
	- line 4279: other => panic!("expected message response but got {other:?}"),
	- line 4310: other => panic!("expected placeholder text but found {other:?}"),
	- line 4313: other => panic!("expected message response but got {other:?}"),
	- line 4344: other => panic!("expected placeholder text but found {other:?}"),
	- line 4347: other => panic!("expected message response but got {other:?}"),
	- line 4377: other => panic!("expected placeholder text but found {other:?}"),
	- line 4380: other => panic!("expected message response but got {other:?}"),


codex-rs/tui/src/bottom_pane/app_link_view.rs (18 lines):
	- line 1214: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1215: Err(err) => panic!("missing app event: {err}"),
	- line 1249: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1250: Err(err) => panic!("missing app event: {err}"),
	- line 1269: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1270: Err(err) => panic!("missing app event: {err}"),
	- line 1398: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1399: Err(err) => panic!("missing app event: {err}"),
	- line 1408: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1409: Err(err) => panic!("missing app event: {err}"),
	- line 1425: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1426: Err(err) => panic!("missing app event: {err}"),
	- line 1467: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1468: Err(err) => panic!("missing app event: {err}"),
	- line 1500: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1501: Err(err) => panic!("missing app event: {err}"),
	- line 1517: Ok(other) => panic!("unexpected app event: {other:?}"),
	- line 1518: Err(err) => panic!("missing app event: {err}"),


codex-rs/app-server-client/src/lib.rs (18 lines):
	- line 935: panic!("expected initialize request");
	- line 952: panic!("expected initialized notification");
	- line 977: Message::Close(_) => panic!("unexpected close frame"),
	- line 1263: panic!("expected account/read request");
	- line 1317: panic!("expected account/read request");
	- line 1367: panic!("expected account/read request");
	- line 1454: Ok(_) => panic!("non-loopback ws should be rejected before connect"),
	- line 1484: panic!("expected account/read request");
	- line 1686: _ => panic!("unexpected remaining event: {event:?}"),
	- line 1688: _ => panic!("unexpected remaining event: {event:?}"),
	- line 1734: panic!("expected server request response");
	- line 1748: panic!("expected server request event");
	- line 1763: panic!("expected initialize request");
	- line 1807: panic!("expected initialized notification");
	- line 1813: panic!("expected server request response");
	- line 1827: panic!("expected server request event");
	- line 1855: panic!("expected JSON-RPC error response");
	- line 2030: _ => panic!("expected shutdown command"),


codex-rs/app-server-transport/src/transport/remote_control/client_tracker.rs (17 lines):
	- line 515: other => panic!("expected connection opened, got {other:?}"),
	- line 526: other => panic!("expected incoming initialize, got {other:?}"),
	- line 548: other => panic!("expected connection closed, got {other:?}"),
	- line 583: other => panic!("expected connection opened, got {other:?}"),
	- line 652: other => panic!("expected connection opened, got {other:?}"),
	- line 693: other => panic!("expected incoming message, got {other:?}"),
	- line 723: other => panic!("expected connection opened, got {other:?}"),
	- line 730: other => panic!("expected connection closed, got {other:?}"),
	- line 751: other => panic!("expected connection opened, got {other:?}"),
	- line 784: other => panic!("expected incoming message, got {other:?}"),
	- line 795: other => panic!("expected connection closed, got {other:?}"),
	- line 816: other => panic!("expected connection opened, got {other:?}"),
	- line 856: other => panic!("expected connection closed, got {other:?}"),
	- line 877: other => panic!("expected connection opened, got {other:?}"),
	- line 890: other => panic!("expected connection opened, got {other:?}"),
	- line 910: other => panic!("expected connection opened, got {other:?}"),
	- line 937: other => panic!("expected incoming message, got {other:?}"),


codex-rs/state/src/runtime/goals.rs (17 lines):
	- line 684: .unwrap()
	- line 737: .unwrap()
	- line 745: .unwrap()
	- line 753: .unwrap()
	- line 816: .unwrap()
	- line 952: panic!("stale goal version should not be updated");
	- line 989: panic!("active goal should account usage");
	- line 1211: panic!("active goal should be updated");
	- line 1229: panic!("budget crossing should update the goal");
	- line 1247: panic!("budget-limited goal should still account in-flight active usage");
	- line 1282: panic!("budget-limited goal should not be updated");
	- line 1330: panic!("stopped goal should account final usage");
	- line 1509: panic!("budget crossing should update the goal");
	- line 1562: panic!("completed goal should not be updated by active-only accounting");
	- line 1580: panic!("completed goal should be updated for final accounting");
	- line 1629: panic!("paused goal should not be updated by active-only accounting");
	- line 1647: panic!("stopped goal should be updated for in-flight accounting");


codex-rs/windows-sandbox-rs/src/allow.rs (17 lines):
	- line 93: let writable_roots = vec![AbsolutePathBuf::try_from(extra_root.as_path()).unwrap()];
	- line 111: .contains(&dunce::canonicalize(&command_cwd).unwrap())
	- line 116: .contains(&dunce::canonicalize(&extra_root).unwrap())
	- line 145: .contains(&dunce::canonicalize(&workspace_root).unwrap())
	- line 150: .contains(&dunce::canonicalize(&command_cwd).unwrap())
	- line 183: .contains(&dunce::canonicalize(&command_cwd).unwrap())
	- line 188: .contains(&dunce::canonicalize(&temp_dir).unwrap())
	- line 219: dunce::canonicalize(&command_cwd).unwrap(),
	- line 220: dunce::canonicalize(&temp_dir).unwrap(),
	- line 248: let expected_allow: HashSet<PathBuf> = [dunce::canonicalize(&command_cwd).unwrap()]
	- line 276: let expected_allow: HashSet<PathBuf> = [dunce::canonicalize(&command_cwd).unwrap()]
	- line 279: let expected_deny: HashSet<PathBuf> = [dunce::canonicalize(&git_dir).unwrap()]
	- line 308: let expected_allow: HashSet<PathBuf> = [dunce::canonicalize(&command_cwd).unwrap()]
	- line 311: let expected_deny: HashSet<PathBuf> = [dunce::canonicalize(&git_file).unwrap()]
	- line 341: let expected_allow: HashSet<PathBuf> = [dunce::canonicalize(&command_cwd).unwrap()]
	- line 345: dunce::canonicalize(&codex_dir).unwrap(),
	- line 346: dunce::canonicalize(&agents_dir).unwrap(),


codex-rs/tui/src/keymap_setup.rs (15 lines):
	- line 1430: keymap_with_replacement(&TuiKeymap::default(), "global", "copy", "ctrl-x").unwrap();
	- line 1431: let runtime = RuntimeKeymap::from_config(&keymap).unwrap();
	- line 1445: let runtime = RuntimeKeymap::from_config(&keymap).unwrap();
	- line 1476: panic!("expected OpenKeymapCapture event");
	- line 1499: panic!("expected KeymapCaptured event");
	- line 1508: keymap_with_replacement(&TuiKeymap::default(), &context, &action, &key).unwrap();
	- line 1509: let runtime = RuntimeKeymap::from_config(&keymap).unwrap();
	- line 1542: .unwrap();
	- line 1543: let runtime = RuntimeKeymap::from_config(&keymap).unwrap();
	- line 1566: panic!("expected KeymapCleared event");
	- line 1772: panic!("expected updated keymap");
	- line 1802: panic!("expected updated keymap");
	- line 1833: panic!("expected updated keymap");
	- line 1895: panic!("expected updated keymap");
	- line 1935: panic!("expected updated keymap");


codex-rs/core-plugins/src/marketplace_add/source.rs (15 lines):
	- line 86: MarketplaceSource::Local { .. } => unreachable!(
	- line 226: parse_marketplace_source("owner/repo@main", /*explicit_ref*/ None).unwrap(),
	- line 241: .unwrap(),
	- line 252: parse_marketplace_source("owner/repo@main", Some("release".to_string())).unwrap(),
	- line 262: let shorthand = parse_marketplace_source("owner/repo", /*explicit_ref*/ None).unwrap();
	- line 267: .unwrap();
	- line 283: .unwrap(),
	- line 295: .unwrap(),
	- line 318: let source = parse_marketplace_source(".", /*explicit_ref*/ None).unwrap();
	- line 321: panic!("expected local path source");
	- line 336: let tempdir = TempDir::new().unwrap();
	- line 338: std::fs::write(&file, "{}").unwrap();
	- line 341: parse_marketplace_source(file.to_str().unwrap(), /*explicit_ref*/ None).unwrap_err();
	- line 363: let path = std::env::current_dir().unwrap();
	- line 386: .unwrap(),


codex-rs/codex-api/src/endpoint/realtime_call.rs (15 lines):
	- line 329: response_headers.insert(LOCATION, HeaderValue::from_str(location).unwrap());
	- line 346: *self.last_request.lock().unwrap() = Some(req);
	- line 439: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 443: request.headers.get(CONTENT_TYPE).unwrap(),
	- line 482: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 519: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 526: request.headers.get(CONTENT_TYPE).unwrap(),
	- line 530: panic!("multipart body should be raw");
	- line 577: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 581: panic!("multipart body should be raw");
	- line 615: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 644: assert!(transport.last_request.lock().unwrap().is_none());
	- line 672: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 722: let request = transport.last_request.lock().unwrap().clone().unwrap();
	- line 729: panic!("backend request body should be JSON");


codex-rs/tui/src/pets/image_protocol.rs (14 lines):
	- line 347: let dir = tempfile::tempdir().unwrap();
	- line 349: fs::write(&path, b"png").unwrap();
	- line 354: .unwrap();
	- line 374: "auto".parse::<ProtocolSelection>().unwrap(),
	- line 378: "kitty".parse::<ProtocolSelection>().unwrap(),
	- line 382: "sixel".parse::<ProtocolSelection>().unwrap(),
	- line 659: let dir = tempfile::tempdir().unwrap();
	- line 662: rgba.save(&frame_path).unwrap();
	- line 665: sixel_frame(&frame_path, &dir.path().join("sixel"), /*height_px*/ 1).unwrap();
	- line 666: let sixel = fs::read_to_string(sixel_path).unwrap();
	- line 678: let dir = tempfile::tempdir().unwrap();
	- line 680: fs::write(&path, b"png").unwrap();
	- line 688: .unwrap();
	- line 689: let path = path.canonicalize().unwrap();


codex-rs/exec-server/src/rpc.rs (14 lines):
	- line 879: Err(err) => panic!("timed out waiting for JSON-RPC line: {err}"),
	- line 883: Err(err) => panic!("failed to read JSON-RPC line: {err}"),
	- line 887: None => panic!("server connection closed before JSON-RPC line arrived"),
	- line 891: Err(err) => panic!("failed to parse JSON-RPC line: {err}"),
	- line 901: Err(err) => panic!("failed to encode JSON-RPC message: {err}"),
	- line 904: panic!("failed to write JSON-RPC line: {err}");
	- line 965: panic!("expected an inbound client request");
	- line 1007: _ => panic!("expected slow and fast requests"),
	- line 1035: let slow = slow.unwrap_or_else(|err| panic!("slow request failed: {err:?}"));
	- line 1036: let fast = fast.unwrap_or_else(|err| panic!("fast request failed: {err:?}"));
	- line 1043: panic!("server task failed: {err}");
	- line 1062: other => panic!("expected JSON-RPC request, got {other:?}"),
	- line 1110: panic!("server task failed: {err}");
	- line 1246: other => panic!("expected JSON-RPC request, got {other:?}"),


codex-rs/http-client/src/chatgpt_cloudflare_cookies.rs (14 lines):
	- line 192: let first_url = reqwest::Url::parse("https://cookies.chatgpt.com/a").unwrap();
	- line 193: let second_url = reqwest::Url::parse("https://cookies.chatgpt.com/b").unwrap();
	- line 203: assert!(store.cookies(&first_url).unwrap().is_sensitive());
	- line 225: let url = reqwest::Url::parse(url).unwrap();
	- line 228: let url = reqwest::Url::parse("https://chatgpt.com/a").unwrap();
	- line 233: assert!(!store.cookies(&url).unwrap().is_sensitive());
	- line 239: let url = reqwest::Url::parse("https://chatgpt.com/backend-api/codex/responses").unwrap();
	- line 271: let url = reqwest::Url::parse("https://api.openai.com/v1/responses").unwrap();
	- line 282: let url = reqwest::Url::parse("https://chatgpt.com/backend-api/codex/responses").unwrap();
	- line 295: let url = reqwest::Url::parse("https://chatgpt.com/backend-api/codex/responses").unwrap();
	- line 314: reqwest::Url::parse("https://chatgpt.com/backend-api/codex/responses").unwrap();
	- line 315: let api_url = reqwest::Url::parse("https://api.openai.com/v1/responses").unwrap();
	- line 340: let url = reqwest::Url::parse("http://chatgpt.com/backend-api/codex/responses").unwrap();
	- line 344: let url = reqwest::Url::parse("wss://chatgpt.com/backend-api/codex/responses").unwrap();


codex-rs/tui/src/bottom_pane/request_user_input/mod.rs (13 lines):
	- line 1570: panic!("expected CodexOp");
	- line 1871: panic!("expected UserInputAnswer event");
	- line 1996: panic!("expected UserInputAnswer event");
	- line 2242: panic!("expected UserInputAnswer");
	- line 2264: panic!("expected UserInputAnswer");
	- line 2300: panic!("expected UserInputAnswer");
	- line 2333: panic!("expected UserInputAnswer");
	- line 2706: panic!("expected UserInputAnswer");
	- line 3097: panic!("expected UserInputAnswer");
	- line 3122: panic!("expected UserInputAnswer");
	- line 3165: panic!("expected UserInputAnswer");
	- line 3201: panic!("expected UserInputAnswer");
	- line 3315: panic!("expected UserInputAnswer");


codex-rs/tui/src/lib.rs (13 lines):
	- line 588: .unwrap_or_else(|err| panic!("cli session source should deserialize: {err}")),
	- line 1126: unreachable!("app server should exist when auth is required");
	- line 1279: unreachable!("app server should be initialized for --fork <id>");
	- line 1314: unreachable!("app server should be initialized for --fork --last");
	- line 1344: unreachable!("app server should be initialized for --fork picker");
	- line 1373: unreachable!("app server should be initialized for --resume <id>");
	- line 1408: unreachable!("app server should be initialized for --resume --last");
	- line 1438: unreachable!("app server should be initialized for --resume picker");
	- line 2320: panic!("configured cwd should not prompt during startup")
	- line 2322: ResolveCwdOutcome::Exit => panic!("configured cwd should not exit startup"),
	- line 3306: Ok(_) => panic!("startup failure should be returned"),
	- line 3330: Ok(_) => panic!("embedded startup should surface state db init failures"),
	- line 3365: Ok(_) => panic!("embedded startup should surface state db init failures"),


codex-rs/codex-api/src/sse/responses.rs (13 lines):
	- line 731: regex_lite::Regex::new(r"(?i)try again in\s*(\d+(?:\.\d+)?)\s*(s|ms|seconds?)").unwrap()
	- line 878: other => panic!("unexpected third event: {other:?}"),
	- line 961: other => panic!("unexpected second event: {other:?}"),
	- line 1076: other => panic!("unexpected event: {other:?}"),
	- line 1098: other => panic!("unexpected rate-limit event: {other:?}"),
	- line 1138: _ => panic!("unexpected events for {code}: {events:?}"),
	- line 1196: other => panic!("unexpected event: {other:?}"),
	- line 1217: other => panic!("unexpected event: {other:?}"),
	- line 1237: other => panic!("unexpected event: {other:?}"),
	- line 1265: other => panic!("unexpected event: {other:?}"),
	- line 1311: other => panic!("unexpected event: {other:?}"),
	- line 1377: other => panic!("unexpected event for {code}: {other:?}"),
	- line 1512: other => panic!("expected server model event, got {other:?}"),


codex-rs/apply-patch/src/parser.rs (13 lines):
	- line 302: .unwrap()
	- line 327: .unwrap()
	- line 346: .unwrap()
	- line 381: .unwrap()
	- line 413: .unwrap()
	- line 456: let dir = tempfile::tempdir().unwrap();
	- line 475: .unwrap()
	- line 502: let cwd_dir = tempfile::tempdir().unwrap();
	- line 503: let cwd = PathUri::from_host_native_path(cwd_dir.path()).unwrap();
	- line 504: let absolute_dir = tempfile::tempdir().unwrap();
	- line 515: cwd.join("relative-add.py").unwrap(),
	- line 521: cwd.join("relative-delete.py").unwrap(),
	- line 529: cwd.join("relative-update.py").unwrap(),


codex-rs/utils/stream-parser/src/utf8_stream.rs (12 lines):
	- line 217: Err(err) => panic!("valid UTF-8 stream should parse: {err}"),
	- line 230: Err(err) => panic!("leading byte may be buffered until next chunk: {err}"),
	- line 235: Ok(out) => panic!("invalid continuation byte should error, got output: {out:?}"),
	- line 248: Err(err) => panic!("state should still allow a valid continuation: {err}"),
	- line 252: Err(err) => panic!("stream should finish: {err}"),
	- line 265: Ok(out) => panic!("invalid byte should error, got output: {out:?}"),
	- line 278: Err(err) => panic!("parser should recover after rollback: {err}"),
	- line 291: Err(err) => panic!("partial code point should be buffered: {err}"),
	- line 296: Ok(out) => panic!("unfinished code point should error, got output: {out:?}"),
	- line 308: Err(err) => panic!("partial code point should be buffered: {err}"),
	- line 313: Ok(_) => panic!("buffered partial code point should be rejected"),
	- line 325: Err(err) => panic!("partial code point should be buffered: {err}"),


codex-rs/core/src/guardian/tests.rs (12 lines):
	- line 651: panic!("parent environment should be ready");
	- line 1881: panic!("expected guardian assessment");
	- line 2132: panic!("expected guardian assessment");
	- line 2532: panic!("expected first guardian assessment");
	- line 2536: panic!("expected second guardian assessment");
	- line 2539: panic!("expected third guardian assessment");
	- line 2543: panic!("expected fourth guardian assessment");
	- line 2748: panic!("expected first guardian assessment");
	- line 2795: panic!("expected second guardian assessment");
	- line 2873: panic!("guardian error should deny the approval");
	- line 2962: panic!("expected guardian assessment");
	- line 3053: panic!("expected guardian assessment");


codex-rs/tui/src/text_formatting.rs (12 lines):
	- line 444: let result = format_json_compact(json).unwrap();
	- line 451: let result = format_json_compact(json).unwrap();
	- line 504: let result = format_json_compact(json).unwrap();
	- line 511: let result = format_json_compact(json).unwrap();
	- line 526: let result = format_json_compact(json).unwrap();
	- line 543: let result = format_json_compact(json).unwrap();
	- line 550: let result = format_json_compact(json).unwrap();
	- line 556: assert_eq!(format_json_compact("42").unwrap(), "42");
	- line 557: assert_eq!(format_json_compact("true").unwrap(), "true");
	- line 558: assert_eq!(format_json_compact("false").unwrap(), "false");
	- line 559: assert_eq!(format_json_compact("null").unwrap(), "null");
	- line 560: assert_eq!(format_json_compact(r#""string""#).unwrap(), r#""string""#);


codex-rs/app-server-transport/src/transport/remote_control/tests.rs (12 lines):
	- line 671: other => panic!("expected connection open event, got {other:?}"),
	- line 686: other => panic!("expected initialize incoming message, got {other:?}"),
	- line 719: other => panic!("expected followup incoming message, got {other:?}"),
	- line 795: other => panic!("expected connection close event, got {other:?}"),
	- line 918: other => panic!("expected connection open after reconnect, got {other:?}"),
	- line 1342: other => panic!("expected connection open event, got {other:?}"),
	- line 1350: other => panic!("expected initialize incoming message, got {other:?}"),
	- line 1414: other => panic!("expected connection close event, got {other:?}"),
	- line 1599: other => panic!("expected connection open event, got {other:?}"),
	- line 1614: other => panic!("expected initialize incoming message, got {other:?}"),
	- line 2867: panic!("unexpected websocket close frame: {frame:?}");
	- line 2870: panic!("unexpected binary websocket frame");


codex-rs/shell-command/src/bash.rs (11 lines):
	- line 326: let cmds = parse_seq("ls -1").unwrap();
	- line 333: let cmds = parse_seq(src).unwrap();
	- line 345: let cmds = parse_seq("echo \"hello world\"").unwrap();
	- line 351: let cmds2 = parse_seq("echo 'hi there'").unwrap();
	- line 360: let cmds = parse_seq("git commit -m \"line1\nline2\"").unwrap();
	- line 375: parse_seq(r#"echo "/usr"'/'"local"/bin"#).unwrap(),
	- line 379: parse_seq(r#"echo '/usr'"/"'local'/bin"#).unwrap(),
	- line 392: let cmds = parse_seq("echo 123 456").unwrap();
	- line 519: let parsed = parse_shell_lc_plain_commands(&command).unwrap();
	- line 526: let cmds = parse_seq("rg -n \"foo\" -g\"*.py\"").unwrap();
	- line 540: let cmds = parse_seq("grep -n 'pattern' -g'*.txt'").unwrap();


codex-rs/git-utils/src/apply.rs (11 lines):
	- line 600: Regex::new(&format!("(?i){pat}")).unwrap_or_else(|e| panic!("invalid regex: {e}"))
	- line 676: let _g = env_lock().lock().unwrap();
	- line 695: let _g = env_lock().lock().unwrap();
	- line 699: std::fs::write(root.join("file.txt"), "line1\nline2\nline3\n").unwrap();
	- line 703: std::fs::write(root.join("file.txt"), "line1\nlocal2\nline3\n").unwrap();
	- line 718: let _g = env_lock().lock().unwrap();
	- line 735: let _g = env_lock().lock().unwrap();
	- line 739: std::fs::write(root.join("file.txt"), "orig\n").unwrap();
	- line 771: let _g = env_lock().lock().unwrap();
	- line 775: std::fs::write(root.join("file.txt"), "orig\n").unwrap();
	- line 816: let _g = env_lock().lock().unwrap();


codex-rs/tui/src/onboarding/auth/headless_chatgpt_login.rs (11 lines):
	- line 25: *widget.sign_in_state.write().unwrap() =
	- line 58: *error.write().unwrap() = None;
	- line 168: let mut guard = sign_in_state.write().unwrap();
	- line 186: let mut guard = sign_in_state.write().unwrap();
	- line 193: *error.write().unwrap() = Some(message);
	- line 245: &*sign_in_state.read().unwrap(),
	- line 265: &*sign_in_state.read().unwrap(),
	- line 287: &*sign_in_state.read().unwrap(),
	- line 291: error.read().unwrap().as_deref(),
	- line 308: &*sign_in_state.read().unwrap(),
	- line 311: assert_eq!(*error.read().unwrap(), None);


codex-rs/app-server/src/extensions.rs (11 lines):
	- line 399: _ => panic!("unexpected listener command"),
	- line 438: panic!("expected warning listener command");
	- line 485: panic!("expected connection-targeted warning notification");
	- line 489: panic!("expected app-server warning notification");
	- line 492: panic!("expected warning notification");
	- line 544: panic!("expected connection-targeted warning notification");
	- line 548: panic!("expected app-server warning notification");
	- line 551: panic!("expected warning notification");
	- line 604: panic!("expected connection-targeted warning notification");
	- line 608: panic!("expected app-server warning notification");
	- line 611: panic!("expected warning notification");


codex-rs/codex-mcp/src/runtime.rs (10 lines):
	- line 922: Ok(_) => panic!("local stdio MCP should require a local environment"),
	- line 942: Err(error) => panic!("local HTTP MCP should resolve: {error}"),
	- line 988: Ok(_) => panic!("unknown MCP environment should fail"),
	- line 1012: unreachable!("stdio helper should build stdio transport");
	- line 1021: Err(error) => panic!("remote MCP should resolve: {error}"),
	- line 1032: unreachable!("HTTP helper should build streamable HTTP transport");
	- line 1036: Ok(_) => panic!("remote HTTP helper should be rejected"),
	- line 1072: unreachable!("stdio helper should build stdio transport");
	- line 1083: Err(error) => panic!("foreign cwd should resolve: {error}"),
	- line 1099: Err(error) => panic!("local stdio MCP should resolve: {error}"),


codex-rs/mcp-server/src/outgoing_message.rs (10 lines):
	- line 308: panic!("expected a tool-call response");
	- line 347: let result = outgoing_rx.recv().await.unwrap();
	- line 349: panic!("expected Notification for first message");
	- line 354: panic!("Event must serialize");
	- line 398: let result = outgoing_rx.recv().await.unwrap();
	- line 400: panic!("expected Notification for first message");
	- line 422: assert_eq!(params.unwrap(), expected_params);
	- line 464: let result = outgoing_rx.recv().await.unwrap();
	- line 466: panic!("expected Notification for first message");
	- line 489: assert_eq!(params.unwrap(), expected_params);


codex-rs/tui/src/tui/event_stream.rs (10 lines):
	- line 72: EventBrokerState::Paused | EventBrokerState::Start => unreachable!(),
	- line 411: *broker.state.lock().unwrap() = EventBrokerState::Running(source);
	- line 435: let next = stream.next().await.unwrap();
	- line 440: other => panic!("expected key event, got {other:?}"),
	- line 498: other => panic!("expected queued key event, got {other:?}"),
	- line 511: let first = stream.next().await.unwrap();
	- line 512: let second = stream.next().await.unwrap();
	- line 525: other => panic!("expected draw or key event, got {other:?}"),
	- line 593: other => panic!("expected key event, got {other:?}"),
	- line 616: other => panic!("expected key event, got {other:?}"),


codex-rs/utils/fuzzy-match/src/lib.rs (9 lines):
	- line 79: None => panic!("expected a match"),
	- line 90: None => panic!("expected a match"),
	- line 106: None => panic!("expected a match"),
	- line 110: None => panic!("expected a match"),
	- line 123: None => panic!("expected a match"),
	- line 127: None => panic!("expected a match"),
	- line 140: None => panic!("empty needle should match"),
	- line 150: None => panic!("expected a match"),
	- line 162: None => panic!("expected a match"),


codex-rs/login/src/auth/manager.rs (9 lines):
	- line 396: AuthMode::ApiKey => unreachable!("api key mode is handled above"),
	- line 398: unreachable!("externally provided auth is never loaded from auth storage")
	- line 400: AuthMode::AgentIdentity => unreachable!("agent identity mode is handled above"),
	- line 402: unreachable!("personal access token mode is handled above")
	- line 404: AuthMode::BedrockApiKey => unreachable!("bedrock api key mode is handled above"),
	- line 406: unreachable!("bedrock access keys mode is handled above")
	- line 672: state.auth_dot_json.lock().unwrap().clone()
	- line 869: self.state.auth_dot_json.lock().unwrap().clone()
	- line 1238: None => unreachable!("unrestricted login methods accept every auth mode"),


codex-rs/tui/src/pets/picker.rs (9 lines):
	- line 202: fs::create_dir_all(&pet_dir).unwrap();
	- line 214: .unwrap();
	- line 220: fs::create_dir_all(&avatar_dir).unwrap();
	- line 231: .unwrap();
	- line 237: let codex_home = tempfile::tempdir().unwrap();
	- line 274: let codex_home = tempfile::tempdir().unwrap();
	- line 288: let codex_home = tempfile::tempdir().unwrap();
	- line 307: let codex_home = tempfile::tempdir().unwrap();
	- line 319: .unwrap();


codex-rs/tui/src/bottom_pane/command_popup.rs (9 lines):
	- line 317: panic!("expected init command, got service tier {command:?}")
	- line 319: None => panic!("expected a selected command for exact match"),
	- line 331: panic!("expected model command, got service tier {command:?}")
	- line 333: None => panic!("expected at least one match for '/mo'"),
	- line 361: other => panic!("expected fast service tier to be selected, got {other:?}"),
	- line 548: panic!("expected plan command, got service tier {command:?}")
	- line 550: other => panic!("expected plan to be selected for exact match, got {other:?}"),
	- line 607: panic!("expected personality command, got service tier {command:?}")
	- line 609: other => panic!("expected personality to be selected for exact match, got {other:?}"),


codex-rs/code-mode-runtime/src/session_runtime/tests.rs (9 lines):
	- line 62: panic!("cell close panic probe");
	- line 158: .unwrap();
	- line 168: runtime.shutdown().await.unwrap();
	- line 215: Poll::Ready(Ok(_)) => panic!("execution completed before the registry lock was released"),
	- line 217: panic!("execution failed before the registry lock was released: {error}")
	- line 226: Poll::Ready(Ok(())) => panic!("shutdown completed before acquiring the registry lock"),
	- line 228: panic!("shutdown failed before acquiring the registry lock: {error}")
	- line 247: .unwrap();
	- line 263: .unwrap();


codex-rs/app-server-daemon/src/remote_control_client.rs (8 lines):
	- line 515: panic!("expected remoteControl/disable request");
	- line 537: panic!("expected fallback remoteControl/disable request");
	- line 581: panic!("expected remoteControl/pairing/start request");
	- line 653: panic!("expected remoteControl/enable request");
	- line 676: panic!("expected fallback remoteControl/enable request");
	- line 709: panic!("expected initialize request");
	- line 714: panic!("expected initialize params");
	- line 736: panic!("expected initialized notification");


codex-rs/utils/template/src/lib.rs (8 lines):
	- line 297: .unwrap();
	- line 307: let template = Template::parse("{{greeting}}, {{ name }}!").unwrap();
	- line 321: let template = Template::parse("{{ b }} {{ a }} {{ b }}").unwrap();
	- line 332: .unwrap();
	- line 343: .unwrap();
	- line 387: let template = Template::parse("Hello, {{ name }}.").unwrap();
	- line 399: let template = Template::parse("Hello, {{ name }}.").unwrap();
	- line 411: let template = Template::parse("Hello, {{ name }}.").unwrap();


codex-rs/config/src/loader/tests.rs (8 lines):
	- line 235: let mut config = toml::from_str(&format!("{safe}{key} = 'page-down'")).unwrap();
	- line 244: assert_eq!(config, toml::from_str::<TomlValue>(safe).unwrap());
	- line 331: Box::pin(async move { unimplemented!("test filesystem only supports reads") })
	- line 340: Box::pin(async move { unimplemented!("test filesystem only supports reads") })
	- line 368: Box::pin(async move { unimplemented!("test filesystem only supports reads") })
	- line 377: unimplemented!()
	- line 386: Box::pin(async move { unimplemented!("test filesystem only supports reads") })
	- line 396: Box::pin(async move { unimplemented!("test filesystem only supports reads") })


codex-rs/core/src/tools/handlers/extension_tools.rs (8 lines):
	- line 461: panic!("expected raw response item event");
	- line 516: payload => panic!("expected function payload, got {payload:?}"),
	- line 521: panic!("expected item started event");
	- line 524: panic!("expected extension web search item");
	- line 594: panic!("expected item started event");
	- line 597: panic!("expected extension item");
	- line 603: panic!("expected item completed event");
	- line 606: panic!("expected extension item");


codex-rs/exec-server/src/local_process.rs (8 lines):
	- line 1252: None => panic!("outbound notifications closed"),
	- line 1313: panic!("finished process metric should be a u64 sum");
	- line 1342: panic!("non-native cwd should be rejected");
	- line 1494: panic!("test process should be running");
	- line 1605: panic!("process should be running");
	- line 1629: panic!("process should be running");
	- line 1742: panic!("test process should be running");
	- line 1774: panic!("expected policy request");


codex-rs/app-server/src/command_exec.rs (8 lines):
	- line 800: panic!("expected connection-scoped outgoing message");
	- line 804: panic!("expected execution failure to be reported as an error");
	- line 881: panic!("expected connection-scoped outgoing message");
	- line 885: panic!("expected execution response after termination");
	- line 891: panic!("expected command/exec response");
	- line 960: panic!("expected connection-scoped outgoing message");
	- line 964: panic!("expected execution response after cancellation");
	- line 970: panic!("expected command/exec response");


codex-rs/tui/src/pets/sixel.rs (8 lines):
	- line 258: let sixel = encode_rgba(&[255, 0, 0, 255], /*width*/ 1, /*height*/ 1).unwrap();
	- line 259: let sixel = String::from_utf8(sixel).unwrap();
	- line 269: let sixel = encode_rgba(&[255, 0, 0, 0], /*width*/ 1, /*height*/ 1).unwrap();
	- line 270: let sixel = String::from_utf8(sixel).unwrap();
	- line 285: let sixel = encode_rgba(&rgba, /*width*/ 1, /*height*/ 7).unwrap();
	- line 286: let sixel = String::from_utf8(sixel).unwrap();
	- line 303: let sixel = encode_rgba(&rgba, /*width*/ 4, /*height*/ 1).unwrap();
	- line 304: let sixel = String::from_utf8(sixel).unwrap();


codex-rs/app-server/src/outgoing_message.rs (8 lines):
	- line 1054: panic!("expected command execution approval response");
	- line 1094: panic!("expected response message");
	- line 1102: other => panic!("expected targeted response envelope, got: {other:?}"),
	- line 1163: panic!("expected error message");
	- line 1168: other => panic!("expected targeted error envelope, got: {other:?}"),
	- line 1203: _ => panic!("expected targeted server notification"),
	- line 1239: panic!("expected targeted server notification envelope");
	- line 1243: panic!("expected app-server notification");


codex-rs/windows-sandbox-rs/src/unified_exec/tests.rs (8 lines):
	- line 213: .unwrap_or_else(|_| panic!("timed out waiting for exit\n{}", sandbox_log(codex_home)))
	- line 218: panic!(
	- line 436: panic!(
	- line 443: panic!(
	- line 454: .unwrap_or_else(|_| panic!("timed out waiting for exit\n{}", sandbox_log(codex_home.path())))
	- line 564: other => panic!("expected stdin frame, got {other:?}"),
	- line 569: other => panic!("expected close-stdin frame, got {other:?}"),
	- line 602: other => panic!("expected resize frame, got {other:?}"),


codex-rs/tui/src/bottom_pane/chat_composer_history.rs (8 lines):
	- line 1004: history.local_history.last().unwrap(),
	- line 1016: history.local_history.last().unwrap(),
	- line 1143: panic!("unexpected event variant");
	- line 1171: panic!("unexpected event variant");
	- line 1364: panic!("unexpected event variant");
	- line 1415: panic!("unexpected event variant");
	- line 1436: panic!("unexpected event variant");
	- line 1508: panic!("unexpected event variant");


codex-rs/network-proxy/src/network_policy.rs (7 lines):
	- line 652: let state = build_config_state(config, NetworkProxyConstraints::default()).unwrap();
	- line 752: .unwrap()
	- line 817: .unwrap()
	- line 858: .unwrap()
	- line 904: .unwrap()
	- line 955: .unwrap()
	- line 1041: .unwrap();


codex-rs/core-plugins/src/marketplace_add/metadata.rs (7 lines):
	- line 210: let codex_home = TempDir::new().unwrap();
	- line 212: fs::create_dir(&config_path).unwrap();
	- line 239: let codex_home = TempDir::new().unwrap();
	- line 242: fs::create_dir_all(source_root.join(".agents/plugins")).unwrap();
	- line 247: .unwrap();
	- line 252: record_added_marketplace_entry(codex_home.path(), "debug", &install_metadata).unwrap();
	- line 259: .unwrap();


codex-rs/backend-client/src/client.rs (6 lines):
	- line 1064: .unwrap(),
	- line 1071: .unwrap(),
	- line 1130: .unwrap();
	- line 1137: .unwrap();
	- line 1155: serde_json::from_value::<CodexUserSettingsResponse>(serde_json::json!({})).unwrap(),
	- line 1169: .unwrap();


codex-rs/tui/src/external_editor.rs (6 lines):
	- line 275: let cmd = resolve_editor_command().unwrap();
	- line 298: let dir = tempdir().unwrap();
	- line 300: fs::write(&script_path, "#!/bin/sh\nprintf \"edited\" > \"$1\"\n").unwrap();
	- line 301: let mut perms = fs::metadata(&script_path).unwrap().permissions();
	- line 303: fs::set_permissions(&script_path, perms).unwrap();
	- line 309: .unwrap();


codex-rs/ext/image-generation/src/tests.rs (6 lines):
	- line 49: panic!("imagegen should advertise a namespace tool");
	- line 53: panic!("imagegen should advertise a function tool");
	- line 260: panic!("imagegen should return function tool output");
	- line 263: panic!("imagegen output should contain generated image bytes");
	- line 306: panic!("imagegen should return function tool output");
	- line 309: panic!("imagegen output should contain generated image bytes");


codex-rs/tui/src/pets/asset_pack.rs (6 lines):
	- line 184: fs::create_dir_all(&assets_dir).unwrap();
	- line 198: let pet = catalog::builtin_pet("dewey").unwrap();
	- line 200: let url = builtin_pet_url(pet).unwrap();
	- line 213: append_download_chunk(&mut bytes, b"1234", /*max_bytes*/ 8, url).unwrap();
	- line 226: let dir = tempfile::tempdir().unwrap();
	- line 233: validate_cached_spritesheet(&path).unwrap();


codex-rs/codex-api/src/endpoint/models.rs (6 lines):
	- line 118: *self.last_request.lock().unwrap() = Some(req);
	- line 119: let body = serde_json::to_vec(&*self.body).unwrap();
	- line 122: headers.insert(ETAG, etag.parse().unwrap());
	- line 184: .unwrap()
	- line 186: .unwrap()
	- line 219: .unwrap(),


codex-rs/tui/src/bottom_pane/hooks_browser_view.rs (6 lines):
	- line 842: HookSource::Plugin => unreachable!("plugin hooks are handled by summary_source"),
	- line 1210: panic!("expected command hook");
	- line 1546: other => panic!("expected hook toggle event, got {other:?}"),
	- line 1613: other => panic!("expected hook trust event, got {other:?}"),
	- line 1652: other => panic!("expected hook trust event, got {other:?}"),
	- line 1729: other => panic!("expected hook trust event, got {other:?}"),


codex-rs/app-server-transport/src/transport/auth.rs (6 lines):
	- line 476: let claims_segment = URL_SAFE_NO_PAD.encode(serde_json::to_vec(&claims).unwrap());
	- line 478: let mut mac = HmacSha256::new_from_slice(shared_secret).unwrap();
	- line 488: "0.0.0.0:8765".parse().unwrap(),
	- line 492: "127.0.0.1:8765".parse().unwrap(),
	- line 496: "0.0.0.0:8765".parse().unwrap(),
	- line 706: .unwrap(),


codex-rs/tui/src/ide_context/ipc.rs (6 lines):
	- line 916: panic!("write ide-context response failed: {err}");
	- line 926: panic!("accept failed");
	- line 930: Err(err) => panic!("read ide-context failed: {err}"),
	- line 933: panic!("ide-context request did not include a request id");
	- line 953: panic!("set listener nonblocking failed: {err}");
	- line 957: Ok(_) => panic!("listener should not receive a connection"),


codex-rs/tui/src/clipboard_copy.rs (6 lines):
	- line 562: .unwrap();
	- line 656: panic!("expected OSC 52 error");
	- line 745: panic!("expected tmux and OSC 52 errors");
	- line 767: || panic!("tmux info should not be queried when forwarding is disabled"),
	- line 963: panic!("expected native and OSC 52 errors");
	- line 998: panic!("expected native, WSL, and OSC 52 errors");


codex-rs/core/src/tools/handlers/view_image.rs (6 lines):
	- line 368: panic!("primary environment should be ready");
	- line 391: panic!("expected sandboxed filesystem error");
	- line 421: panic!("expected unsupported detail error");
	- line 440: panic!("primary environment should be ready");
	- line 477: panic!("primary environment should be ready");
	- line 503: panic!("expected invalid image error");


codex-rs/ext/guardian-v2/src/async_scorer/transcript/window.rs (6 lines):
	- line 90: TranscriptEntryKind::User => unreachable!("user entries were selected separately"),
	- line 110: TranscriptEntryKind::User => unreachable!("user entries were selected separately"),
	- line 167: (None, None) => unreachable!("removable evidence was counted before eviction"),
	- line 200: TranscriptEntryKind::User => unreachable!("user entries were selected separately"),
	- line 211: TranscriptEntryKind::User => unreachable!("user entries were selected separately"),
	- line 220: TranscriptEntryKind::User => unreachable!("user entries were selected separately"),


codex-rs/cli/src/marketplace_cmd.rs (6 lines):
	- line 524: .unwrap();
	- line 530: .unwrap();
	- line 542: .unwrap();
	- line 552: let upgrade_all = UpgradeMarketplaceArgs::try_parse_from(["upgrade"]).unwrap();
	- line 555: let upgrade_one = UpgradeMarketplaceArgs::try_parse_from(["upgrade", "debug"]).unwrap();
	- line 561: let remove = RemoveMarketplaceArgs::try_parse_from(["remove", "debug"]).unwrap();


codex-rs/code-mode-runtime/src/cell_actor/mod.rs (5 lines):
	- line 218: panic!("pending delivery returned an unexpected event: {event:?}")
	- line 361: panic!("pending delivery returned an unexpected event: {event:?}")
	- line 530: Err(Err(error)) => panic!("cell event delivery returned an actor error: {error:?}"),
	- line 543: Err(event) => panic!("yield delivery returned an unexpected event: {event:?}"),
	- line 551: Some(event) => panic!("completion commit rejected an unexpected event: {event:?}"),


codex-rs/utils/pty/src/win/conpty.rs (5 lines):
	- line 161: let mut inner = self.inner.lock().unwrap();
	- line 166: let inner = self.inner.lock().unwrap();
	- line 171: Ok(Box::new(self.inner.lock().unwrap().readable.try_clone()?))
	- line 178: .unwrap()
	- line 188: let inner = self.inner.lock().unwrap();


codex-rs/sandboxing/src/landlock.rs (5 lines):
	- line 32: .unwrap_or_else(|err| panic!("failed to serialize permission profile: {err}"));
	- line 35: .unwrap_or_else(|| panic!("cwd must be valid UTF-8"))
	- line 39: .unwrap_or_else(|| panic!("command cwd must be valid UTF-8"))
	- line 74: .unwrap_or_else(|| panic!("command cwd must be valid UTF-8"))
	- line 78: .unwrap_or_else(|| panic!("cwd must be valid UTF-8"))


codex-rs/rmcp-client/src/protocol_mode.rs (5 lines):
	- line 88: .unwrap(),
	- line 92: McpProtocolMode::Legacy.stdio_mode(modern_version).unwrap(),
	- line 98: .unwrap(),
	- line 104: .unwrap(),
	- line 124: .unwrap(),


codex-rs/core/src/guardian/metrics.rs (5 lines):
	- line 286: panic!("metric {name} missing");
	- line 310: _ => panic!("unexpected counter aggregation"),
	- line 312: _ => panic!("unexpected counter data type"),
	- line 333: _ => panic!("unexpected histogram aggregation"),
	- line 335: _ => panic!("unexpected histogram data type"),


codex-rs/linux-sandbox/src/exec_util.rs (5 lines):
	- line 10: Err(err) => panic!("failed to convert argv to CString: {err}"),
	- line 27: panic!("failed to read fd flags for preserved bubblewrap file descriptor {fd}: {err}");
	- line 38: panic!("failed to clear CLOEXEC for preserved bubblewrap file descriptor {fd}: {err}");
	- line 64: panic!("failed to set CLOEXEC for test fd {fd}: {err}");
	- line 73: panic!("failed to read fd flags for test fd {fd}: {err}");


codex-rs/prompts/src/review_request.rs (5 lines):
	- line 24: .unwrap_or_else(|err| panic!("base branch backup review prompt must parse: {err}"))
	- line 28: .unwrap_or_else(|err| panic!("base branch review prompt must parse: {err}"))
	- line 35: .unwrap_or_else(|err| panic!("commit review prompt with title must parse: {err}"))
	- line 39: .unwrap_or_else(|err| panic!("commit review prompt must parse: {err}"))
	- line 107: .unwrap_or_else(|err| panic!("review prompt template must render: {err}"))


codex-rs/utils/pty/src/win/mod.rs (5 lines):
	- line 70: let proc = self.proc.lock().unwrap().try_clone().unwrap();
	- line 136: let proc = self.proc.lock().unwrap().try_clone().unwrap();
	- line 151: let res = unsafe { GetProcessId(self.proc.lock().unwrap().as_raw_handle() as _) };
	- line 156: let proc = self.proc.lock().unwrap();
	- line 169: let proc = self.proc.lock().unwrap().try_clone()?;


codex-rs/core/src/session/input_queue.rs (5 lines):
	- line 397: assert_eq!(serde_json::to_value(&input).unwrap(), value);
	- line 398: assert_eq!(serde_json::from_value::<TurnInput>(value).unwrap(), input);
	- line 417: let TurnInput::ResponseItem(envelope) = serde_json::from_value(forged).unwrap() else {
	- line 418: panic!("expected response item");
	- line 503: .unwrap();


codex-rs/linux-sandbox/src/bundled_bwrap.rs (5 lines):
	- line 38: panic!(
	- line 52: .unwrap_or_else(|err| panic!("invalid bundled bubblewrap fd path: {err}"));
	- line 67: panic!(
	- line 86: panic!(
	- line 123: .unwrap_or_else(|err| panic!("invalid CODEX_BWRAP_SHA256 value: {err}"));


codex-rs/shell-escalation/src/unix/socket.rs (5 lines):
	- line 144: unreachable!("header loop always returns")
	- line 176: unreachable!("loop exits only after returning payload")
	- line 451: let (received_payload, received_fds) = receive_task.await.unwrap()?;
	- line 468: let received_payload = receive_task.await.unwrap()?;
	- line 483: let (received_bytes, received_fds) = receive_task.await.unwrap()?;


codex-rs/linux-sandbox/src/launcher.rs (5 lines):
	- line 45: .unwrap_or_else(|error| panic!("invalid legacy bubblewrap fd mount: {error}"));
	- line 51: panic!(
	- line 166: Err(err) => panic!(
	- line 217: .unwrap_or_else(|err| panic!("invalid system bubblewrap path: {err}"));
	- line 232: panic!("failed to exec system bubblewrap {program_path}: {err}");


codex-rs/history/src/tests.rs (5 lines):
	- line 56: panic!("expected response item");
	- line 95: panic!("expected response item");
	- line 128: panic!("expected response item");
	- line 291: panic!("expected legacy response item");
	- line 308: panic!("expected legacy compacted item");


codex-rs/core/src/thread_manager.rs (5 lines):
	- line 519: unreachable!("thread ID generator must be set before thread manager is shared");
	- line 531: unreachable!("code-mode session provider must be set before thread manager is shared");
	- line 543: unreachable!("new thread manager state should not be shared");
	- line 563: .unwrap_or_else(|err| panic!("temp codex home dir create failed: {err}"));
	- line 603: Err(err) => panic!("test codex_home should be absolute: {err}"),


codex-rs/tui/src/bottom_pane/mcp_server_elicitation.rs (4 lines):
	- line 2207: panic!("expected SubmitThreadOp");
	- line 2365: panic!("expected SubmitThreadOp");
	- line 2419: panic!("expected SubmitThreadOp");
	- line 2472: panic!("expected SubmitThreadOp");


codex-rs/app-server-protocol/src/protocol/event_mapping.rs (4 lines):
	- line 465: _ => unreachable!("unsupported item event"),
	- line 485: other => panic!("expected item started notification, got {other:?}"),
	- line 495: other => panic!("expected item completed notification, got {other:?}"),
	- line 507: other => panic!("expected command execution output delta, got {other:?}"),


codex-rs/thread-store/src/local/read_thread.rs (4 lines):
	- line 702: panic!("expected invalid request error");
	- line 1381: parse_rfc3339_non_optional("2025-01-03T12:00:00Z").unwrap()
	- line 1491: panic!("expected invalid request error");
	- line 1576: panic!("expected invalid request error");


codex-rs/cli/src/doctor/thread_inventory.rs (4 lines):
	- line 867: panic!("expected session metadata");
	- line 986: panic!("expected session metadata");
	- line 1119: panic!("expected session metadata");
	- line 1153: panic!("expected session metadata");


codex-rs/tui/src/chatwidget/tool_requests.rs (4 lines):
	- line 195: GuardianAssessmentAction::Command { .. } => unreachable!(),
	- line 196: GuardianAssessmentAction::Execve { .. } => unreachable!(),
	- line 246: GuardianAssessmentAction::Command { .. } => unreachable!(),
	- line 247: GuardianAssessmentAction::Execve { .. } => unreachable!(),


codex-rs/responses-api-proxy/src/read_api_key.rs (4 lines):
	- line 239: .unwrap();
	- line 255: .unwrap();
	- line 272: .unwrap();
	- line 302: let io_error = err.downcast_ref::<io::Error>().unwrap();


codex-rs/code-mode-runtime/src/cell_actor/types.rs (4 lines):
	- line 259: panic!("completion delivery unexpectedly carried an actor error: {error:?}")
	- line 298: panic!("initial yield delivery returned an unexpected event: {event:?}")
	- line 301: panic!("initial yield delivery returned an actor error: {error:?}")
	- line 324: panic!("completion delivery unexpectedly carried an actor error: {error:?}")


codex-rs/utils/sandbox-summary/src/sandbox_summary.rs (4 lines):
	- line 132: let writable_root = AbsolutePathBuf::try_from(root).unwrap();
	- line 151: AbsolutePathBuf::try_from(if cfg!(windows) { "C:\\repo" } else { "/repo" }).unwrap();
	- line 157: .unwrap();
	- line 163: .unwrap();


codex-rs/core-plugins/src/remote_bundle.rs (4 lines):
	- line 860: store.remote_plugin_id(&result.plugin_id).unwrap(),
	- line 1117: panic!("failed to append tar test data: {error}");
	- line 1124: Err(error) => panic!("failed to finish tar test data: {error}"),
	- line 1128: Err(error) => panic!("failed to finish gzip test data: {error}"),


codex-rs/utils/path-uri/src/lib.rs (4 lines):
	- line 165: unreachable!("URL-safe base64 always produces a valid fallback path URI");
	- line 312: Err(()) => unreachable!("validated file URLs support hierarchical path segments"),
	- line 502: unreachable!("validated file URLs support hierarchical path segments");
	- line 709: unreachable!("validated file URLs can remove a localhost authority");


codex-rs/ext/goal/src/steering.rs (4 lines):
	- line 41: Err(err) => panic!("embedded template {template_name} is invalid: {err}"),
	- line 92: panic!("embedded goals/continuation.md template failed to render: {err}")
	- line 113: panic!("embedded goals/budget_limit.md template failed to render: {err}")
	- line 136: panic!("embedded goals/objective_updated.md template failed to render: {err}")


codex-rs/rmcp-client/src/elicitation_client_service.rs (4 lines):
	- line 379: panic!("legacy elicitation/create must dispatch to the typed handler");
	- line 385: panic!("an omitted legacy elicitation mode must default to form");
	- line 431: panic!("omitted legacy elicitation mode must default to form");
	- line 560: panic!("meta must be an object");


codex-rs/hooks/src/events/stop.rs (4 lines):
	- line 265: panic!("expected stop hook event, got {event_name:?}");
	- line 286: _ => unreachable!("validated stop hook event"),
	- line 337: _ => unreachable!("validated stop hook event"),
	- line 364: _ => unreachable!("validated stop hook event"),


codex-rs/core-plugins/src/marketplace_add.rs (4 lines):
	- line 332: panic!("git cloner should not be called for local marketplace sources")
	- line 377: panic!("git cloner should not be called for local marketplace sources")
	- line 413: panic!("git cloner should not be called for local marketplace sources")
	- line 421: panic!("git cloner should not be called for local marketplace sources")


codex-rs/utils/cli/src/resume_command.rs (4 lines):
	- line 39: let thread_id = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap();
	- line 46: let thread_id = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap();
	- line 77: let thread_id = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap();
	- line 90: let thread_id = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap();


codex-rs/prompts/src/permissions_instructions.rs (4 lines):
	- line 40: .unwrap_or_else(|err| panic!("danger-full-access sandbox template must parse: {err}"))
	- line 44: .unwrap_or_else(|err| panic!("workspace-write sandbox template must parse: {err}"))
	- line 48: .unwrap_or_else(|err| panic!("read-only sandbox template must parse: {err}"))
	- line 325: .unwrap_or_else(|err| panic!("sandbox template must render: {err}"))


bazel/rules/testing/wine/src/lib.rs (4 lines):
	- line 111: panic!("Wine process guard is missing");
	- line 122: panic!("Wine process guard is missing");
	- line 125: panic!("Wine process stdout has already been taken");
	- line 164: panic!("WineTestProcess dropped without async teardown");


codex-rs/app-server-client/src/remote.rs (4 lines):
	- line 965: Err(err) => panic!("client request should serialize: {err}"),
	- line 969: Err(err) => panic!("client request should encode as JSON-RPC request: {err}"),
	- line 978: Err(err) => panic!("client notification should serialize: {err}"),
	- line 982: Err(err) => panic!("client notification should encode as JSON-RPC notification: {err}"),


codex-rs/core/src/session/turn_context.rs (4 lines):
	- line 85: unreachable!("ready turn environments always carry resolved configuration")
	- line 97: unreachable!("ready turn environments always carry resolved configuration")
	- line 296: unreachable!("every turn has a host skills snapshot");
	- line 833: unreachable!("unconditional turn construction must accept valid settings");


codex-rs/tui/src/file_search.rs (3 lines):
	- line 47: let mut st = self.state.lock().unwrap();
	- line 55: let mut st = self.state.lock().unwrap();
	- line 111: let st = self.state.lock().unwrap();


codex-rs/core/src/codex_thread.rs (3 lines):
	- line 369: unreachable!("start-if-idle submission cannot steer")
	- line 409: unreachable!("recovered turn submission cannot steer")
	- line 470: unreachable!("steer-only submission cannot start a turn")


codex-rs/state/src/log_db.rs (3 lines):
	- line 840: LogDbCommand::Flush(_) => panic!("expected queued entry"),
	- line 868: LogDbCommand::Flush(_) => panic!("expected queued entry"),
	- line 876: LogDbCommand::Entry(_) => panic!("expected flush command"),


codex-rs/tui/src/markdown_stream.rs (3 lines):
	- line 601: panic!("expected to find the third-level ordered list line; got: {streamed_strs:?}")
	- line 658: None => panic!("para present"),
	- line 662: None => panic!("heading present"),


codex-rs/utils/path-uri/src/tests.rs (3 lines):
	- line 13: let base = PathUri::parse("file:///root/%FE/admin").unwrap();
	- line 26: assert_eq!(base.join_native_bytes(path).unwrap().to_string(), expected);
	- line 31: .unwrap()


codex-rs/app-server-transport/src/transport/remote_control/websocket.rs (3 lines):
	- line 2125: Ok(_) => panic!("http error response should fail the websocket connect"),
	- line 3060: _ => panic!("expected completed client message"),
	- line 3518: panic!("expected text event, got {message:?}");


codex-rs/protocol/src/permissions.rs (3 lines):
	- line 312: Err(_) => unreachable!("fail-closed glob handling does not return errors"),
	- line 1989: .unwrap_or_else(|| panic!("cwd must have a filesystem root"));
	- line 1991: .unwrap_or_else(|err| panic!("cwd root must be an absolute path: {err}"))


codex-rs/rmcp-client/src/oauth.rs (3 lines):
	- line 1367: store.values_mut().next().unwrap().access_token = "new".to_string();
	- line 1606: super::save_oauth_tokens_to_file(&tokens).unwrap();
	- line 1616: assert!(super::fallback_file_path().unwrap().exists());


codex-rs/ext/image-generation/src/tool.rs (3 lines):
	- line 584: .unwrap_or_else(|err| panic!("imagegen schema should serialize: {err}"));
	- line 586: unreachable!("imagegen root schema must be an object");
	- line 602: .unwrap_or_else(|err| panic!("imagegen input schema should parse: {err}")),


codex-rs/codex-api/src/endpoint/responses_websocket.rs (3 lines):
	- line 1038: panic!("expected ApiError::Transport(Http)");
	- line 1091: panic!("expected ApiError::Transport(Http)");
	- line 1117: panic!("expected ApiError::Retryable");


codex-rs/app-server/src/request_processors/thread_processor.rs (3 lines):
	- line 4762: (Some(_), Some(_)) => unreachable!("fork boundaries are mutually exclusive"),
	- line 4934: (Some(_), Some(_)) => unreachable!("fork boundaries are mutually exclusive"),
	- line 5409: StoreThreadSortKey::SectionPosition => unreachable!("section positions use rank cursors"),


codex-rs/app-server/src/thread_status.rs (3 lines):
	- line 863: panic!("expected broadcast notification");
	- line 866: panic!("expected thread/status/changed notification");
	- line 869: panic!("expected thread/status/changed notification");


codex-rs/windows-sandbox-rs/src/wrapper.rs (3 lines):
	- line 58: .unwrap_or_else(|err| panic!("failed to serialize permission profile: {err}"));
	- line 60: .unwrap_or_else(|err| panic!("failed to serialize env: {err}"));
	- line 128: .unwrap_or_else(|err| panic!("failed to serialize {flag}: {err}")),


codex-rs/app-server/src/bespoke_event_handling.rs (3 lines):
	- line 2496: other => panic!("unexpected notification: {other:?}"),
	- line 2551: other => panic!("unexpected notification: {other:?}"),
	- line 2599: other => panic!("unexpected notification: {other:?}"),


codex-rs/exec-server/src/environment_toml.rs (3 lines):
	- line 579: panic!("expected stdio transport");
	- line 625: panic!("expected websocket transport");
	- line 636: panic!("expected stdio transport");


codex-rs/shell-escalation/src/unix/escalate_server.rs (3 lines):
	- line 473: unreachable!("run() is not used by handle_escalate_session_with_policy() tests")
	- line 529: unreachable!("run() is not used by handle_escalate_session_with_policy() tests")
	- line 625: Box::pin(async { unreachable!("prepare_escalated_exec() is not used by exec() tests") })


codex-rs/config/src/config_requirements.rs (3 lines):
	- line 4459: panic!("unexpected error: {err:?}");
	- line 4572: panic!("unexpected error: {err:?}");
	- line 4595: panic!("rule should match so heuristic should not be called");


codex-rs/tui/src/bottom_pane/mod.rs (3 lines):
	- line 1616: AppLinkSuggestionType::Auth => unreachable!(
	- line 1619: AppLinkSuggestionType::ExternalAction => unreachable!(
	- line 2134: other => panic!("unexpected banner action: {other:?}"),


codex-rs/ext/memories/src/tests.rs (3 lines):
	- line 279: Ok(_) => panic!("path-like filename should be rejected"),
	- line 575: Ok(_) => panic!("legacy query field should be rejected"),
	- line 594: .unwrap_or_else(|| panic!("{tool_name} tool should be registered"))


codex-rs/ext/items/src/tests.rs (3 lines):
	- line 61: panic!("expected image-generation item");
	- line 96: panic!("expected image-generation item");
	- line 106: panic!("expected image-generation item");


codex-rs/bwrap/src/main.rs (3 lines):
	- line 15: .unwrap_or_else(|err| panic!("failed to convert argv to CString: {err}"))
	- line 33: panic!(
	- line 44: panic!("bwrap is only supported on Linux");


codex-rs/app-server-transport/src/transport/remote_control/mod.rs (3 lines):
	- line 148: Err(_) => unreachable!("remote control enrollment lock should stay open"),
	- line 318: .unwrap_or_else(|_| unreachable!());
	- line 333: .unwrap_or_else(|_| unreachable!());


codex-rs/cloud-tasks/src/app.rs (3 lines):
	- line 522: let root = load_tasks(&backend, /*env*/ None).await.unwrap();
	- line 526: let a = load_tasks(&backend, Some("env-A")).await.unwrap();
	- line 530: let b = load_tasks(&backend, Some("env-B")).await.unwrap();


codex-rs/codex-api/src/endpoint/realtime_websocket/methods_common.rs (3 lines):
	- line 70: unreachable!("realtime v2 does not send conversation handoff output")
	- line 87: unreachable!("realtime v2 does not send standalone handoff output")
	- line 153: RealtimeWireAdapter::FramelessBidi => unreachable!(),


codex-rs/tui/src/onboarding/onboarding_screen.rs (3 lines):
	- line 817: panic!("trust step should remain present");
	- line 836: panic!("trust step should remain present");
	- line 866: panic!("trust step should remain present");


codex-rs/exec-server/src/environment.rs (3 lines):
	- line 170: Err(err) => panic!("default provider should create valid environments: {err}"),
	- line 264: Err(err) => panic!("test provider with local should create valid environments: {err}"),
	- line 1861: panic!("sandbox cwd should be rejected after resolving runtime paths");


codex-rs/model-provider/src/auth.rs (3 lines):
	- line 314: unreachable!("{BEDROCK_API_KEY_UNSUPPORTED_MESSAGE}")
	- line 611: details => panic!("unexpected auth error: {details:?}"),
	- line 613: Ok(_) => panic!("Bedrock API key auth should be rejected"),


codex-rs/tui/src/pets/frames.rs (3 lines):
	- line 84: let dir = tempfile::tempdir().unwrap();
	- line 93: spritesheet.save(&spritesheet_path).unwrap();
	- line 110: .unwrap();


codex-rs/cli/src/doctor/updates.rs (3 lines):
	- line 593: windows_store_update(&serde_json::to_vec(&manifest).unwrap(), "26.803.5235.0"),
	- line 597: windows_store_update(&serde_json::to_vec(&manifest).unwrap(), "26.803.5235.1"),
	- line 602: windows_store_update(&serde_json::to_vec(&manifest).unwrap(), "26.803.5235.0").is_err()


codex-rs/app-server-transport/src/transport/remote_control/desired_state.rs (3 lines):
	- line 35: lock.acquire().await.unwrap_or_else(|_| unreachable!())
	- line 62: .unwrap_or_else(|_| unreachable!());
	- line 106: .unwrap_or_else(|_| unreachable!());


codex-rs/app-server/src/in_process.rs (3 lines):
	- line 703: _ => unreachable!("we just sent a ServerRequest variant"),
	- line 931: Err(err) => panic!("request transport should work: {err}"),
	- line 975: _ => panic!("expected in-process shutdown request"),


codex-rs/exec-server/src/server/processor.rs (3 lines):
	- line 361: panic!("expected outbound network policy request");
	- line 563: JSONRPCMessage::Error(error) => panic!("unexpected JSON-RPC error: {error:?}"),
	- line 564: other => panic!("expected JSON-RPC response, got {other:?}"),


codex-rs/app-server-transport/src/transport/mod.rs (3 lines):
	- line 435: _ => panic!("expected queued incoming message"),
	- line 502: _ => panic!("expected queued incoming message"),
	- line 521: _ => panic!("expected forwarded response message"),


codex-rs/tui/src/bottom_pane/footer.rs (3 lines):
	- line 1471: .unwrap();
	- line 1497: let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
	- line 1536: let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();


codex-rs/ansi-escape/src/lib.rs (2 lines):
	- line 50: panic!();
	- line 54: panic!();


codex-rs/tui/src/exec_cell/render.rs (2 lines):
	- line 337: _ => unreachable!(),
	- line 392: panic!("Expected exactly one call in a command display cell");


codex-rs/app-server-protocol/src/export.rs (2 lines):
	- line 1549: panic!(
	- line 1816: panic!(


codex-rs/app-server/src/fuzzy_file_search.rs (2 lines):
	- line 105: let mut latest_query = self.shared.latest_query.lock().unwrap();
	- line 180: self.shared.latest_query.lock().unwrap().clone()


codex-rs/tui/src/pets/catalog.rs (2 lines):
	- line 87: .unwrap();
	- line 90: fs::write(path, TEST_SPRITESHEET.as_slice()).unwrap();


codex-rs/core/src/hook_runtime.rs (2 lines):
	- line 1090: panic!("expected input text content, got {item:?}")
	- line 1096: other => panic!("expected developer message, got {other:?}"),


codex-rs/ext/memories/src/schema.rs (2 lines):
	- line 23: .unwrap_or_else(|err| panic!("generated tool schema should serialize: {err}"));
	- line 25: unreachable!("root tool schema must be an object");


codex-rs/tui/src/wrapping.rs (2 lines):
	- line 365: unreachable!("checked end < text.len()");
	- line 1871: panic!("expected at least one wrapped line");


codex-rs/tui/src/history_cell/tests.rs (2 lines):
	- line 2489: let image_start = message.find("[Image #1]").unwrap();
	- line 2694: row.strip_prefix("› ").unwrap().trim()


codex-rs/prompts/src/review_exit.rs (2 lines):
	- line 13: .unwrap_or_else(|err| panic!("review exit success template must parse: {err}"))
	- line 19: .unwrap_or_else(|err| panic!("review exit success template must render: {err}"))


codex-rs/model-provider/src/amazon_bedrock/catalog.rs (2 lines):
	- line 113: .unwrap_or_else(|err| panic!("bundled models.json should parse: {err}"))
	- line 117: .unwrap_or_else(|| panic!("bundled models.json should include {slug}"))


codex-rs/login/src/server.rs (2 lines):
	- line 65: .unwrap_or_else(|err| panic!("login error page template must parse: {err}"))
	- line 1116: .unwrap_or_else(|err| panic!("login error page template must render: {err}"))


codex-rs/core/src/tools/code_mode/mod.rs (2 lines):
	- line 502: other => panic!("expected function payload, got {other:?}"),
	- line 519: other => panic!("expected freeform payload, got {other:?}"),


codex-rs/core/src/tools/spec_plan.rs (2 lines):
	- line 277: (true, true, _) => unreachable!("direct and deferred exposure are mutually exclusive"),
	- line 919: unreachable!("namespace index must point to a namespace spec");


codex-rs/core/src/tools/runtimes/unified_exec.rs (2 lines):
	- line 616: other => panic!("expected timeout-or-cancellation expiration, got {other:?}"),
	- line 756: let cwd = AbsolutePathBuf::try_from(std::env::current_dir().unwrap())


codex-rs/mcp-server/src/codex_tool_config.rs (2 lines):
	- line 135: _ => unreachable!("json literal must be an object"),
	- line 251: _ => panic!("tool schema should serialize to a JSON object"),


codex-rs/core/src/compact_remote_v2.rs (2 lines):
	- line 471: unreachable!("compaction output must exist when count is exactly one");
	- line 474: unreachable!("response id must exist after response.completed");


codex-rs/network-proxy/src/socks5.rs (2 lines):
	- line 868: let _mitm_config_state_guard = config.mitm.then(|| MITM_CONFIG_STATE_LOCK.lock().unwrap());
	- line 869: let state = build_config_state(config, NetworkProxyConstraints::default()).unwrap();


codex-rs/utils/cli/src/config_override.rs (2 lines):
	- line 167: assert_eq!(tbl.get("a").unwrap().as_integer(), Some(1));
	- line 168: assert_eq!(tbl.get("b").unwrap().as_integer(), Some(2));


codex-rs/execpolicy/src/amend.rs (2 lines):
	- line 224: std::fs::create_dir_all(policy_path.parent().unwrap()).expect("create policy dir");
	- line 251: std::fs::create_dir_all(policy_path.parent().unwrap()).expect("create policy dir");


codex-rs/http-client/src/route_aware_client_pool.rs (2 lines):
	- line 735: Err(error) => panic!("route-aware client cache lock should not be poisoned: {error}"),
	- line 770: Err(error) => panic!("route-aware client cache lock should not be poisoned: {error}"),


codex-rs/code-mode-protocol/src/description.rs (2 lines):
	- line 544: parse_exec_source("text('hi')").unwrap(),
	- line 556: parse_exec_source("// @exec: {\"yield_time_ms\": 10}\ntext('hi')").unwrap(),


codex-rs/cli/src/remote_control_cmd.rs (2 lines):
	- line 382: unreachable!("errored and disabled statuses are rejected before formatting")
	- line 771: panic!("expected app-server exit before ready");


codex-rs/tui/src/status/rate_limits.rs (2 lines):
	- line 466: other => panic!("unexpected status: {other:?}"),
	- line 504: other => panic!("unexpected status: {other:?}"),


codex-rs/ext/skills/src/tools/schema.rs (2 lines):
	- line 23: .unwrap_or_else(|err| panic!("generated skill tool schema should serialize: {err}"));
	- line 25: unreachable!("root tool schema must be an object");


codex-rs/test-binary-support/lib.rs (2 lines):
	- line 49: Err(error) => panic!("failed to create test CODEX_HOME: {error}"),
	- line 59: None => panic!("failed to configure arg0 dispatch aliases for test binary"),


codex-rs/otel/src/provider.rs (2 lines):
	- line 442: OtelExporter::Statsig => unreachable!("statsig exporter should be resolved"),
	- line 510: OtelExporter::Statsig => unreachable!("statsig exporter should be resolved"),


codex-rs/tui/src/app/side.rs (2 lines):
	- line 119: panic!("expected hidden side boundary prompt to be a user message");
	- line 123: panic!("expected hidden side boundary prompt text");


codex-rs/hooks/src/engine/dispatcher.rs (2 lines):
	- line 80: unreachable!("executor-scoped hooks do not produce public hook summaries");
	- line 234: unreachable!("executor-scoped hooks do not produce public hook summaries");


codex-rs/models-manager/src/collaboration_mode_presets.rs (2 lines):
	- line 13: .unwrap_or_else(|err| panic!("collaboration mode default template must parse: {err}"))
	- line 44: .unwrap_or_else(|err| panic!("collaboration mode default template must render: {err}"))


codex-rs/core/src/environment_selection.rs (2 lines):
	- line 1006: other => panic!("expected JSON-RPC message, got {other:?}"),
	- line 1709: other => panic!("expected connected event, got {other:?}"),


codex-rs/http-client/src/request.rs (2 lines):
	- line 203: RequestCompression::None => unreachable!("guarded by compression != None"),
	- line 306: panic!("expected an encoded JSON body");


codex-rs/otel/src/trace_context.rs (2 lines):
	- line 364: TraceId::from_hex(trace_id).unwrap()
	- line 366: assert_eq!(span_context.span_id(), SpanId::from_hex(span_id).unwrap());


codex-rs/tui/src/bottom_pane/memories_settings_view.rs (2 lines):
	- line 165: _ => unreachable!("reset confirmation only renders two rows"),
	- line 344: Some(other) => unreachable!("unexpected reset confirmation row: {other}"),


codex-rs/file-search/src/main.rs (2 lines):
	- line 31: let json = serde_json::to_string(file_match).unwrap();
	- line 68: let json = serde_json::to_string(&value).unwrap();


codex-rs/protocol/src/config_types.rs (2 lines):
	- line 616: None => panic!("{field_name} must be non-zero"),
	- line 628: Err(err) => panic!("provider auth cwd must resolve: {err}"),


codex-rs/app-server-transport/src/transport/remote_control/segment.rs (2 lines):
	- line 312: unreachable!("server message variant checked above");
	- line 332: unreachable!("server message variant checked above");


codex-rs/ext/web-search/src/schema.rs (2 lines):
	- line 16: Err(err) => panic!("search commands schema should serialize: {err}"),
	- line 19: unreachable!("search commands schema must be an object");


codex-rs/tui/src/keymap.rs (2 lines):
	- line 577: panic!("built-in keymap defaults must be valid: {error}")
	- line 2947: .unwrap()


codex-rs/core/src/tools/handlers/tool_search_spec.rs (2 lines):
	- line 169: panic!("expected tool search spec");
	- line 191: panic!("expected tool search spec");


codex-rs/codex-mcp/src/rmcp_client.rs (2 lines):
	- line 950: _ => unreachable!("Codex Apps fetch ticket requires cache context"),
	- line 1119: unreachable!(


codex-rs/windows-sandbox-rs/src/elevated/ipc_framed.rs (2 lines):
	- line 210: other => panic!("unexpected message: {other:?}"),
	- line 251: panic!("unexpected message");


codex-rs/tui/src/app/thread_events.rs (2 lines):
	- line 717: other => panic!("expected buffered hook notification, saw: {other:?}"),
	- line 751: other => panic!("expected one buffered MCP notification, saw: {other:?}"),


codex-rs/tui/src/bottom_pane/list_selection_view.rs (2 lines):
	- line 2148: Ok(other) => panic!("expected OpenApprovalsPopup cancel event, got {other:?}"),
	- line 2149: Err(err) => panic!("expected cancel callback event, got {err}"),


codex-rs/hooks/src/schema.rs (2 lines):
	- line 1011: _ => panic!("unexpected fixture name: {name}"),
	- line 1066: .unwrap_or_else(|err| panic!("read generated schema {fixture}: {err}"));


codex-rs/features/src/tests.rs (2 lines):
	- line 752: panic!("expected warning event");
	- line 782: panic!("expected warning event");


codex-rs/exec-server/src/remote.rs (2 lines):
	- line 1019: Ok(_) => panic!("stalled connect response should time out"),
	- line 1065: Ok(_) => panic!("stalled connect response body should time out"),


codex-rs/cli/src/doctor/output.rs (2 lines):
	- line 1375: .unwrap();
	- line 1384: assert_eq!(desktop_update_note(update).unwrap().summary, expected);


codex-rs/tui/src/markdown_render.rs (2 lines):
	- line 370: Err(error) => panic!("invalid location suffix regex: {error}"),
	- line 378: Err(error) => panic!("invalid hash location regex: {error}"),


codex-rs/hooks/src/events/session_start.rs (2 lines):
	- line 253: panic!("expected start hook event, got {event_name:?}")
	- line 297: panic!("expected start hook event, got {event_name:?}")


codex-rs/ext/extension-api/src/state.rs (1 line):
	- line 144: unreachable!("typed extension data stored an incompatible value");


codex-rs/rmcp-client/src/streamable_http_retry.rs (1 line):
	- line 108: unreachable!("initialize retry loop should return on success or final error")


codex-rs/state/src/runtime/queued_items.rs (1 line):
	- line 42: unreachable!("queue change-version connection was initialized");


codex-rs/app-server-protocol/src/protocol/v2/turn.rs (1 line):
	- line 467: _ => unreachable!("unsupported user input variant"),


codex-rs/memories/write/src/prompts.rs (1 line):
	- line 38: Err(err) => panic!("embedded template {template_name} is invalid: {err}"),


codex-rs/ext/memories/src/prompts.rs (1 line):
	- line 19: Err(err) => panic!("embedded template {template_name} is invalid: {err}"),


codex-rs/exec/src/lib.rs (1 line):
	- line 2111: unreachable!("required stdin prompt should produce content");


codex-rs/core/src/session/rollout_reconstruction.rs (1 line):
	- line 429: unreachable!("only world-state replay items are collected")


codex-rs/tui/src/ide_context/prompt.rs (1 line):
	- line 45: unreachable!("position matched a text item");


codex-rs/features/src/lib.rs (1 line):
	- line 413: .unwrap_or_else(|| unreachable!("missing FeatureSpec for {self:?}"))


codex-rs/core/src/mcp_tool_call.rs (1 line):
	- line 1494: unreachable!("only MCP actions can request MCP tool approval");


codex-rs/tui/src/chatwidget/tests.rs (1 line):
	- line 191: .unwrap_or_else(|| panic!("snapshot file has no parent: {}", snapshot_file.display()))


codex-rs/tui/src/chatwidget/interrupts.rs (1 line):
	- line 228: panic!("expected remaining queued user input");


codex-rs/core/src/context/internal_model_context.rs (1 line):
	- line 36: .unwrap_or_else(|_| panic!("invalid static internal context source: {source}"))


codex-rs/utils/path-uri/src/api_path_string.rs (1 line):
	- line 333: .unwrap_or_else(|| unreachable!("validated file URLs have path segments"))


codex-rs/protocol/src/items.rs (1 line):
	- line 794: panic!("expected hook prompt message");


codex-rs/codex-mcp/src/plugin_config.rs (1 line):
	- line 228: (_, Some(source)) => unreachable!("validated env_vars source `{source}`"),


codex-rs/tui/src/tui/keyboard_modes.rs (1 line):
	- line 321: command.write_ansi(&mut out).unwrap();


codex-rs/thread-store/src/local/list_threads.rs (1 line):
	- line 44: ThreadSortKey::SectionPosition => unreachable!("section order uses the state database"),


codex-rs/tui/src/chatwidget/notifications.rs (1 line):
	- line 53: display_path_for(changes.first().unwrap(), cwd)


codex-rs/utils/string/src/lib.rs (1 line):
	- line 61: .unwrap() // Unwrap is safe thanks to the tests.


codex-rs/app-server/src/message_processor.rs (1 line):
	- line 968: panic!("Initialize should be handled before initialized request dispatch");


codex-rs/ollama/src/client.rs (1 line):
	- line 557: _ => panic!("unexpected test proxy policy: {policy_name}"),


codex-rs/ext/memories/src/tools/mod.rs (1 line):
	- line 69: .unwrap_or_else(|err| panic!("generated input schema for {name} should parse: {err}")),


codex-rs/hooks/src/engine/schema_loader.rs (1 line):
	- line 132: .unwrap_or_else(|err| panic!("invalid generated hooks schema {name}: {err}"))


codex-rs/backend-client/src/types.rs (1 line):
	- line 538: other => panic!("unknown fixture {other}"),


codex-rs/cli/src/debug_sandbox.rs (1 line):
	- line 441: unreachable!("Windows sandbox should have been handled above");


codex-rs/linux-sandbox/src/landlock.rs (1 line):
	- line 259: unimplemented!("unsupported architecture for seccomp filter");


codex-rs/core/src/mcp_openai_file.rs (1 line):
	- line 285: panic!("expected ready primary environment");


codex-rs/windows-sandbox-rs/src/logging.rs (1 line):
	- line 112: let previewed = result.unwrap();


codex-rs/tui/src/app/startup.rs (1 line):
	- line 228: .unwrap_or_else(|err| panic!("cli session source should deserialize: {err}")),


codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs (1 line):
	- line 457: unreachable!("exec_command has a function schema");


codex-rs/tui/src/chatwidget/usage.rs (1 line):
	- line 400: | ConsumeAccountRateLimitResetCreditOutcome::AlreadyRedeemed => unreachable!(),


codex-rs/ext/skills/src/loader/host_merge.rs (1 line):
	- line 82: .unwrap_or_else(|_| unreachable!());


codex-rs/tui/src/app_server_session.rs (1 line):
	- line 2878: unreachable!("workspace-write profiles use restricted managed permissions");


codex-rs/core/src/util.rs (1 line):
	- line 95: panic!("{}", message.to_string());


codex-rs/utils/pty/src/win/psuedocon.rs (1 line):
	- line 365: let version = windows_build_number().unwrap();


codex-rs/secrets/src/sanitizer.rs (1 line):
	- line 27: Err(err) => panic!("invalid regex pattern `{pattern}`: {err}"),


codex-rs/utils/image/src/lib.rs (1 line):
	- line 407: _ => unreachable!("unsupported target_format should have been handled earlier"),


codex-rs/core/src/tools/handlers/mcp.rs (1 line):
	- line 664: panic!("builtin-like MCP tool should stay function-shaped");


codex-rs/analytics/src/reducer.rs (1 line):
	- line 3386: unreachable!("turn event params require a fully populated turn state");


codex-rs/app-server-protocol/src/protocol/thread_history.rs (1 line):
	- line 1384: unreachable!("current turn must exist after initialization");


codex-rs/cli/src/doctor/runtime.rs (1 line):
	- line 110: CheckStatus::Fail => unreachable!(),


codex-rs/cli/src/debug_sandbox/pid_tracker.rs (1 line):
	- line 359: let output = child.wait_with_output().unwrap().stdout;


codex-rs/utils/rustls-provider/src/lib.rs (1 line):
	- line 25: panic!("aws-lc-rs rustls crypto provider should be installed");


codex-rs/app-server/src/request_processors/plugins.rs (1 line):
	- line 2116: unreachable!("invalid plugin ids are handled above");


codex-rs/thread-store/src/in_memory.rs (1 line):
	- line 315: panic!("canonical session meta");


codex-rs/protocol/src/dynamic_tools.rs (1 line):
	- line 148: unreachable!("namespace index must point to a namespace");


codex-rs/codex-mcp/src/connection_manager/tool_catalog.rs (1 line):
	- line 416: _ => unreachable!("Codex Apps fetch ticket requires cache context"),


codex-rs/ext/web-search/src/tool.rs (1 line):
	- line 61: Err(err) => panic!("search command schema should parse: {err}"),


codex-rs/model-provider-info/src/lib.rs (1 line):
	- line 188: None => panic!("AWS auth refresh timeout must be non-zero"),


codex-rs/thread-store/src/thread_metadata_sync.rs (1 line):
	- line 684: panic!("thread settings applied item");


codex-rs/rollout/src/list.rs (1 line):
	- line 1442: let limit = NonZero::new(1).unwrap();


codex-rs/exec-server/src/shell_snapshot.rs (1 line):
	- line 201: ShellType::PowerShell | ShellType::Cmd => unreachable!(),


codex-rs/tui/src/diff_render.rs (1 line):
	- line 2621: panic!(


codex-rs/login/src/auth/agent_identity.rs (1 line):
	- line 180: None => unreachable!("AgentIdentityAuth should only be constructed with a task_id"),


codex-rs/cli/src/debug_sandbox/seatbelt.rs (1 line):
	- line 108: regex_lite::Regex::new(r"^Sandbox:\s*(.+?)\((\d+)\)\s+deny\(.*?\)\s*(.+)$").unwrap()


codex-rs/codex-api/src/endpoint/images.rs (1 line):
	- line 320: panic!("expected image response decode error");


codex-rs/core/src/session/turn_input.rs (1 line):
	- line 289: unreachable!("explicit user input can enter Plan mode");


codex-rs/app-server/src/current_time.rs (1 line):
	- line 161: require_single_current_time_connection(&[ConnectionId(7)]).unwrap(),


codex-rs/git-utils/src/branch.rs (1 line):
	- line 214: &["remote", "add", "origin", remote.to_str().unwrap()],


codex-rs/rollout/src/seekable_reader.rs (1 line):
	- line 38: unreachable!("the final open attempt returns its error")


codex-rs/http-client/src/outbound_proxy.rs (1 line):
	- line 548: Err(error) => panic!("system proxy cache lock should not be poisoned: {error}"),


codex-rs/cli/src/login.rs (1 line):
	- line 480: unreachable!("header auth cannot be loaded from auth storage")


codex-rs/http-client/src/custom_ca.rs (1 line):
	- line 753: panic!("write cert fixture failed for {}: {error}", path.display())


codex-rs/tui/src/bottom_pane/scroll_state.rs (1 line):
	- line 164: None => panic!("expected Some(selected_idx) after wrap"),


codex-rs/core-plugins/src/store.rs (1 line):
	- line 104: .unwrap_or_else(|err| panic!("plugin cache root should be absolute: {err}"))


codex-rs/bwrap/build.rs (1 line):
	- line 28: panic!("failed to compile bubblewrap for Linux target: {err}");


codex-rs/tui/src/branch_summary.rs (1 line):
	- line 754: .unwrap_or_else(|| panic!("missing fake response for {:?}", command.argv));


codex-rs/core-plugins/src/marketplace.rs (1 line):
	- line 645: unreachable!("unsupported plugin sources should be filtered before resolution")


codex-rs/tui/src/pets/ambient.rs (1 line):
	- line 470: .unwrap(),


codex-rs/tui/src/chatwidget/model_popups.rs (1 line):
	- line 622: _ => unreachable!("advanced choices are limited to Max and Ultra"),


codex-rs/login/src/auth/storage.rs (1 line):
	- line 233: Err(err) => unreachable!("CODEX_AUTH should be a valid secret name: {err}"),


codex-rs/ext/skills/src/tools/mod.rs (1 line):
	- line 306: .unwrap_or_else(|err| panic!("generated input schema for {name} should parse: {err}")),


codex-rs/ext/goal/src/tool.rs (1 line):
	- line 256: | ThreadGoalStatus::BudgetLimited => unreachable!("status validated above"),


codex-rs/core/src/exec.rs (1 line):
	- line 1032: None => unreachable!("expiration wait only resolves while expiration is active"),


codex-rs/core/src/session/mod.rs (1 line):
	- line 1646: unreachable!("unconditional settings updates must commit");


codex-rs/hooks/src/engine/discovery.rs (1 line):
	- line 776: unreachable!("normalized hook identity should serialize to TOML");


codex-rs/thread-store/src/local/archive_thread.rs (1 line):
	- line 190: result = &mut archive => panic!("archive completed while the source was reserved: {result:?}"),


codex-rs/linux-sandbox/src/lib.rs (1 line):
	- line 38: panic!("codex-linux-sandbox is only supported on Linux");


codex-rs/app-server-daemon/src/backend/pid.rs (1 line):
	- line 145: unreachable!("lock holder cannot observe starting")


codex-rs/sandboxing/src/seatbelt.rs (1 line):
	- line 374: Err(err) => panic!("root path must be absolute: {err}"),


codex-rs/ext/skills/src/loader/namespace.rs (1 line):
	- line 112: None => unreachable!("pending namespace ancestor was not probed"),


codex-rs/rmcp-client/src/rmcp_client.rs (1 line):
	- line 1365: unreachable!("service operation retry loop should return on success or final error")


codex-rs/core/src/session/thread_settings.rs (1 line):
	- line 85: .unwrap_or_else(|_| unreachable!("thread settings persistence semaphore is never closed"))


codex-rs/core/src/compact_remote_v2_images.rs (1 line):
	- line 91: ContentItem::InputImage { .. } => unreachable!("images are handled atomically above"),


codex-rs/apply-patch/src/streaming_parser.rs (1 line):
	- line 541: let updated_hunks = parser.push_delta(&ch.to_string()).unwrap();


codex-rs/tui/src/pager_overlay.rs (1 line):
	- line 1731: let expected_page2_first = *page1.last().unwrap() + 1;


codex-rs/core/src/tools/approvals.rs (1 line):
	- line 889: unreachable!("permission requests are routed directly to Guardian")


codex-rs/codex-mcp/src/binding.rs (1 line):
	- line 230: unreachable!("prepared MCP calls retain their immutable permission authority");


codex-rs/code-mode/src/remote_session.rs (1 line):
	- line 201: Err(_) => unreachable!("a generated code-mode session ID is nonempty"),


codex-rs/core/src/tasks/review.rs (1 line):
	- line 113: panic!("by construction Constrained<WebSearchMode> must always support Disabled: {err}");


codex-rs/hooks/src/engine/mod.rs (1 line):
	- line 292: unreachable!("allowlisted executor handler must be an MCP tool");


codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs (1 line):
	- line 227: unreachable!();
