放宽 AGC 测试的 mock 请求等待预算

- 测试内 78 处 recv_timeout(Duration::from_secs(5)) 是等待 mock Provider / 运行时请求的正向等待，高负载 CI 上会超时并让每轮随机一批用例变红
- 统一放宽到 30 秒，仍保持有界；负向用例使用的更短等待（1~3 秒）保持不变
- 覆盖 tests/** 与 runner/tests.rs，涉及 command_runtime、provider、response_stream、sessions、goal、recovery 等文件

apps/ai-game-creator-shell/src-tauri/src/runner/tests.rs

@@ -3714,7 +3714,7 @@ fn project_execution_owner_concurrent_claims_single_flight_recovery() {
             first_recoveries.fetch_add(1, Ordering::SeqCst);
             first_recovery_entered.wait();
             release_recovery_rx
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("test must release the active recovery");
             Ok(())
         })
@@ -3733,7 +3733,7 @@ fn project_execution_owner_concurrent_claims_single_flight_recovery() {
         })
     });
     second_started_rx
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("second claim must start");
     std::thread::sleep(Duration::from_millis(50));
     assert_eq!(
@@ -3800,13 +3800,13 @@ fn project_execution_owner_recovery_panic_resets_running_and_wakes_waiter() {
             first_recoveries.fetch_add(1, Ordering::SeqCst);
             first_entered_tx.send(()).expect("signal panic recovery");
             release_first_rx
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("release panic recovery");
             panic!("injected recovery callback panic");
         })
     });
     first_entered_rx
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first recovery must enter");
 
     let second_state = Arc::clone(&state);
@@ -3821,7 +3821,7 @@ fn project_execution_owner_recovery_panic_resets_running_and_wakes_waiter() {
         })
     });
     second_started_rx
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("waiting claim must start");
     std::thread::sleep(Duration::from_millis(50));
     assert_eq!(

apps/ai-game-creator-shell/src-tauri/src/tests/command_runtime.rs

@@ -623,12 +623,12 @@ async fn background_agent_runtime_command_exec_repairs_failure_and_finishes_once
     .expect("confirm failed command");
 
     let repair_request = receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("repair plan request");
     assert!(repair_request.contains("command.exec"));
     assert!(repair_request.contains("command-failed") || repair_request.contains("failed"));
     let retry_request = receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("retry command plan request");
     assert!(retry_request.contains("file.patch"));
     assert!(retry_request.contains("已局部修改 src/answer.mjs"));
@@ -649,7 +649,7 @@ async fn background_agent_runtime_command_exec_repairs_failure_and_finishes_once
     .expect("confirm passing command");
 
     let final_request = receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("final plan request");
     assert!(final_request.contains("COMMAND_EXEC_RECOVERY_PASS"));
     let runtime = wait_for_agent_runtime_idle(&root, "code-prototype");
@@ -833,7 +833,7 @@ async fn background_agent_runtime_reads_long_command_output_without_leaking_line
     };
 
     let short_observation_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("followup request after command exec");
     assert!(short_observation_request.contains("outputRef"));
     assert!(short_observation_request.contains("totalLines"));
@@ -890,7 +890,7 @@ async fn background_agent_runtime_reads_long_command_output_without_leaking_line
         .expect("release output read plan response");
 
     let output_read_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("followup request after output read");
     assert!(output_read_request.contains(ROOT_MARKER));
     assert!(output_read_request.contains("TRACE_LINE_139"));

apps/ai-game-creator-shell/src-tauri/src/tests/goal.rs

@@ -1443,7 +1443,7 @@ async fn provider_action_batch_goal_resume_projects_batch_phase_before_runner_co
         .as_str()
         .is_some_and(|value| value.contains("Provider action 批次")));
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider request after resumed Goal batch completes");
     assert!(second_request.contains(READ_MARKER));
     let runtime_after_batch = read_game_creator_agent_runtime_at(&root, "design-director")
@@ -1567,7 +1567,7 @@ async fn provider_action_batch_goal_resume_never_rewinds_newer_steer_cursor() {
             .expect("resume Goal with stale Provider batch");
     assert_eq!(resumed.runtime.state.applied_steer_cursor, newer_cursor);
     request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider replan after stale Goal batch");
     assert!(!game_creator_agent_runtime_provider_action_batch_path(
         &root,
@@ -1803,10 +1803,10 @@ async fn provider_retry_waiting_goal_pause_preserves_attempt_until_same_run_resu
     )
     .expect("start Goal Provider retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first Goal Provider request");
     let first_provider_request = request_capture_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("capture first Goal Provider request");
     wait_for_agent_runtime_phase(&root, "code-prototype", "waiting-for-provider-retry");
     let retry = crate::provider_retry::read_for_run_at(&root, "code-prototype", run_id)
@@ -1858,10 +1858,10 @@ async fn provider_retry_waiting_goal_pause_preserves_attempt_until_same_run_resu
     assert_eq!(resumed_event["status"], "running");
     assert_eq!(resumed_event["phase"], "waiting-for-provider-retry");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("resumed Goal Provider retry request");
     let resumed_provider_request = request_capture_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("capture resumed Goal Provider retry request");
     if first_provider_request != resumed_provider_request {
         let first_body = first_provider_request

apps/ai-game-creator-shell/src-tauri/src/tests/mod.rs

@@ -3430,7 +3430,7 @@ fn spawn_mock_external_canvas_api_server_with_capture_and_generation_gate(
             ) {
                 assert!(normalized_request.contains("authorization: bearer "));
                 if let Some(gate) = generation_response_gate.take() {
-                    gate.recv_timeout(Duration::from_secs(5))
+                    gate.recv_timeout(Duration::from_secs(30))
                         .expect("release mock canvas generation response");
                 }
                 let status = match generation_poll_index {
@@ -4271,7 +4271,7 @@ fn run_response_stream_distinct_final_reply_case(api_kind: &str, case_name: &str
     let session_id = started.state.session_id.clone();
 
     mock.first_delta_written
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first public final-reply delta");
     let streaming =
         wait_for_response_stream_status(&root, "design-director", &run_id, "streaming", 1);

apps/ai-game-creator-shell/src-tauri/src/tests/provider.rs

@@ -1177,7 +1177,7 @@ async fn provider_action_batch_auto_confirm_auto_executes_once_before_next_provi
     )
     .expect("confirm provider batch action");
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider request after completed batch");
     assert!(second_request.contains("PROVIDER_BATCH_CONFIRMED_READ"));
     assert!(
@@ -1395,7 +1395,7 @@ async fn provider_action_batch_mutation_then_verification_rolls_forward_gate() {
         .expect("release mutation verification plan");
 
     let final_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider request after mutation verification batch");
     assert!(final_request.contains("game.static_smoke 已完成"));
     assert!(final_request.contains("通过："));
@@ -1502,7 +1502,7 @@ async fn provider_action_batch_auto_deny_auto_executes_no_batch_actions() {
         .send(plan)
         .expect("release denied provider batch plan");
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("replan after provider batch abort");
     assert!(!second_request.contains("PROVIDER_BATCH_DENIED_READ_MUST_NOT_APPEAR"));
     assert!(!game_creator_agent_runtime_provider_action_batch_path(
@@ -1684,7 +1684,7 @@ async fn provider_action_batch_read_read_confirm_waits_then_keeps_one_parallel_b
     )
     .expect("confirm trailing provider batch action");
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider request after read read confirm batch");
     assert!(second_request.contains("PROVIDER_BATCH_ALPHA_READ"));
     assert!(second_request.contains("PROVIDER_BATCH_BETA_READ"));
@@ -1803,7 +1803,7 @@ async fn provider_action_batch_ready_restart_resumes_original_cursor_without_pro
     assert_eq!(u64::from(resumed[0].state.loop_iteration), loop_iteration);
     assert_eq!(resumed[0].state.applied_steer_cursor, steer_cursor);
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider request after original batch completion");
     assert!(second_request.contains(READ_MARKER));
     assert!(!game_creator_agent_runtime_provider_action_batch_path(
@@ -1961,7 +1961,7 @@ async fn provider_action_batch_advanced_cursor_reuses_observed_pending_without_d
         .expect("resume advanced Provider batch cursor");
     assert_eq!(resumed.len(), 1);
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider request after remaining suffix completes");
     assert!(second_request.contains(READ_MARKER));
     assert!(!game_creator_agent_runtime_provider_action_batch_path(
@@ -2110,7 +2110,7 @@ async fn provider_action_batch_aborted_restart_rebuilds_rejection_with_zero_effe
         .expect("resume aborted Provider action batch");
     assert_eq!(resumed.len(), 1);
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider replan after recovered batch rejection");
     assert!(!second_request.contains("PROVIDER_BATCH_ABORT_RESTART_READ_NEVER"));
     assert!(!game_creator_agent_runtime_provider_action_batch_path(
@@ -2241,7 +2241,7 @@ async fn provider_action_batch_ready_restart_supersedes_suffix_after_queued_stee
     resume_game_creator_agent_background_tasks_at(&root)
         .expect("resume stale ready Provider batch");
     let second_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider replan after old batch is superseded");
     assert!(second_request.contains("放弃旧批次"));
     assert!(!second_request.contains("PROVIDER_BATCH_STEER_READ_NEVER"));
@@ -2903,7 +2903,7 @@ async fn background_agent_runtime_resumes_approved_pending_action_without_llm_re
         runtime.state.run_id == "design-approved-recovery-run" && runtime.state.status == "running"
     }));
     let replan_request = receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("replan after exact action observation");
     assert!(replan_request.contains("核心循环笔记"));
     assert!(receiver.recv_timeout(Duration::from_millis(200)).is_err());
@@ -3339,10 +3339,10 @@ async fn provider_transient_retry_transport_failure_closes_then_stable_retry_suc
     .expect("start transient retry task");
 
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first physical Provider request");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("transient retry Provider request");
     assert!(request_notice_receiver
         .recv_timeout(Duration::from_millis(100))
@@ -3580,7 +3580,7 @@ async fn provider_retry_waiting_tool_plan_resumes_only_after_due_and_cleans_side
     )
     .expect("start persisted retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first physical Provider request");
 
     let waiting =
@@ -3630,7 +3630,7 @@ async fn provider_retry_waiting_tool_plan_resumes_only_after_due_and_cleans_side
     resume_game_creator_agent_background_tasks_at(&root)
         .expect("duplicate due resume remains idempotent");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("one due retry physical Provider request");
     assert!(request_notice_receiver
         .recv_timeout(Duration::from_millis(100))
@@ -3717,7 +3717,7 @@ async fn provider_retry_waiting_restart_repairs_sidecar_before_task_projection()
     )
     .expect("start torn Provider retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first torn Provider physical request");
 
     let mut retry = None;
@@ -3760,7 +3760,7 @@ async fn provider_retry_waiting_restart_repairs_sidecar_before_task_projection()
         .expect("force repaired Provider retry due");
     resume_game_creator_agent_background_tasks_at(&root).expect("resume repaired Provider retry");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("repaired Provider retry physical request");
     let completed = wait_for_agent_runtime_idle(&root, "design-director");
     assert_eq!(completed.phase, "completed");
@@ -3846,7 +3846,7 @@ async fn provider_retry_waiting_context_compaction_resumes_source_once_before_to
     )
     .expect("start persisted compaction retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first failed compaction Provider request");
     let waiting = wait_for_agent_runtime_phase(&root, agent_id, "waiting-for-provider-retry");
     assert_eq!(waiting.run_id, run_id);
@@ -3867,10 +3867,10 @@ async fn provider_retry_waiting_context_compaction_resumes_source_once_before_to
     resume_game_creator_agent_background_tasks_at(&root)
         .expect("resume persisted compaction retry");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("retried compaction Provider request");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("tool-plan request after compaction commit");
     assert!(request_notice_receiver
         .recv_timeout(Duration::from_millis(100))
@@ -3963,7 +3963,7 @@ async fn provider_retry_waiting_cancel_removes_sidecar_without_second_request()
     )
     .expect("start cancellable Provider retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first physical Provider request");
     let waiting =
         wait_for_agent_runtime_phase(&root, "design-director", "waiting-for-provider-retry");
@@ -4018,7 +4018,7 @@ async fn provider_retry_waiting_steer_supersedes_old_attempt_and_wakes_same_run(
     )
     .expect("start steerable Provider retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first steerable Provider request");
     wait_for_agent_runtime_phase(&root, "design-director", "waiting-for-provider-retry");
 
@@ -4040,7 +4040,7 @@ async fn provider_retry_waiting_steer_supersedes_old_attempt_and_wakes_same_run(
             .is_none()
     );
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("steer wakes a fresh Provider request");
     assert!(request_notice_receiver
         .recv_timeout(Duration::from_millis(100))
@@ -4116,10 +4116,10 @@ async fn provider_repair_retry_waiting_steer_uses_distinct_audit_cursor() {
     .expect("start repair retry steer task");
 
     request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("initial invalid tool-plan request");
     request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("repair transport failure request");
     wait_for_agent_runtime_phase(&root, "design-director", "waiting-for-provider-retry");
 
@@ -4135,10 +4135,10 @@ async fn provider_repair_retry_waiting_steer_uses_distinct_audit_cursor() {
     .expect("steer waiting repair Provider retry");
 
     request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("fresh invalid tool-plan request after steer");
     request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("fresh repair request after steer");
     let completed = wait_for_agent_runtime_idle(&root, "design-director");
     assert_eq!(completed.phase, "completed");
@@ -4217,7 +4217,7 @@ async fn provider_retry_waiting_exhaustion_fails_and_removes_sidecar() {
     )
     .expect("start exhausted Provider retry task");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first physical Provider request");
     wait_for_agent_runtime_phase(&root, "design-director", "waiting-for-provider-retry");
     let retry = crate::provider_retry::read_for_run_at(&root, "design-director", run_id)
@@ -4227,7 +4227,7 @@ async fn provider_retry_waiting_exhaustion_fails_and_removes_sidecar() {
         .expect("force exhausted Provider retry due");
     resume_game_creator_agent_background_tasks_at(&root).expect("resume exhausted Provider retry");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("last allowed physical Provider request");
     let failed = wait_for_agent_runtime_idle(&root, "design-director");
     assert_eq!(failed.phase, "failed");
@@ -4356,7 +4356,7 @@ async fn provider_retry_waiting_releases_other_agent_and_preserves_same_lane_fif
     )
     .expect("start waiting design task");
     design_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first design Provider request");
     wait_for_agent_runtime_phase(&root, "design-director", "waiting-for-provider-retry");
 
@@ -4391,7 +4391,7 @@ async fn provider_retry_waiting_releases_other_agent_and_preserves_same_lane_fif
     cancel_game_creator_agent_runtime_task_at(&root, "design-director", waiting_run_id)
         .expect("cancel waiting design task and drain queue");
     design_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("queued same-lane task starts after cancellation");
     let design_completed = wait_for_agent_runtime_idle(&root, "design-director");
     assert_eq!(design_completed.run_id, queued_run_id);
@@ -4446,7 +4446,7 @@ async fn provider_transient_retry_zero_max_retries_stops_after_first_failure() {
     .expect("start zero retry task");
 
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("first physical Provider request");
     let runtime = wait_for_agent_runtime_terminal_and_lane_release(
         &root,
@@ -4516,7 +4516,7 @@ async fn provider_transient_retry_provider_error_is_not_retried() {
     .expect("start non-transient Provider error task");
 
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("Provider error request");
     let runtime = wait_for_agent_runtime_idle(&root, "design-director");
     assert_eq!(runtime.phase, "failed");
@@ -5138,7 +5138,7 @@ async fn provider_transient_retry_backoff_is_exponential_and_capped_at_thirty_se
     .expect("start exponential backoff task");
     for _ in 0..4 {
         request_notice_receiver
-            .recv_timeout(Duration::from_secs(5))
+            .recv_timeout(Duration::from_secs(30))
             .expect("exponential backoff physical Provider request");
     }
     let runtime = wait_for_agent_runtime_idle(&root, "design-director");
@@ -5725,7 +5725,7 @@ async fn background_agent_runtime_reuses_terminal_image_inspect_receipt_without_
 
     resume_game_creator_agent_background_tasks_at(&root).expect("resume image inspect recovery");
     let request = receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("replan from existing image observation");
     assert!(request.contains(conclusion));
     assert!(!request.contains("\"type\":\"input_image\""));

apps/ai-game-creator-shell/src-tauri/src/tests/response_stream.rs

@@ -514,7 +514,7 @@ async fn response_stream_private_process_output_is_never_published_or_committed_
     });
 
     mock.first_delta_written
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("private Provider first raw delta");
     let streaming =
         wait_for_response_stream_status(&root, "code-prototype", run_id, "streaming", 0);
@@ -659,7 +659,7 @@ async fn response_stream_final_disconnect_with_retry_disabled_fails_without_comm
     .expect("start final stream single-attempt task");
 
     mock.first_delta_written
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("final stream request reached disconnect boundary");
     let finalization_lock = acquire_project_write_lock(
         &root,
@@ -2675,7 +2675,7 @@ async fn background_finalization_replans_same_run_after_cross_agent_revision_dri
         .expect("release stale final reply response");
 
     let replanned_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("same run replanning request");
     assert!(replanned_request.contains(run_id));
     assert!(replanned_request.contains(&session_id));
@@ -2693,7 +2693,7 @@ async fn background_finalization_replans_same_run_after_cross_agent_revision_dri
     assert!(verified_request.contains("project.verify"));
     assert!(verified_request.contains("AGENT_RUNTIME_CURRENT_REVISION_OK"));
     let current_final_reply_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("current final reply request");
     assert!(current_final_reply_request.contains(run_id));
 
@@ -2828,7 +2828,7 @@ async fn read_only_background_finalization_replans_when_reply_revision_becomes_s
         .expect("release stale read-only final reply");
 
     let replanned_request = request_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("read-only same-run replanning request");
     assert!(replanned_request.contains(run_id));
     assert!(replanned_request.contains(&session_id));
@@ -3106,7 +3106,7 @@ async fn provider_retry_waiting_final_reply_restart_commits_once() {
 
     for _ in 0..2 {
         request_notice_receiver
-            .recv_timeout(Duration::from_secs(5))
+            .recv_timeout(Duration::from_secs(30))
             .expect("expected physical Provider request");
     }
     let mut retry = None;
@@ -3143,7 +3143,7 @@ async fn provider_retry_waiting_final_reply_restart_commits_once() {
         .is_err());
 
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("final reply Provider retry must wake at its durable deadline");
     server_handle
         .join()
@@ -3151,7 +3151,7 @@ async fn provider_retry_waiting_final_reply_restart_commits_once() {
     let captured_requests = (0..3)
         .map(|_| {
             request_capture_receiver
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("captured Provider request")
         })
         .collect::<Vec<_>>();
@@ -3388,14 +3388,14 @@ async fn provider_retry_waiting_final_reply_compaction_resumes_without_new_tool_
     .expect("start final compaction retry task");
 
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("initial tool-plan request");
     let updated_config = load_game_creator_app_config().expect("load final compaction config");
     let updated_llm = resolve_game_creator_llm_config_for_agent(&updated_config, agent_id);
     assert!(updated_llm.stream);
     assert_eq!(updated_llm.auto_compact_token_limit, 8_000);
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("failed final-reply context compaction request");
     let mut retry = None;
     for _ in 0..250 {
@@ -3427,10 +3427,10 @@ async fn provider_retry_waiting_final_reply_compaction_resumes_without_new_tool_
         .is_err());
 
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("retried final-reply context compaction request");
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("final reply request after recovered compaction");
     server_handle
         .join()
@@ -3438,7 +3438,7 @@ async fn provider_retry_waiting_final_reply_compaction_resumes_without_new_tool_
     let captured_requests = (0..4)
         .map(|_| {
             request_capture_receiver
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("captured final compaction Provider request")
         })
         .collect::<Vec<_>>();
@@ -3687,7 +3687,7 @@ async fn provider_handoff_final_reply_restart_replays_success_without_network_re
 
     for _ in 0..3 {
         request_notice_receiver
-            .recv_timeout(Duration::from_secs(5))
+            .recv_timeout(Duration::from_secs(30))
             .expect("expected Provider request before final reply handoff stop");
     }
     let handoff = wait_for_provider_handoff_test_stop(&root, agent_id, run_id);
@@ -3747,7 +3747,7 @@ async fn provider_handoff_final_reply_restart_replays_success_without_network_re
     let captured_requests = (0..3)
         .map(|_| {
             request_capture_receiver
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("captured Provider request before handoff replay")
         })
         .collect::<Vec<_>>();
@@ -3922,7 +3922,7 @@ async fn project_execution_owner_cross_boot_replays_same_run_provider_handoff_to
 
     for _ in 0..3 {
         request_notice_receiver
-            .recv_timeout(Duration::from_secs(5))
+            .recv_timeout(Duration::from_secs(30))
             .expect("Provider request before simulated old Runner exit");
     }
     let handoff = wait_for_provider_handoff_test_stop(&root, agent_id, run_id);
@@ -3930,7 +3930,7 @@ async fn project_execution_owner_cross_boot_replays_same_run_provider_handoff_to
     let captured_requests = (0..3)
         .map(|_| {
             request_capture_receiver
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("captured Provider request before ownership transfer")
         })
         .collect::<Vec<_>>();
@@ -4116,7 +4116,7 @@ async fn provider_handoff_final_reply_compaction_restart_only_requests_final_rep
 
     for _ in 0..3 {
         request_notice_receiver
-            .recv_timeout(Duration::from_secs(5))
+            .recv_timeout(Duration::from_secs(30))
             .expect("expected Provider request before compaction handoff stop");
     }
     let handoff = wait_for_provider_handoff_test_stop(&root, agent_id, run_id);
@@ -4156,7 +4156,7 @@ async fn provider_handoff_final_reply_compaction_restart_only_requests_final_rep
         .expect("resume final compaction Provider handoff");
     assert_eq!(resumed.len(), 1);
     request_notice_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("only necessary final reply request after compaction handoff replay");
     server_handle
         .join()
@@ -4164,7 +4164,7 @@ async fn provider_handoff_final_reply_compaction_restart_only_requests_final_rep
     let captured_requests = (0..4)
         .map(|_| {
             request_capture_receiver
-                .recv_timeout(Duration::from_secs(5))
+                .recv_timeout(Duration::from_secs(30))
                 .expect("captured final compaction handoff Provider request")
         })
         .collect::<Vec<_>>();

apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/recovery.rs

@@ -1830,7 +1830,7 @@ async fn background_agent_runtime_repairs_terminal_receipt_through_reconciliatio
 
     resume_game_creator_agent_background_tasks_at(&root).expect("resume receipt repair");
     let request = receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("replan after receipt repair");
     assert!(request.contains("已读取项目文件摘要，恢复时不得重放"));
     let runtime = wait_for_agent_runtime_terminal_and_lane_release(

apps/ai-game-creator-shell/src-tauri/src/tests/sessions.rs

@@ -1651,13 +1651,13 @@ fn agent_conversation_session_fork_is_linearizable_with_default_session_enqueue(
             || {
                 lane_ready_sender.send(()).expect("signal lane acquired");
                 lane_release_receiver
-                    .recv_timeout(Duration::from_secs(5))
+                    .recv_timeout(Duration::from_secs(30))
                     .expect("release runtime enqueue");
             },
         )
     });
     lane_ready_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("runtime acquired session lane");
 
     let (fork_sender, fork_receiver) = mpsc::channel();
@@ -1687,7 +1687,7 @@ fn agent_conversation_session_fork_is_linearizable_with_default_session_enqueue(
         Some("fork-linearizable-run")
     );
     let fork_error = fork_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("receive blocked fork")
         .expect_err("queued runtime must block fork");
     fork_thread.join().expect("join fork thread");
@@ -1825,13 +1825,13 @@ fn agent_conversation_session_list_hides_uncommitted_fork_file() {
                     .send(())
                     .expect("signal fork file written");
                 hook_release_receiver
-                    .recv_timeout(Duration::from_secs(5))
+                    .recv_timeout(Duration::from_secs(30))
                     .expect("release catalog write");
             },
         )
     });
     hook_ready_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("fork reached catalog write hook");
 
     let (list_sender, list_receiver) = mpsc::channel();
@@ -1854,7 +1854,7 @@ fn agent_conversation_session_list_hides_uncommitted_fork_file() {
         .expect("join fork thread")
         .expect("commit fork");
     let listed = list_receiver
-        .recv_timeout(Duration::from_secs(5))
+        .recv_timeout(Duration::from_secs(30))
         .expect("receive committed session list")
         .expect("list committed sessions");
     list_thread.join().expect("join list thread");