From 81d9252b6b49256ef37f20261016d59b83769929 Mon Sep 17 00:00:00 2001
From: AIGameCreator App <dsk@genarrative.world>
Date: Tue, 21 Jul 2026 16:18:35 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E8=87=AA=E4=B8=BB=E6=9E=84?=
 =?UTF-8?q?=E5=BB=BA=E4=BA=A4=E4=BB=98=E4=B8=8E=E8=AF=95=E7=8E=A9=E6=94=B6?=
 =?UTF-8?q?=E6=95=9B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修复截断 scaffold 强制小范围补丁并提高修复输出预算
修复验证后并行读取批次快照不一致
收窄已验证交付并支持总控验收专业产物 revision
补充自主构建、Provider 批次和试玩验证门回归测试
---
 .../src-tauri/src/agent.rs                    | 232 +++++-
 .../src-tauri/src/tests.rs                    | 700 ++++++++++++++++++
 2 files changed, 897 insertions(+), 35 deletions(-)

diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent.rs b/apps/ai-game-creator-shell/src-tauri/src/agent.rs
index 00d1635fd..7e6382cb6 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent.rs
@@ -7984,9 +7984,35 @@ async fn run_game_creator_agent_background_task_pass_with_context(
             plan = requested_plan.plan;
             if runtime.run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
                 && !plan.response.trim().is_empty()
-                && agent_runtime_task_requires_read_only_delivery(&agent_id, &task)
             {
-                plan.plan_update = agent_runtime_read_only_delivery_completion_plan_update(&runtime);
+                let read_only_delivery =
+                    agent_runtime_task_requires_read_only_delivery(&agent_id, &task);
+                let verification_gate = read_game_creator_agent_runtime_verification_gate(
+                    &root,
+                    &agent_id,
+                    &runtime.run_id,
+                );
+                let verified_delivery = match verification_gate {
+                    Ok(gate) => agent_runtime_autonomous_verified_delivery_allows_plan_completion(
+                        &agent_id, &gate,
+                    ),
+                    Err(error) => {
+                        return fail_game_creator_agent_background_context_at(
+                            &root,
+                            &agent_id,
+                            &session_id,
+                            runtime,
+                            &format!("读取自主构建交付验证门失败：{error}"),
+                        );
+                    }
+                };
+                plan.plan_update = if read_only_delivery {
+                    agent_runtime_read_only_delivery_completion_plan_update(&runtime)
+                } else if verified_delivery {
+                    agent_runtime_verified_delivery_completion_plan_update(&runtime)
+                } else {
+                    plan.plan_update
+                };
             }
             if plan.actions.iter().any(|action| {
                 action.tool == GAME_CREATOR_MCP_CALL_TOOL
@@ -10381,6 +10407,7 @@ pub(crate) const AGENT_RUNTIME_AUTONOMOUS_PROVIDER_UPSTREAM_400_RETRY_LIMIT: u32
 const AGENT_RUNTIME_AUTONOMOUS_TOOL_PLAN_FORMAT_REPAIR_ATTEMPTS: usize = 4;
 const AGENT_RUNTIME_AUTONOMOUS_FORCED_ACTION_MAX_OUTPUT_TOKENS: u32 = 2_000;
 pub(crate) const AGENT_RUNTIME_AUTONOMOUS_SCAFFOLD_MAX_OUTPUT_TOKENS: u32 = 2_600;
+pub(crate) const AGENT_RUNTIME_AUTONOMOUS_TRUNCATED_SCAFFOLD_MAX_OUTPUT_TOKENS: u32 = 8_000;
 const AGENT_RUNTIME_AUTONOMOUS_SCAFFOLD_SOURCE_MAX_CHARS: usize = 6_000;
 pub(crate) const AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT: usize = 4;
 pub(crate) const AGENT_RUNTIME_AUTONOMOUS_LIVENESS_OBSERVATION_LIMIT: usize = 3;
@@ -10396,6 +10423,8 @@ const AGENT_RUNTIME_AUTONOMOUS_FAILED_PLAYTEST_LIVENESS_ERROR_PREFIX: &str =
     "自主构建 Project Supervisor 的最近一次交互试玩仍未通过";
 const AGENT_RUNTIME_AUTONOMOUS_RESPONSE_PLAN_LIVENESS_ERROR_PREFIX: &str =
     "自主构建专业 Agent 已给出结论但结构化计划仍未完成";
+const AGENT_RUNTIME_AUTONOMOUS_TRUNCATED_SCAFFOLD_ERROR_PREFIX: &str =
+    "自主构建完整写入 game/index.html 时必须提交闭合且可运行的 HTML";
 const AGENT_RUNTIME_QUALITY_REVIEW_AGENT_ID: &str = "quality-review";
 const AGENT_RUNTIME_SUPERVISOR_INITIAL_COLLABORATION_LIVENESS_ERROR_PREFIX: &str =
     "Project Supervisor 首批协作在首个 planning 窗口内未建立";
@@ -20486,6 +20515,16 @@ fn prepare_and_execute_game_creator_agent_runtime_parallel_read_batch_blocking(
         }
         pending_actions.push(pending);
     }
+    if provider_batch.is_some() {
+        let current_cursor_gate = pending_actions
+            .first()
+            .ok_or_else(|| "Provider action 批次缺少只读并行 cursor 成员".to_string())?
+            .verification_gate_before
+            .clone();
+        for pending in &mut pending_actions {
+            pending.verification_gate_before = current_cursor_gate.clone();
+        }
+    }
     let project_id = game_creator_agent_runtime_context_project_id(&root)?;
     let batch_id = agent_runtime_parallel_read_batch_id(
         &project_id,
@@ -21429,6 +21468,13 @@ pub(crate) fn finish_agent_runtime_project_verification_locked(
     gate.verified_revision = passed
         .then_some(current_revision.revision)
         .filter(|value| *value > 0);
+    if passed
+        && gate
+            .failed_playtest_revision
+            .is_some_and(|failed_revision| failed_revision < current_revision.revision)
+    {
+        gate.failed_playtest_revision = None;
+    }
     if passed && verification_tool.as_deref() == Some("preview.validate") {
         gate.failed_playtest_revision = None;
     }
@@ -21451,7 +21497,7 @@ pub(crate) fn finish_agent_runtime_project_verification_locked(
     Ok(())
 }
 
-fn clear_agent_runtime_failed_playtest_at(
+pub(crate) fn clear_agent_runtime_failed_playtest_at(
     root: &Path,
     agent_id: &str,
     run_id: &str,
@@ -21467,7 +21513,12 @@ fn clear_agent_runtime_failed_playtest_at(
         ));
     }
     let mut gate = read_game_creator_agent_runtime_verification_gate(root, agent_id, run_id)?;
-    if gate.mutation_revision != Some(expected_revision) {
+    let owns_current_mutation = gate.mutation_revision == Some(expected_revision);
+    let supervisor_verified_current_revision = agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+        && gate.verified_revision == Some(expected_revision)
+        && gate.last_verification_status.as_deref()
+            == Some(AGENT_RUNTIME_VERIFICATION_STATUS_PASSED);
+    if !owns_current_mutation && !supervisor_verified_current_revision {
         return Err("浏览器试玩通过时没有当前 revision 的项目修改凭证".to_string());
     }
     gate.failed_playtest_revision = None;
@@ -21491,10 +21542,21 @@ pub(crate) fn invalidate_agent_runtime_project_verification_after_preview_failur
         ));
     }
     let mut gate = read_game_creator_agent_runtime_verification_gate(root, agent_id, run_id)?;
-    if gate.mutation_revision != Some(expected_revision) {
+    let owns_current_mutation = gate.mutation_revision == Some(expected_revision);
+    let supervisor_verified_current_revision = agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+        && gate.verified_revision == Some(expected_revision)
+        && gate.last_verification_status.as_deref()
+            == Some(AGENT_RUNTIME_VERIFICATION_STATUS_PASSED);
+    if !owns_current_mutation && !supervisor_verified_current_revision {
         return Err("浏览器试玩失败时没有当前 revision 的项目修改凭证".to_string());
     }
-    gate.requires_verification = true;
+    if owns_current_mutation {
+        gate.requires_verification = true;
+    } else {
+        gate.requires_verification = false;
+        gate.mutation_revision = None;
+        gate.last_mutation_tool = None;
+    }
     gate.verified_revision = None;
     gate.last_verification_tool = Some("preview.validate".to_string());
     gate.last_verification_status = Some(AGENT_RUNTIME_VERIFICATION_STATUS_FAILED.to_string());
@@ -24641,6 +24703,17 @@ async fn request_game_creator_agent_background_tool_plan_at(
     };
     let read_only_delivery = run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
         && agent_runtime_task_requires_read_only_delivery(agent_id, task);
+    let verified_delivery = if run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD {
+        let verification_gate =
+            read_game_creator_agent_runtime_verification_gate(root, agent_id, run_id)?;
+        agent_runtime_autonomous_verified_delivery_allows_plan_completion(
+            agent_id,
+            &verification_gate,
+        )
+    } else {
+        false
+    };
+    let allow_runtime_plan_completion = read_only_delivery || verified_delivery;
     let mut autonomous_scaffold_repair_active = false;
     for repair_attempt in 0..=format_repair_attempts {
         if game_creator_agent_runtime_cancel_requested_for(root, agent_id, run_id) {
@@ -24765,7 +24838,7 @@ async fn request_game_creator_agent_background_tool_plan_at(
                     root,
                     agent_id,
                     session_id,
-                    read_only_delivery,
+                    allow_runtime_plan_completion,
                     &parsed.plan,
                 )
                 .map_err(|error| {
@@ -24786,9 +24859,12 @@ async fn request_game_creator_agent_background_tool_plan_at(
             {
                 let verification_gate =
                     read_game_creator_agent_runtime_verification_gate(root, agent_id, run_id)?;
+                let project_revision =
+                    read_game_creator_agent_runtime_project_revision(root)?.revision;
                 match validate_agent_runtime_autonomous_plan_liveness(
                     agent_id,
                     loop_index,
+                    project_revision,
                     &verification_gate,
                     observations,
                     &parsed.plan,
@@ -25029,6 +25105,11 @@ async fn request_game_creator_agent_background_tool_plan_at(
                         AGENT_RUNTIME_AUTONOMOUS_RESPONSE_PLAN_LIVENESS_ERROR_PREFIX,
                     )
                     && !request.function_tools.is_empty();
+                let force_autonomous_truncated_scaffold = run_profile
+                    == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
+                    && protocol_error
+                        .starts_with(AGENT_RUNTIME_AUTONOMOUS_TRUNCATED_SCAFFOLD_ERROR_PREFIX)
+                    && !request.function_tools.is_empty();
                 let force_supervisor_initial_collaboration =
                     agent_runtime_protocol_error_requires_supervisor_collaboration_repair(
                         &protocol_error,
@@ -25039,6 +25120,7 @@ async fn request_game_creator_agent_background_tool_plan_at(
                     || force_autonomous_pending_verification
                     || force_autonomous_reverify_after_mutation
                     || force_autonomous_verified_delivery
+                    || force_autonomous_truncated_scaffold
                     || force_autonomous_pre_mutation
                 {
                     request.function_tools =
@@ -25070,9 +25152,17 @@ async fn request_game_creator_agent_background_tool_plan_at(
                         "上一条输出不符合工具计划协议：{protocol_error}\n本次修复的原生工具目录已收窄。必须直接调用实际项目修改工具修复已知问题，或在项目已经满足要求时立即调用 project.verify / command.run_limited 取得当前 revision 的通过凭证。不得只更新计划、读取、搜索、查询状态或 respond_to_user。源码仍须遵守单字段 {AGENT_RUNTIME_AUTONOMOUS_SOURCE_FIELD_MAX_CHARS} 字符和单轮总计 {AGENT_RUNTIME_AUTONOMOUS_SOURCE_TOTAL_MAX_CHARS} 字符上限；优先使用小范围 file.patch。不要解释，不要 markdown，不要代码围栏。"
                     )));
                 } else if force_autonomous_verified_delivery {
-                    restrict_agent_runtime_autonomous_liveness_repair_tools(&mut request)?;
+                    restrict_agent_runtime_autonomous_verified_delivery_repair_tools(&mut request)?;
                     request.messages.push(LlmMessage::user(format!(
-                        "上一条输出不符合工具计划协议：{protocol_error}\n当前 revision 已通过验证。本次修复必须直接调用 respond_to_user 交付专业合同结论；只有确有阻塞性交付缺口时才调用一个实际项目修改工具并使验证凭证失效。不得继续只更新计划、读取、搜索或查询状态。不要解释，不要 markdown，不要代码围栏。"
+                        "上一条输出不符合工具计划协议：{protocol_error}\n当前 revision 已通过验证。本次修复的原生工具目录只保留 respond_to_user；必须立即调用它交付专业合同结论，Runtime 会使用当前验证凭证收束结构化计划。不得更新计划、读取、搜索、查询状态、修改项目或解释。不要 markdown，不要代码围栏。"
+                    )));
+                } else if force_autonomous_truncated_scaffold {
+                    autonomous_scaffold_repair_active = true;
+                    restrict_agent_runtime_autonomous_truncated_scaffold_repair_tools(
+                        &mut request,
+                    )?;
+                    request.messages.push(LlmMessage::user(format!(
+                        "上一条输出不符合工具计划协议：{protocol_error}\n无效的完整写入已被拒绝，现有 game/index.html 仍保持闭合且未修改。本次修复的原生工具目录只保留 file.patch；必须使用之前 file.read / project.search observation 中的短小精确原文作为 oldText，将一个可独立运行的小功能补丁插入现有文档，保留已有 </script> 与 </html>，不能再次完整重写文件。newText 不得超过 {AGENT_RUNTIME_AUTONOMOUS_SCAFFOLD_SOURCE_MAX_CHARS} 字符，且本轮结束后的 HTML 和 JavaScript 必须完整闭合；其余功能留到后续 planning 继续小步 patch。不要解释，不要 markdown，不要代码围栏。"
                     )));
                 } else if force_autonomous_read_only_delivery {
                     restrict_agent_runtime_autonomous_read_only_delivery_repair_tools(
@@ -28253,6 +28343,7 @@ fn validate_agent_runtime_autonomous_response_plan_completion(
 fn validate_agent_runtime_autonomous_plan_liveness(
     agent_id: &str,
     loop_index: usize,
+    project_revision: u64,
     verification_gate: &AgentRuntimeVerificationGate,
     observations: &[AgentRuntimeToolObservation],
     plan: &AgentRuntimeToolPlan,
@@ -28261,21 +28352,30 @@ fn validate_agent_runtime_autonomous_plan_liveness(
         .actions
         .iter()
         .any(|action| is_supervisor_orchestrator_project_mutation_tool(&action.tool));
+    let has_verification = plan.actions.iter().any(|action| {
+        matches!(
+            action.tool.trim(),
+            "project.verify" | "command.run_limited" | "command.exec"
+        )
+    });
     if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
-        if verification_gate
-            .failed_playtest_revision
-            .zip(verification_gate.mutation_revision)
-            .is_some_and(|(failed_playtest_revision, mutation_revision)| {
-                failed_playtest_revision == mutation_revision
-            })
-            && !has_mutation
-        {
-            return Err(format!(
-                "{AGENT_RUNTIME_AUTONOMOUS_FAILED_PLAYTEST_LIVENESS_ERROR_PREFIX}；持久验证门仍标记 revision {} 的试玩失败，即使上下文压缩后也必须根据最近一次试玩诊断直接修改 game/index.html；不得继续只更新计划、读取、搜索、重复验证、查询状态、委派或返回最终回复",
-                verification_gate
-                    .failed_playtest_revision
-                    .unwrap_or_default()
-            ));
+        if let Some(failed_playtest_revision) = verification_gate.failed_playtest_revision {
+            if project_revision < failed_playtest_revision {
+                return Err("自主构建持久试玩失败 revision 晚于当前项目 revision".to_string());
+            }
+            if project_revision > failed_playtest_revision {
+                if has_mutation || has_verification {
+                    return Ok(());
+                }
+                return Err(format!(
+                    "{AGENT_RUNTIME_AUTONOMOUS_REVERIFY_AFTER_MUTATION_LIVENESS_ERROR_PREFIX}；试玩失败后项目已从 revision {failed_playtest_revision} 推进到 {project_revision}，必须先验证当前 revision，才能重新执行 preview.validate；不得继续只更新计划、读取、搜索、查询状态、委派或返回最终回复"
+                ));
+            }
+            if !has_mutation {
+                return Err(format!(
+                    "{AGENT_RUNTIME_AUTONOMOUS_FAILED_PLAYTEST_LIVENESS_ERROR_PREFIX}；持久验证门仍标记 revision {failed_playtest_revision} 的试玩失败，即使上下文压缩后也必须根据最近一次试玩诊断直接修改 game/index.html；不得继续只更新计划、读取、搜索、重复验证、查询状态、委派或返回最终回复"
+                ));
+            }
         }
         let Some(failed_playtest_index) = observations.iter().rposition(|observation| {
             observation.tool == "preview.validate"
@@ -28299,12 +28399,6 @@ fn validate_agent_runtime_autonomous_plan_liveness(
             observations_after_failure.len()
         ));
     }
-    let has_verification = plan.actions.iter().any(|action| {
-        matches!(
-            action.tool.trim(),
-            "project.verify" | "command.run_limited" | "command.exec"
-        )
-    });
     let latest_mutation_index = observations
         .iter()
         .rposition(is_agent_runtime_project_mutation_observation);
@@ -28343,11 +28437,10 @@ fn validate_agent_runtime_autonomous_plan_liveness(
             "{error_prefix}；最近一次修改或验证后已有 {trailing_non_progress} 条非推进观察，本响应仍未提交项目修改或验证动作。请根据当前 revision 立即修复或验证；不得继续只更新计划、读取、搜索、查询状态或返回最终回复"
         ));
     }
-    if mutation_revision.is_some()
-        && verified_revision == mutation_revision
-        && verification_gate.last_verification_status.as_deref()
-            == Some(AGENT_RUNTIME_VERIFICATION_STATUS_PASSED)
-    {
+    if agent_runtime_autonomous_verified_delivery_allows_plan_completion(
+        agent_id,
+        verification_gate,
+    ) {
         if has_mutation
             || !plan.response.trim().is_empty()
             || trailing_non_progress < AGENT_RUNTIME_AUTONOMOUS_LIVENESS_OBSERVATION_LIMIT
@@ -28370,6 +28463,17 @@ fn validate_agent_runtime_autonomous_plan_liveness(
     ))
 }
 
+fn agent_runtime_autonomous_verified_delivery_allows_plan_completion(
+    agent_id: &str,
+    verification_gate: &AgentRuntimeVerificationGate,
+) -> bool {
+    agent_id != GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+        && verification_gate.mutation_revision.is_some()
+        && verification_gate.verified_revision == verification_gate.mutation_revision
+        && verification_gate.last_verification_status.as_deref()
+            == Some(AGENT_RUNTIME_VERIFICATION_STATUS_PASSED)
+}
+
 fn agent_runtime_task_requires_read_only_delivery(agent_id: &str, task: &str) -> bool {
     let normalized = task.to_ascii_lowercase();
     let explicitly_read_only = [
@@ -28417,6 +28521,22 @@ fn agent_runtime_task_requires_read_only_delivery(agent_id: &str, task: &str) ->
 
 pub(crate) fn agent_runtime_read_only_delivery_completion_plan_update(
     runtime: &AgentRuntimeState,
+) -> Option<AgentRuntimePlanUpdate> {
+    agent_runtime_delivery_completion_plan_update(runtime, "只读合同结论和证据已经交付")
+}
+
+pub(crate) fn agent_runtime_verified_delivery_completion_plan_update(
+    runtime: &AgentRuntimeState,
+) -> Option<AgentRuntimePlanUpdate> {
+    agent_runtime_delivery_completion_plan_update(
+        runtime,
+        "当前 revision 已通过验证，专业合同结论已经交付",
+    )
+}
+
+fn agent_runtime_delivery_completion_plan_update(
+    runtime: &AgentRuntimeState,
+    fallback_explanation: &str,
 ) -> Option<AgentRuntimePlanUpdate> {
     if !agent_runtime_has_structured_plan(runtime)
         || runtime
@@ -28432,7 +28552,7 @@ pub(crate) fn agent_runtime_read_only_delivery_completion_plan_update(
     }
     Some(AgentRuntimePlanUpdate {
         explanation: if runtime.plan_explanation.trim().is_empty() {
-            "只读合同结论和证据已经交付".to_string()
+            fallback_explanation.to_string()
         } else {
             runtime.plan_explanation.clone()
         },
@@ -28494,6 +28614,24 @@ fn restrict_agent_runtime_autonomous_read_only_delivery_repair_tools(
     Ok(())
 }
 
+fn restrict_agent_runtime_autonomous_verified_delivery_repair_tools(
+    request: &mut LlmRunRequest,
+) -> Result<(), String> {
+    request
+        .function_tools
+        .retain(|tool| tool.name == AGENT_RUNTIME_RESPOND_FUNCTION_NAME);
+    if request.function_tools.len() != 1 {
+        return Err("autonomous 已验证交付修复工具目录缺少 respond_to_user".to_string());
+    }
+    request.max_output_tokens = Some(
+        request
+            .max_output_tokens
+            .unwrap_or(AGENT_RUNTIME_AUTONOMOUS_FORCED_ACTION_MAX_OUTPUT_TOKENS)
+            .min(AGENT_RUNTIME_AUTONOMOUS_FORCED_ACTION_MAX_OUTPUT_TOKENS),
+    );
+    Ok(())
+}
+
 fn restrict_agent_runtime_autonomous_liveness_repair_tools(
     request: &mut LlmRunRequest,
 ) -> Result<(), String> {
@@ -28534,6 +28672,30 @@ fn restrict_agent_runtime_autonomous_liveness_repair_tools(
     Ok(())
 }
 
+fn restrict_agent_runtime_autonomous_truncated_scaffold_repair_tools(
+    request: &mut LlmRunRequest,
+) -> Result<(), String> {
+    let patch_function = native_runtime_function_name("file.patch")
+        .ok_or_else(|| "无法生成 autonomous 截断 scaffold 修复工具名".to_string())?;
+    request
+        .function_tools
+        .retain(|tool| tool.name == patch_function);
+    apply_agent_runtime_autonomous_source_schema_limits_with_max(
+        &mut request.function_tools,
+        AGENT_RUNTIME_AUTONOMOUS_SCAFFOLD_SOURCE_MAX_CHARS,
+    )?;
+    if request.function_tools.len() != 1 {
+        return Err("autonomous 截断 scaffold 修复工具目录缺少 file.patch".to_string());
+    }
+    request.max_output_tokens = Some(
+        request
+            .max_output_tokens
+            .unwrap_or(AGENT_RUNTIME_AUTONOMOUS_TRUNCATED_SCAFFOLD_MAX_OUTPUT_TOKENS)
+            .max(AGENT_RUNTIME_AUTONOMOUS_TRUNCATED_SCAFFOLD_MAX_OUTPUT_TOKENS),
+    );
+    Ok(())
+}
+
 fn restrict_agent_runtime_autonomous_failed_playtest_repair_tools(
     request: &mut LlmRunRequest,
 ) -> Result<(), String> {
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests.rs b/apps/ai-game-creator-shell/src-tauri/src/tests.rs
index 0bc8277bb..8b3d28cd2 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests.rs
@@ -6652,6 +6652,162 @@ async fn autonomous_game_build_repairs_oversized_native_source_payload() {
     fs::remove_dir_all(root).ok();
 }
 
+#[tokio::test]
+async fn autonomous_game_build_repairs_truncated_scaffold_into_bounded_patch() {
+    let root = unique_project_path();
+    init_local_game_project_at(
+        &root,
+        "project-autonomous-truncated-scaffold-repair",
+        "自主截断 scaffold 修复项目",
+    )
+    .expect("project init");
+    write_supervisor_collaboration_policy_at(&root, SupervisorCollaborationPolicy::default())
+        .expect("keep truncated scaffold fixture collaboration-neutral");
+    let (sender, receiver) = mpsc::channel();
+    let write_function = native_runtime_function_name("file.write").expect("write function");
+    let patch_function = native_runtime_function_name("file.patch").expect("patch function");
+    let truncated_arguments = serde_json::json!({
+        "reason": "先写入游戏入口",
+        "input": {
+            "path": "game/index.html",
+            "content": "<!doctype html><html><body><canvas id=\"game\"></canvas><script>requestAnimationFrame(()=>{});"
+        }
+    })
+    .to_string();
+    let repaired_arguments = serde_json::json!({
+        "reason": "在现有闭合入口中补入可运行控件",
+        "input": {
+            "path": "game/index.html",
+            "oldText": "<body>",
+            "newText": "<body><button data-playtest-id=\"start\">开始</button>",
+            "expectedReplacements": 1
+        }
+    })
+    .to_string();
+    let base_url = spawn_mock_llm_raw_responses_with_capture(
+        vec![
+            native_agent_tool_plan_chat_response(
+                "call-autonomous-truncated-scaffold",
+                &write_function,
+                truncated_arguments,
+            ),
+            native_agent_tool_plan_chat_response(
+                "call-autonomous-truncated-scaffold-patch",
+                &patch_function,
+                repaired_arguments,
+            ),
+        ],
+        Some(sender),
+    );
+    let _config_guard = write_test_local_config(format!(
+        r#"{{
+  "agentLlm": {{
+    "project-supervisor": {{
+      "apiKey": "autonomous-truncated-scaffold-repair-key",
+      "baseUrl": {base_url:?},
+      "model": "autonomous-truncated-scaffold-repair-model",
+      "apiKind": "openai_chat",
+      "maxRetries": 0
+    }}
+  }}
+}}"#
+    ));
+    let run_id = "autonomous-truncated-scaffold-repair-run";
+    bind_game_creator_agent_runtime_run_profile_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        run_id,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+        None,
+    )
+    .expect("bind autonomous profile");
+    let runtime = start_game_creator_agent_runtime_task_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        "将截断入口修复为可继续扩展的游戏 scaffold",
+        run_id,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        "修复截断 scaffold",
+        vec!["保留闭合 HTML 并继续实现".to_string()],
+    )
+    .expect("start autonomous runtime");
+
+    let plan = request_game_creator_agent_background_tool_plan_for_test(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        &runtime.session_id,
+        run_id,
+        &runtime.current_task,
+        &[],
+        1,
+        0,
+    )
+    .await
+    .expect("repair truncated autonomous scaffold")
+    .expect("repaired autonomous patch plan");
+    assert_eq!(plan.actions.len(), 1);
+    assert_eq!(plan.actions[0].tool, "file.patch");
+
+    let initial_request = receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("initial truncated scaffold request");
+    assert!(initial_request.contains("闭合的 <script> 和 </html>"));
+    let repair_request = receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("truncated scaffold repair request");
+    assert!(repair_request.contains("只保留 file.patch"));
+    assert!(repair_request.contains("不能再次完整重写文件"));
+    let repair_request_json = mock_http_request_json(&repair_request);
+    let repair_function_names = repair_request_json["tools"]
+        .as_array()
+        .expect("restricted truncated scaffold tools")
+        .iter()
+        .filter_map(|tool| {
+            tool.get("name")
+                .and_then(serde_json::Value::as_str)
+                .or_else(|| {
+                    tool.get("function")
+                        .and_then(|function| function.get("name"))
+                        .and_then(serde_json::Value::as_str)
+                })
+        })
+        .collect::<BTreeSet<_>>();
+    assert_eq!(
+        repair_function_names,
+        BTreeSet::from([patch_function.as_str()])
+    );
+    assert_eq!(
+        repair_request_json["max_tokens"].as_u64(),
+        Some(AGENT_RUNTIME_AUTONOMOUS_TRUNCATED_SCAFFOLD_MAX_OUTPUT_TOKENS as u64)
+    );
+    assert!(receiver.recv_timeout(Duration::from_millis(200)).is_err());
+
+    let records = read_agent_db_records_for_test(&root);
+    let repairs = records
+        .iter()
+        .filter(|record| {
+            record["recordType"] == "agent.runtime.tool_plan.repair"
+                && record["runId"] == run_id
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(repairs.len(), 1);
+    assert_eq!(repairs[0]["protocolErrorKind"], "plan-semantics");
+    assert_eq!(repairs[0]["maxAttempts"], 4);
+    let protocol = records
+        .iter()
+        .find(|record| {
+            record["recordType"] == "agent.runtime.tool_plan.protocol"
+                && record["runId"] == run_id
+                && record["repairAttempt"] == 1
+        })
+        .expect("truncated scaffold repaired protocol audit");
+    assert_eq!(protocol["autonomousSourcePayloadValidated"], true);
+    assert_eq!(protocol["autonomousSourceMutationActionCount"], 1);
+
+    fs::remove_dir_all(root).ok();
+}
+
 #[tokio::test]
 async fn autonomous_game_build_repairs_pre_mutation_read_loop_into_action() {
     let root = unique_project_path();
@@ -7222,6 +7378,196 @@ async fn autonomous_game_build_repairs_explicit_read_only_loop_into_completed_de
     fs::remove_dir_all(root).ok();
 }
 
+#[tokio::test]
+async fn autonomous_game_build_verified_revision_forces_response_only_delivery() {
+    let root = unique_project_path();
+    init_local_game_project_at(
+        &root,
+        "project-autonomous-verified-delivery",
+        "自主构建已验证交付活性测试",
+    )
+    .expect("project init");
+    let parent_run_id = "autonomous-verified-delivery-parent";
+    bind_game_creator_agent_runtime_run_profile_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        parent_run_id,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+        None,
+    )
+    .expect("bind autonomous parent profile");
+    let child_run_id = "autonomous-verified-delivery-child";
+    let child_link = AgentRuntimeTaskLink {
+        parent_agent_id: Some(GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID.to_string()),
+        parent_run_id: Some(parent_run_id.to_string()),
+        delegation_id: Some("autonomous-verified-delivery".to_string()),
+    };
+    bind_game_creator_agent_runtime_run_profile_at(
+        &root,
+        "code-prototype",
+        child_run_id,
+        "agent-delegate",
+        None,
+        Some(&child_link),
+    )
+    .expect("bind autonomous child profile");
+
+    let incomplete_plan = serde_json::json!({
+        "explanation": "实现和验证已完成，准备交付",
+        "steps": [
+            {"step": "完成实现", "status": "completed"},
+            {"step": "验证原型", "status": "completed"},
+            {"step": "交付结论", "status": "in_progress"}
+        ]
+    })
+    .to_string();
+    let response = serde_json::json!({
+        "response": "原型已完成当前 revision 验证，可以交由 Supervisor 继续试玩。"
+    })
+    .to_string();
+    let (sender, receiver) = mpsc::channel();
+    let base_url = spawn_mock_llm_raw_responses_with_capture(
+        vec![
+            native_agent_tool_plan_chat_response(
+                "call-autonomous-verified-plan-only",
+                AGENT_RUNTIME_UPDATE_PLAN_FUNCTION_NAME,
+                incomplete_plan,
+            ),
+            native_agent_tool_plan_chat_response(
+                "call-autonomous-verified-response",
+                AGENT_RUNTIME_RESPOND_FUNCTION_NAME,
+                response,
+            ),
+        ],
+        Some(sender),
+    );
+    let _config_guard = write_test_local_config(format!(
+        r#"{{
+  "agentLlm": {{
+    "code-prototype": {{
+      "apiKey": "autonomous-verified-delivery-key",
+      "baseUrl": {base_url:?},
+      "model": "autonomous-verified-delivery-model",
+      "apiKind": "openai_chat",
+      "maxRetries": 0
+    }}
+  }}
+}}"#
+    ));
+    let mut runtime = start_game_creator_agent_runtime_task_at(
+        &root,
+        "code-prototype",
+        "完成可玩原型、验证当前 revision 并交付专业结论",
+        child_run_id,
+        "agent-delegate",
+        "准备已验证交付",
+        vec![
+            "完成实现".to_string(),
+            "验证原型".to_string(),
+            "交付结论".to_string(),
+        ],
+    )
+    .expect("start autonomous verified runtime");
+    apply_agent_runtime_plan_update(
+        &mut runtime,
+        &AgentRuntimePlanUpdate {
+            explanation: "实现和验证已完成，准备交付".to_string(),
+            steps: vec![
+                AgentRuntimePlanUpdateStep {
+                    step: "完成实现".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_COMPLETED.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "验证原型".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_COMPLETED.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "交付结论".to_string(),
+                    status: "in_progress".to_string(),
+                },
+            ],
+        },
+    )
+    .expect("persist verified delivery plan");
+    write_game_creator_agent_runtime_state(&root, &runtime)
+        .expect("write verified delivery runtime");
+    advance_project_revision_for_test(&root, "code-prototype", child_run_id, "file.patch");
+    persist_project_verification_for_test(
+        &root,
+        "code-prototype",
+        child_run_id,
+        "game.static_smoke",
+        true,
+    );
+    let observations = vec![
+        verification_gate_observation("file.patch", "ok", "已更新 game/index.html"),
+        verification_gate_observation(
+            "command.run_limited",
+            "ok",
+            "game.static_smoke 已通过 revision 1",
+        ),
+        verification_gate_observation("file.read", "ok", "已回读入口"),
+        verification_gate_observation("project.search", "ok", "已核对状态合同"),
+        verification_gate_observation("file.list", "ok", "已核对项目文件"),
+    ];
+
+    let plan = request_game_creator_agent_background_tool_plan_for_test(
+        &root,
+        "code-prototype",
+        &runtime.session_id,
+        child_run_id,
+        &runtime.current_task,
+        &observations,
+        10,
+        0,
+    )
+    .await
+    .expect("repair verified delivery liveness")
+    .expect("completed verified delivery plan");
+    assert!(plan.actions.is_empty());
+    assert_eq!(
+        plan.response,
+        "原型已完成当前 revision 验证，可以交由 Supervisor 继续试玩。"
+    );
+
+    receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("initial verified delivery request");
+    let repair_request = receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("verified delivery repair request");
+    assert!(repair_request.contains("当前 revision 已通过验证"));
+    assert!(repair_request.contains("只保留 respond_to_user"));
+    let repair_request_json = mock_http_request_json(&repair_request);
+    let repair_function_names = repair_request_json["tools"]
+        .as_array()
+        .expect("verified delivery repair tools")
+        .iter()
+        .filter_map(|tool| {
+            tool.get("name")
+                .and_then(serde_json::Value::as_str)
+                .or_else(|| {
+                    tool.get("function")
+                        .and_then(|function| function.get("name"))
+                        .and_then(serde_json::Value::as_str)
+                })
+        })
+        .collect::<BTreeSet<_>>();
+    assert_eq!(
+        repair_function_names,
+        BTreeSet::from([AGENT_RUNTIME_RESPOND_FUNCTION_NAME])
+    );
+    let completion_update = agent_runtime_verified_delivery_completion_plan_update(&runtime)
+        .expect("runtime verified delivery completion update");
+    apply_agent_runtime_plan_update(&mut runtime, &completion_update)
+        .expect("apply runtime verified delivery completion update");
+    assert!(structured_plan_completion_blocker(&runtime).is_none());
+    assert!(receiver.recv_timeout(Duration::from_millis(200)).is_err());
+
+    fs::remove_dir_all(root).ok();
+}
+
 #[tokio::test]
 async fn autonomous_game_build_repairs_post_mutation_read_loop_into_verification_action() {
     let root = unique_project_path();
@@ -7769,6 +8115,155 @@ async fn autonomous_game_build_repairs_persisted_failed_playtest_after_context_c
     fs::remove_dir_all(root).ok();
 }
 
+#[tokio::test]
+async fn autonomous_game_build_repairs_new_revision_after_failed_playtest_with_verification() {
+    let root = unique_project_path();
+    init_local_game_project_at(
+        &root,
+        "project-autonomous-supervisor-reverify-new-revision",
+        "自主构建总控新 revision 复验测试",
+    )
+    .expect("project init");
+    write_supervisor_collaboration_policy_at(&root, SupervisorCollaborationPolicy::default())
+        .expect("disable unrelated collaboration preflight");
+    let run_id = "autonomous-supervisor-reverify-new-revision-run";
+    bind_game_creator_agent_runtime_run_profile_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        run_id,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+        None,
+    )
+    .expect("bind autonomous supervisor profile");
+    let runtime = start_game_creator_agent_runtime_task_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        "验收专业 Agent 修复后的新 revision",
+        run_id,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        "重新验证新 revision",
+        vec!["验证当前 revision".to_string(), "重新试玩".to_string()],
+    )
+    .expect("start autonomous supervisor runtime");
+
+    let failed_revision =
+        prepare_agent_runtime_project_mutation_locked(&root, "code-prototype", "child-run-1", "file.write")
+            .expect("record specialist mutation");
+    let (expected_revision, gate) = begin_agent_runtime_project_verification_locked(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        run_id,
+        "game.static_smoke",
+    )
+    .expect("begin supervisor static smoke");
+    finish_agent_runtime_project_verification_locked(&root, &expected_revision, gate, true)
+        .expect("finish supervisor static smoke");
+    invalidate_agent_runtime_project_verification_after_preview_failure_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        run_id,
+        failed_revision,
+    )
+    .expect("persist supervisor failed playtest");
+    let repaired_revision =
+        prepare_agent_runtime_project_mutation_locked(&root, "code-prototype", "child-run-2", "file.patch")
+            .expect("record specialist repair mutation");
+    assert_eq!(repaired_revision, failed_revision + 1);
+
+    let read_arguments =
+        serde_json::json!({"reason": "继续读取而不验证", "input": {}}).to_string();
+    let verify_arguments = serde_json::json!({
+        "reason": "专业 Agent 已产生新 revision，先重新执行静态验证",
+        "input": {"commandId": "game.static_smoke"}
+    })
+    .to_string();
+    let (sender, receiver) = mpsc::channel();
+    let base_url = spawn_mock_llm_raw_responses_with_capture(
+        vec![
+            native_agent_tool_plan_chat_response(
+                "call-autonomous-supervisor-new-revision-read",
+                &native_runtime_function_name("project.index").expect("index function"),
+                read_arguments,
+            ),
+            native_agent_tool_plan_chat_response(
+                "call-autonomous-supervisor-new-revision-verify",
+                &native_runtime_function_name("command.run_limited")
+                    .expect("limited command function"),
+                verify_arguments,
+            ),
+        ],
+        Some(sender),
+    );
+    let _config_guard = write_test_local_config(format!(
+        r#"{{
+  "agentLlm": {{
+    "project-supervisor": {{
+      "apiKey": "autonomous-supervisor-new-revision-key",
+      "baseUrl": {base_url:?},
+      "model": "autonomous-supervisor-new-revision-model",
+      "apiKind": "openai_chat",
+      "maxRetries": 0
+    }}
+  }}
+}}"#
+    ));
+
+    let plan = request_game_creator_agent_background_tool_plan_for_test(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        &runtime.session_id,
+        run_id,
+        &runtime.current_task,
+        &[],
+        30,
+        0,
+    )
+    .await
+    .expect("repair new revision revalidation stall")
+    .expect("repaired supervisor verification plan");
+    assert_eq!(plan.actions.len(), 1);
+    assert_eq!(plan.actions[0].tool, "command.run_limited");
+
+    receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("initial new revision request");
+    let repair_request = receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("new revision verification repair request");
+    assert!(repair_request.contains("试玩失败后项目已从 revision"));
+    assert!(repair_request.contains("必须先验证当前 revision"));
+    let repair_request_json = mock_http_request_json(&repair_request);
+    let repair_function_names = repair_request_json["tools"]
+        .as_array()
+        .expect("new revision verification repair tools")
+        .iter()
+        .filter_map(|tool| {
+            tool.get("name")
+                .and_then(serde_json::Value::as_str)
+                .or_else(|| {
+                    tool.get("function")
+                        .and_then(|function| function.get("name"))
+                        .and_then(serde_json::Value::as_str)
+                })
+        })
+        .collect::<BTreeSet<_>>();
+    assert_eq!(
+        repair_function_names,
+        BTreeSet::from([
+            native_runtime_function_name("project.verify")
+                .expect("verify function")
+                .as_str(),
+            native_runtime_function_name("command.run_limited")
+                .expect("limited command function")
+                .as_str(),
+        ])
+    );
+    assert!(receiver.recv_timeout(Duration::from_millis(200)).is_err());
+
+    fs::remove_dir_all(root).ok();
+}
+
 #[test]
 fn failed_autonomous_preview_invalidates_static_smoke_verification_gate() {
     let root = unique_project_path();
@@ -7838,6 +8333,96 @@ fn failed_autonomous_preview_invalidates_static_smoke_verification_gate() {
     fs::remove_dir_all(root).ok();
 }
 
+#[test]
+fn supervisor_preview_tracks_specialist_revision_without_fake_mutation() {
+    let root = unique_project_path();
+    init_local_game_project_at(
+        &root,
+        "project-supervisor-specialist-preview-gate",
+        "总控验收专业产物验证门测试",
+    )
+    .expect("project init");
+    let supervisor_run_id = "supervisor-specialist-preview-run";
+    let first_revision = prepare_agent_runtime_project_mutation_locked(
+        &root,
+        "code-prototype",
+        "specialist-run-1",
+        "file.write",
+    )
+    .expect("record first specialist revision");
+    let (expected_revision, gate) = begin_agent_runtime_project_verification_locked(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+        "game.static_smoke",
+    )
+    .expect("begin supervisor verification");
+    finish_agent_runtime_project_verification_locked(&root, &expected_revision, gate, true)
+        .expect("finish supervisor verification");
+    let gate = read_game_creator_agent_runtime_verification_gate(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+    )
+    .expect("read supervisor verified gate");
+    assert_eq!(gate.mutation_revision, None);
+    assert_eq!(gate.verified_revision, Some(first_revision));
+
+    invalidate_agent_runtime_project_verification_after_preview_failure_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+        first_revision,
+    )
+    .expect("record failed Supervisor preview without fake mutation");
+    let failed_gate = read_game_creator_agent_runtime_verification_gate(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+    )
+    .expect("read failed supervisor gate");
+    assert!(!failed_gate.requires_verification);
+    assert_eq!(failed_gate.mutation_revision, None);
+    assert_eq!(failed_gate.verified_revision, None);
+    assert_eq!(failed_gate.failed_playtest_revision, Some(first_revision));
+
+    let second_revision = prepare_agent_runtime_project_mutation_locked(
+        &root,
+        "code-prototype",
+        "specialist-run-2",
+        "file.patch",
+    )
+    .expect("record repaired specialist revision");
+    assert_eq!(second_revision, first_revision + 1);
+    let (expected_revision, gate) = begin_agent_runtime_project_verification_locked(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+        "game.static_smoke",
+    )
+    .expect("begin repaired supervisor verification");
+    finish_agent_runtime_project_verification_locked(&root, &expected_revision, gate, true)
+        .expect("finish repaired supervisor verification");
+    let repaired_gate = read_game_creator_agent_runtime_verification_gate(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+    )
+    .expect("read repaired supervisor gate");
+    assert_eq!(repaired_gate.mutation_revision, None);
+    assert_eq!(repaired_gate.verified_revision, Some(second_revision));
+    assert_eq!(repaired_gate.failed_playtest_revision, None);
+    clear_agent_runtime_failed_playtest_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        supervisor_run_id,
+        second_revision,
+    )
+    .expect("clear successful supervisor preview without fake mutation");
+
+    fs::remove_dir_all(root).ok();
+}
+
 #[tokio::test]
 async fn autonomous_game_build_profile_blocks_user_input_before_waiting_state() {
     let root = unique_project_path();
@@ -14684,6 +15269,121 @@ async fn provider_action_batch_read_read_confirm_waits_then_keeps_one_parallel_b
     fs::remove_dir_all(root).ok();
 }
 
+#[tokio::test]
+async fn provider_action_batch_verification_then_parallel_reads_share_current_gate_snapshot() {
+    let root = unique_project_path();
+    init_local_game_project_at(
+        &root,
+        "project-provider-batch-verification-parallel-read",
+        "Provider 批次验证后并行读取测试",
+    )
+    .expect("project init");
+    fs::write(
+        root.join("game/index.html"),
+        fake_llm_game_draft().game_html,
+    )
+    .expect("write playable game fixture");
+    fs::write(root.join("game/alpha.txt"), "PROVIDER_BATCH_VERIFIED_ALPHA")
+        .expect("write alpha fixture");
+    fs::write(root.join("game/beta.txt"), "PROVIDER_BATCH_VERIFIED_BETA")
+        .expect("write beta fixture");
+    let run_id = "provider-batch-verification-parallel-read-run";
+    write_project_permission_policy_at(
+        &root,
+        ProjectPermissionPolicy {
+            denied_commands: Vec::new(),
+            confirm_commands: Vec::new(),
+            agent_policies: BTreeMap::new(),
+        },
+    )
+    .expect("allow deterministic Provider batch execution");
+    advance_project_revision_for_test(&root, "design-director", run_id, "file.write");
+
+    let plan = serde_json::json!({
+        "thinkingSummary": "先验证当前 revision，再并行回读两个证据文件",
+        "plan": ["验证当前 revision", "读取 alpha", "读取 beta"],
+        "actions": [
+            {
+                "tool": "command.run_limited",
+                "reason": "运行受控静态游戏验证",
+                "input": {"commandId": "game.static_smoke"}
+            },
+            {
+                "tool": "file.read",
+                "reason": "读取 alpha 证据",
+                "input": {"path": "game/alpha.txt"}
+            },
+            {
+                "tool": "file.read",
+                "reason": "读取 beta 证据",
+                "input": {"path": "game/beta.txt"}
+            }
+        ],
+        "response": ""
+    })
+    .to_string();
+    let (request_sender, request_receiver) = mpsc::channel();
+    let (response_sender, response_receiver) = mpsc::channel();
+    let base_url =
+        spawn_interactive_mock_llm_server_with_capture(2, request_sender, response_receiver);
+    let _config_guard = write_provider_action_batch_test_config(&base_url);
+
+    start_game_creator_agent_background_task_at(
+        &root,
+        "design-director",
+        "验证当前 revision 后并行回读两个项目证据",
+        run_id,
+    )
+    .expect("start verified parallel read task");
+    request_receiver
+        .recv_timeout(Duration::from_secs(2))
+        .expect("initial verified parallel read request");
+    response_sender
+        .send(plan)
+        .expect("release verified parallel read plan");
+
+    let final_request = request_receiver
+        .recv_timeout(Duration::from_secs(10))
+        .expect("Provider request after verification and parallel reads");
+    assert!(final_request.contains("game.static_smoke 已完成"));
+    assert!(final_request.contains("PROVIDER_BATCH_VERIFIED_ALPHA"));
+    assert!(final_request.contains("PROVIDER_BATCH_VERIFIED_BETA"));
+    response_sender
+        .send(final_tool_plan_response(
+            "当前 revision 已验证，并完成两个证据文件的并行回读。",
+        ))
+        .expect("release verified parallel read response");
+
+    let runtime = wait_for_agent_runtime_idle(&root, "design-director");
+    assert_eq!(runtime.run_id, run_id);
+    assert_eq!(runtime.phase, "completed");
+    let gate = read_game_creator_agent_runtime_verification_gate(&root, "design-director", run_id)
+        .expect("read verification gate after parallel reads");
+    assert_eq!(gate.verified_revision, Some(1));
+    assert_eq!(gate.last_verification_status.as_deref(), Some("passed"));
+    let parallel_records = read_agent_db_records_for_test(&root)
+        .into_iter()
+        .filter(|record| {
+            record["recordType"] == "agent.runtime.parallel_read_batch.completed"
+                && record["runId"] == run_id
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(parallel_records.len(), 1);
+    assert_eq!(parallel_records[0]["actionCount"], 2);
+    assert!(!game_creator_agent_runtime_provider_action_batch_path(
+        &root,
+        "design-director",
+        run_id,
+    )
+    .exists());
+    assert!(
+        !game_creator_agent_runtime_parallel_read_batch_path(&root, "design-director", run_id,)
+            .exists()
+    );
+
+    fs::remove_dir_all(root).ok();
+}
+
 #[tokio::test]
 async fn provider_action_batch_restart_rebuilds_missing_confirmation_once_and_blocks_finalization()
 {