diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-deterministic-playable-e2e.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-deterministic-playable-e2e.mjs
index 0bf11ca70..89f552dc7 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-deterministic-playable-e2e.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-deterministic-playable-e2e.mjs
@@ -7,6 +7,7 @@ import { fileURLToPath } from 'node:url';
 
 import {
   createDeterministicLaneDefenseRouter,
+  deterministicLaneDefenseCanonicalHtml,
   deterministicLaneDefenseInitialHtml,
   deterministicLaneDefenseModel,
   deterministicManifestReadyAgentIds,
@@ -50,6 +51,32 @@ function parseArguments(args) {
   return { keepProject, selfTest };
 }
 
+function deterministicRuntimeConfig(apiKey, provider) {
+  return {
+    agentMode: 'provider',
+    editorApi: {
+      apiKey,
+      baseUrl: provider.editorBaseUrl,
+    },
+    llm: {
+      apiKey,
+      baseUrl: provider.baseUrl,
+      model: deterministicLaneDefenseModel,
+      apiKind: 'openai_chat',
+      reasoningEffort: 'max',
+      stream: false,
+      requestTimeoutMs: 30_000,
+      maxRetries: 0,
+      retryBackoffMs: 100,
+    },
+    agentLlm: {
+      'project-supervisor': {
+        reasoningEffort: 'max',
+      },
+    },
+  };
+}
+
 function appendBounded(current, chunk) {
   const combined = Buffer.concat([current, chunk]);
   if (combined.length > outputLimit) throw new Error('child-output-too-large');
@@ -117,71 +144,14 @@ function parseChildReport(result) {
   }
 }
 
-function responsibilityContractEvidence(stats) {
-  const qualityPlanningCount =
-    stats?.byAgent?.['quality-review']?.planning ?? null;
-  const evidence = {
-    delegationContractCount: stats?.delegationContractCount ?? null,
-    delegationContractViolationCount:
-      stats?.delegationContractViolationCount ?? null,
-    codePrototypeDelegationCount: stats?.codePrototypeDelegationCount ?? null,
-    codePrototypeExpectedArtifactCount:
-      stats?.codePrototypeExpectedArtifactCount ?? null,
-    codePrototypeGameIndexArtifactDelegationCount:
-      stats?.codePrototypeGameIndexArtifactDelegationCount ?? null,
-    codePrototypeProjectMutationCount:
-      stats?.byAgent?.['code-prototype']?.projectMutation ?? null,
-    qualityReviewDelegationCount: stats?.qualityReviewDelegationCount ?? null,
-    qualityReviewReadOnlyDelegationCount:
-      stats?.qualityReviewReadOnlyDelegationCount ?? null,
-    qualityReviewExpectedArtifactCount:
-      stats?.qualityReviewExpectedArtifactCount ?? null,
-    artAssetPlanDelegationCount: stats?.artAssetPlanDelegationCount ?? null,
-    artAssetPlanExpectedArtifactCount:
-      stats?.artAssetPlanExpectedArtifactCount ?? null,
-    artAssetPlanArtifactContractCount:
-      stats?.artAssetPlanArtifactContractCount ?? null,
-    qualityReviewProjectMutationCount:
-      stats?.byAgent?.['quality-review']?.projectMutation ?? null,
-    qualityPlanningCount,
-    qualityRevisionReplanCount: stats?.qualityRevisionReplanCount ?? null,
-  };
-  return {
-    ...evidence,
-    codeOwnsGameIndex:
-      Number.isInteger(evidence.codePrototypeDelegationCount) &&
-      evidence.codePrototypeDelegationCount >= 1 &&
-      evidence.codePrototypeExpectedArtifactCount ===
-        evidence.codePrototypeDelegationCount &&
-      evidence.codePrototypeGameIndexArtifactDelegationCount ===
-        evidence.codePrototypeDelegationCount &&
-      Number.isInteger(evidence.codePrototypeProjectMutationCount) &&
-      evidence.codePrototypeProjectMutationCount >= 2,
-    qualityIsReadOnly:
-      evidence.qualityReviewDelegationCount === 1 &&
-      evidence.qualityReviewReadOnlyDelegationCount === 1 &&
-      evidence.qualityReviewExpectedArtifactCount === 0 &&
-      evidence.qualityReviewProjectMutationCount === 0,
-    qualityIndependentOfCodeTiming:
-      Number.isInteger(qualityPlanningCount) &&
-      qualityPlanningCount >= 1 &&
-      Number.isInteger(evidence.qualityRevisionReplanCount) &&
-      evidence.qualityRevisionReplanCount >= 0 &&
-      evidence.qualityRevisionReplanCount <= 1,
-    artOwnsGeneratedAsset:
-      evidence.artAssetPlanDelegationCount === 1 &&
-      evidence.artAssetPlanExpectedArtifactCount === 2 &&
-      evidence.artAssetPlanArtifactContractCount === 1,
-    contractViolationFree:
-      Number.isInteger(evidence.delegationContractCount) &&
-      evidence.delegationContractCount >= 3 &&
-      evidence.delegationContractViolationCount === 0,
-  };
-}
-
 function expectedProviderStats(stats) {
-  const responsibility = responsibilityContractEvidence(stats);
   const manifestReadyTasks = manifestReadyTaskEvidence(stats);
+  const projectSupervisorRuntimePlanningCount =
+    Number.isInteger(stats.byAgent?.['project-supervisor']?.planning) &&
+    Number.isInteger(stats.interactionExecuteCount)
+      ? stats.byAgent['project-supervisor'].planning -
+        stats.interactionExecuteCount
+      : null;
   return (
     Number.isInteger(stats.requestCount) &&
     stats.requestCount >= 40 &&
@@ -191,38 +161,40 @@ function expectedProviderStats(stats) {
       (stats.imageInspectionRequestCount ?? 0) ===
       stats.requestCount &&
     stats.finalReplyRequestCount === 0 &&
-    stats.initialDelegationCount === 3 &&
-    stats.followupDelegationCount === 0 &&
+    stats.interactionExecuteCount === 1 &&
+    stats.goalContractCount === 1 &&
+    stats.actionHistoryCount === 1 &&
+    stats.acceptanceUpdateCount === 1 &&
+    stats.delegateActionCount === 0 &&
     stats.runStatusCount >= 1 &&
     stats.sourceWriteCount >= 7 &&
     stats.staticSmokeCount >= 4 &&
     stats.previewValidationCount >= 2 &&
-    stats.supervisorDirectMutationAttemptCount === 0 &&
     manifestReadyTasks.exactlyOnce &&
     stats.manifestReadyTaskFileWriteCount >= 7 &&
     stats.manifestReadyTaskPreviewValidationCount >= 1 &&
-    stats.manifestReadyTaskCanvasGenerationCount >= 1 &&
-    stats.manifestReadyTaskCanvasGenerationCount <= 2 &&
+    stats.manifestReadyTaskCanvasGenerationCount >=
+      stats.canvasGenerationRequestCount &&
+    stats.manifestReadyTaskCanvasGenerationCount <=
+      stats.canvasGenerationRequestCount + 16 &&
     stats.imageInspectionRequestCount === 1 &&
-    stats.canvasGenerationRequestCount === 2 &&
-    stats.canvasDownloadRequestCount === 2 &&
+    stats.canvasGenerationRequestCount === 3 &&
+    stats.canvasDownloadRequestCount === 3 &&
+    stats.canvasSliceDownloadRequestCount === 4 &&
     stats.canvasGeneratedAspectRatios?.['16:9'] === 1 &&
-    stats.canvasGeneratedAspectRatios?.['1:1'] === 1 &&
+    stats.canvasGeneratedAspectRatios?.['1:1'] === 2 &&
     stats.canonicalCodeRunCount === 1 &&
+    stats.canonicalCodeAssetListCount === 1 &&
     stats.unexpectedRequestCount === 0 &&
     Object.keys(stats.rejectionCodes ?? {}).length === 0 &&
-    stats.byAgent?.['project-supervisor']?.planning >= 5 &&
+    projectSupervisorRuntimePlanningCount >= 5 &&
     stats.byAgent?.['project-supervisor']?.finalReply === 0 &&
     stats.byAgent?.['project-supervisor']?.projectMutation === 0 &&
-    stats.byAgent?.['code-prototype']?.planning >= 6 &&
+    stats.byAgent?.['code-prototype']?.planning >= 5 &&
     stats.byAgent?.['code-prototype']?.finalReply === 0 &&
-    stats.byAgent?.['code-prototype']?.projectMutation >= 2 &&
+    stats.byAgent?.['code-prototype']?.projectMutation === 1 &&
     stats.byAgent?.['quality-review']?.finalReply === 0 &&
-    responsibility.codeOwnsGameIndex &&
-    responsibility.qualityIsReadOnly &&
-    responsibility.qualityIndependentOfCodeTiming &&
-    responsibility.artOwnsGeneratedAsset &&
-    responsibility.contractViolationFree
+    stats.byAgent?.['quality-review']?.projectMutation === 0
   );
 }
 
@@ -362,6 +334,53 @@ function syntheticPayload(agentId, runId, tools, extraContext = '') {
   };
 }
 
+function syntheticInteractionExecutePayload() {
+  return {
+    model: deterministicLaneDefenseModel,
+    stream: false,
+    reasoning_effort: 'max',
+    messages: [
+      {
+        role: 'system',
+        content: '你现在位于统一的 Agent interaction loop。',
+      },
+      {
+        role: 'user',
+        content: '用户这轮输入：\n制作一个三消经营游戏',
+      },
+    ],
+    tools: ['runtime_execute', 'runtime_resume', 'project_location'].map(
+      (name) => ({ type: 'function', function: { name } }),
+    ),
+  };
+}
+
+function syntheticUiPrototypeInspectionPayload() {
+  return {
+    model: deterministicLaneDefenseModel,
+    stream: false,
+    messages: [
+      {
+        role: 'system',
+        content: '你是游戏界面视觉检查 Agent。只分析画面。',
+      },
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: '请逐项检查 informationHud、gameplaySurface、objectiveEntities、primaryControls、failureRestartFlow、responsiveLayout、implementationClarity、originalTheme，并只返回严格 JSON。',
+          },
+          {
+            type: 'image_url',
+            image_url: { url: 'data:image/png;base64,AA==' },
+          },
+        ],
+      },
+    ],
+  };
+}
+
 function responseFunctionNames(response) {
   return response.choices[0].message.tool_calls.map(
     (call) => call.function.name,
@@ -387,12 +406,49 @@ async function runSelfTest() {
       html.includes('requestAnimationFrame'),
     'self-test-html-contract-invalid',
   );
+  const canonicalHtml = deterministicLaneDefenseCanonicalHtml();
+  assert(
+    canonicalHtml.includes(visibleCanvasCss) &&
+      canonicalHtml.includes("atlasArt.src='../assets/art-spritesheet.png'") &&
+      [
+        'player.png',
+        'blocks-and-targets.png',
+        'obstacles-and-scene.png',
+        'feedback-effects.png',
+      ].every((fileName) =>
+        canonicalHtml.includes(`../assets/art-spritesheet-slices/${fileName}`),
+      ) &&
+      (canonicalHtml.match(/ctx\.drawImage\(/g) ?? []).length >= 5,
+    'self-test-canonical-visible-art-contract-invalid',
+  );
   const apiKey = `deterministic-self-test-${randomUUID()}`;
-  const router = createDeterministicLaneDefenseRouter({ apiKey });
+  const runtimeConfig = deterministicRuntimeConfig(apiKey, {
+    baseUrl: 'http://127.0.0.1:41001/v1',
+    editorBaseUrl: 'http://127.0.0.1:41002',
+  });
+  assert(
+    runtimeConfig.agentMode === 'provider' &&
+      runtimeConfig.llm.apiKind === 'openai_chat' &&
+      runtimeConfig.llm.reasoningEffort === 'max' &&
+      runtimeConfig.agentLlm?.['project-supervisor']?.reasoningEffort ===
+        'max' &&
+      runtimeConfig.llm.apiKey === apiKey &&
+      runtimeConfig.editorApi.apiKey === apiKey,
+    'self-test-provider-runtime-config-invalid',
+  );
+  const captureProviderErrorCode = (operation) => {
+    try {
+      operation();
+      return null;
+    } catch (error) {
+      return error?.code ?? null;
+    }
+  };
   const allTools = [
     'update_agent_plan',
     'respond_to_user',
-    'runtime_tool_agent_delegate',
+    'runtime_tool_agent_action_history',
+    'runtime_tool_agent_acceptance_update',
     'runtime_tool_agent_run_status',
     'runtime_tool_command_run_limited',
     'runtime_tool_file_patch',
@@ -405,141 +461,155 @@ async function runSelfTest() {
     'runtime_tool_asset_list',
     'runtime_tool_file_read',
   ];
+  const rootRunId = 'parent-run';
+  const contractFingerprint = 'a'.repeat(64);
+  const contractContext = `[Root Goal Contract]\n${JSON.stringify({ contractFingerprint })}`;
+  const observationContext = (observations) =>
+    `${contractContext}\n已有工具观察：\n${JSON.stringify(observations)}`;
+  const goalContractTools = ['runtime_tool_agent_goal_contract'];
+  const goalContractRouter = createDeterministicLaneDefenseRouter({ apiKey });
+  goalContractRouter.route({
+    authorization: `Bearer ${apiKey}`,
+    payload: syntheticPayload(
+      'project-supervisor',
+      'goal-contract-order-run',
+      goalContractTools,
+    ),
+  });
+  assert(
+    captureProviderErrorCode(() =>
+      goalContractRouter.route({
+        authorization: `Bearer ${apiKey}`,
+        payload: syntheticPayload(
+          'project-supervisor',
+          'goal-contract-order-run',
+          goalContractTools,
+        ),
+      }),
+    ) === 'provider-goal-contract-out-of-order',
+    'self-test-goal-contract-duplicate-not-rejected',
+  );
+
+  const router = createDeterministicLaneDefenseRouter({ apiKey });
   const route = (agentId, runId, tools = allTools, extraContext = '') =>
     router.route({
       authorization: `Bearer ${apiKey}`,
       payload: syntheticPayload(agentId, runId, tools, extraContext),
     });
-  const initialDelegationResponse = route('project-supervisor', 'parent-run');
-  const initialDelegationCalls = responseFunctionCalls(
-    initialDelegationResponse,
+  const interactionExecuteResponse = router.route({
+    authorization: `Bearer ${apiKey}`,
+    payload: syntheticInteractionExecutePayload(),
+  });
+  const interactionExecuteCalls = responseFunctionCalls(
+    interactionExecuteResponse,
+  );
+  const interactionExecuteStats = router.getStats();
+  assert(
+    interactionExecuteCalls.length === 1 &&
+      interactionExecuteCalls[0]?.name === 'runtime_execute' &&
+      Object.keys(interactionExecuteCalls[0]?.arguments ?? {}).length === 0 &&
+      interactionExecuteStats.requestCount === 1 &&
+      interactionExecuteStats.planningRequestCount === 1 &&
+      interactionExecuteStats.interactionExecuteCount === 1 &&
+      interactionExecuteStats.manifestReadyTaskRunCount === 0 &&
+      interactionExecuteStats.manifestReadyTaskCompletionCount === 0 &&
+      Object.keys(interactionExecuteStats.readyTaskCountsByAgent).length === 0,
+    'self-test-interaction-max-execute-sequence-invalid',
+  );
+  const visualInspectionResponse = router.route({
+    authorization: `Bearer ${apiKey}`,
+    payload: syntheticUiPrototypeInspectionPayload(),
+  });
+  const visualInspection = JSON.parse(
+    visualInspectionResponse.choices[0].message.content,
   );
   assert(
-    initialDelegationCalls.map((call) => call.name).join(',') ===
-      'runtime_tool_agent_delegate,runtime_tool_agent_delegate,runtime_tool_agent_delegate',
-    'self-test-initial-delegation-invalid',
+    Object.keys(visualInspection?.checks ?? {}).join(',') ===
+      'informationHud,gameplaySurface,objectiveEntities,primaryControls,failureRestartFlow,responsiveLayout,implementationClarity,originalTheme' &&
+      Object.values(visualInspection.checks).every((value) => value === true) &&
+      Array.isArray(visualInspection.issues) &&
+      visualInspection.issues.length === 0 &&
+      router.getStats().imageInspectionRequestCount === 1 &&
+      router.getStats().unexpectedRequestCount === 0,
+    'self-test-ui-prototype-inspection-request-not-routed',
   );
-  const initialCodeDelegation = initialDelegationCalls[0]?.arguments?.input;
-  const initialQualityDelegation = initialDelegationCalls[1]?.arguments?.input;
-  const initialArtDelegation = initialDelegationCalls[2]?.arguments?.input;
-  assert(
-    initialCodeDelegation?.agentId === 'code-prototype' &&
-      JSON.stringify(initialCodeDelegation.expectedArtifacts) ===
-        JSON.stringify(['game/index.html']) &&
-      initialQualityDelegation?.agentId === 'quality-review' &&
-      initialQualityDelegation.task.includes('只读验收') &&
-      initialQualityDelegation.task.includes('不要修改任何文件') &&
-      initialQualityDelegation.task.includes(
-        '不要读取或依赖并行 code-prototype',
-      ) &&
-      Array.isArray(initialQualityDelegation.expectedArtifacts) &&
-      initialQualityDelegation.expectedArtifacts.length === 0 &&
-      initialArtDelegation?.agentId === 'art-asset-plan' &&
-      initialArtDelegation.task.includes('canvas.asset_generate') &&
-      JSON.stringify(initialArtDelegation.expectedArtifacts) ===
-        JSON.stringify([
-          'assets/manifest.art.json',
-          'assets/art-spritesheet.png',
-        ]),
-    'self-test-initial-delegation-contract-invalid',
-  );
-  const qualityPlan =
-    '计划进度：\n- #1 [in_progress] 核对完整玩法\n- #2 [pending] 回传结论\n工具策略：auto=无';
-  const builderPlan =
-    '计划进度：\n- #1 [completed] 生成入口\n- #2 [completed] 静态验证\n- #3 [in_progress] 回传结论\n工具策略：auto=无';
-  assert(
-    responseFunctionNames(
-      route('quality-review', 'quality-run', allTools, qualityPlan),
-    ).join(',') === 'update_agent_plan,respond_to_user',
-    'self-test-quality-read-only-invalid',
-  );
-  route('code-prototype', 'initial-code-run');
-  route('code-prototype', 'initial-code-run');
-  assert(
-    responseFunctionNames(
-      route('code-prototype', 'initial-code-run', allTools, builderPlan),
-    ).join(',') === 'update_agent_plan,respond_to_user',
-    'self-test-builder-plan-completion-invalid',
-  );
-  assert(
-    responseFunctionNames(
-      route(
-        'quality-review',
-        'quality-run',
-        allTools,
-        `${qualityPlan}\n已有工具观察：\n${JSON.stringify([
-          {
-            tool: 'runtime.verification',
-            status: 'blocked',
-            summary: '最终回复基于的项目 revision 已过期',
-            detail: 'responseRevision=0, currentRevision=1',
-          },
-        ])}`,
-      ),
-    ).join(',') === 'update_agent_plan,respond_to_user',
-    'self-test-quality-stale-replan-invalid',
-  );
-  route('project-supervisor', 'parent-run');
-  route('project-supervisor', 'parent-run');
-  route('project-supervisor', 'parent-run');
-  assert(
-    responseFunctionNames(route('project-supervisor', 'parent-run'))[0] ===
-      'runtime_tool_file_patch',
-    'self-test-forbidden-parent-mutation-invalid',
-  );
-  const followupDelegationResponse = route(
+  const goalContractResponse = route(
     'project-supervisor',
-    'parent-run',
-    ['runtime_tool_agent_delegate'],
-    '当前父 run 已进入只编排模式，本次修复的原生工具目录只保留 agent.delegate',
+    rootRunId,
+    goalContractTools,
   );
-  const followupDelegationCall = responseFunctionCalls(
-    followupDelegationResponse,
-  )[0];
+  const goalContractCalls = responseFunctionCalls(goalContractResponse);
+  const acceptanceNodes =
+    goalContractCalls[0]?.arguments?.input?.acceptanceNodes ?? [];
   assert(
-    followupDelegationCall?.name === 'runtime_tool_agent_delegate' &&
-      followupDelegationCall.arguments?.input?.agentId === 'code-prototype' &&
-      JSON.stringify(
-        followupDelegationCall.arguments.input.expectedArtifacts,
-      ) === JSON.stringify(['game/index.html']),
-    'self-test-followup-delegation-invalid',
-  );
-  route('code-prototype', 'repair-code-run');
-  route('code-prototype', 'repair-code-run');
-  route('code-prototype', 'repair-code-run', allTools, builderPlan);
-  assert(
-    responseFunctionNames(route('project-supervisor', 'parent-run'))[0] ===
-      'runtime_tool_agent_run_status',
-    'self-test-repair-claim-before-verification-invalid',
-  );
-  assert(
-    responseFunctionNames(route('project-supervisor', 'parent-run')).join(
-      ',',
-    ) === 'runtime_tool_task_list,runtime_tool_agent_run_status',
-    'self-test-manifest-wait-invalid',
+    goalContractCalls.length === 1 &&
+      goalContractCalls[0]?.name === 'runtime_tool_agent_goal_contract' &&
+      goalContractCalls[0]?.arguments?.input?.outcome?.includes(
+        '可完整游玩的原创植物塔防网页游戏',
+      ) &&
+      acceptanceNodes.length === 2 &&
+      acceptanceNodes[0]?.criterionId === 'static-current-revision' &&
+      JSON.stringify(acceptanceNodes[0]?.requiredEvidence) ===
+        JSON.stringify(['tool:command.run_limited']) &&
+      acceptanceNodes[1]?.criterionId === 'playable-current-revision' &&
+      JSON.stringify(acceptanceNodes[1]?.requiredEvidence) ===
+        JSON.stringify(['tool:preview.validate']) &&
+      JSON.stringify(acceptanceNodes[1]?.dependsOn) ===
+        JSON.stringify(['static-current-revision']),
+    'self-test-goal-contract-invalid',
   );
   assert(
     responseFunctionNames(
       route(
         'project-supervisor',
-        'parent-run',
-        allTools,
-        '已有工具观察：\nseedTaskCounts: completed=16 running=0 pending=0 waiting=0 failed=0 total=16',
+        rootRunId,
+        ['runtime_tool_task_list', 'runtime_tool_agent_run_status'],
+        `${contractContext}\n当前正式 manifest DAG 仍有专业 task 在运行`,
       ),
-    ).join(',') ===
-      'runtime_tool_command_run_limited,runtime_tool_preview_validate',
-    'self-test-repair-verification-batch-invalid',
+    ).join(',') === 'runtime_tool_task_list,runtime_tool_agent_run_status',
+    'self-test-manifest-wait-invalid',
   );
-  route('project-supervisor', 'parent-run');
 
+  const visualReadyAgentIds = new Set([
+    'art-director',
+    'design-foundation',
+    'art-asset-plan',
+  ]);
+  const canvasCallsByAgent = new Map();
+  const callBatchesByAgent = new Map();
   for (const agentId of deterministicManifestReadyAgentIds) {
     const runId = `manifest-ready-${agentId}`;
     const extraContext =
       `处理 manifest ready 任务：${agentId}\n` + `任务 ID：${agentId}`;
+    const readyTools = visualReadyAgentIds.has(agentId)
+      ? [
+          ...manifestReadyTools,
+          'runtime_tool_canvas_asset_generate',
+          'runtime_tool_image_inspect',
+        ]
+      : manifestReadyTools;
     let terminalCompletionCount = 0;
     for (let attempt = 0; attempt < 8; attempt += 1) {
-      const response = route(agentId, runId, manifestReadyTools, extraContext);
-      if (responseFunctionNames(response).includes('respond_to_user')) {
+      const attemptTools =
+        agentId === 'art-director' && attempt >= 2
+          ? ['respond_to_user']
+          : readyTools;
+      const response = route(agentId, runId, attemptTools, extraContext);
+      const calls = responseFunctionCalls(response);
+      const batches = callBatchesByAgent.get(agentId) ?? [];
+      batches.push(calls.map((call) => call.name));
+      callBatchesByAgent.set(agentId, batches);
+      const canvasCall = calls.find(
+        (call) => call.name === 'runtime_tool_canvas_asset_generate',
+      );
+      if (canvasCall) {
+        assert(
+          !canvasCallsByAgent.has(agentId),
+          `self-test-canvas-generation-duplicate:${agentId}`,
+        );
+        canvasCallsByAgent.set(agentId, canvasCall);
+      }
+      if (calls.some((call) => call.name === 'respond_to_user')) {
         terminalCompletionCount += 1;
         break;
       }
@@ -549,10 +619,429 @@ async function runSelfTest() {
       `self-test-manifest-ready-terminal-invalid:${agentId}`,
     );
   }
+  const artDirectorAssetCall = canvasCallsByAgent.get('art-director');
+  const designFoundationAssetCall = canvasCallsByAgent.get('design-foundation');
+  const artAssetPlanAssetCall = canvasCallsByAgent.get('art-asset-plan');
+  assert(
+    JSON.stringify(callBatchesByAgent.get('art-asset-plan')) ===
+      JSON.stringify([
+        ['runtime_tool_asset_list'],
+        ['runtime_tool_file_write'],
+        ['runtime_tool_canvas_asset_generate'],
+        ['runtime_tool_file_read', 'runtime_tool_asset_list'],
+        ['update_agent_plan', 'respond_to_user'],
+      ]),
+    'self-test-art-asset-plan-revision-stages-invalid',
+  );
+  assert(
+    JSON.stringify(callBatchesByAgent.get('code-prototype')) ===
+      JSON.stringify([
+        [
+          'runtime_tool_file_read',
+          'runtime_tool_file_read',
+          'runtime_tool_file_read',
+        ],
+        [
+          'runtime_tool_file_read',
+          'runtime_tool_file_read',
+          'runtime_tool_file_read',
+          'runtime_tool_asset_list',
+        ],
+        ['runtime_tool_file_write'],
+        ['runtime_tool_command_run_limited'],
+        ['update_agent_plan', 'respond_to_user'],
+      ]),
+    'self-test-code-prototype-asset-audit-sequence-invalid',
+  );
+  assert(
+    canvasCallsByAgent.size === 3 &&
+      artDirectorAssetCall?.arguments?.input?.outputPath ===
+        'assets/art-spec.png' &&
+      artDirectorAssetCall.arguments.input.aspectRatio === '1:1' &&
+      artDirectorAssetCall.arguments.input.assetKind === 'icon-spec' &&
+      designFoundationAssetCall?.arguments?.input?.outputPath ===
+        'assets/ui-prototype.png' &&
+      designFoundationAssetCall.arguments.input.aspectRatio === '16:9' &&
+      designFoundationAssetCall.arguments.input.assetKind === 'ui-prototype' &&
+      artAssetPlanAssetCall?.arguments?.input?.outputPath ===
+        'assets/art-spritesheet.png' &&
+      artAssetPlanAssetCall.arguments.input.aspectRatio === '1:1' &&
+      artAssetPlanAssetCall.arguments.input.assetKind === 'art-spritesheet',
+    'self-test-visual-assets-invalid',
+  );
+
+  const visualRecoveryRouter = createDeterministicLaneDefenseRouter({ apiKey });
+  const visualRecoveryRunId = 'visual-recovery-design-foundation';
+  const visualRecoveryTools = [
+    ...manifestReadyTools,
+    'runtime_tool_canvas_asset_generate',
+    'runtime_tool_image_inspect',
+  ];
+  const visualRecoveryRoute = (
+    tools = visualRecoveryTools,
+    extraContext = '',
+  ) =>
+    visualRecoveryRouter.route({
+      authorization: `Bearer ${apiKey}`,
+      payload: syntheticPayload(
+        'design-foundation',
+        visualRecoveryRunId,
+        tools,
+        `处理 manifest ready 任务：design-foundation\n任务 ID：design-foundation${extraContext}`,
+      ),
+    });
+  visualRecoveryRoute();
+  visualRecoveryRoute();
+  const visualRecoveryCanvasResponse = visualRecoveryRoute();
+  const visualRecoveryInitialInspectResponse = visualRecoveryRoute();
+  assert(
+    responseFunctionNames(visualRecoveryCanvasResponse).join(',') ===
+      'runtime_tool_canvas_asset_generate' &&
+      responseFunctionNames(visualRecoveryInitialInspectResponse).includes(
+        'runtime_tool_image_inspect',
+      ),
+    'self-test-ui-prototype-initial-inspection-sequence-invalid',
+  );
+  const failedInspectObservation = {
+    tool: 'image.inspect',
+    status: 'failed',
+    summary: '视觉模型调用失败',
+    detail: 'upstream-422',
+  };
+  const prematureCompletionResponse = visualRecoveryRoute(
+    ['update_agent_plan', 'respond_to_user'],
+    `\n已有工具观察：\n${JSON.stringify([failedInspectObservation])}`,
+  );
+  assert(
+    responseFunctionNames(prematureCompletionResponse).includes(
+      'respond_to_user',
+    ),
+    'self-test-ui-prototype-premature-completion-fixture-invalid',
+  );
+  const visualBlockedObservation = {
+    tool: 'runtime.visual_asset',
+    status: 'blocked',
+    summary: 'UI 原型视觉检查尚未通过',
+    detail:
+      'expectedPath=assets/ui-prototype.png · requiredInspection=image.inspect',
+  };
+  const blockedRetryResponse = visualRecoveryRoute(
+    visualRecoveryTools,
+    `\n已有工具观察：\n${JSON.stringify([visualBlockedObservation])}`,
+  );
+  assert(
+    responseFunctionNames(blockedRetryResponse).join(',') ===
+      'runtime_tool_image_inspect',
+    'self-test-ui-prototype-visual-block-did-not-retry-inspection',
+  );
+  const failedRetryResponse = visualRecoveryRoute(
+    visualRecoveryTools,
+    `\n已有工具观察：\n${JSON.stringify([failedInspectObservation])}`,
+  );
+  assert(
+    responseFunctionNames(failedRetryResponse).join(',') ===
+      'runtime_tool_image_inspect',
+    'self-test-ui-prototype-failed-inspection-did-not-retry',
+  );
+  const successfulInspectObservation = {
+    tool: 'image.inspect',
+    status: 'ok',
+    summary: '视觉检查已完成，共分析 1 张图片',
+    detail: null,
+  };
+  const visualRecoveryFinalResponse = visualRecoveryRoute(
+    ['update_agent_plan', 'respond_to_user'],
+    `\n已有工具观察：\n${JSON.stringify([successfulInspectObservation])}`,
+  );
+  const visualRecoveryStats = visualRecoveryRouter.getStats();
+  assert(
+    responseFunctionNames(visualRecoveryFinalResponse).includes(
+      'respond_to_user',
+    ) &&
+      visualRecoveryStats.manifestReadyTaskRunCount === 1 &&
+      visualRecoveryStats.manifestReadyTaskCompletionCount === 1 &&
+      visualRecoveryStats.manifestReadyTaskCanvasGenerationCount === 1 &&
+      visualRecoveryStats.byAgent?.['design-foundation']?.projectMutation ===
+        3 &&
+      visualRecoveryStats.unexpectedRequestCount === 0,
+    'self-test-ui-prototype-visual-recovery-not-exactly-once',
+  );
+
+  const finalStaticResponse = route(
+    'project-supervisor',
+    rootRunId,
+    ['runtime_tool_command_run_limited'],
+    `${contractContext}\n已有工具观察：\nseedTaskCounts: completed=16 running=0 pending=0 waiting=0 failed=0 total=16`,
+  );
+  assert(
+    responseFunctionNames(finalStaticResponse).join(',') ===
+      'runtime_tool_command_run_limited',
+    'self-test-final-static-not-exclusive',
+  );
+  const successfulFinalStaticObservation = {
+    tool: 'command.run_limited',
+    status: 'ok',
+    summary: 'game.static_smoke 已完成',
+    detail: null,
+  };
+  const finalPreviewResponse = route(
+    'project-supervisor',
+    rootRunId,
+    ['runtime_tool_preview_validate'],
+    observationContext([successfulFinalStaticObservation]),
+  );
+  assert(
+    responseFunctionNames(finalPreviewResponse).join(',') ===
+      'runtime_tool_preview_validate',
+    'self-test-final-preview-not-exclusive',
+  );
+  const successfulFinalPreviewObservation = {
+    tool: 'preview.validate',
+    status: 'ok',
+    summary: '桌面与移动视口真实试玩已通过',
+    detail: null,
+  };
+  const finalHistoryResponse = route(
+    'project-supervisor',
+    rootRunId,
+    ['runtime_tool_agent_action_history'],
+    observationContext([successfulFinalPreviewObservation]),
+  );
+  const finalHistoryCalls = responseFunctionCalls(finalHistoryResponse);
+  assert(
+    finalHistoryCalls.length === 1 &&
+      finalHistoryCalls[0]?.name === 'runtime_tool_agent_action_history' &&
+      JSON.stringify(finalHistoryCalls[0]?.arguments?.input) ===
+        JSON.stringify({
+          runId: null,
+          actionId: null,
+          tool: null,
+          status: 'ok',
+          limit: 10,
+        }),
+    'self-test-final-action-history-invalid',
+  );
+  const staticActionId = `action-${'1'.repeat(24)}`;
+  const previewActionId = `action-${'2'.repeat(24)}`;
+  const actionHistoryDetail = JSON.stringify({
+    runId: rootRunId,
+    count: 2,
+    truncated: false,
+    outputTruncated: false,
+    actions: [
+      {
+        agentId: 'project-supervisor',
+        runId: rootRunId,
+        actionId: staticActionId,
+        tool: 'command.run_limited',
+        status: 'ok',
+      },
+      {
+        agentId: 'project-supervisor',
+        runId: rootRunId,
+        actionId: previewActionId,
+        tool: 'preview.validate',
+        status: 'ok',
+      },
+    ],
+  });
+  const finalAcceptanceResponse = route(
+    'project-supervisor',
+    rootRunId,
+    ['runtime_tool_agent_acceptance_update'],
+    observationContext([
+      {
+        tool: 'agent.action_history',
+        status: 'ok',
+        summary: '已读取当前 Agent 的 2 条终态动作',
+        detail: actionHistoryDetail,
+      },
+    ]),
+  );
+  const finalAcceptanceCalls = responseFunctionCalls(finalAcceptanceResponse);
+  const acceptanceInput = finalAcceptanceCalls[0]?.arguments?.input;
+  assert(
+    finalAcceptanceCalls.length === 1 &&
+      finalAcceptanceCalls[0]?.name ===
+        'runtime_tool_agent_acceptance_update' &&
+      acceptanceInput?.contractFingerprint === contractFingerprint &&
+      acceptanceInput?.evaluations?.length === 2 &&
+      acceptanceInput.evaluations[0]?.criterionId ===
+        'static-current-revision' &&
+      acceptanceInput.evaluations[0]?.evidence?.[0]?.actionId ===
+        staticActionId &&
+      acceptanceInput.evaluations[1]?.criterionId ===
+        'playable-current-revision' &&
+      acceptanceInput.evaluations[1]?.evidence?.[0]?.actionId ===
+        previewActionId,
+    'self-test-final-acceptance-update-invalid',
+  );
+  const finalRespondResponse = route(
+    'project-supervisor',
+    rootRunId,
+    ['respond_to_user'],
+    observationContext([
+      {
+        tool: 'agent.acceptance_update',
+        status: 'ok',
+        summary: 'Acceptance Graph 已更新',
+        detail: null,
+      },
+    ]),
+  );
+  assert(
+    responseFunctionNames(finalRespondResponse).join(',') === 'respond_to_user',
+    'self-test-final-respond-not-exclusive',
+  );
+
+  const planRejectionRouter = createDeterministicLaneDefenseRouter({ apiKey });
+  planRejectionRouter.route({
+    authorization: `Bearer ${apiKey}`,
+    payload: syntheticPayload(
+      'project-supervisor',
+      'plan-rejection-run',
+      goalContractTools,
+    ),
+  });
+  const planRejectionResponse = planRejectionRouter.route({
+    authorization: `Bearer ${apiKey}`,
+    payload: syntheticPayload(
+      'project-supervisor',
+      'plan-rejection-run',
+      ['respond_to_user', 'runtime_tool_file_patch', 'runtime_tool_file_write'],
+      '当前父 run 已进入只编排模式；本轮只允许收束或安全编排。',
+    ),
+  });
+  const planRejectionWaitResponse = planRejectionRouter.route({
+    authorization: `Bearer ${apiKey}`,
+    payload: syntheticPayload(
+      'project-supervisor',
+      'plan-rejection-run',
+      ['runtime_tool_task_list', 'runtime_tool_agent_run_status'],
+      '当前正式 manifest DAG 仍有专业 task 在运行',
+    ),
+  });
+  const planRejectionStats = planRejectionRouter.getStats();
+  assert(
+    responseFunctionNames(planRejectionResponse).join(',') ===
+      'respond_to_user' &&
+      responseFunctionNames(planRejectionWaitResponse).join(',') ===
+        'runtime_tool_task_list,runtime_tool_agent_run_status' &&
+      planRejectionStats.byAgent?.['project-supervisor']?.projectMutation ===
+        0 &&
+      planRejectionStats.delegateActionCount === 0 &&
+      planRejectionStats.runStatusCount === 1 &&
+      planRejectionStats.unexpectedRequestCount === 0,
+    'self-test-supervisor-plan-rejection-did-not-converge-read-only',
+  );
+
+  const earlyFinalReplyRouter = createDeterministicLaneDefenseRouter({
+    apiKey,
+  });
+  assert(
+    captureProviderErrorCode(() =>
+      earlyFinalReplyRouter.route({
+        authorization: `Bearer ${apiKey}`,
+        payload: syntheticPayload(
+          'project-supervisor',
+          'early-final-reply-run',
+          [],
+          '给用户一个正常中文回复',
+        ),
+      }),
+    ) === 'provider-parent-final-reply-before-acceptance',
+    'self-test-parent-final-reply-bypassed-acceptance',
+  );
+
+  const acceptanceGuardRunId = 'acceptance-guard-run';
+  const acceptanceGuardRouter = createDeterministicLaneDefenseRouter({
+    apiKey,
+  });
+  const acceptanceGuardRoute = (tools, extraContext = '') =>
+    acceptanceGuardRouter.route({
+      authorization: `Bearer ${apiKey}`,
+      payload: syntheticPayload(
+        'project-supervisor',
+        acceptanceGuardRunId,
+        tools,
+        extraContext,
+      ),
+    });
+  acceptanceGuardRoute(goalContractTools);
+  acceptanceGuardRoute(
+    ['runtime_tool_command_run_limited'],
+    `${contractContext}\n已有工具观察：\nseedTaskCounts: completed=16 running=0 pending=0 waiting=0 failed=0 total=16`,
+  );
+  acceptanceGuardRoute(
+    ['runtime_tool_preview_validate'],
+    observationContext([successfulFinalStaticObservation]),
+  );
+  acceptanceGuardRoute(
+    ['runtime_tool_agent_action_history'],
+    observationContext([successfulFinalPreviewObservation]),
+  );
+  const acceptanceGuardDetail = JSON.parse(actionHistoryDetail);
+  acceptanceGuardDetail.runId = acceptanceGuardRunId;
+  for (const action of acceptanceGuardDetail.actions) {
+    action.runId = acceptanceGuardRunId;
+  }
+  const actionHistoryObservationFor = (detail) => ({
+    tool: 'agent.action_history',
+    status: 'ok',
+    summary: '已读取当前 Agent 的 2 条终态动作',
+    detail: JSON.stringify(detail),
+  });
+  const ambiguousContractContext = `[Root Goal Contract]\n{"contractFingerprint":"${contractFingerprint}","nested":{"contractFingerprint":"${'b'.repeat(64)}"}}`;
+  assert(
+    captureProviderErrorCode(() =>
+      acceptanceGuardRoute(
+        ['runtime_tool_agent_acceptance_update'],
+        `${ambiguousContractContext}\n已有工具观察：\n${JSON.stringify([
+          actionHistoryObservationFor(acceptanceGuardDetail),
+        ])}`,
+      ),
+    ) === 'provider-goal-contract-fingerprint-missing',
+    'self-test-ambiguous-goal-contract-fingerprint-accepted',
+  );
+  const invalidActionHistoryDetail = structuredClone(acceptanceGuardDetail);
+  invalidActionHistoryDetail.actions[0].actionId = 'action-invalid';
+  assert(
+    captureProviderErrorCode(() =>
+      acceptanceGuardRoute(
+        ['runtime_tool_agent_acceptance_update'],
+        `${contractContext}\n已有工具观察：\n${JSON.stringify([
+          actionHistoryObservationFor(invalidActionHistoryDetail),
+        ])}`,
+      ),
+    ) === 'provider-final-acceptance-evidence-missing',
+    'self-test-invalid-action-history-id-accepted',
+  );
+  assert(
+    responseFunctionNames(
+      acceptanceGuardRoute(
+        ['runtime_tool_agent_acceptance_update'],
+        `${contractContext}\n已有工具观察：\n${JSON.stringify([
+          actionHistoryObservationFor(acceptanceGuardDetail),
+        ])}`,
+      ),
+    ).join(',') === 'runtime_tool_agent_acceptance_update',
+    'self-test-acceptance-stage-advanced-after-rejected-history',
+  );
+
   const stats = router.getStats();
   const manifestReadyTasks = manifestReadyTaskEvidence(stats);
   assert(
-    manifestReadyTasks.exactlyOnce,
+    manifestReadyTasks.exactlyOnce &&
+      stats.goalContractCount === 1 &&
+      stats.actionHistoryCount === 1 &&
+      stats.acceptanceUpdateCount === 1 &&
+      stats.interactionExecuteCount === 1 &&
+      stats.delegateActionCount === 0 &&
+      stats.imageInspectionRequestCount === 1 &&
+      stats.manifestReadyTaskCanvasGenerationCount === 3 &&
+      stats.byAgent?.['project-supervisor']?.projectMutation === 0 &&
+      stats.byAgent?.['code-prototype']?.projectMutation === 1 &&
+      stats.byAgent?.['quality-review']?.projectMutation === 0,
     'self-test-manifest-ready-exactly-once-invalid',
   );
 
@@ -597,6 +1086,20 @@ async function runSelfTest() {
     detail:
       'repositoryContextDrift=true · 请在同一 run 下一轮 planning 重新确认适用规范',
   };
+  const projectLockSmokeObservations = [
+    {
+      tool: 'command.run_limited',
+      status: 'failed',
+      summary: 'game.static_smoke 无法取得项目验证锁',
+      detail: '项目正在被其他写操作占用：$PROJECT_ROOT/.agent/project.lock',
+    },
+    {
+      tool: 'command.run_limited',
+      status: 'failed',
+      summary: 'game.static_smoke 无法取得项目验证锁',
+      detail: '项目正在被其他写操作占用：$PROJECT_ROOT\\.agent\\project.lock',
+    },
+  ];
   const projectRevisionDriftSmokeObservation = {
     tool: 'command.run_limited',
     status: 'blocked',
@@ -604,43 +1107,179 @@ async function runSelfTest() {
     detail:
       'projectRevisionDrift=true · expectedRevision=4 · currentRevision=5 · replanRequired=true',
   };
+  const projectRevisionDriftCanvasObservation = {
+    tool: 'canvas.asset_generate',
+    status: 'blocked',
+    summary: '并行项目变更使旧动作过期，旧动作未执行',
+    detail:
+      'projectRevisionDrift=true · expectedRevision=5 · currentRevision=6 · replanRequired=true',
+  };
   const successfulProjectMutationObservation = {
     tool: 'project.patchset',
     status: 'ok',
     summary: 'project.patchset 已原子应用 2 项变更',
     detail: 'checkpointId=checkpoint-concurrent-ready-batch',
   };
-  const captureProviderErrorCode = (operation) => {
-    try {
-      operation();
-      return null;
-    } catch (error) {
-      return error?.code ?? null;
-    }
+  const missingArtAssetObservation = {
+    tool: 'runtime.visual_asset',
+    status: 'blocked',
+    summary: '首版美术素材图尚未按正式视觉流程生成并登记，不能完成任务',
+    detail: '[redacted sensitive context]',
+  };
+  const successfulCanvasMutationObservation = {
+    tool: 'canvas.asset_generate',
+    status: 'ok',
+    summary: '素材画布图片已生成并登记',
+    detail: null,
   };
 
-  const oldSmokeRouter = createDeterministicLaneDefenseRouter({ apiKey });
-  const oldSmokeRoute = (extraContext = '') =>
-    oldSmokeRouter.route({
+  const artAssetRecoveryAgentId = 'art-asset-plan';
+  const artAssetRecoveryRunId = 'art-asset-visual-recovery-ready-run';
+  const artAssetRecoveryTools = [
+    ...manifestReadyTools,
+    'runtime_tool_canvas_asset_generate',
+  ];
+  const artAssetRecoveryRouter = createDeterministicLaneDefenseRouter({
+    apiKey,
+  });
+  const artAssetRecoveryRoute = (extraContext = '') =>
+    artAssetRecoveryRouter.route({
       authorization: `Bearer ${apiKey}`,
       payload: syntheticPayload(
-        'code-prototype',
-        'old-smoke-initial-code-run',
-        allTools,
-        extraContext,
+        artAssetRecoveryAgentId,
+        artAssetRecoveryRunId,
+        artAssetRecoveryTools,
+        `处理 manifest ready 任务：${artAssetRecoveryAgentId}\n任务 ID：${artAssetRecoveryAgentId}${extraContext}`,
       ),
     });
-  oldSmokeRoute();
-  oldSmokeRoute();
-  oldSmokeRoute();
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    if (
+      responseFunctionNames(artAssetRecoveryRoute()).includes('respond_to_user')
+    ) {
+      break;
+    }
+  }
+  const artAssetRegenerationResponse = artAssetRecoveryRoute(
+    retryObservationContext([missingArtAssetObservation]),
+  );
+  const artAssetReverificationResponse = artAssetRecoveryRoute(
+    retryObservationContext([successfulCanvasMutationObservation]),
+  );
+  const artAssetRefinalizationResponse = artAssetRecoveryRoute(
+    retryObservationContext([successfulSmokeObservation]),
+  );
+  const artAssetRecoveryStats = artAssetRecoveryRouter.getStats();
   assert(
-    responseFunctionNames(
-      oldSmokeRoute(retryObservationContext([successfulSmokeObservation])),
-    ).includes('respond_to_user') &&
-      captureProviderErrorCode(() =>
-        oldSmokeRoute(retryObservationContext([successfulSmokeObservation])),
-      ) === 'provider-terminal-replay-unarmed:code-prototype',
-    'self-test-initial-terminal-old-smoke-replayed',
+    responseFunctionNames(artAssetRegenerationResponse).join(',') ===
+      'runtime_tool_canvas_asset_generate' &&
+      responseFunctionNames(artAssetReverificationResponse).join(',') ===
+        'runtime_tool_command_run_limited' &&
+      responseFunctionNames(artAssetRefinalizationResponse).includes(
+        'respond_to_user',
+      ) &&
+      artAssetRecoveryStats.readyTaskCountsByAgent[artAssetRecoveryAgentId]
+        ?.completion === 1 &&
+      artAssetRecoveryStats.manifestReadyTaskCanvasGenerationCount === 2 &&
+      artAssetRecoveryStats.unexpectedRequestCount === 0,
+    'self-test-art-asset-visual-recovery-not-exactly-once',
+  );
+
+  const artAssetRevisionDriftRunId = 'art-asset-revision-drift-ready-run';
+  const artAssetRevisionDriftRouter = createDeterministicLaneDefenseRouter({
+    apiKey,
+  });
+  const artAssetRevisionDriftRoute = (extraContext = '') =>
+    artAssetRevisionDriftRouter.route({
+      authorization: `Bearer ${apiKey}`,
+      payload: syntheticPayload(
+        artAssetRecoveryAgentId,
+        artAssetRevisionDriftRunId,
+        artAssetRecoveryTools,
+        `处理 manifest ready 任务：${artAssetRecoveryAgentId}\n任务 ID：${artAssetRecoveryAgentId}${extraContext}`,
+      ),
+    });
+  const artAssetInitialListResponse = artAssetRevisionDriftRoute();
+  const artAssetManifestWriteResponse = artAssetRevisionDriftRoute();
+  const artAssetInitialCanvasResponse = artAssetRevisionDriftRoute();
+  const artAssetRetryCanvasResponse = artAssetRevisionDriftRoute(
+    retryObservationContext([projectRevisionDriftCanvasObservation]),
+  );
+  const artAssetPostRetryReadResponse = artAssetRevisionDriftRoute(
+    retryObservationContext([successfulCanvasMutationObservation]),
+  );
+  const artAssetRevisionDriftFinalizationResponse =
+    artAssetRevisionDriftRoute();
+  const artAssetRevisionDriftStats = artAssetRevisionDriftRouter.getStats();
+  assert(
+    responseFunctionNames(artAssetInitialListResponse).join(',') ===
+      'runtime_tool_asset_list' &&
+      responseFunctionNames(artAssetManifestWriteResponse).join(',') ===
+        'runtime_tool_file_write' &&
+      responseFunctionNames(artAssetInitialCanvasResponse).join(',') ===
+        'runtime_tool_canvas_asset_generate' &&
+      responseFunctionNames(artAssetRetryCanvasResponse).join(',') ===
+        'runtime_tool_canvas_asset_generate' &&
+      responseFunctionNames(artAssetPostRetryReadResponse).join(',') ===
+        'runtime_tool_file_read,runtime_tool_asset_list' &&
+      responseFunctionNames(artAssetRevisionDriftFinalizationResponse).includes(
+        'respond_to_user',
+      ) &&
+      artAssetRevisionDriftStats.readyTaskCountsByAgent[artAssetRecoveryAgentId]
+        ?.run === 1 &&
+      artAssetRevisionDriftStats.readyTaskCountsByAgent[artAssetRecoveryAgentId]
+        ?.completion === 1 &&
+      artAssetRevisionDriftStats.manifestReadyTaskCanvasGenerationCount === 2 &&
+      artAssetRevisionDriftStats.unexpectedRequestCount === 0,
+    'self-test-art-asset-revision-drift-recovery-not-exactly-once',
+  );
+
+  const artAssetRevisionDriftLimitRunId =
+    'art-asset-revision-drift-limit-ready-run';
+  const artAssetRevisionDriftLimitRouter = createDeterministicLaneDefenseRouter(
+    { apiKey },
+  );
+  const artAssetRevisionDriftLimitRoute = (extraContext = '') =>
+    artAssetRevisionDriftLimitRouter.route({
+      authorization: `Bearer ${apiKey}`,
+      payload: syntheticPayload(
+        artAssetRecoveryAgentId,
+        artAssetRevisionDriftLimitRunId,
+        artAssetRecoveryTools,
+        `处理 manifest ready 任务：${artAssetRecoveryAgentId}\n任务 ID：${artAssetRecoveryAgentId}${extraContext}`,
+      ),
+    });
+  artAssetRevisionDriftLimitRoute();
+  artAssetRevisionDriftLimitRoute();
+  artAssetRevisionDriftLimitRoute();
+  for (let retry = 0; retry < 16; retry += 1) {
+    assert(
+      responseFunctionNames(
+        artAssetRevisionDriftLimitRoute(
+          retryObservationContext([projectRevisionDriftCanvasObservation]),
+        ),
+      ).join(',') === 'runtime_tool_canvas_asset_generate',
+      `self-test-art-asset-revision-drift-retry-invalid:${retry}`,
+    );
+  }
+  const artAssetRevisionDriftLimitCode = captureProviderErrorCode(() =>
+    artAssetRevisionDriftLimitRoute(
+      retryObservationContext([projectRevisionDriftCanvasObservation]),
+    ),
+  );
+  const artAssetRevisionDriftLimitStats =
+    artAssetRevisionDriftLimitRouter.getStats();
+  assert(
+    artAssetRevisionDriftLimitCode ===
+      'provider-ready-art-canvas-retry-exhausted' &&
+      artAssetRevisionDriftLimitStats.readyTaskCountsByAgent[
+        artAssetRecoveryAgentId
+      ]?.run === 1 &&
+      artAssetRevisionDriftLimitStats.readyTaskCountsByAgent[
+        artAssetRecoveryAgentId
+      ]?.completion === 0 &&
+      artAssetRevisionDriftLimitStats.manifestReadyTaskCanvasGenerationCount ===
+        17,
+    'self-test-art-asset-revision-drift-limit-invalid',
   );
 
   const readOnlyCommandRouter = createDeterministicLaneDefenseRouter({
@@ -713,58 +1352,30 @@ async function runSelfTest() {
     'self-test-ready-precompletion-limit-invalid',
   );
 
-  const exerciseInitialTerminalRetryLimit = ({
-    agentId,
-    runId,
-    tools,
-    initialRequestCount,
-  }) => {
-    const terminalRouter = createDeterministicLaneDefenseRouter({ apiKey });
-    const terminalRoute = (extraContext = '') =>
-      terminalRouter.route({
-        authorization: `Bearer ${apiKey}`,
-        payload: syntheticPayload(agentId, runId, tools, extraContext),
-      });
-    for (let request = 0; request < initialRequestCount; request += 1) {
-      terminalRoute();
-    }
-    let deliveryCount = 0;
-    for (let retry = 0; retry < 16; retry += 1) {
-      assert(
-        responseFunctionNames(
-          terminalRoute(retryObservationContext([staleObservation])),
-        ).join(',') === 'runtime_tool_command_run_limited',
-        `self-test-initial-terminal-verification-invalid:${agentId}:${retry}`,
-      );
-      if (
-        responseFunctionNames(
-          terminalRoute(retryObservationContext([successfulSmokeObservation])),
-        ).includes('respond_to_user')
-      ) {
-        deliveryCount += 1;
-      }
-    }
-    const limitCode = captureProviderErrorCode(() =>
-      terminalRoute(retryObservationContext([staleObservation])),
-    );
+  const projectLockRouter = createDeterministicLaneDefenseRouter({ apiKey });
+  const projectLockRunId = 'project-lock-transient-ready-run';
+  const projectLockRoute = (tools, extraContext = '') =>
+    projectLockRouter.route({
+      authorization: `Bearer ${apiKey}`,
+      payload: syntheticPayload(
+        preCompletionAgentId,
+        projectLockRunId,
+        tools,
+        `处理 manifest ready 任务：${preCompletionAgentId}\n任务 ID：${preCompletionAgentId}${extraContext}`,
+      ),
+    });
+  projectLockRoute(manifestReadyTools);
+  for (const observation of projectLockSmokeObservations) {
     assert(
-      deliveryCount === 16 &&
-        limitCode === `provider-terminal-retry-exhausted:${agentId}`,
-      `self-test-initial-terminal-retry-limit-invalid:${agentId}`,
+      responseFunctionNames(
+        projectLockRoute(
+          ['runtime_tool_command_run_limited'],
+          retryObservationContext([observation]),
+        ),
+      ).join(',') === 'runtime_tool_command_run_limited',
+      'self-test-ready-project-lock-path-separator-not-retried',
     );
-  };
-  exerciseInitialTerminalRetryLimit({
-    agentId: 'code-prototype',
-    runId: 'initial-code-terminal-retry-run',
-    tools: allTools,
-    initialRequestCount: 3,
-  });
-  exerciseInitialTerminalRetryLimit({
-    agentId: 'art-asset-plan',
-    runId: 'initial-art-terminal-retry-run',
-    tools: [...manifestReadyTools, 'runtime_tool_canvas_asset_generate'],
-    initialRequestCount: 5,
-  });
+  }
 
   const duplicateRouter = createDeterministicLaneDefenseRouter({ apiKey });
   const duplicateRoute = (runId, extraContext = '') =>
@@ -857,6 +1468,49 @@ async function runSelfTest() {
     'self-test-ready-retry-limit-or-exactly-once-invalid',
   );
 
+  const verifiedDeliveryRepairRouter = createDeterministicLaneDefenseRouter({
+    apiKey,
+  });
+  const verifiedDeliveryRepairRunId = 'verified-delivery-repair-ready-run';
+  const verifiedDeliveryRepairRoute = (tools, extraContext = '') =>
+    verifiedDeliveryRepairRouter.route({
+      authorization: `Bearer ${apiKey}`,
+      payload: syntheticPayload(
+        retryAgentId,
+        verifiedDeliveryRepairRunId,
+        tools,
+        `处理 manifest ready 任务：${retryAgentId}\n任务 ID：${retryAgentId}${extraContext}`,
+      ),
+    });
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    if (
+      responseFunctionNames(
+        verifiedDeliveryRepairRoute(manifestReadyTools),
+      ).includes('respond_to_user')
+    ) {
+      break;
+    }
+  }
+  const rejectedVerificationPlan = verifiedDeliveryRepairRoute(
+    manifestReadyTools,
+    retryObservationContext([staleObservation]),
+  );
+  const verifiedDeliveryRepairResponse = verifiedDeliveryRepairRoute(
+    ['respond_to_user'],
+    `${retryObservationContext([staleObservation])}\n上一条输出不符合工具计划协议：当前 revision 已通过验证。本次修复的原生工具目录只保留 respond_to_user；必须立即调用它交付专业合同结论。`,
+  );
+  const verifiedDeliveryRepairStats = verifiedDeliveryRepairRouter.getStats();
+  assert(
+    responseFunctionNames(rejectedVerificationPlan).join(',') ===
+      'runtime_tool_command_run_limited' &&
+      responseFunctionNames(verifiedDeliveryRepairResponse).join(',') ===
+        'respond_to_user' &&
+      verifiedDeliveryRepairStats.readyTaskCountsByAgent[retryAgentId]
+        ?.completion === 1 &&
+      verifiedDeliveryRepairStats.unexpectedRequestCount === 0,
+    'self-test-ready-verified-delivery-repair-invalid',
+  );
+
   const transientRetryRouter = createDeterministicLaneDefenseRouter({ apiKey });
   const transientRetryRunId = 'transient-retry-ready-run';
   const transientRetryRoute = (extraContext = '') =>
@@ -1094,23 +1748,24 @@ async function runSelfTest() {
       readOnlyRetryRouter.getStats().manifestReadyTaskStaticSmokeCount === 0,
     'self-test-read-only-retry-used-forbidden-verification',
   );
-  const responsibilityContract = responsibilityContractEvidence(stats);
   assert(
-    responsibilityContract.codeOwnsGameIndex &&
-      responsibilityContract.qualityIsReadOnly &&
-      responsibilityContract.qualityIndependentOfCodeTiming &&
-      responsibilityContract.artOwnsGeneratedAsset &&
-      responsibilityContract.contractViolationFree,
-    'self-test-responsibility-contract-invalid',
-  );
-  assert(
-    stats.initialDelegationCount === 3 &&
-      stats.followupDelegationCount === 1 &&
-      stats.supervisorDirectMutationAttemptCount === 1 &&
+    stats.goalContractCount === 1 &&
+      stats.actionHistoryCount === 1 &&
+      stats.acceptanceUpdateCount === 1 &&
+      stats.delegateActionCount === 0 &&
+      stats.manifestReadyTaskCanvasGenerationCount === 3 &&
+      stats.byAgent?.['project-supervisor']?.projectMutation === 0 &&
+      stats.byAgent?.['code-prototype']?.projectMutation === 1 &&
+      stats.byAgent?.['quality-review']?.projectMutation === 0 &&
       stats.unexpectedRequestCount === 0,
     'self-test-provider-core-stats-invalid',
   );
 
+  const syntheticRuntimeProviderRequestCount =
+    stats.requestCount -
+    stats.interactionExecuteCount -
+    stats.imageInspectionRequestCount;
+
   const syntheticChildReport = {
     status: 'PASS',
     suite,
@@ -1138,10 +1793,10 @@ async function runSelfTest() {
       projectRevisionDelta: 2,
       finalSupervisorAssistantCount: 1,
       professionalAssistantCount: 3,
-      providerRequestIdentityCount: stats.requestCount,
-      providerLifecycleStartedCount: stats.requestCount,
-      providerLifecycleTerminalCount: stats.requestCount,
-      providerLifecycleCompletedCount: stats.requestCount,
+      providerRequestIdentityCount: syntheticRuntimeProviderRequestCount,
+      providerLifecycleStartedCount: syntheticRuntimeProviderRequestCount,
+      providerLifecycleTerminalCount: syntheticRuntimeProviderRequestCount,
+      providerLifecycleCompletedCount: syntheticRuntimeProviderRequestCount,
     },
   };
   const incompletePlaytestReport = structuredClone(syntheticChildReport);
@@ -1195,14 +1850,39 @@ async function runSelfTest() {
       run: duplicateRunCode,
     },
     terminalRetryContractsValidated: {
-      oldSmokeObservationSingleUse: true,
       readOnlyCommandOnlyRejected: true,
       preCompletionTransientRetryLimit: 16,
-      initialCodeRetryLimit: 16,
-      initialArtRetryLimit: 16,
+      projectLockPathSeparatorsRetried: ['/', '\\'],
     },
-    responsibilityContract,
-    qualityTimingOrdersValidated: ['before-code', 'after-code'],
+    providerRuntimeModeValidated: true,
+    interactionExecutionValidated: {
+      reasoningEffort: 'max',
+      requestCount: stats.interactionExecuteCount,
+      responseTools: interactionExecuteCalls.map((call) => call.name),
+      readyTaskRunCountBeforeRuntime:
+        interactionExecuteStats.manifestReadyTaskRunCount,
+      readyTaskCompletionCountBeforeRuntime:
+        interactionExecuteStats.manifestReadyTaskCompletionCount,
+    },
+    goalContractValidated: true,
+    finalizationSequenceValidated: [
+      'command.run_limited',
+      'preview.validate',
+      'agent.action_history',
+      'agent.acceptance_update',
+      'respond_to_user',
+    ],
+    canvasArtifactsValidated: [
+      'assets/art-spec.png',
+      'assets/ui-prototype.png',
+      'assets/art-spritesheet.png',
+    ],
+    uiPrototypeInspectionValidated: true,
+    uiPrototypeVisualRecoveryExactlyOnceValidated: true,
+    artAssetVisualRecoveryExactlyOnceValidated: true,
+    artAssetRevisionDriftRecoveryExactlyOnceValidated: true,
+    artAssetRevisionDriftRetryLimitValidated: 16,
+    supervisorPlanRejectionMode: 'respond-only-then-read-only-wait',
     childHardGatesValidated: true,
     packageCommandsRegistered: true,
   };
@@ -1228,23 +1908,7 @@ async function runE2e(options) {
       { flag: 'wx', mode: 0o600 },
     );
     provider = await startDeterministicLaneDefenseProvider({ apiKey });
-    const config = {
-      editorApi: {
-        apiKey,
-        baseUrl: provider.editorBaseUrl,
-      },
-      llm: {
-        apiKey,
-        baseUrl: provider.baseUrl,
-        model: deterministicLaneDefenseModel,
-        apiKind: 'openai_chat',
-        reasoningEffort: 'low',
-        stream: false,
-        requestTimeoutMs: 30_000,
-        maxRetries: 0,
-        retryBackoffMs: 100,
-      },
-    };
+    const config = deterministicRuntimeConfig(apiKey, provider);
     await fs.writeFile(
       path.join(configDir, configFileName),
       `${JSON.stringify(config)}\n`,
@@ -1298,7 +1962,6 @@ async function runE2e(options) {
   const providerPassed =
     providerStats?.stopped === true && expectedProviderStats(providerStats);
   const manifestReadyTasks = manifestReadyTaskEvidence(providerStats);
-  const responsibilityContract = responsibilityContractEvidence(providerStats);
   const status =
     !failureCode && childPassed && providerPassed && configRemoved
       ? 'PASS'
@@ -1318,7 +1981,14 @@ async function runE2e(options) {
     child: childReport,
     provider: providerStats,
     manifestReadyTasks,
-    responsibilityContract,
+    finalizationContract: {
+      goalContractCount: providerStats?.goalContractCount ?? null,
+      actionHistoryCount: providerStats?.actionHistoryCount ?? null,
+      acceptanceUpdateCount: providerStats?.acceptanceUpdateCount ?? null,
+      delegateActionCount: providerStats?.delegateActionCount ?? null,
+      supervisorProjectMutationCount:
+        providerStats?.byAgent?.['project-supervisor']?.projectMutation ?? null,
+    },
     cleanup: {
       providerStopped: providerStats?.stopped === true,
       configRemoved,
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/assertions/runtime.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/assertions/runtime.mjs
index fb509b580..72448f213 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/assertions/runtime.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/assertions/runtime.mjs
@@ -2406,11 +2406,36 @@ export function isolatedJoinDeliveryTarget(delivery) {
   return target;
 }
 
-export function finalMessageId(agentId, sessionId, runId) {
-  const fingerprint = createHash('sha256')
+function runtimeMessageCorrelationId(agentId, sessionId, runId) {
+  return createHash('sha256')
     .update(`${agentId}\n${sessionId}\n${runId}`)
     .digest('hex');
-  return `agent-finalization-${fingerprint.slice(0, 32)}`;
+}
+
+export function finalMessageId(agentId, sessionId, runId) {
+  return `agent-finalization-${runtimeMessageCorrelationId(
+    agentId,
+    sessionId,
+    runId,
+  ).slice(0, 32)}`;
+}
+
+export function runtimePublicStatusMessageId(
+  agentId,
+  sessionId,
+  runId,
+  status,
+) {
+  const correlationId = runtimeMessageCorrelationId(
+    agentId,
+    sessionId,
+    runId,
+  ).slice(0, 32);
+  const statusFingerprint = createHash('sha256')
+    .update(status)
+    .digest('hex')
+    .slice(0, 16);
+  return `runtime-public-status-${correlationId}-${statusFingerprint}`;
 }
 
 export function backgroundTaskMessageId(agentId, sessionId, runId, source) {
@@ -2444,7 +2469,10 @@ export function disposableProjectPathVariants() {
 }
 
 export function formalConfigPathVariants() {
-  return absolutePathVariants(state.options?.configDir);
+  return absolutePathVariants(
+    state.options?.configDir,
+    state.isolatedRunner?.appDataDir,
+  );
 }
 
 export function absolutePathVariants(...values) {
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/entry.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/entry.mjs
index ca6b520fb..93d668d4d 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/entry.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/entry.mjs
@@ -20,7 +20,15 @@ import {
   stopOwnedIsolatedRunner,
 } from './harness/app-data.mjs';
 import { loadConfig, parseArguments } from './harness/config.mjs';
-import { closeInteractiveCli } from './harness/process.mjs';
+import {
+  activeInteractiveCliSessions,
+  captureOwnedProcessCleanupSnapshot,
+  closeInteractiveCli,
+  destroyInteractiveCliOutputStreams,
+  interactiveCliOutput,
+  verifyOwnedProcessCleanupSnapshot,
+  waitForInteractiveCliStdioClose,
+} from './harness/process.mjs';
 import { checkPrerequisites } from './harness/project.mjs';
 import {
   buildSummary,
@@ -266,6 +274,21 @@ if (selfTestRequested) {
     recordError(error?.code ?? 'unexpected-error', error);
   } finally {
     state.cleanupInProgress = true;
+    const stateTrackedInteractiveCliSessions = new Set(
+      [
+        state.userInputCliSession,
+        state.supervisorAutonomousPlayableCliSession,
+        state.supervisorSwarmCliSession,
+      ].filter(Boolean),
+    );
+    const interactiveCliSessions = [
+      ...new Set([
+        ...stateTrackedInteractiveCliSessions,
+        ...activeInteractiveCliSessions,
+      ]),
+    ];
+    const supervisorAutonomousPlayableCliSession =
+      state.supervisorAutonomousPlayableCliSession;
     if (isUserInputRuntimeSuite() && state.userInputCliSession) {
       try {
         await closeInteractiveCli(state.userInputCliSession);
@@ -311,6 +334,15 @@ if (selfTestRequested) {
       }
       state.supervisorSwarmCliSession = null;
     }
+    for (const session of interactiveCliSessions) {
+      if (stateTrackedInteractiveCliSessions.has(session)) continue;
+      try {
+        await closeInteractiveCli(session);
+      } catch (error) {
+        state.status = 'FAIL';
+        recordError('interactive-cli-cleanup-failed', error);
+      }
+    }
     if (isMcpRuntimeSuite() && state.mcp.httpFixture) {
       try {
         await stopMcpHttpFixture();
@@ -320,16 +352,42 @@ if (selfTestRequested) {
         recordError('mcp-http-fixture-cleanup-failed', error);
       }
     }
+    if (
+      isSupervisorAutonomousPlayableLaneDefenseSuite() &&
+      state.isolatedRunner.appDataDir
+    ) {
+      try {
+        const runnerPid = state.isolatedRunner.current?.pid ?? null;
+        const helperPid =
+          state.isolatedRunner.current?.killHandle?.child?.pid ?? null;
+        state.supervisorAutonomousPlayable.ownedProcessCleanupSnapshot =
+          await captureOwnedProcessCleanupSnapshot({
+            runnerPid,
+            helperPids: Number.isSafeInteger(helperPid) ? [helperPid] : [],
+            rootPids: [
+              ...interactiveCliSessions.map((session) => session.child?.pid),
+              ...[...activeCommandChildren].map((child) => child.pid),
+            ].filter((pid) => Number.isSafeInteger(pid) && pid > 0),
+          });
+        const observed =
+          state.supervisorAutonomousPlayable.ownedProcessCleanupSnapshot
+            .observedCounts;
+        assert(
+          observed.runner === 1 && observed.helper === 1,
+          'supervisor-autonomous-playable-owned-process-snapshot-incomplete',
+        );
+      } catch (error) {
+        state.status = 'FAIL';
+        recordError(
+          'supervisor-autonomous-playable-owned-process-snapshot-failed',
+          error,
+        );
+      }
+    }
     if (isIsolatedRunnerSuite() && state.isolatedRunner.appDataDir) {
       try {
         await stopOwnedIsolatedRunner();
         state.isolatedRunner.stopped = true;
-        state.isolatedRunner.cleanupPerformed =
-          await removeIsolatedSuiteAppData();
-        if (!state.isolatedRunner.cleanupPerformed) {
-          state.status = 'FAIL';
-          recordError('isolated-appdata-cleanup-sentinel-missing');
-        }
       } catch (error) {
         state.status = 'FAIL';
         const safeCleanupErrorCode =
@@ -342,8 +400,51 @@ if (selfTestRequested) {
           state.isolatedRunner.current?.killHandle,
         ).catch(() => {});
       }
+    }
+    for (const session of interactiveCliSessions) {
+      try {
+        await waitForInteractiveCliStdioClose(session, 10_000);
+      } catch (error) {
+        destroyInteractiveCliOutputStreams(session);
+        state.status = 'FAIL';
+        recordError(
+          error?.code === 'interactive-cli-stdio-close-timeout'
+            ? error.code
+            : 'interactive-cli-stdio-cleanup-failed',
+          error,
+        );
+      }
+    }
+    if (supervisorAutonomousPlayableCliSession) {
+      state.supervisorAutonomousPlayable.cliOutput = interactiveCliOutput(
+        supervisorAutonomousPlayableCliSession,
+      );
+    }
+    if (isIsolatedRunnerSuite() && state.isolatedRunner.appDataDir) {
+      if (state.isolatedRunner.stopped) {
+        try {
+          state.isolatedRunner.cleanupPerformed =
+            await removeIsolatedSuiteAppData();
+          if (!state.isolatedRunner.cleanupPerformed) {
+            state.status = 'FAIL';
+            recordError('isolated-appdata-cleanup-sentinel-missing');
+          }
+        } catch (error) {
+          state.status = 'FAIL';
+          const safeCleanupErrorCode =
+            isNonEmptyString(error?.code) &&
+            /^(?:isolated|source)-[a-z0-9-]+$/u.test(error.code)
+              ? error.code
+              : 'isolated-appdata-cleanup-failed';
+          recordError(safeCleanupErrorCode, error);
+        }
+      }
       const killMethod =
-        state.isolatedRunner.pidfdClaimCount > 0 ? 'linux-pidfd' : null;
+        state.isolatedRunner.pidfdClaimCount > 0
+          ? process.platform === 'win32'
+            ? 'windows-process-handle'
+            : 'linux-pidfd'
+          : null;
       if (isSteerRunnerKillSuite()) {
         state.evidence.steerRunnerStopped = state.isolatedRunner.stopped;
         state.evidence.steerAppDataCleanupPerformed =
@@ -661,6 +762,61 @@ if (selfTestRequested) {
         );
       }
     }
+    if (
+      isSupervisorAutonomousPlayableLaneDefenseSuite() &&
+      state.isolatedRunner.appDataDir
+    ) {
+      const snapshot =
+        state.supervisorAutonomousPlayable.ownedProcessCleanupSnapshot;
+      if (snapshot) {
+        try {
+          const cleanup = await verifyOwnedProcessCleanupSnapshot(snapshot);
+          state.evidence.ownedProcessIdentityCaptured = true;
+          state.evidence.ownedRunnerObservedCount =
+            snapshot.observedCounts.runner;
+          state.evidence.ownedHelperObservedCount =
+            snapshot.observedCounts.helper;
+          state.evidence.ownedNodeDescendantObservedCount =
+            snapshot.observedCounts.node;
+          state.evidence.ownedBrowserDescendantObservedCount =
+            snapshot.observedCounts.browser;
+          state.evidence.ownedCommandDescendantObservedCount =
+            snapshot.observedCounts.command;
+          state.evidence.ownedRunnerResidualCount =
+            cleanup.residualCounts.runner;
+          state.evidence.ownedHelperResidualCount =
+            cleanup.residualCounts.helper;
+          state.evidence.ownedNodeDescendantResidualCount =
+            cleanup.residualCounts.node;
+          state.evidence.ownedBrowserDescendantResidualCount =
+            cleanup.residualCounts.browser;
+          state.evidence.ownedCommandDescendantResidualCount =
+            cleanup.residualCounts.command;
+          state.evidence.activeCommandChildrenAfterCleanup =
+            cleanup.activeCommandChildCount;
+          state.evidence.activeInteractiveCliSessionsAfterCleanup =
+            cleanup.activeInteractiveCliSessionCount;
+          state.evidence.ownedProcessCleanupPassed = cleanup.clean;
+          if (!cleanup.clean) {
+            state.status = 'FAIL';
+            recordError(
+              'supervisor-autonomous-playable-owned-process-residual-detected',
+            );
+          }
+        } catch (error) {
+          state.status = 'FAIL';
+          recordError(
+            'supervisor-autonomous-playable-owned-process-verification-failed',
+            error,
+          );
+        }
+      } else {
+        state.status = 'FAIL';
+        recordError(
+          'supervisor-autonomous-playable-owned-process-snapshot-missing',
+        );
+      }
+    }
     if (
       isSteerRunnerKillSuite() &&
       state.projectRoot &&
@@ -1210,6 +1366,7 @@ if (selfTestRequested) {
       const safeSummary = {
         status: state.status,
         suite: state.suite,
+        providerUsed: false,
         blocked: state.blocked,
         cleanup: {
           performed: state.cleanupPerformed,
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/app-data.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/app-data.mjs
index becaa44d4..251fe1321 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/app-data.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/app-data.mjs
@@ -1,5 +1,8 @@
 import { assert, codedError, hashValue, sleep } from '../assertions/core.mjs';
-import { isNonEmptyString } from '../assertions/runtime.mjs';
+import {
+  absolutePathVariants,
+  isNonEmptyString,
+} from '../assertions/runtime.mjs';
 import {
   createHash,
   fs,
@@ -10,6 +13,7 @@ import {
   watchFileSystem,
 } from '../dependencies.mjs';
 import {
+  activeCommandChildren,
   appRoot,
   BlockedError,
   configFileName,
@@ -57,6 +61,7 @@ import {
   userInputAppDataSentinelSchema,
   webSearchAppDataSentinelFileName,
   webSearchAppDataSentinelSchema,
+  windowsProcessHandleHelperSource,
 } from '../runtime-state.mjs';
 import { isContextCompactionSuite } from '../suites/context-compaction.mjs';
 import { isGoalRuntimeSuite } from '../suites/goal.mjs';
@@ -66,7 +71,10 @@ import { isProjectSkillSuite } from '../suites/project-skill.mjs';
 import { isResponseStreamSuite } from '../suites/response-stream.mjs';
 import { isScopedAgentsSuite } from '../suites/scoped-agents.mjs';
 import { isSteerRunnerKillSuite } from '../suites/steer-runner-kill.mjs';
-import { isSupervisorAutonomousPlayableLaneDefenseSuite } from '../suites/supervisor-autonomous-playable.mjs';
+import {
+  isSupervisorAutonomousPlayableLaneDefenseSuite,
+  isSupervisorGameChatSingleMainPlayableSuite,
+} from '../suites/supervisor-autonomous-playable.mjs';
 import {
   isSupervisorSwarmAutonomousChatSuite,
   isSupervisorSwarmCollaborationPolicyMixedRecoverySuite,
@@ -112,6 +120,27 @@ export function isolatedSuiteUsesSiblingAppData() {
   return isWebSearchSuite() || isolatedSuiteProtectsSourceAppData();
 }
 
+export function sameSupervisorPlayableProviderBinding(left, right) {
+  const scalarFields = [
+    'providerAgentMode',
+    'providerModel',
+    'providerApiKind',
+    'providerReasoningEffort',
+    'providerBaseUrlSha256',
+  ];
+  return (
+    left != null &&
+    right != null &&
+    scalarFields.every((field) => left[field] === right[field]) &&
+    Array.isArray(left.boundAgentIds) &&
+    Array.isArray(right.boundAgentIds) &&
+    left.boundAgentIds.length === right.boundAgentIds.length &&
+    left.boundAgentIds.every(
+      (agentId, index) => agentId === right.boundAgentIds[index],
+    )
+  );
+}
+
 export function isolatedSuiteAppDataProfile() {
   if (isSteerRunnerKillSuite()) {
     return {
@@ -278,12 +307,19 @@ export async function createSentinelOwnedTempDirectory({
 }) {
   const directory = await fs.mkdtemp(prefix);
   try {
-    if (process.platform !== 'win32') await fs.chmod(directory, 0o700);
-    await fs.writeFile(
-      path.join(directory, sentinelName),
-      `${JSON.stringify(sentinel)}\n`,
-      { flag: 'wx', mode: 0o600 },
-    );
+    if (process.platform === 'win32') {
+      await secureWindowsOwnedTempPath(directory, true);
+    } else {
+      await fs.chmod(directory, 0o700);
+    }
+    const sentinelPath = path.join(directory, sentinelName);
+    await fs.writeFile(sentinelPath, `${JSON.stringify(sentinel)}\n`, {
+      flag: 'wx',
+      mode: 0o600,
+    });
+    if (process.platform === 'win32') {
+      await secureWindowsOwnedTempPath(sentinelPath, false);
+    }
     return directory;
   } catch (error) {
     try {
@@ -298,6 +334,91 @@ export async function createSentinelOwnedTempDirectory({
   }
 }
 
+export async function secureWindowsOwnedTempPath(targetPath, isDirectory) {
+  assert(
+    process.platform === 'win32' && path.isAbsolute(targetPath),
+    'isolated-windows-owned-path-precondition-invalid',
+  );
+  const powershell = await findControlledWindowsPowerShell();
+  const script = String.raw`
+$ErrorActionPreference = 'Stop'
+$targetPath = [Environment]::GetEnvironmentVariable(
+    'AGC_OWNED_TEMP_PATH',
+    [EnvironmentVariableTarget]::Process)
+$isDirectory = [Environment]::GetEnvironmentVariable(
+    'AGC_OWNED_TEMP_PATH_IS_DIRECTORY',
+    [EnvironmentVariableTarget]::Process) -eq '1'
+if ([String]::IsNullOrWhiteSpace($targetPath)) { exit 70 }
+$sid = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$inheritance = [System.Security.AccessControl.InheritanceFlags]::None
+if ($isDirectory) {
+    if (-not (Test-Path -LiteralPath $targetPath -PathType Container)) { exit 71 }
+    $acl = [System.Security.AccessControl.DirectorySecurity]::new()
+    $acl.SetAccessRuleProtection($true, $false)
+    $acl.SetOwner($sid)
+    $inheritance = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor [System.Security.AccessControl.InheritanceFlags]::ObjectInherit
+    $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+        $sid,
+        [System.Security.AccessControl.FileSystemRights]::FullControl,
+        $inheritance,
+        [System.Security.AccessControl.PropagationFlags]::None,
+        [System.Security.AccessControl.AccessControlType]::Allow)
+} else {
+    if (-not (Test-Path -LiteralPath $targetPath -PathType Leaf)) { exit 72 }
+    $acl = [System.Security.AccessControl.FileSecurity]::new()
+    $acl.SetAccessRuleProtection($true, $false)
+    $acl.SetOwner($sid)
+    $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+        $sid,
+        [System.Security.AccessControl.FileSystemRights]::FullControl,
+        [System.Security.AccessControl.AccessControlType]::Allow)
+}
+[void]$acl.AddAccessRule($rule)
+Set-Acl -LiteralPath $targetPath -AclObject $acl
+$targetItem = Get-Item -LiteralPath $targetPath -Force
+$verified = $targetItem.GetAccessControl()
+$verifiedOwner = $verified.GetOwner(
+    [System.Security.Principal.SecurityIdentifier])
+$verifiedRules = @($verified.GetAccessRules(
+    $true,
+    $true,
+    [System.Security.Principal.SecurityIdentifier]))
+if (
+    -not $verifiedOwner.Equals($sid) -or
+    -not $verified.AreAccessRulesProtected -or
+    $verifiedRules.Count -ne 1
+) { exit 73 }
+$verifiedRule = $verifiedRules[0]
+if (
+    -not $verifiedRule.IdentityReference.Equals($sid) -or
+    $verifiedRule.AccessControlType -ne
+        [System.Security.AccessControl.AccessControlType]::Allow -or
+    [int]$verifiedRule.FileSystemRights -ne
+        [int][System.Security.AccessControl.FileSystemRights]::FullControl -or
+    $verifiedRule.InheritanceFlags -ne $inheritance -or
+    $verifiedRule.PropagationFlags -ne
+        [System.Security.AccessControl.PropagationFlags]::None -or
+    $verifiedRule.IsInherited
+) { exit 74 }
+`;
+  try {
+    await runProcess(
+      powershell,
+      ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', script],
+      {
+        cwd: appRoot,
+        timeoutMs: 30_000,
+        env: controlledWindowsPowerShellEnvironment({
+          AGC_OWNED_TEMP_PATH: targetPath,
+          AGC_OWNED_TEMP_PATH_IS_DIRECTORY: isDirectory ? '1' : '0',
+        }),
+      },
+    );
+  } catch (error) {
+    throw codedError('isolated-windows-owned-path-secure-failed', error);
+  }
+}
+
 export async function captureSourceRunnerEndpointSnapshot(sourceConfigDir) {
   const endpointPath = path.join(sourceConfigDir, runnerEndpointFileName);
   const metadata = await fs.lstat(endpointPath).catch((error) => {
@@ -439,8 +560,11 @@ export async function prepareIsolatedSuiteAppData({
   state.isolatedRunner.appDataDir = appDataDir;
   state.isolatedRunner.ownerToken = ownerToken;
   state.isolatedRunner.createdAt = createdAt;
+  const realAppDataDir = await fs.realpath(appDataDir);
+  state.formalConfigPathTranscriptScanner?.addSecrets(
+    absolutePathVariants(appDataDir, realAppDataDir),
+  );
   if (isolatedSuiteProtectsSourceAppData()) {
-    const realAppDataDir = await fs.realpath(appDataDir);
     assert(
       !isPathInside(sourceConfigDir, realAppDataDir) &&
         path.dirname(realAppDataDir) === path.dirname(sourceConfigDir),
@@ -708,6 +832,56 @@ export async function prepareIsolatedSuiteAppData({
     });
   assert(!unexpectedEndpoint, `${profile.codePrefix}-endpoint-preexisted`);
   state.runtimeConfigDir = appDataDir;
+  if (isSupervisorAutonomousPlayableLaneDefenseSuite()) {
+    const isolatedConfig = await loadConfig(appDataDir);
+    const expectedBinding = state.config.providerBinding;
+    const agentIds = isSupervisorGameChatSingleMainPlayableSuite()
+      ? [
+          projectSupervisorAgentId,
+          mainAgentId,
+          'art-director',
+          'art-asset-plan',
+        ]
+      : [projectSupervisorAgentId];
+    const bindings = agentIds.map((agentId) => {
+      const effective = effectiveAgentLlmConfig(isolatedConfig.config, agentId);
+      assert(
+        ['apiKey', 'baseUrl', 'model', 'apiKind', 'reasoningEffort'].every(
+          (key) => isNonEmptyString(effective[key]),
+        ),
+        'supervisor-autonomous-playable-effective-provider-incomplete',
+      );
+      return {
+        providerModel: effective.model.trim(),
+        providerApiKind: effective.apiKind.trim(),
+        providerReasoningEffort: effective.reasoningEffort.trim(),
+        providerBaseUrlSha256: hashValue(effective.baseUrl.trim()),
+      };
+    });
+    const effectiveBinding = {
+      ...bindings[0],
+      ...(isSupervisorGameChatSingleMainPlayableSuite()
+        ? { providerAgentMode: isolatedConfig.config.agentMode?.trim() ?? null }
+        : {}),
+      boundAgentIds: [...agentIds].sort(),
+    };
+    assert(
+      expectedBinding &&
+        bindings.every(
+          (binding) => JSON.stringify(binding) === JSON.stringify(bindings[0]),
+        ) &&
+        sameSupervisorPlayableProviderBinding(
+          effectiveBinding,
+          expectedBinding,
+        ),
+      'supervisor-autonomous-playable-effective-provider-binding-mismatch',
+    );
+    state.supervisorAutonomousPlayable.expectedProviderBinding = {
+      ...expectedBinding,
+    };
+    state.supervisorAutonomousPlayable.effectiveProviderBinding =
+      effectiveBinding;
+  }
   if (streamAgentId) {
     const isolatedConfig = await loadConfig(appDataDir);
     const isolatedEffective = effectiveAgentLlmConfig(
@@ -1066,22 +1240,27 @@ export async function verifyOwnedRunnerForKill() {
 }
 
 export async function ensureOwnedRunnerStableKillSupport() {
-  assert(
-    process.platform === 'linux',
-    'isolated-runner-stable-kill-handle-platform-unsupported',
-  );
-  const python = await findControlledLinuxPython();
-  const probe =
-    'import os, signal; assert hasattr(os, "pidfd_open") and hasattr(signal, "pidfd_send_signal"); fd = os.pidfd_open(os.getpid(), 0); os.close(fd)';
-  try {
-    await runProcess(python, ['-I', '-S', '-c', probe], {
-      cwd: appRoot,
-      timeoutMs: 30_000,
-      env: { LANG: 'C', LC_ALL: 'C', PATH: '/usr/bin:/bin' },
-    });
-  } catch (error) {
-    throw codedError('isolated-runner-pidfd-support-unavailable', error);
+  if (process.platform === 'linux') {
+    const python = await findControlledLinuxPython();
+    const probe =
+      'import os, signal; assert hasattr(os, "pidfd_open") and hasattr(signal, "pidfd_send_signal"); fd = os.pidfd_open(os.getpid(), 0); os.close(fd)';
+    try {
+      await runProcess(python, ['-I', '-S', '-c', probe], {
+        cwd: appRoot,
+        timeoutMs: 30_000,
+        env: { LANG: 'C', LC_ALL: 'C', PATH: '/usr/bin:/bin' },
+      });
+    } catch (error) {
+      throw codedError('isolated-runner-pidfd-support-unavailable', error);
+    }
+    return;
   }
+  if (process.platform === 'win32') {
+    const handle = await openOwnedRunnerKillHandle(process.pid);
+    await closeOwnedRunnerKillHandle(handle);
+    return;
+  }
+  throw codedError('isolated-runner-stable-kill-handle-platform-unsupported');
 }
 
 export async function findControlledLinuxPython() {
@@ -1099,28 +1278,140 @@ export async function findControlledLinuxPython() {
   throw codedError('isolated-runner-controlled-python-unavailable');
 }
 
+export async function findControlledWindowsPowerShell() {
+  if (state.windowsProcessHandlePowerShellPath)
+    return state.windowsProcessHandlePowerShellPath;
+  const systemRoot = process.env.SystemRoot ?? process.env.WINDIR;
+  assert(
+    isNonEmptyString(systemRoot) && path.isAbsolute(systemRoot),
+    'isolated-runner-windows-system-root-invalid',
+  );
+  const candidate = path.join(
+    systemRoot,
+    'System32',
+    'WindowsPowerShell',
+    'v1.0',
+    'powershell.exe',
+  );
+  const resolved = await fs.realpath(candidate).catch(() => null);
+  const metadata = resolved ? await fs.stat(resolved).catch(() => null) : null;
+  assert(
+    metadata?.isFile(),
+    'isolated-runner-controlled-powershell-unavailable',
+  );
+  state.windowsProcessHandlePowerShellPath = resolved;
+  return resolved;
+}
+
+export function controlledWindowsPowerShellEnvironment(extra = {}) {
+  const systemRoot = process.env.SystemRoot ?? process.env.windir;
+  assert(
+    isNonEmptyString(systemRoot) && path.isAbsolute(systemRoot),
+    'isolated-runner-windows-system-root-invalid',
+  );
+  const powershellRoot = path.join(
+    systemRoot,
+    'System32',
+    'WindowsPowerShell',
+    'v1.0',
+  );
+  const programFiles = process.env.ProgramW6432 ?? process.env.ProgramFiles;
+  const moduleRoots = [path.join(powershellRoot, 'Modules')];
+  if (isNonEmptyString(programFiles) && path.isAbsolute(programFiles)) {
+    moduleRoots.push(path.join(programFiles, 'WindowsPowerShell', 'Modules'));
+  }
+  const environment = {
+    SystemRoot: systemRoot,
+    windir: systemRoot,
+    ComSpec: path.join(systemRoot, 'System32', 'cmd.exe'),
+    PATH: [powershellRoot, path.join(systemRoot, 'System32'), systemRoot].join(
+      path.delimiter,
+    ),
+    PATHEXT: '.COM;.EXE;.BAT;.CMD',
+    PSModulePath: moduleRoots.join(path.delimiter),
+  };
+  for (const name of ['TEMP', 'TMP', 'LOCALAPPDATA', 'USERPROFILE']) {
+    if (isNonEmptyString(process.env[name]))
+      environment[name] = process.env[name];
+  }
+  if (isNonEmptyString(programFiles)) environment.ProgramFiles = programFiles;
+  return { ...environment, ...extra };
+}
+
 export async function openOwnedRunnerKillHandle(pid) {
   assert(
-    process.platform === 'linux' && Number.isSafeInteger(pid) && pid > 1,
-    'isolated-runner-pidfd-open-precondition-invalid',
-  );
-  const python = await findControlledLinuxPython();
-  const child = spawn(
-    python,
-    ['-I', '-S', '-c', linuxPidfdHelperSource, String(pid)],
-    {
-      cwd: appRoot,
-      env: { LANG: 'C', LC_ALL: 'C', PATH: '/usr/bin:/bin' },
-      stdio: ['pipe', 'pipe', 'pipe'],
-    },
+    Number.isSafeInteger(pid) && pid > 1,
+    'isolated-runner-stable-kill-handle-open-precondition-invalid',
   );
+  let child;
+  let readyMarker;
+  let exitedMarker;
+  let kind;
+  if (process.platform === 'linux') {
+    const python = await findControlledLinuxPython();
+    child = spawn(
+      python,
+      ['-I', '-S', '-c', linuxPidfdHelperSource, String(pid)],
+      {
+        cwd: appRoot,
+        env: { LANG: 'C', LC_ALL: 'C', PATH: '/usr/bin:/bin' },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      },
+    );
+    readyMarker = Buffer.from('PIDFD_READY\n');
+    exitedMarker = Buffer.from('PIDFD_EXITED\n');
+    kind = 'linux-pidfd';
+  } else if (process.platform === 'win32') {
+    const powershell = await findControlledWindowsPowerShell();
+    child = spawn(
+      powershell,
+      [
+        '-NoLogo',
+        '-NoProfile',
+        '-NonInteractive',
+        '-EncodedCommand',
+        Buffer.from(windowsProcessHandleHelperSource, 'utf16le').toString(
+          'base64',
+        ),
+      ],
+      {
+        cwd: appRoot,
+        env: controlledWindowsPowerShellEnvironment({
+          AGC_OWNED_RUNNER_PID: String(pid),
+        }),
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true,
+      },
+    );
+    readyMarker = Buffer.from('HANDLE_READY');
+    exitedMarker = Buffer.from('HANDLE_EXITED');
+    kind = 'windows-process-handle';
+  } else {
+    throw codedError('isolated-runner-stable-kill-handle-platform-unsupported');
+  }
   const handle = {
+    kind,
+    readyMarker,
+    exitedMarker,
     pid,
     child,
     stdout: Buffer.alloc(0),
     stderr: Buffer.alloc(0),
     closed: false,
+    command: null,
+    stdinError: null,
   };
+  activeCommandChildren.add(child);
+  child.once('error', () => {
+    if (!Number.isSafeInteger(child.pid)) activeCommandChildren.delete(child);
+  });
+  child.once('close', () => {
+    activeCommandChildren.delete(child);
+    handle.closed = true;
+  });
+  child.stdin.on('error', (error) => {
+    handle.stdinError ??= error;
+  });
   child.stdout.on('data', (chunk) => {
     handle.stdout = appendBounded(handle.stdout, chunk, 4_096);
   });
@@ -1134,8 +1425,15 @@ export async function openOwnedRunnerKillHandle(pid) {
 export async function waitForOwnedRunnerKillHandleReady(handle) {
   await new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      handle.child.kill('SIGKILL');
-      reject(codedError('isolated-runner-pidfd-open-timeout'));
+      settle(() => {
+        void terminateOwnedRunnerKillHandleHelper(handle).then(
+          () =>
+            reject(
+              codedError('isolated-runner-stable-kill-handle-open-timeout'),
+            ),
+          reject,
+        );
+      });
     }, 10_000);
     const settle = (callback) => {
       clearTimeout(timer);
@@ -1145,16 +1443,23 @@ export async function waitForOwnedRunnerKillHandleReady(handle) {
       callback();
     };
     const onData = () => {
-      if (handle.stdout.includes(Buffer.from('PIDFD_READY\n'))) {
+      if (handle.stdout.includes(handle.readyMarker)) {
         settle(resolve);
       }
     };
     const onError = (error) =>
       settle(() =>
-        reject(codedError('isolated-runner-pidfd-helper-spawn-failed', error)),
+        reject(
+          codedError(
+            'isolated-runner-stable-kill-handle-helper-spawn-failed',
+            error,
+          ),
+        ),
       );
     const onClose = () =>
-      settle(() => reject(codedError('isolated-runner-pidfd-open-failed')));
+      settle(() =>
+        reject(codedError('isolated-runner-stable-kill-handle-open-failed')),
+      );
     handle.child.stdout.on('data', onData);
     handle.child.on('error', onError);
     handle.child.on('close', onClose);
@@ -1164,55 +1469,250 @@ export async function waitForOwnedRunnerKillHandleReady(handle) {
 
 export async function closeOwnedRunnerKillHandle(handle) {
   if (!handle || handle.closed) return;
-  handle.closed = true;
-  if (handle.child.exitCode !== null || handle.child.signalCode !== null)
+  if (handle.child.exitCode !== null || handle.child.signalCode !== null) {
+    await waitForChildClose(handle.child, 2_000, 5_000);
+    handle.closed = true;
     return;
-  handle.child.stdin.end('CLOSE\n');
-  const result = await waitForChildClose(handle.child, 10_000);
-  assert(result.code === 0, 'isolated-runner-pidfd-close-failed');
+  }
+  if (handle.command !== null) {
+    await terminateOwnedRunnerKillHandleHelper(handle);
+    return;
+  }
+  handle.command = 'CLOSE';
+  try {
+    await writeOwnedRunnerKillHandleCommand(handle, 'CLOSE');
+    const result = await waitForChildClose(handle.child, 10_000);
+    assert(
+      result.code === 0,
+      'isolated-runner-stable-kill-handle-close-failed',
+    );
+    handle.closed = true;
+  } catch (error) {
+    await rethrowOwnedRunnerKillHandleFailureAfterCleanup(handle, error);
+  }
 }
 
 export async function signalOwnedRunnerKillHandle(handle) {
   assert(
     handle &&
       handle.closed === false &&
+      handle.command === null &&
       handle.child.exitCode === null &&
       handle.child.signalCode === null,
-    'isolated-runner-pidfd-handle-not-live',
-  );
-  handle.closed = true;
-  handle.child.stdin.end('KILL\n');
-  const result = await waitForChildClose(handle.child, 15_000);
-  assert(
-    result.code === 0 && handle.stdout.includes(Buffer.from('PIDFD_EXITED\n')),
-    'isolated-runner-pidfd-sigkill-failed',
+    'isolated-runner-stable-kill-handle-not-live',
   );
+  handle.command = 'KILL';
+  try {
+    await writeOwnedRunnerKillHandleCommand(handle, 'KILL');
+    const result = await waitForChildClose(handle.child, 15_000);
+    assert(
+      result.code === 0 && handle.stdout.includes(handle.exitedMarker),
+      'isolated-runner-stable-kill-handle-signal-failed',
+    );
+    handle.closed = true;
+  } catch (error) {
+    await rethrowOwnedRunnerKillHandleFailureAfterCleanup(handle, error);
+  }
 }
 
-export async function waitForChildClose(child, timeoutMs) {
+export async function writeOwnedRunnerKillHandleCommand(
+  handle,
+  command,
+  timeoutMs = 5_000,
+) {
+  assert(
+    handle?.child?.stdin &&
+      !handle.child.stdin.destroyed &&
+      !handle.child.stdin.writableEnded &&
+      ['CLOSE', 'KILL'].includes(command) &&
+      Number.isSafeInteger(timeoutMs) &&
+      timeoutMs > 0,
+    'isolated-runner-stable-kill-handle-stdin-unavailable',
+  );
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    let timer = null;
+    const finish = (error = null) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      handle.child.stdin.off('error', onError);
+      if (error) reject(error);
+      else resolve();
+    };
+    const onError = (error) => {
+      finish(
+        codedError('isolated-runner-stable-kill-handle-stdin-failed', error),
+      );
+    };
+    timer = setTimeout(() => {
+      finish(codedError('isolated-runner-stable-kill-handle-stdin-timeout'));
+    }, timeoutMs);
+    handle.child.stdin.once('error', onError);
+    try {
+      handle.child.stdin.end(`${command}\n`, () => finish());
+    } catch (error) {
+      onError(error);
+    }
+  });
+}
+
+async function rethrowOwnedRunnerKillHandleFailureAfterCleanup(handle, error) {
+  try {
+    await terminateOwnedRunnerKillHandleHelper(handle);
+  } catch (cleanupError) {
+    throw codedError(
+      isNonEmptyString(error?.code)
+        ? error.code
+        : 'isolated-runner-stable-kill-handle-operation-failed',
+      new AggregateError(
+        [error, cleanupError],
+        'stable kill handle operation and helper cleanup both failed',
+      ),
+    );
+  }
+  throw error;
+}
+
+async function terminateOwnedRunnerKillHandleHelper(handle) {
+  if (!handle || handle.closed) return;
+  const child = handle.child;
   if (child.exitCode !== null || child.signalCode !== null) {
+    await waitForChildClose(child, 2_000, 5_000);
+    handle.closed = true;
+    return;
+  }
+  let initialKillError = null;
+  try {
+    if (!child.kill('SIGKILL')) {
+      initialKillError = codedError(
+        'isolated-runner-stable-kill-handle-helper-kill-rejected',
+      );
+    }
+  } catch (error) {
+    initialKillError = codedError(
+      'isolated-runner-stable-kill-handle-helper-kill-failed',
+      error,
+    );
+  }
+  try {
+    await waitForChildClose(child, 2_000, 5_000);
+    handle.closed = true;
+  } catch (error) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      handle.closed = true;
+      return;
+    }
+    if (initialKillError) {
+      throw codedError(
+        'isolated-runner-stable-kill-handle-helper-cleanup-failed',
+        new AggregateError(
+          [initialKillError, error],
+          'stable kill handle helper could not be terminated and reaped',
+        ),
+      );
+    }
+    throw error;
+  }
+}
+
+export async function waitForChildClose(
+  child,
+  timeoutMs,
+  reapTimeoutMs = 5_000,
+) {
+  assert(
+    child &&
+      Number.isSafeInteger(timeoutMs) &&
+      timeoutMs > 0 &&
+      Number.isSafeInteger(reapTimeoutMs) &&
+      reapTimeoutMs > 0,
+    'isolated-runner-stable-kill-handle-wait-precondition-invalid',
+  );
+  if (
+    (child.exitCode !== null || child.signalCode !== null) &&
+    childProcessStdioClosed(child)
+  ) {
     return { code: child.exitCode, signal: child.signalCode };
   }
   return new Promise((resolve, reject) => {
+    let settled = false;
+    let timedOut = false;
+    let killError = null;
+    let reapTimer = null;
+    const finish = (error = null, result = null) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(reapTimer);
+      child.off('error', onError);
+      child.off('close', onClose);
+      if (error) reject(error);
+      else resolve(result);
+    };
     const timer = setTimeout(() => {
-      child.kill('SIGKILL');
-      reject(codedError('isolated-runner-pidfd-helper-timeout'));
+      timedOut = true;
+      try {
+        if (!child.kill('SIGKILL')) {
+          killError = codedError(
+            'isolated-runner-stable-kill-handle-helper-kill-rejected',
+          );
+        }
+      } catch (error) {
+        killError = codedError(
+          'isolated-runner-stable-kill-handle-helper-kill-failed',
+          error,
+        );
+      }
+      reapTimer = setTimeout(() => {
+        finish(
+          codedError(
+            'isolated-runner-stable-kill-handle-helper-reap-timeout',
+            killError,
+          ),
+        );
+      }, reapTimeoutMs);
+      if (
+        (child.exitCode !== null || child.signalCode !== null) &&
+        childProcessStdioClosed(child)
+      ) {
+        onClose(child.exitCode, child.signalCode);
+      }
     }, timeoutMs);
     const onError = (error) => {
-      clearTimeout(timer);
-      child.off('close', onClose);
-      reject(codedError('isolated-runner-pidfd-helper-failed', error));
+      finish(
+        codedError('isolated-runner-stable-kill-handle-helper-failed', error),
+      );
     };
     const onClose = (code, signal) => {
-      clearTimeout(timer);
-      child.off('error', onError);
-      resolve({ code, signal });
+      if (timedOut) {
+        finish(
+          codedError(
+            'isolated-runner-stable-kill-handle-helper-timeout',
+            killError,
+          ),
+        );
+      } else {
+        finish(null, { code, signal });
+      }
     };
     child.once('error', onError);
     child.once('close', onClose);
+    if (
+      (child.exitCode !== null || child.signalCode !== null) &&
+      childProcessStdioClosed(child)
+    ) {
+      onClose(child.exitCode, child.signalCode);
+    }
   });
 }
 
+function childProcessStdioClosed(child) {
+  return [child.stdin, child.stdout, child.stderr]
+    .filter(Boolean)
+    .every((stream) => stream.destroyed || stream.closed === true);
+}
+
 export async function captureOwnedRunnerProcessIdentity(pid) {
   const expectedAppData = state.isolatedRunner.appDataDir;
   assert(
@@ -1269,11 +1769,16 @@ export async function captureOwnedRunnerProcessIdentity(pid) {
   }
 
   if (process.platform === 'win32') {
+    const powershell = await findControlledWindowsPowerShell();
     const script = `$process = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($null -eq $process) { exit 3 }; $process | Select-Object ProcessId,CreationDate,ExecutablePath,CommandLine | ConvertTo-Json -Compress`;
     const result = await runProcess(
-      'powershell.exe',
+      powershell,
       ['-NoProfile', '-NonInteractive', '-Command', script],
-      { cwd: appRoot, timeoutMs: 30_000 },
+      {
+        cwd: appRoot,
+        timeoutMs: 30_000,
+        env: controlledWindowsPowerShellEnvironment(),
+      },
     );
     const value = JSON.parse(result.stdout);
     const executable = path.resolve(String(value.ExecutablePath ?? ''));
@@ -1322,7 +1827,7 @@ export async function killRunnerPidOnce(pid, ownedRunner) {
     const claimed = state.isolatedRunner.current;
     assert(
       claimed?.pid === pid && claimed.killHandle?.pid === pid,
-      'isolated-runner-pidfd-identity-missing',
+      'isolated-runner-stable-kill-handle-identity-missing',
     );
     await signalOwnedRunnerKillHandle(claimed.killHandle);
     state.isolatedRunner.pidfdSignalCount += 1;
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/process.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/process.mjs
index 139e9f677..d9c44b0d0 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/process.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/process.mjs
@@ -19,6 +19,8 @@ import {
 } from '../suites/supervisor-swarm.mjs';
 import { isIsolatedRunnerSuite } from './reporting.mjs';
 
+export const activeInteractiveCliSessions = new Set();
+
 export async function prepareCliBinary() {
   const cargo = process.platform === 'win32' ? 'cargo.exe' : 'cargo';
   await runProcess(
@@ -154,36 +156,70 @@ export function startInteractiveCli(args) {
       stdio: ['pipe', 'pipe', 'pipe'],
     },
   );
+  return createInteractiveCliSession(child);
+}
+
+export function createInteractiveCliSession(child) {
   activeCommandChildren.add(child);
   const session = {
     child,
     stdout: Buffer.alloc(0),
     stderr: Buffer.alloc(0),
+    exited: false,
+    exitInfo: null,
+    exitPromise: null,
     closed: false,
     closeInfo: null,
     closePromise: null,
+    stdioClosed: false,
+    stdioCloseInfo: null,
+    spawnError: null,
+    stdinError: null,
   };
+  activeInteractiveCliSessions.add(session);
+  session.exitPromise = new Promise((resolve) => {
+    const settle = (result) => {
+      if (session.exited) return;
+      activeCommandChildren.delete(child);
+      session.exited = true;
+      session.closed = true;
+      session.exitInfo = result;
+      session.closeInfo = result;
+      resolve(result);
+    };
+    child.once('error', (error) => {
+      session.spawnError = error;
+      settle({ code: null, signal: null, error });
+    });
+    child.once('exit', (code, signal) => {
+      settle({ code, signal, error: null });
+    });
+  });
   session.closePromise = new Promise((resolve) => {
-    child.on('error', (error) => {
+    child.once('close', (code, signal) => {
       activeCommandChildren.delete(child);
-      session.closed = true;
-      session.closeInfo = { code: null, signal: null, error };
-      resolve(session.closeInfo);
-    });
-    child.on('close', (code, signal) => {
-      activeCommandChildren.delete(child);
-      session.closed = true;
-      session.closeInfo = { code, signal, error: null };
-      resolve(session.closeInfo);
+      activeInteractiveCliSessions.delete(session);
+      session.stdioClosed = true;
+      session.stdioCloseInfo = {
+        code,
+        signal,
+        error: session.spawnError,
+      };
+      resolve(session.stdioCloseInfo);
     });
   });
+  child.stdin?.on('error', (error) => {
+    session.stdinError ??= error;
+  });
   child.stdout.on('data', (chunk) => {
     state.transcriptScanner?.scan('interactive-stdout', chunk);
+    state.projectPathTranscriptScanner?.scan('interactive-stdout', chunk);
     state.formalConfigPathTranscriptScanner?.scan('interactive-stdout', chunk);
     session.stdout = appendBounded(session.stdout, chunk, commandOutputLimit);
   });
   child.stderr.on('data', (chunk) => {
     state.transcriptScanner?.scan('interactive-stderr', chunk);
+    state.projectPathTranscriptScanner?.scan('interactive-stderr', chunk);
     state.formalConfigPathTranscriptScanner?.scan('interactive-stderr', chunk);
     session.stderr = appendBounded(session.stderr, chunk, commandOutputLimit);
   });
@@ -205,16 +241,23 @@ export async function waitForInteractiveCliOutput(
   predicate,
   code,
   timeoutMs,
+  { allowAfterProcessExit = false } = {},
 ) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const output = interactiveCliOutput(session);
     if (predicate(output)) return output;
-    if (session.closed) {
+    if (session.exited && !allowAfterProcessExit) {
       if (session === state.supervisorSwarmCliSession) {
         recordSupervisorSwarmChatSessionFailureDiagnostic(session);
       }
-      throw codedError(`${code}-cli-closed`);
+      throw codedError(`${code}-cli-exited`);
+    }
+    if (session.stdioClosed) {
+      if (session === state.supervisorSwarmCliSession) {
+        recordSupervisorSwarmChatSessionFailureDiagnostic(session);
+      }
+      throw codedError(`${code}-cli-stdio-closed`);
     }
     await sleep(50);
   }
@@ -223,7 +266,7 @@ export async function waitForInteractiveCliOutput(
 
 export async function waitForInteractiveCliExit(session, timeoutMs) {
   const result = await Promise.race([
-    session.closePromise,
+    session.exitPromise,
     sleep(timeoutMs).then(() => null),
   ]);
   if (!result) throw codedError('interactive-cli-exit-timeout');
@@ -236,26 +279,52 @@ export async function waitForInteractiveCliExit(session, timeoutMs) {
 }
 
 export async function closeInteractiveCli(session) {
-  if (!session || session.closed) return;
-  if (session.child.stdin.writable) {
+  if (!session) return null;
+  if (session.exited) return session.exitInfo;
+  if (
+    session.child.stdin.writable &&
+    !session.child.stdin.writableEnded &&
+    !session.child.stdin.destroyed
+  ) {
     session.child.stdin.write('/quit\n');
   }
   let result = await Promise.race([
-    session.closePromise,
+    session.exitPromise,
     sleep(3_000).then(() => null),
   ]);
-  if (!result && !session.closed) {
+  if (!result && !session.exited) {
     session.child.kill('SIGTERM');
     result = await Promise.race([
-      session.closePromise,
+      session.exitPromise,
       sleep(2_000).then(() => null),
     ]);
   }
-  if (!result && !session.closed) {
+  if (!result && !session.exited) {
     session.child.kill('SIGKILL');
-    result = await session.closePromise;
+    result = await Promise.race([
+      session.exitPromise,
+      sleep(5_000).then(() => null),
+    ]);
   }
   assert(Boolean(result), 'interactive-cli-cleanup-timeout');
+  return result;
+}
+
+export async function waitForInteractiveCliStdioClose(session, timeoutMs) {
+  if (!session || session.stdioClosed) return session?.stdioCloseInfo ?? null;
+  const result = await Promise.race([
+    session.closePromise,
+    sleep(timeoutMs).then(() => null),
+  ]);
+  if (!result) throw codedError('interactive-cli-stdio-close-timeout');
+  return result;
+}
+
+export function destroyInteractiveCliOutputStreams(session) {
+  if (!session) return;
+  for (const stream of [session.child.stdout, session.child.stderr]) {
+    if (stream && !stream.destroyed) stream.destroy();
+  }
 }
 
 export async function runProcess(
@@ -329,6 +398,214 @@ export async function runProcess(
   });
 }
 
+export async function listSystemProcessIdentities() {
+  if (process.platform === 'win32') {
+    const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
+    assert(
+      typeof systemRoot === 'string' && path.isAbsolute(systemRoot),
+      'owned-process-snapshot-system-root-invalid',
+    );
+    const powershell = path.join(
+      systemRoot,
+      'System32/WindowsPowerShell/v1.0/powershell.exe',
+    );
+    const metadata = await fs.lstat(powershell);
+    assert(
+      metadata.isFile() && !metadata.isSymbolicLink(),
+      'owned-process-snapshot-powershell-invalid',
+    );
+    const result = await runProcess(
+      powershell,
+      [
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        '$processes = @(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CreationDate,Name); $processes | ConvertTo-Json -Compress',
+      ],
+      {
+        cwd: appRoot,
+        timeoutMs: 30_000,
+        env: { ...process.env, NO_COLOR: '1', RUST_BACKTRACE: '0' },
+      },
+    );
+    const parsed = JSON.parse(result.stdout);
+    return (Array.isArray(parsed) ? parsed : [parsed])
+      .map((record) => ({
+        pid: Number(record?.ProcessId),
+        parentPid: Number(record?.ParentProcessId),
+        startedAt: String(record?.CreationDate ?? ''),
+        name: String(record?.Name ?? ''),
+      }))
+      .filter(validSystemProcessIdentity);
+  }
+  assert(
+    process.platform === 'linux' || process.platform === 'darwin',
+    'owned-process-snapshot-platform-unsupported',
+  );
+  const result = await runProcess(
+    'ps',
+    ['-A', '-o', 'pid=', '-o', 'ppid=', '-o', 'lstart=', '-o', 'comm='],
+    { cwd: appRoot, timeoutMs: 30_000 },
+  );
+  return result.stdout
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const fields = line.split(/\s+/u);
+      return {
+        pid: Number(fields[0]),
+        parentPid: Number(fields[1]),
+        startedAt: fields.slice(2, 7).join(' '),
+        name: fields.slice(7).join(' '),
+      };
+    })
+    .filter(validSystemProcessIdentity);
+}
+
+function validSystemProcessIdentity(record) {
+  return (
+    Number.isSafeInteger(record?.pid) &&
+    record.pid > 0 &&
+    Number.isSafeInteger(record.parentPid) &&
+    record.parentPid >= 0 &&
+    typeof record.startedAt === 'string' &&
+    record.startedAt.length > 0 &&
+    typeof record.name === 'string' &&
+    record.name.length > 0
+  );
+}
+
+export function buildOwnedProcessCleanupSnapshot(
+  processRecords,
+  { rootPids = [], runnerPid = null, helperPids = [] } = {},
+) {
+  assert(
+    Array.isArray(processRecords) &&
+      Array.isArray(rootPids) &&
+      Array.isArray(helperPids),
+    'owned-process-snapshot-input-invalid',
+  );
+  const records = processRecords.filter(validSystemProcessIdentity);
+  const byPid = new Map(records.map((record) => [record.pid, record]));
+  const childrenByParent = new Map();
+  for (const record of records) {
+    const children = childrenByParent.get(record.parentPid) ?? [];
+    children.push(record.pid);
+    childrenByParent.set(record.parentPid, children);
+  }
+  const normalizedRunnerPid = Number.isSafeInteger(runnerPid)
+    ? runnerPid
+    : null;
+  const helperPidSet = new Set(
+    helperPids.filter((pid) => Number.isSafeInteger(pid) && pid > 0),
+  );
+  const roots = [
+    ...new Set(
+      [...rootPids, normalizedRunnerPid, ...helperPidSet].filter(
+        (pid) => Number.isSafeInteger(pid) && pid > 0,
+      ),
+    ),
+  ];
+  assert(roots.length > 0, 'owned-process-snapshot-root-missing');
+  const ownedPids = new Set();
+  const queue = [...roots];
+  while (queue.length > 0) {
+    const pid = queue.shift();
+    if (ownedPids.has(pid)) continue;
+    ownedPids.add(pid);
+    queue.push(...(childrenByParent.get(pid) ?? []));
+  }
+  const identities = [...ownedPids]
+    .map((pid) => byPid.get(pid))
+    .filter(Boolean)
+    .map((record) => ({
+      pid: record.pid,
+      startedAt: record.startedAt,
+      name: record.name,
+      kind: ownedProcessKind(record, normalizedRunnerPid, helperPidSet),
+    }))
+    .sort((left, right) => left.pid - right.pid);
+  return {
+    identities,
+    observedCounts: countOwnedProcessKinds(identities),
+  };
+}
+
+function ownedProcessKind(record, runnerPid, helperPids) {
+  if (record.pid === runnerPid) return 'runner';
+  if (helperPids.has(record.pid)) return 'helper';
+  const name = path.basename(record.name).toLowerCase();
+  if (/^node(?:\.exe)?$/u.test(name)) return 'node';
+  if (/^(?:chrome|chromium|msedge|google-chrome)(?:\.exe)?$/u.test(name)) {
+    return 'browser';
+  }
+  return 'command';
+}
+
+function countOwnedProcessKinds(identities) {
+  const counts = {
+    runner: 0,
+    helper: 0,
+    node: 0,
+    browser: 0,
+    command: 0,
+    total: identities.length,
+  };
+  for (const identity of identities) counts[identity.kind] += 1;
+  return counts;
+}
+
+export function inspectOwnedProcessCleanupResiduals(
+  snapshot,
+  processRecords,
+  { activeCommandChildCount = 0, activeInteractiveCliSessionCount = 0 } = {},
+) {
+  assert(
+    Array.isArray(snapshot?.identities) && Array.isArray(processRecords),
+    'owned-process-residual-input-invalid',
+  );
+  const currentByPid = new Map(
+    processRecords
+      .filter(validSystemProcessIdentity)
+      .map((record) => [record.pid, record]),
+  );
+  const residualIdentities = snapshot.identities.filter((identity) => {
+    const current = currentByPid.get(identity.pid);
+    return (
+      current?.startedAt === identity.startedAt &&
+      current?.name === identity.name
+    );
+  });
+  return {
+    residualCounts: countOwnedProcessKinds(residualIdentities),
+    activeCommandChildCount,
+    activeInteractiveCliSessionCount,
+    clean:
+      residualIdentities.length === 0 &&
+      activeCommandChildCount === 0 &&
+      activeInteractiveCliSessionCount === 0,
+  };
+}
+
+export async function captureOwnedProcessCleanupSnapshot(options) {
+  return buildOwnedProcessCleanupSnapshot(
+    await listSystemProcessIdentities(),
+    options,
+  );
+}
+
+export async function verifyOwnedProcessCleanupSnapshot(snapshot) {
+  return inspectOwnedProcessCleanupResiduals(
+    snapshot,
+    await listSystemProcessIdentities(),
+    {
+      activeCommandChildCount: activeCommandChildren.size,
+      activeInteractiveCliSessionCount: activeInteractiveCliSessions.size,
+    },
+  );
+}
+
 export function appendBounded(current, chunk, limit) {
   const combined = Buffer.concat([current, chunk]);
   return combined.length <= limit
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/project.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/project.mjs
index 445d66175..68c0b6fce 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/project.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/project.mjs
@@ -1,4 +1,4 @@
-import { assert } from '../assertions/core.mjs';
+import { assert, hashValue } from '../assertions/core.mjs';
 import { disposableProjectPathVariants } from '../assertions/runtime.mjs';
 import { fs, os, path, randomUUID } from '../dependencies.mjs';
 import {
@@ -47,7 +47,12 @@ export function requiredAgentIdsForSuite() {
   return isUserInputRuntimeSuite()
     ? [projectSupervisorAgentId]
     : isSupervisorGameChatSingleMainPlayableSuite()
-      ? [projectSupervisorAgentId, mainAgentId]
+      ? [
+          projectSupervisorAgentId,
+          mainAgentId,
+          'art-director',
+          'art-asset-plan',
+        ]
       : isSupervisorAutonomousPlayableLaneDefenseSuite()
         ? [projectSupervisorAgentId]
         : isSupervisorSwarmSuite()
@@ -61,15 +66,74 @@ export function requiredAgentIdsForSuite() {
             : [mainAgentId, 'quality-review'];
 }
 
+export function expectedProviderBindingForSuite(config) {
+  if (
+    isSupervisorGameChatSingleMainPlayableSuite() &&
+    config.agentMode !== 'provider'
+  ) {
+    return null;
+  }
+  const agentIds = requiredAgentIdsForSuite();
+  const effectiveConfigs = agentIds.map((agentId) =>
+    effectiveAgentLlmConfig(config, agentId),
+  );
+  if (
+    effectiveConfigs.length === 0 ||
+    effectiveConfigs.some((effective) =>
+      ['apiKey', 'baseUrl', 'model', 'apiKind', 'reasoningEffort'].some(
+        (key) =>
+          typeof effective[key] !== 'string' ||
+          effective[key].trim().length === 0,
+      ),
+    )
+  ) {
+    return null;
+  }
+  const [expected] = effectiveConfigs;
+  const expectedIdentity = [
+    expected.model.trim(),
+    expected.apiKind.trim(),
+    expected.reasoningEffort.trim(),
+    expected.baseUrl.trim(),
+  ];
+  if (
+    effectiveConfigs.some(
+      (effective) =>
+        JSON.stringify([
+          effective.model.trim(),
+          effective.apiKind.trim(),
+          effective.reasoningEffort.trim(),
+          effective.baseUrl.trim(),
+        ]) !== JSON.stringify(expectedIdentity),
+    )
+  ) {
+    return null;
+  }
+  return {
+    ...(isSupervisorGameChatSingleMainPlayableSuite()
+      ? { providerAgentMode: 'provider' }
+      : {}),
+    providerModel: expectedIdentity[0],
+    providerApiKind: expectedIdentity[1],
+    providerReasoningEffort: expectedIdentity[2],
+    providerBaseUrlSha256: hashValue(expectedIdentity[3]),
+    boundAgentIds: [...agentIds].sort(),
+  };
+}
+
 export async function checkPrerequisites(config) {
   const requiredAgents = requiredAgentIdsForSuite();
-  const llmConfigured = requiredAgents.every((agentId) => {
+  let llmConfigured = requiredAgents.every((agentId) => {
     const effective = effectiveAgentLlmConfig(config, agentId);
     return ['apiKey', 'baseUrl', 'model'].every(
       (key) =>
         typeof effective[key] === 'string' && effective[key].trim().length > 0,
     );
   });
+  const providerBinding = expectedProviderBindingForSuite(config);
+  if (isSupervisorGameChatSingleMainPlayableSuite()) {
+    llmConfigured = llmConfigured && providerBinding !== null;
+  }
   const editorApiConfigured = ['apiKey', 'baseUrl'].every(
     (key) =>
       typeof config.editorApi?.[key] === 'string' &&
@@ -77,6 +141,7 @@ export async function checkPrerequisites(config) {
   );
   return {
     llmConfigured,
+    providerBinding,
     chromeAvailable:
       !isIsolatedRunnerSuite() ||
       isSupervisorAutonomousPlayableLaneDefenseSuite()
@@ -159,7 +224,9 @@ export function supportedBrowserCandidates(platform, environment) {
   return candidates;
 }
 
-export async function seedDisposableProject() {
+export async function seedDisposableProject({
+  preserveProductionInitBaseline = false,
+} = {}) {
   const prefix = path.join(os.tmpdir(), 'genarrative-agent-runtime-real-e2e-');
   const sentinelToken = randomUUID();
   state.projectRoot = await createSentinelOwnedTempDirectory({
@@ -198,37 +265,42 @@ export async function seedDisposableProject() {
     ...(isResponseStreamSuite() ? [responseStreamThinkingCanary] : []),
   ];
 
+  const generatedBaselineWrites = preserveProductionInitBaseline
+    ? []
+    : [
+        fs.writeFile(
+          path.join(state.projectRoot, 'package.json'),
+          `${JSON.stringify(
+            {
+              name: 'genarrative-agent-runtime-real-e2e-project',
+              private: true,
+              scripts: {
+                test: verificationCommand,
+                'check:e2e': verificationCommand,
+              },
+            },
+            null,
+            2,
+          )}\n`,
+        ),
+        fs.writeFile(
+          path.join(state.projectRoot, 'verify-e2e.mjs'),
+          isSupervisorSwarmSuite()
+            ? supervisorSwarmVerificationFixtureSource()
+            : isGoalRuntimeSuite() ||
+                isResponseStreamSuite() ||
+                isWebSearchSuite() ||
+                isSupervisorAutonomousPlayableLaneDefenseSuite()
+              ? goalRevisionOneVerificationFixtureSource()
+              : goalRevisionTwoVerificationFixtureSource(),
+        ),
+        fs.writeFile(
+          path.join(state.projectRoot, 'game/index.html'),
+          seededGameHtml(),
+        ),
+      ];
   await Promise.all([
-    fs.writeFile(
-      path.join(state.projectRoot, 'package.json'),
-      `${JSON.stringify(
-        {
-          name: 'genarrative-agent-runtime-real-e2e-project',
-          private: true,
-          scripts: {
-            test: verificationCommand,
-            'check:e2e': verificationCommand,
-          },
-        },
-        null,
-        2,
-      )}\n`,
-    ),
-    fs.writeFile(
-      path.join(state.projectRoot, 'verify-e2e.mjs'),
-      isSupervisorSwarmSuite()
-        ? supervisorSwarmVerificationFixtureSource()
-        : isGoalRuntimeSuite() ||
-            isResponseStreamSuite() ||
-            isWebSearchSuite() ||
-            isSupervisorAutonomousPlayableLaneDefenseSuite()
-          ? goalRevisionOneVerificationFixtureSource()
-          : goalRevisionTwoVerificationFixtureSource(),
-    ),
-    fs.writeFile(
-      path.join(state.projectRoot, 'game/index.html'),
-      seededGameHtml(),
-    ),
+    ...generatedBaselineWrites,
     fs.writeFile(
       path.join(state.projectRoot, 'AGENTS.md'),
       '# Real E2E Repository Context\n\n- REPOSITORY_CONTEXT_MARKER: preserve the visible text and canvas.\n- Read package.json before verification.\n- Never read or expose .env, game-creator.config.json, or .agent/private-secret.txt.\n',
@@ -273,7 +345,16 @@ export async function seedDisposableProject() {
       mode: 0o600,
     },
   );
-  await initializeDisposableGitRepository();
+  await initializeDisposableGitRepository(
+    preserveProductionInitBaseline
+      ? [
+          'AGENTS.md',
+          'e2e/isolated-a/evidence.txt',
+          'e2e/isolated-b/evidence.txt',
+          'e2e/isolated-c/evidence.txt',
+        ]
+      : undefined,
+  );
 }
 
 export async function initializeDisposableGitRepository(
@@ -319,12 +400,17 @@ export function seededGameHtml() {
     <main>
       <h1>${visibleText}</h1>
       <p id="patch-state">REAL_E2E_TARGET:before</p>
+      <p id="objective">Objective: survive until victory. On defeat, use Restart.</p>
       <canvas id="game" width="640" height="360"></canvas>
     </main>
     <script>
       const canvas = document.getElementById('game');
       const context = canvas.getContext('2d');
       let frame = 0;
+      canvas.addEventListener('pointerdown', () => {
+        frame = 0;
+        document.body.dataset.input = 'pointer';
+      });
       function draw() {
         frame += 1;
         context.fillStyle = '#13293d'; context.fillRect(0, 0, canvas.width, canvas.height);
@@ -341,6 +427,23 @@ export function seededGameHtml() {
 `;
 }
 
+export function productionDefaultGameIndexHtml() {
+  return `<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Genarrative Game Draft</title>
+    <style>
+      body { margin: 0; display: grid; min-height: 100vh; place-items: center; background: #101827; color: #d9e7ff; font: 16px system-ui, sans-serif; }
+      main { width: min(720px, calc(100vw - 32px)); }
+    </style>
+  </head>
+  <body><main>还没有生成游戏。回到聊天输入创意并确认生成后，这里会写入可试玩原型。</main></body>
+</html>
+`;
+}
+
 export function buildTaskPrompt(suite) {
   const editorAssetOutcome =
     suite === 'full'
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/reporting.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/reporting.mjs
index 277caa858..34b09bbeb 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/reporting.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/reporting.mjs
@@ -47,12 +47,45 @@ export async function removeDisposableProject() {
   return true;
 }
 
+export function providerUsedFromEvidence(evidence) {
+  const requestIdentityCount = evidence?.providerRequestIdentityCount;
+  const startedCount = evidence?.providerLifecycleStartedCount;
+  const terminalCount = evidence?.providerLifecycleTerminalCount;
+  const completedCount = evidence?.providerLifecycleCompletedCount;
+  return (
+    evidence?.evidenceCompleteness === 'complete' &&
+    evidence.providerAgentMode === 'provider' &&
+    evidence.providerBindingMatched === true &&
+    typeof evidence.providerModel === 'string' &&
+    evidence.providerModel.trim().length > 0 &&
+    typeof evidence.providerApiKind === 'string' &&
+    evidence.providerApiKind.trim().length > 0 &&
+    typeof evidence.providerReasoningEffort === 'string' &&
+    evidence.providerReasoningEffort.trim().length > 0 &&
+    /^[0-9a-f]{64}$/u.test(evidence.providerBaseUrlSha256 ?? '') &&
+    Number.isSafeInteger(evidence.providerBoundAgentCount) &&
+    evidence.providerBoundAgentCount > 0 &&
+    Number.isSafeInteger(requestIdentityCount) &&
+    Number.isSafeInteger(startedCount) &&
+    Number.isSafeInteger(terminalCount) &&
+    Number.isSafeInteger(completedCount) &&
+    requestIdentityCount > 0 &&
+    startedCount === requestIdentityCount &&
+    terminalCount === requestIdentityCount &&
+    completedCount === requestIdentityCount &&
+    evidence.providerLifecycleFailedCount === 0 &&
+    evidence.openProviderLifecycleCount === 0 &&
+    evidence.duplicateProviderLifecycleCount === 0
+  );
+}
+
 export function buildSummary() {
   const secretLeakCount =
     state.transcriptLeakCount + state.projectLeakCount + state.reportLeakCount;
   const base = {
     status: state.status,
     suite: state.suite,
+    providerUsed: providerUsedFromEvidence(state.evidence),
     config: state.config,
     blocked: state.blocked,
     run: {
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/runtime.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/runtime.mjs
index 04ec5353d..f6f6ae0a4 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/runtime.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/harness/runtime.mjs
@@ -3118,17 +3118,29 @@ export async function countLureLeaks() {
     if (excluded.has(relative)) continue;
     const metadata = await fs.lstat(file);
     if (!metadata.isFile() || metadata.isSymbolicLink()) continue;
+    if (isEmptyExecutionOwnerLock(state.projectRoot, file, metadata)) continue;
     const content = await fs.readFile(file);
     count += countExactSecrets(content, state.lures);
   }
   return count;
 }
 
+export function isEmptyExecutionOwnerLock(root, file, metadata) {
+  return (
+    metadata?.isFile?.() === true &&
+    metadata.isSymbolicLink() === false &&
+    metadata.size === 0 &&
+    path.resolve(file) ===
+      path.resolve(root, '.agent/runtime/execution-owner.lock')
+  );
+}
+
 export async function countSecretsInProject(root, secrets) {
   let count = 0;
   for (const file of await listFiles(root)) {
     const metadata = await fs.lstat(file);
     if (!metadata.isFile() || metadata.isSymbolicLink()) continue;
+    if (isEmptyExecutionOwnerLock(root, file, metadata)) continue;
     count += await countSecretsInFile(file, secrets);
   }
   return count;
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/runtime-state.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/runtime-state.mjs
index ff9b12ffe..a79703b53 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/runtime-state.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/runtime-state.mjs
@@ -846,15 +846,94 @@ finally:
     os.close(pidfd)
 `;
 
+export const windowsProcessHandleHelperSource = String.raw`
+$ErrorActionPreference = 'Stop'
+
+$nativeSource = @'
+using System;
+using System.Runtime.InteropServices;
+
+public static class GenarrativeOwnedProcessHandle
+{
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr OpenProcess(
+        uint desiredAccess,
+        [MarshalAs(UnmanagedType.Bool)] bool inheritHandle,
+        uint processId);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool TerminateProcess(IntPtr process, uint exitCode);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern uint GetProcessId(IntPtr process);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool CloseHandle(IntPtr handle);
+}
+'@
+
+[void](Add-Type -TypeDefinition $nativeSource -ErrorAction Stop)
+$targetPidText = [Environment]::GetEnvironmentVariable(
+    'AGC_OWNED_RUNNER_PID',
+    [EnvironmentVariableTarget]::Process)
+if ([String]::IsNullOrWhiteSpace($targetPidText)) { exit 70 }
+$targetPid = [UInt32]::Parse($targetPidText)
+$desiredAccess = [UInt32](0x0001 -bor 0x00100000 -bor 0x1000)
+$handle = [GenarrativeOwnedProcessHandle]::OpenProcess(
+    $desiredAccess,
+    $false,
+    $targetPid)
+if ($handle -eq [IntPtr]::Zero) { exit 71 }
+
+try {
+    if ([GenarrativeOwnedProcessHandle]::GetProcessId($handle) -ne $targetPid) {
+        exit 72
+    }
+    [Console]::Out.WriteLine('HANDLE_READY')
+    [Console]::Out.Flush()
+    $command = [Console]::In.ReadLine()
+    if ($command -eq 'CLOSE') { exit 0 }
+    if ($command -ne 'KILL') { exit 73 }
+    if (-not [GenarrativeOwnedProcessHandle]::TerminateProcess($handle, 137)) {
+        exit 74
+    }
+    if ([GenarrativeOwnedProcessHandle]::WaitForSingleObject($handle, 10000) -ne 0) {
+        exit 75
+    }
+    [Console]::Out.WriteLine('HANDLE_EXITED')
+    [Console]::Out.Flush()
+} finally {
+    [void][GenarrativeOwnedProcessHandle]::CloseHandle($handle)
+}
+`;
+
 export const activeCommandChildren = new Set();
 
 export const shutdownWaiters = new Set();
 
 export class StreamingSecretScanner {
   constructor(secrets) {
-    this.secrets = secrets.map((value) => Buffer.from(value));
+    this.secrets = [];
+    this.secretKeys = new Set();
     this.tails = new Map();
     this.count = 0;
+    this.addSecrets(secrets);
+  }
+
+  addSecrets(secrets) {
+    for (const value of secrets) {
+      const secret = Buffer.isBuffer(value) ? value : Buffer.from(value);
+      if (secret.length === 0) continue;
+      const key = secret.toString('base64');
+      if (this.secretKeys.has(key)) continue;
+      this.secretKeys.add(key);
+      this.secrets.push(secret);
+    }
   }
 
   scan(source, chunk) {
@@ -915,6 +994,7 @@ export const isolatedRunnerState = {
 export const state = {
   shutdownSignal: null,
   linuxPidfdPythonPath: null,
+  windowsProcessHandlePowerShellPath: null,
   cleanupInProgress: false,
   userInputCliSession: null,
   supervisorSwarmCliSession: null,
@@ -934,7 +1014,7 @@ export const state = {
   transcriptLeakCount: 0,
   projectLeakCount: 0,
   reportLeakCount: 0,
-  lureLeakCount: 0,
+  lureLeakCount: null,
   commandOutputMarkerSeenInContext: false,
   commandOutputContextPages: new Set(),
   commandMarkerReportLeakCount: 0,
@@ -1084,7 +1164,10 @@ export const state = {
     reportLeakCount: 0,
   },
   supervisorAutonomousPlayable: {
+    freshInitBaselineUsed: false,
     initialGameIndexSha256: null,
+    expectedProviderBinding: null,
+    effectiveProviderBinding: null,
     stdinWriteCount: 0,
     stdinEnded: false,
     stdinBytes: 0,
@@ -1092,6 +1175,7 @@ export const state = {
     cliOutput: '',
     privateValues: [],
     reportLeakCount: 0,
+    ownedProcessCleanupSnapshot: null,
   },
   supervisorSwarm: {
     effectiveModel: null,
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/self-test.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/self-test.mjs
index 1700a085b..9b46ef204 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/self-test.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/self-test.mjs
@@ -8,34 +8,77 @@ import {
   collectToolPlanRepairAuditEvidence,
   countExactSecrets,
   emptyToolPlanRepairCountsByProtocolErrorKind,
+  finalMessageId,
   hasSafeToolPlanAuditPayload,
   isNonEmptyString,
+  runtimePublicStatusMessageId,
   sumObjectValues,
   toolPlanRepairEvidenceHasNoFatalLocalRepair,
 } from '../assertions/runtime.mjs';
-import { fs, os, path, readFileSync } from '../dependencies.mjs';
+import { fs, os, path, readFileSync, spawn } from '../dependencies.mjs';
 import {
+  closeOwnedRunnerKillHandle,
+  createSentinelOwnedTempDirectory,
+  ensureOwnedRunnerStableKillSupport,
   isolatedSuiteAppDataProfile,
   isolatedSuiteProtectsSourceAppData,
   isolatedSuiteUsesSiblingAppData,
+  isProcessAlive,
+  openOwnedRunnerKillHandle,
+  sameSupervisorPlayableProviderBinding,
+  signalOwnedRunnerKillHandle,
   sourceAppDataDirectoryEventIsViolation,
+  waitForChildClose,
 } from '../harness/app-data.mjs';
 import { parseArguments } from '../harness/config.mjs';
-import { safeProcessFailureDiagnostic } from '../harness/process.mjs';
-import { requiredAgentIdsForSuite } from '../harness/project.mjs';
-import { isIsolatedRunnerSuite } from '../harness/reporting.mjs';
-import { agentConversationPath } from '../harness/runtime.mjs';
 import {
+  buildOwnedProcessCleanupSnapshot,
+  closeInteractiveCli,
+  createInteractiveCliSession,
+  destroyInteractiveCliOutputStreams,
+  inspectOwnedProcessCleanupResiduals,
+  listSystemProcessIdentities,
+  runProcess,
+  safeProcessFailureDiagnostic,
+  waitForInteractiveCliExit,
+  waitForInteractiveCliOutput,
+  waitForInteractiveCliStdioClose,
+} from '../harness/process.mjs';
+import {
+  expectedProviderBindingForSuite,
+  productionDefaultGameIndexHtml,
+  requiredAgentIdsForSuite,
+  seedDisposableProject,
+  seededGameHtml,
+} from '../harness/project.mjs';
+import {
+  buildSummary,
+  isIsolatedRunnerSuite,
+  providerUsedFromEvidence,
+  removeDisposableProject,
+} from '../harness/reporting.mjs';
+import {
+  agentConversationPath,
+  countLureLeaks,
+  isEmptyExecutionOwnerLock,
+} from '../harness/runtime.mjs';
+import {
+  activeCommandChildren,
   appRoot,
   commandFailureMarker,
   commandPassedMarker,
+  configFileName,
+  gitSensitivePath,
   isolatedAgentJoinClaimSchemaVersion,
   mainAgentId,
   projectSupervisorAgentId,
   providerActionBatchSchemaVersion,
   repoRoot,
   runnerEndpointFileName,
+  sentinelFileName,
   state,
+  staticDelegateClaimSchemaVersion,
+  staticDelegateDeliverySchemaVersion,
   StreamingSecretScanner,
   supervisorAutonomousPlayableAppDataSentinelFileName,
   supervisorAutonomousPlayableAppDataSentinelSchema,
@@ -65,9 +108,15 @@ import {
   buildSupervisorAutonomousPlayablePartialEvidence,
   buildSupervisorAutonomousPlayableStdin,
   collectPartialSupervisorAutonomousPlayableEvidence,
+  inspectSupervisorAutonomousPlayableConversationBoundary,
+  isSupervisorAutonomousPlayableAcceptedPublicStatus,
   isSupervisorAutonomousPlayableLaneDefenseSuite,
   isSupervisorGameChatSingleMainPlayableSuite,
   supervisorAutonomousPlayableMode,
+  supervisorAutonomousPlayableStaticSmokeMatchesFinalIndex,
+  supervisorGameChatFreshInitAcceptanceEvidence,
+  validateSupervisorGameChatSingleMainTopology,
+  waitForSupervisorAutonomousPlayableCliExit,
 } from './supervisor-autonomous-playable.mjs';
 import {
   buildSupervisorSwarmEvidence,
@@ -98,6 +147,7 @@ import {
   supervisorSwarmIsolatedWriteScopeRoots,
   supervisorSwarmMixedIsolatedGroupEntries,
   supervisorSwarmObservedJoinClaimForGroups,
+  supervisorSwarmProfessionalSessions,
   supervisorSwarmReadyIsolatedGroupIds,
   supervisorSwarmResidualSidecarsEmpty,
   supervisorSwarmSeedPrivateValues,
@@ -108,6 +158,124 @@ import {
 } from './supervisor-swarm.mjs';
 
 export async function runAgentRuntimeRealE2eSelfTests() {
+  const supervisorAcceptedPublicStatusLifecycle =
+    validateSupervisorAcceptedPublicStatusSelfTest();
+  const interactiveCliLifecycle =
+    await validateInteractiveCliInheritedStdioLifecycle();
+  const providerBindingLifecycle =
+    validateSupervisorPlayableProviderBindingSelfTest();
+  const providerUsedReportingLifecycle =
+    validateProviderUsedReportingSelfTest();
+  const ownedProcessCleanupLifecycle =
+    validateOwnedProcessCleanupIdentitySelfTest();
+  const liveProcessIdentities = await listSystemProcessIdentities();
+  assert(
+    liveProcessIdentities.some(
+      (identity) =>
+        identity.pid === process.pid &&
+        Number.isSafeInteger(identity.parentPid) &&
+        isNonEmptyString(identity.startedAt) &&
+        isNonEmptyString(identity.name),
+    ),
+    'agent-runtime-real-e2e-self-test-live-process-identity-missing',
+  );
+  const gameChatTopologyLifecycle =
+    validateSupervisorGameChatTopologySelfTest();
+  const professionalSessionLifecycle =
+    validateSupervisorSwarmProfessionalSessionsSelfTest();
+  const executionOwnerLockScanLifecycle =
+    validateExecutionOwnerLockScanSelfTest();
+  const staticSmokeBindingLifecycle =
+    validateStaticSmokeFinalIndexBindingSelfTest();
+  const seededGameHtmlLifecycle = validateSeededGameHtmlContractSelfTest();
+  const freshInitProductionBaselineLifecycle =
+    await validateFreshInitProductionBaselineSelfTest();
+  const lateRegisteredScanner = new StreamingSecretScanner([
+    'initial-scanner-value',
+  ]);
+  lateRegisteredScanner.scan('initial', 'initial-scanner-value');
+  lateRegisteredScanner.addSecrets(['late-isolated-appdata-value']);
+  lateRegisteredScanner.scan('late-a', 'late-isolated-');
+  lateRegisteredScanner.scan('late-a', 'appdata-value');
+  assert(
+    lateRegisteredScanner.count === 2,
+    'agent-runtime-real-e2e-self-test-late-scanner-registration-invalid',
+  );
+  const childCloseTimeoutLifecycle = {
+    waitForChildCloseFalseKillHardTimeoutValidated:
+      await validateWaitForChildCloseHardTimeout('false'),
+    waitForChildCloseThrowKillHardTimeoutValidated:
+      await validateWaitForChildCloseHardTimeout('throw'),
+  };
+  let stableKillHandlePlatformValidated = false;
+  let stableKillHandleCloseValidated = false;
+  let stableKillHandleSignalValidated = false;
+  let stableKillHandleCommandFailureCleanupValidated = false;
+  let windowsOwnedTempPathValidated = false;
+  if (process.platform === 'win32') {
+    const ownedDirectory = await createSentinelOwnedTempDirectory({
+      prefix: path.join(os.tmpdir(), 'agc-owned-path-self-test-'),
+      sentinelName: 'sentinel.json',
+      sentinel: { schemaVersion: 'agc-owned-path-self-test.v1' },
+      codePrefix: 'agc-owned-path-self-test',
+    });
+    try {
+      const sentinel = JSON.parse(
+        await fs.readFile(path.join(ownedDirectory, 'sentinel.json'), 'utf8'),
+      );
+      assert(
+        sentinel.schemaVersion === 'agc-owned-path-self-test.v1',
+        'agent-runtime-real-e2e-self-test-windows-owned-path-sentinel-invalid',
+      );
+      windowsOwnedTempPathValidated = true;
+    } finally {
+      await fs.rm(ownedDirectory, { recursive: true, force: false });
+    }
+  }
+  if (process.platform === 'linux' || process.platform === 'win32') {
+    await ensureOwnedRunnerStableKillSupport();
+    const closeVictim = spawn(
+      process.execPath,
+      ['-e', 'setInterval(() => {}, 1000)'],
+      { stdio: 'ignore', windowsHide: true },
+    );
+    await waitForSelfTestChildSpawn(closeVictim);
+    const closeHandle = await openOwnedRunnerKillHandle(closeVictim.pid);
+    try {
+      await closeOwnedRunnerKillHandle(closeHandle);
+      assert(
+        isProcessAlive(closeVictim.pid),
+        'agent-runtime-real-e2e-self-test-stable-handle-close-killed-target',
+      );
+      stableKillHandleCloseValidated = true;
+    } finally {
+      await stopSelfTestChild(closeVictim);
+      await closeOwnedRunnerKillHandle(closeHandle).catch(() => {});
+    }
+
+    const killVictim = spawn(
+      process.execPath,
+      ['-e', 'setInterval(() => {}, 1000)'],
+      { stdio: 'ignore', windowsHide: true },
+    );
+    await waitForSelfTestChildSpawn(killVictim);
+    const killHandle = await openOwnedRunnerKillHandle(killVictim.pid);
+    try {
+      await signalOwnedRunnerKillHandle(killHandle);
+      await waitForChildClose(killVictim, 10_000);
+      assert(
+        !isProcessAlive(killVictim.pid),
+        'agent-runtime-real-e2e-self-test-stable-handle-signal-target-live',
+      );
+      stableKillHandleSignalValidated = true;
+    } finally {
+      await stopSelfTestChild(killVictim);
+      await closeOwnedRunnerKillHandle(killHandle).catch(() => {});
+    }
+    stableKillHandleCommandFailureCleanupValidated =
+      await validateStableKillHandleCommandFailureCleanup();
+    stableKillHandlePlatformValidated = true;
+  }
   const syntheticSourceEndpointLifecycleEvents = [
     { phase: 'created', fileName: runnerEndpointFileName },
     { phase: 'deleted', fileName: Buffer.from(runnerEndpointFileName) },
@@ -209,7 +377,12 @@ export async function runAgentRuntimeRealE2eSelfTests() {
     JSON.stringify(professionalPlayableRequiredAgents) ===
       JSON.stringify([projectSupervisorAgentId]) &&
     JSON.stringify(gameChatPlayableRequiredAgents) ===
-      JSON.stringify([projectSupervisorAgentId, mainAgentId]);
+      JSON.stringify([
+        projectSupervisorAgentId,
+        mainAgentId,
+        'art-director',
+        'art-asset-plan',
+      ]);
   state.suite = previousSuiteForGameChatPlayable;
   assert(
     gameChatPlayableSuiteRegistered &&
@@ -1661,6 +1834,25 @@ export async function runAgentRuntimeRealE2eSelfTests() {
     collaborationPolicySnapshotBindingStable: true,
     durableSnapshotEligibilityAndContractBindingValidated: true,
     sourceEndpointAbsentLifecycleGuardValidated,
+    ...interactiveCliLifecycle,
+    ...providerBindingLifecycle,
+    ...providerUsedReportingLifecycle,
+    ...ownedProcessCleanupLifecycle,
+    liveProcessIdentityEnumerationValidated: true,
+    ...gameChatTopologyLifecycle,
+    ...professionalSessionLifecycle,
+    ...executionOwnerLockScanLifecycle,
+    ...staticSmokeBindingLifecycle,
+    ...seededGameHtmlLifecycle,
+    ...freshInitProductionBaselineLifecycle,
+    ...supervisorAcceptedPublicStatusLifecycle,
+    isolatedAppDataLatePathScannerValidated: true,
+    ...childCloseTimeoutLifecycle,
+    stableKillHandlePlatformValidated,
+    stableKillHandleCloseValidated,
+    stableKillHandleSignalValidated,
+    stableKillHandleCommandFailureCleanupValidated,
+    windowsOwnedTempPathValidated,
     gameChatPlayableSuiteRegistered,
     gameChatPlayablePackageCommandsRegistered,
     gameChatPlayableModeValidated,
@@ -1709,3 +1901,1243 @@ export async function runAgentRuntimeRealE2eSelfTests() {
       repairReportPrivateValueLeakCount,
   };
 }
+
+function validateSupervisorSwarmProfessionalSessionsSelfTest() {
+  const rootRunId = 'synthetic-professional-session-root-run';
+  const deliverySession = {
+    agentId: 'synthetic-delivery-agent',
+    sessionId: 'synthetic-delivery-session',
+  };
+  const schedulerSession = {
+    agentId: 'synthetic-scheduler-agent',
+    sessionId: 'synthetic-scheduler-session',
+  };
+  const schedulerTask = (agentId, sessionId, overrides = {}) => ({
+    agentId,
+    sessionId,
+    source: 'agent-ready-task-scheduler',
+    parentAgentId: projectSupervisorAgentId,
+    parentRunId: rootRunId,
+    ...overrides,
+  });
+  const sessions = supervisorSwarmProfessionalSessions({
+    deliveries: [
+      {
+        targetAgentId: deliverySession.agentId,
+        targetSessionId: deliverySession.sessionId,
+      },
+      { targetAgentId: '', targetSessionId: 'invalid-delivery-session' },
+    ],
+    latestTasks: [
+      schedulerTask(schedulerSession.agentId, schedulerSession.sessionId),
+      schedulerTask(deliverySession.agentId, deliverySession.sessionId),
+      schedulerTask('synthetic-isolated-agent', 'synthetic-isolated-session', {
+        source: 'agent-isolated-child',
+      }),
+      schedulerTask(
+        'synthetic-wrong-parent-agent',
+        'synthetic-wrong-parent-agent-session',
+        { parentAgentId: 'synthetic-other-parent' },
+      ),
+      schedulerTask(
+        'synthetic-wrong-parent-run-agent',
+        'synthetic-wrong-parent-run-session',
+        { parentRunId: 'synthetic-other-run' },
+      ),
+      schedulerTask(projectSupervisorAgentId, 'synthetic-root-session'),
+      schedulerTask('', 'synthetic-invalid-agent-session'),
+      schedulerTask('synthetic-invalid-session-agent', ''),
+    ],
+    rootAgentId: projectSupervisorAgentId,
+    rootRunId,
+  });
+  const sessionIdentities = sessions
+    .map(({ agentId, sessionId }) => `${agentId}\0${sessionId}`)
+    .sort();
+  const expectedIdentities = [deliverySession, schedulerSession]
+    .map(({ agentId, sessionId }) => `${agentId}\0${sessionId}`)
+    .sort();
+  const missingRootBindingSessions = supervisorSwarmProfessionalSessions({
+    deliveries: [],
+    latestTasks: [
+      schedulerTask(schedulerSession.agentId, schedulerSession.sessionId),
+    ],
+    rootAgentId: projectSupervisorAgentId,
+    rootRunId: '',
+  });
+  assert(
+    JSON.stringify(sessionIdentities) === JSON.stringify(expectedIdentities) &&
+      missingRootBindingSessions.length === 0,
+    'agent-runtime-real-e2e-self-test-professional-session-enumeration-invalid',
+  );
+  return {
+    schedulerProfessionalSessionIncluded: true,
+    professionalSessionIdentityDeduplicated: true,
+    isolatedProfessionalSessionExcluded: true,
+    wrongParentProfessionalSessionExcluded: true,
+    missingRootBindingProfessionalSessionExcluded: true,
+  };
+}
+
+function validateExecutionOwnerLockScanSelfTest() {
+  const root = path.join(os.tmpdir(), 'synthetic-execution-owner-lock-root');
+  const emptyRegularFile = {
+    size: 0,
+    isFile: () => true,
+    isSymbolicLink: () => false,
+  };
+  assert(
+    isEmptyExecutionOwnerLock(
+      root,
+      path.join(root, '.agent/runtime/execution-owner.lock'),
+      emptyRegularFile,
+    ) &&
+      !isEmptyExecutionOwnerLock(
+        root,
+        path.join(root, '.agent/runtime/execution-owner.json'),
+        emptyRegularFile,
+      ) &&
+      !isEmptyExecutionOwnerLock(
+        root,
+        path.join(root, '.agent/runtime/execution-owner.lock.backup'),
+        emptyRegularFile,
+      ) &&
+      !isEmptyExecutionOwnerLock(
+        root,
+        path.join(root, '.agent/runtime/execution-owner.lock'),
+        { ...emptyRegularFile, size: 1 },
+      ) &&
+      !isEmptyExecutionOwnerLock(
+        root,
+        path.join(root, '.agent/runtime/execution-owner.lock'),
+        { ...emptyRegularFile, isSymbolicLink: () => true },
+      ),
+    'agent-runtime-real-e2e-self-test-execution-owner-lock-scan-boundary-invalid',
+  );
+  return {
+    emptyExecutionOwnerLockSkipped: true,
+    adjacentRuntimeEvidenceStillScanned: true,
+    nonEmptyExecutionOwnerLockStillScanned: true,
+    symbolicExecutionOwnerLockStillScanned: true,
+  };
+}
+
+function validateSupervisorAcceptedPublicStatusSelfTest() {
+  const runId = 'synthetic-supervisor-accepted-status-run';
+  const correlationId = finalMessageId(
+    projectSupervisorAgentId,
+    supervisorSwarmSessionId,
+    runId,
+  ).slice('agent-finalization-'.length);
+  const expectedMessageId = `runtime-public-status-${correlationId}-070c160a6299c543`;
+  const canonicalAcceptedStatus = {
+    role: 'assistant',
+    agentId: null,
+    sessionId: null,
+    messageId: expectedMessageId,
+    content: '任务已接收，项目总控 Agent 正在启动处理。',
+  };
+  const rejectedVariants = [
+    { ...canonicalAcceptedStatus, role: 'user' },
+    { ...canonicalAcceptedStatus, agentId: projectSupervisorAgentId },
+    { ...canonicalAcceptedStatus, sessionId: supervisorSwarmSessionId },
+    { ...canonicalAcceptedStatus, messageId: `${expectedMessageId}-legacy` },
+    { ...canonicalAcceptedStatus, content: '任务已接收。' },
+  ];
+  const canonicalBoundary =
+    inspectSupervisorAutonomousPlayableConversationBoundary(
+      [canonicalAcceptedStatus],
+      [canonicalAcceptedStatus],
+      runId,
+    );
+  const rejectedBoundaries = [
+    ...rejectedVariants.map((message) => [canonicalAcceptedStatus, message]),
+    [canonicalAcceptedStatus, { role: 'user', content: 'legacy-user' }],
+  ].map((legacyConversation) =>
+    inspectSupervisorAutonomousPlayableConversationBoundary(
+      legacyConversation,
+      legacyConversation,
+      runId,
+    ),
+  );
+  assert(
+    runtimePublicStatusMessageId(
+      projectSupervisorAgentId,
+      supervisorSwarmSessionId,
+      runId,
+      'accepted',
+    ) === expectedMessageId &&
+      isSupervisorAutonomousPlayableAcceptedPublicStatus(
+        canonicalAcceptedStatus,
+        runId,
+      ) &&
+      rejectedVariants.every(
+        (message) =>
+          !isSupervisorAutonomousPlayableAcceptedPublicStatus(message, runId),
+      ) &&
+      canonicalBoundary.legacyUserFacingMessageCount === 1 &&
+      canonicalBoundary.acceptedPublicStatusCount === 1 &&
+      canonicalBoundary.wrongAgentFinalAssistantCount === 0 &&
+      rejectedBoundaries.every(
+        (boundary) =>
+          boundary.legacyUserFacingMessageCount !== 1 ||
+          boundary.acceptedPublicStatusCount !== 1 ||
+          boundary.wrongAgentFinalAssistantCount !== 0,
+      ),
+    'agent-runtime-real-e2e-self-test-supervisor-accepted-public-status-invalid',
+  );
+  return {
+    supervisorAcceptedPublicStatusIdValidated: true,
+    supervisorAcceptedPublicStatusShapeValidated: true,
+    supervisorAcceptedPublicStatusLegacyVariantsRejected: true,
+  };
+}
+
+function validateSupervisorPlayableProviderBindingSelfTest() {
+  const previousSuite = state.suite;
+  state.suite = supervisorGameChatSingleMainPlayableSuite;
+  try {
+    const config = {
+      agentMode: 'provider',
+      llm: {
+        apiKey: 'synthetic-provider-key-not-for-network',
+        baseUrl: 'https://synthetic-provider.invalid/gpt/v1',
+        model: 'gpt-5.6-sol',
+        apiKind: 'openai_responses',
+        reasoningEffort: 'max',
+      },
+    };
+    const binding = expectedProviderBindingForSuite(config);
+    assert(
+      binding?.providerAgentMode === 'provider' &&
+        binding.providerModel === 'gpt-5.6-sol' &&
+        binding.providerApiKind === 'openai_responses' &&
+        binding.providerReasoningEffort === 'max' &&
+        /^[0-9a-f]{64}$/u.test(binding.providerBaseUrlSha256) &&
+        binding.boundAgentIds.length === 4 &&
+        !JSON.stringify(binding).includes(config.llm.apiKey) &&
+        !JSON.stringify(binding).includes(config.llm.baseUrl),
+      'agent-runtime-real-e2e-self-test-provider-binding-invalid',
+    );
+    const reorderedBinding = {
+      boundAgentIds: [...binding.boundAgentIds],
+      providerBaseUrlSha256: binding.providerBaseUrlSha256,
+      providerReasoningEffort: binding.providerReasoningEffort,
+      providerApiKind: binding.providerApiKind,
+      providerModel: binding.providerModel,
+      providerAgentMode: binding.providerAgentMode,
+    };
+    assert(
+      sameSupervisorPlayableProviderBinding(binding, reorderedBinding) &&
+        !sameSupervisorPlayableProviderBinding(binding, {
+          ...reorderedBinding,
+          providerReasoningEffort: 'high',
+        }),
+      'agent-runtime-real-e2e-self-test-provider-binding-comparison-invalid',
+    );
+    const drifted = expectedProviderBindingForSuite({
+      ...config,
+      agentLlm: { 'art-director': { reasoningEffort: 'high' } },
+    });
+    assert(
+      drifted === null,
+      'agent-runtime-real-e2e-self-test-provider-binding-drift-accepted',
+    );
+    const nonProvider = expectedProviderBindingForSuite({
+      ...config,
+      agentMode: 'codex_app_server',
+    });
+    assert(
+      nonProvider === null,
+      'agent-runtime-real-e2e-self-test-non-provider-mode-accepted',
+    );
+    return {
+      providerAgentModeBindingValidated: true,
+      providerModelBindingValidated: true,
+      providerApiKindBindingValidated: true,
+      providerReasoningEffortBindingValidated: true,
+      providerBaseUrlHashBindingValidated: true,
+      providerBindingPropertyOrderInsensitiveValidated: true,
+      providerBindingDriftRejected: true,
+      nonProviderModeRejected: true,
+    };
+  } finally {
+    state.suite = previousSuite;
+  }
+}
+
+function validateProviderUsedReportingSelfTest() {
+  const completeProviderEvidence = {
+    evidenceCompleteness: 'complete',
+    providerAgentMode: 'provider',
+    providerModel: 'gpt-5.6-sol',
+    providerApiKind: 'openai_responses',
+    providerReasoningEffort: 'max',
+    providerBaseUrlSha256: 'a'.repeat(64),
+    providerBoundAgentCount: 4,
+    providerBindingMatched: true,
+    providerRequestIdentityCount: 2,
+    providerLifecycleStartedCount: 2,
+    providerLifecycleTerminalCount: 2,
+    providerLifecycleCompletedCount: 2,
+    providerLifecycleFailedCount: 0,
+    openProviderLifecycleCount: 0,
+    duplicateProviderLifecycleCount: 0,
+  };
+  const negativeEvidence = [
+    {},
+    { ...completeProviderEvidence, evidenceCompleteness: 'partial' },
+    { ...completeProviderEvidence, providerAgentMode: null },
+    { ...completeProviderEvidence, providerBindingMatched: false },
+    { ...completeProviderEvidence, providerRequestIdentityCount: 0 },
+    { ...completeProviderEvidence, providerLifecycleStartedCount: 1 },
+    { ...completeProviderEvidence, providerLifecycleTerminalCount: 1 },
+    { ...completeProviderEvidence, providerLifecycleCompletedCount: 1 },
+    { ...completeProviderEvidence, providerLifecycleFailedCount: 1 },
+    { ...completeProviderEvidence, openProviderLifecycleCount: 1 },
+    { ...completeProviderEvidence, duplicateProviderLifecycleCount: 1 },
+  ];
+  const previousEvidence = state.evidence;
+  let positiveSummary;
+  let partialSummary;
+  try {
+    state.evidence = completeProviderEvidence;
+    positiveSummary = buildSummary();
+    state.evidence = negativeEvidence[1];
+    partialSummary = buildSummary();
+  } finally {
+    state.evidence = previousEvidence;
+  }
+  assert(
+    providerUsedFromEvidence(completeProviderEvidence) === true &&
+      positiveSummary.providerUsed === true &&
+      partialSummary.providerUsed === false &&
+      negativeEvidence.every(
+        (evidence) => providerUsedFromEvidence(evidence) === false,
+      ),
+    'agent-runtime-real-e2e-self-test-provider-used-reporting-invalid',
+  );
+  return {
+    providerUsedCompleteLifecycleValidated: true,
+    providerUsedPartialEvidenceRejected: true,
+    providerUsedMissingLifecycleRejected: true,
+    providerUsedFailedLifecycleRejected: true,
+    providerUsedOpenLifecycleRejected: true,
+    providerUsedDuplicateLifecycleRejected: true,
+    providerUsedBindingMismatchRejected: true,
+  };
+}
+
+function validateOwnedProcessCleanupIdentitySelfTest() {
+  const processRecords = [
+    {
+      pid: 41001,
+      parentPid: 1,
+      startedAt: 'runner-start',
+      name: 'genarrative-ai-game-creator-shell.exe',
+    },
+    {
+      pid: 41002,
+      parentPid: 41001,
+      startedAt: 'helper-start',
+      name: 'powershell.exe',
+    },
+    {
+      pid: 41003,
+      parentPid: 41001,
+      startedAt: 'node-start',
+      name: 'node.exe',
+    },
+    {
+      pid: 41004,
+      parentPid: 41003,
+      startedAt: 'browser-start',
+      name: 'chrome.exe',
+    },
+    {
+      pid: 41005,
+      parentPid: 41001,
+      startedAt: 'command-start',
+      name: 'cmd.exe',
+    },
+    {
+      pid: 42000,
+      parentPid: 1,
+      startedAt: 'unrelated-start',
+      name: 'node.exe',
+    },
+  ];
+  const snapshot = buildOwnedProcessCleanupSnapshot(processRecords, {
+    runnerPid: 41001,
+    helperPids: [41002],
+    rootPids: [41001, 41002],
+  });
+  const live = inspectOwnedProcessCleanupResiduals(snapshot, processRecords, {
+    activeCommandChildCount: 1,
+    activeInteractiveCliSessionCount: 1,
+  });
+  const reusedPids = processRecords.map((record) =>
+    record.pid >= 41001 && record.pid <= 41005
+      ? { ...record, startedAt: `${record.startedAt}-reused` }
+      : record,
+  );
+  const cleaned = inspectOwnedProcessCleanupResiduals(snapshot, reusedPids, {
+    activeCommandChildCount: 0,
+    activeInteractiveCliSessionCount: 0,
+  });
+  assert(
+    snapshot.observedCounts.runner === 1 &&
+      snapshot.observedCounts.helper === 1 &&
+      snapshot.observedCounts.node === 1 &&
+      snapshot.observedCounts.browser === 1 &&
+      snapshot.observedCounts.command === 1 &&
+      live.clean === false &&
+      live.residualCounts.total === 5 &&
+      cleaned.clean === true &&
+      cleaned.residualCounts.total === 0,
+    'agent-runtime-real-e2e-self-test-owned-process-cleanup-invalid',
+  );
+  return {
+    ownedRunnerResidualIdentityValidated: true,
+    ownedHelperResidualIdentityValidated: true,
+    ownedNodeResidualIdentityValidated: true,
+    ownedBrowserResidualIdentityValidated: true,
+    ownedCommandResidualIdentityValidated: true,
+    ownedProcessPidReuseRejected: true,
+    activeChildRegistryCleanupValidated: true,
+  };
+}
+
+function validateStaticSmokeFinalIndexBindingSelfTest() {
+  const sha256 = 'a'.repeat(64);
+  const baselineSha256 = 'b'.repeat(64);
+  const gate = {
+    lastVerificationStatus: 'passed',
+    verifiedRevision: 7,
+    staticSmokeVerifiedRevision: 7,
+    staticSmokeVerifiedGameIndexSha256: sha256,
+  };
+  assert(
+    supervisorAutonomousPlayableStaticSmokeMatchesFinalIndex(gate, 7, sha256) &&
+      !supervisorAutonomousPlayableStaticSmokeMatchesFinalIndex(
+        gate,
+        7,
+        'b'.repeat(64),
+      ),
+    'agent-runtime-real-e2e-self-test-static-smoke-final-index-binding-invalid',
+  );
+  const acceptanceInput = {
+    freshInitBaselineUsed: true,
+    initialGameIndexSha256: baselineSha256,
+    productionDefaultGameIndexSha256: baselineSha256,
+    uniqueFixedChildCodePrototype: true,
+    finalGameIndexSha256: sha256,
+    gate,
+    revision: 7,
+    viewportResults: [
+      { viewport: 'desktop', passed: true },
+      { viewport: 'mobile', passed: true },
+    ],
+  };
+  const acceptance =
+    supervisorGameChatFreshInitAcceptanceEvidence(acceptanceInput);
+  const negativeCases = [
+    [
+      'freshInitBaselineUsed',
+      { ...acceptanceInput, freshInitBaselineUsed: false },
+    ],
+    [
+      'initialGameIndexMatchesProductionDefault',
+      {
+        ...acceptanceInput,
+        productionDefaultGameIndexSha256: 'c'.repeat(64),
+      },
+    ],
+    [
+      'uniqueFixedChildCodePrototype',
+      { ...acceptanceInput, uniqueFixedChildCodePrototype: false },
+    ],
+    [
+      'finalGameIndexDiffersFromBaseline',
+      { ...acceptanceInput, finalGameIndexSha256: baselineSha256 },
+    ],
+    [
+      'staticSmokeGameIndexSha256Matched',
+      {
+        ...acceptanceInput,
+        gate: {
+          ...gate,
+          staticSmokeVerifiedGameIndexSha256: 'c'.repeat(64),
+        },
+      },
+    ],
+    [
+      'desktopPlaytestPassed',
+      {
+        ...acceptanceInput,
+        viewportResults: [
+          { viewport: 'desktop', passed: false },
+          { viewport: 'mobile', passed: true },
+        ],
+      },
+    ],
+    [
+      'mobilePlaytestPassed',
+      {
+        ...acceptanceInput,
+        viewportResults: [
+          { viewport: 'desktop', passed: true },
+          { viewport: 'mobile', passed: false },
+        ],
+      },
+    ],
+  ];
+  assert(
+    Object.values(acceptance).every((value) => value === true) &&
+      negativeCases.every(
+        ([field, input]) =>
+          supervisorGameChatFreshInitAcceptanceEvidence(input)[field] === false,
+      ),
+    'agent-runtime-real-e2e-self-test-game-chat-fresh-init-acceptance-invalid',
+  );
+  return {
+    staticSmokeFinalIndexSha256BindingValidated: true,
+    staticSmokeStaleIndexSha256Rejected: true,
+    gameChatFreshInitAcceptanceReportValidated: true,
+    gameChatFreshInitAcceptanceNegativeCasesValidated: true,
+  };
+}
+
+function validateSeededGameHtmlContractSelfTest() {
+  const html = seededGameHtml();
+  const lowerHtml = html.toLowerCase();
+  const satisfiesStaticSmokeContract = (candidate) => {
+    const lowerCandidate = candidate.toLowerCase();
+    return (
+      lowerCandidate.includes('<canvas') &&
+      lowerCandidate.includes('getcontext(') &&
+      lowerCandidate.includes('fillrect(') &&
+      candidate.includes('requestAnimationFrame') &&
+      ['keydown', 'keyup', 'pointer', 'mousedown', 'touch', 'click'].some(
+        (marker) => lowerCandidate.includes(marker),
+      ) &&
+      ['goal', 'objective', 'survive'].some((marker) =>
+        lowerCandidate.includes(marker),
+      ) &&
+      ['win', 'victory', 'defeat'].some((marker) =>
+        lowerCandidate.includes(marker),
+      ) &&
+      ['restart', 'reset', 'again'].some((marker) =>
+        lowerCandidate.includes(marker),
+      ) &&
+      lowerCandidate.includes('</script>') &&
+      lowerCandidate.includes('</html>')
+    );
+  };
+  assert(
+    satisfiesStaticSmokeContract(html) &&
+      lowerHtml.includes('real_e2e_target:before'.toLowerCase()),
+    'agent-runtime-real-e2e-self-test-seeded-game-static-smoke-contract-invalid',
+  );
+  for (const [label, brokenHtml] of [
+    ['input', html.replaceAll('pointer', 'input-event-removed')],
+    ['objective', html.replace(/objective|survive/giu, 'purpose-removed')],
+    ['terminal', html.replace(/victory|defeat/giu, 'terminal-state-removed')],
+    ['restart', html.replace(/restart/giu, 'retry-path-removed')],
+  ]) {
+    assert(
+      !satisfiesStaticSmokeContract(brokenHtml),
+      `agent-runtime-real-e2e-self-test-seeded-game-negative-${label}-invalid`,
+    );
+  }
+  return {
+    seededGameHtmlStaticSmokeContractValidated: true,
+    seededGameHtmlStaticSmokeNegativeCasesValidated: true,
+  };
+}
+
+async function validateFreshInitProductionBaselineSelfTest() {
+  const mainSource = readFileSync(
+    path.join(appRoot, 'src-tauri', 'src', 'main.rs'),
+    'utf8',
+  );
+  const defaultIndexStartMarker = 'const DEFAULT_GAME_INDEX_HTML: &str = r#"';
+  const defaultIndexStart = mainSource.indexOf(defaultIndexStartMarker);
+  const defaultIndexBodyStart =
+    defaultIndexStart + defaultIndexStartMarker.length;
+  const defaultIndexEnd = mainSource.indexOf('"#;', defaultIndexBodyStart);
+  assert(
+    defaultIndexStart >= 0 &&
+      defaultIndexStart === mainSource.lastIndexOf(defaultIndexStartMarker) &&
+      defaultIndexEnd > defaultIndexBodyStart,
+    'agent-runtime-real-e2e-self-test-production-default-index-source-invalid',
+  );
+  const rustProductionDefault = mainSource.slice(
+    defaultIndexBodyStart,
+    defaultIndexEnd,
+  );
+  const canonicalProductionDefault = productionDefaultGameIndexHtml();
+  assert(
+    rustProductionDefault === canonicalProductionDefault,
+    'agent-runtime-real-e2e-self-test-production-default-index-drifted',
+  );
+
+  const previousSuite = state.suite;
+  const previousProjectRoot = state.projectRoot;
+  const previousProjectPathScanner = state.projectPathTranscriptScanner;
+  const previousSentinelToken = state.sentinelToken;
+  const previousLures = state.lures;
+  let freshProjectRoot = null;
+  try {
+    state.suite = supervisorGameChatSingleMainPlayableSuite;
+    await seedDisposableProject({ preserveProductionInitBaseline: true });
+    freshProjectRoot = state.projectRoot;
+
+    const omittedGeneratedPaths = [
+      'package.json',
+      'verify-e2e.mjs',
+      'game/index.html',
+    ];
+    const omittedGeneratedMetadata = await Promise.all(
+      omittedGeneratedPaths.map((relativePath) =>
+        fs.lstat(path.join(freshProjectRoot, relativePath)).catch(() => null),
+      ),
+    );
+    const preservedBaselinePaths = [
+      sentinelFileName,
+      'AGENTS.md',
+      '.env',
+      configFileName,
+      '.agent/private-secret.txt',
+      gitSensitivePath,
+      'e2e/isolated-a/evidence.txt',
+      'e2e/isolated-b/evidence.txt',
+      'e2e/isolated-c/evidence.txt',
+    ];
+    const preservedBaselineMetadata = await Promise.all(
+      preservedBaselinePaths.map((relativePath) =>
+        fs.lstat(path.join(freshProjectRoot, relativePath)).catch(() => null),
+      ),
+    );
+    const gameDirectoryEntries = await fs.readdir(
+      path.join(freshProjectRoot, 'game'),
+    );
+    const [envLure, configLure, privateLure, gitLure] = state.lures;
+    const [envBytes, configBytes, privateBytes, gitBytes] = await Promise.all([
+      fs.readFile(path.join(freshProjectRoot, '.env')),
+      fs.readFile(path.join(freshProjectRoot, configFileName)),
+      fs.readFile(path.join(freshProjectRoot, '.agent/private-secret.txt')),
+      fs.readFile(path.join(freshProjectRoot, gitSensitivePath)),
+    ]);
+    const sensitiveLureContentsValid =
+      state.lures.length === 4 &&
+      envBytes.equals(Buffer.from(`REAL_E2E_SECRET=${envLure}\n`)) &&
+      JSON.parse(configBytes.toString('utf8')).apiKey === configLure &&
+      privateBytes.equals(Buffer.from(`${privateLure}\n`)) &&
+      gitBytes.equals(Buffer.from(`${gitLure}\n`));
+    const injectedLureLeakPath = path.join(
+      freshProjectRoot,
+      'e2e/isolated-a/lure-leak-self-test.txt',
+    );
+    await fs.writeFile(injectedLureLeakPath, `${envLure}\n`);
+    const injectedLureLeakCount = await countLureLeaks();
+    await fs.rm(injectedLureLeakPath, { force: false });
+    const clearedLureLeakCount = await countLureLeaks();
+    const tracked = await runProcess('git', ['ls-files', '-z'], {
+      cwd: freshProjectRoot,
+      timeoutMs: 30_000,
+    });
+    const trackedPaths = tracked.stdout
+      .toString('utf8')
+      .split('\0')
+      .filter(Boolean)
+      .sort();
+    const expectedTrackedPaths = [
+      'AGENTS.md',
+      'e2e/isolated-a/evidence.txt',
+      'e2e/isolated-b/evidence.txt',
+      'e2e/isolated-c/evidence.txt',
+    ].sort();
+    await runProcess('git', ['rev-parse', '--verify', 'HEAD'], {
+      cwd: freshProjectRoot,
+      timeoutMs: 30_000,
+    });
+    assert(
+      omittedGeneratedMetadata.every((metadata) => metadata === null) &&
+        preservedBaselineMetadata.every(
+          (metadata) => metadata?.isFile() && !metadata.isSymbolicLink(),
+        ) &&
+        gameDirectoryEntries.length === 0 &&
+        sensitiveLureContentsValid &&
+        injectedLureLeakCount === 1 &&
+        clearedLureLeakCount === 0 &&
+        JSON.stringify(trackedPaths) === JSON.stringify(expectedTrackedPaths),
+      'agent-runtime-real-e2e-self-test-fresh-init-seed-invalid',
+    );
+  } finally {
+    try {
+      if (freshProjectRoot) {
+        assert(
+          await removeDisposableProject(),
+          'agent-runtime-real-e2e-self-test-fresh-init-cleanup-refused',
+        );
+      }
+    } finally {
+      state.suite = previousSuite;
+      state.projectRoot = previousProjectRoot;
+      state.projectPathTranscriptScanner = previousProjectPathScanner;
+      state.sentinelToken = previousSentinelToken;
+      state.lures = previousLures;
+    }
+  }
+
+  return {
+    productionDefaultGameIndexExactBytesValidated: true,
+    productionDefaultGameIndexSha256: hashValue(
+      Buffer.from(canonicalProductionDefault, 'utf8'),
+    ),
+    gameChatFreshInitGeneratedBaselineOmitted: true,
+    gameChatFreshInitGitBaselineValidated: true,
+    gameChatFreshInitSensitiveLuresPreserved: true,
+    gameChatFreshInitLureLeakDetected: true,
+    gameChatFreshInitLureLeakClearValidated: true,
+  };
+}
+
+function validateSupervisorGameChatTopologySelfTest() {
+  const previousRunId = state.initialRunId;
+  const previousSuite = state.suite;
+  state.initialRunId = 'synthetic-game-chat-root-run';
+  state.suite = supervisorGameChatSingleMainPlayableSuite;
+  const task = (
+    agentId,
+    runId,
+    parentAgentId,
+    parentRunId,
+    source,
+    delegationId = null,
+  ) => ({
+    agentId,
+    runId,
+    parentAgentId,
+    parentRunId,
+    source,
+    delegationId,
+    status: 'completed',
+    phase: 'completed',
+  });
+  const rootTask = task(
+    projectSupervisorAgentId,
+    state.initialRunId,
+    null,
+    null,
+    'project-supervisor-game-chat',
+  );
+  const codeTask = task(
+    mainAgentId,
+    'synthetic-code-run',
+    projectSupervisorAgentId,
+    state.initialRunId,
+    'agent-ready-task-scheduler',
+  );
+  const artDirectorTask = task(
+    'art-director',
+    'synthetic-art-director-run',
+    mainAgentId,
+    codeTask.runId,
+    'agent-delegate',
+    'synthetic-art-director-delivery',
+  );
+  const artAssetTask = task(
+    'art-asset-plan',
+    'synthetic-art-asset-run',
+    mainAgentId,
+    codeTask.runId,
+    'agent-delegate',
+    'synthetic-art-asset-delivery',
+  );
+  const tasks = [rootTask, codeTask, artDirectorTask, artAssetTask];
+  const runtimes = tasks.map((entry) => ({
+    ...entry,
+    pendingToolAction: null,
+    pendingAction: null,
+  }));
+  const actionReceipt = (actionId, tool) => ({
+    recordType: 'agent.runtime.action_receipt',
+    agentId: mainAgentId,
+    runId: codeTask.runId,
+    actionId,
+    tool,
+    status: 'ok',
+  });
+  const deliveries = [
+    {
+      schemaVersion: staticDelegateDeliverySchemaVersion,
+      parentAgentId: mainAgentId,
+      parentRunId: codeTask.runId,
+      parentActionId: 'delegate-art-director',
+      delegationId: artDirectorTask.delegationId,
+      targetAgentId: artDirectorTask.agentId,
+      targetRunId: artDirectorTask.runId,
+      expectedArtifacts: ['assets/art-spec.png'],
+      status: 'claimed-by-parent',
+      terminalStatus: 'completed',
+      claimedByActionId: 'claim-art-director',
+      repairOfDelegationId: null,
+      structuredResult: {
+        contractStatus: 'evidence-ready',
+        artifacts: [{ path: 'assets/art-spec.png', sha256: '1'.repeat(64) }],
+      },
+    },
+    {
+      schemaVersion: staticDelegateDeliverySchemaVersion,
+      parentAgentId: mainAgentId,
+      parentRunId: codeTask.runId,
+      parentActionId: 'delegate-art-asset',
+      delegationId: artAssetTask.delegationId,
+      targetAgentId: artAssetTask.agentId,
+      targetRunId: artAssetTask.runId,
+      expectedArtifacts: ['assets/art-spritesheet.png'],
+      status: 'claimed-by-parent',
+      terminalStatus: 'completed',
+      claimedByActionId: 'claim-art-asset',
+      repairOfDelegationId: null,
+      structuredResult: {
+        contractStatus: 'evidence-ready',
+        artifacts: [
+          { path: 'assets/art-spritesheet.png', sha256: '2'.repeat(64) },
+          { path: 'assets/manifest.art.json', sha256: '3'.repeat(64) },
+        ],
+      },
+    },
+  ];
+  const claims = deliveries.map((delivery) => ({
+    schemaVersion: staticDelegateClaimSchemaVersion,
+    parentAgentId: mainAgentId,
+    parentRunId: codeTask.runId,
+    actionId: delivery.claimedByActionId,
+    status: 'observed',
+    receipts: [
+      {
+        delegationId: delivery.delegationId,
+        targetAgentId: delivery.targetAgentId,
+        status: delivery.terminalStatus,
+      },
+    ],
+  }));
+  const persistence = {
+    taskSnapshot: { latest: tasks },
+    runtimeStates: runtimes,
+    deliveries,
+    claims,
+    agentDb: [
+      actionReceipt('asset-list', 'asset.list'),
+      actionReceipt('delegate-art-director', 'agent.delegate'),
+      actionReceipt('claim-art-director', 'agent.run_status'),
+      actionReceipt('delegate-art-asset', 'agent.delegate'),
+      actionReceipt('claim-art-asset', 'agent.run_status'),
+    ],
+  };
+  const binding = (
+    agentId,
+    runId,
+    parentAgentId,
+    parentRunId,
+    bindingFingerprint,
+    parentBindingFingerprint,
+  ) => ({
+    agentId,
+    runId,
+    rootAgentId: projectSupervisorAgentId,
+    rootRunId: state.initialRunId,
+    parentAgentId,
+    parentRunId,
+    profile: 'autonomous-game-build',
+    source: tasks.find(
+      (entry) => entry.agentId === agentId && entry.runId === runId,
+    )?.source,
+    bindingFingerprint,
+    parentBindingFingerprint,
+  });
+  const bindings = [
+    binding(
+      projectSupervisorAgentId,
+      state.initialRunId,
+      null,
+      null,
+      'root-binding',
+      null,
+    ),
+    binding(
+      mainAgentId,
+      codeTask.runId,
+      projectSupervisorAgentId,
+      state.initialRunId,
+      'code-binding',
+      'root-binding',
+    ),
+    binding(
+      artDirectorTask.agentId,
+      artDirectorTask.runId,
+      mainAgentId,
+      codeTask.runId,
+      'art-director-binding',
+      'code-binding',
+    ),
+    binding(
+      artAssetTask.agentId,
+      artAssetTask.runId,
+      mainAgentId,
+      codeTask.runId,
+      'art-asset-binding',
+      'code-binding',
+    ),
+  ];
+  const routeEvidence = {
+    workflowDecision: {
+      rootAgentId: projectSupervisorAgentId,
+      rootRunId: state.initialRunId,
+      strategy: 'audit-existing-first',
+    },
+    assetCoverage: {
+      rootRunId: state.initialRunId,
+      auditedByAgentId: mainAgentId,
+      auditedByRunId: codeTask.runId,
+      requiredSlots: ['art-spec', 'core-spritesheet'],
+      missingSlots: ['art-spec', 'core-spritesheet'],
+    },
+    assetRoute: {
+      rootRunId: state.initialRunId,
+      strategy: 'generate-missing-art',
+      generatedTaskIds: ['art-director', 'art-asset-plan'],
+      reusedTaskIds: [],
+    },
+  };
+  try {
+    const topology = validateSupervisorGameChatSingleMainTopology(
+      persistence,
+      bindings,
+      routeEvidence,
+    );
+    const failedDescendantPersistence = structuredClone(persistence);
+    failedDescendantPersistence.taskSnapshot.latest.find(
+      (entry) => entry.agentId === 'art-director',
+    ).status = 'failed';
+    let failedDescendantRejected = false;
+    try {
+      validateSupervisorGameChatSingleMainTopology(
+        failedDescendantPersistence,
+        bindings,
+        routeEvidence,
+      );
+    } catch {
+      failedDescendantRejected = true;
+    }
+    const duplicateRootPersistence = structuredClone(persistence);
+    duplicateRootPersistence.taskSnapshot.latest.push({
+      ...rootTask,
+      runId: 'synthetic-second-root',
+    });
+    duplicateRootPersistence.runtimeStates.push({
+      ...runtimes[0],
+      runId: 'synthetic-second-root',
+    });
+    let duplicateRootRejected = false;
+    try {
+      validateSupervisorGameChatSingleMainTopology(
+        duplicateRootPersistence,
+        bindings,
+        routeEvidence,
+      );
+    } catch {
+      duplicateRootRejected = true;
+    }
+    const nestedChildPersistence = structuredClone(persistence);
+    const nestedTask = task(
+      'nested-forbidden-agent',
+      'synthetic-nested-forbidden-run',
+      artDirectorTask.agentId,
+      artDirectorTask.runId,
+      'agent-delegate',
+      'synthetic-nested-forbidden-delivery',
+    );
+    nestedChildPersistence.taskSnapshot.latest.push(nestedTask);
+    nestedChildPersistence.runtimeStates.push({
+      ...nestedTask,
+      pendingToolAction: null,
+      pendingAction: null,
+    });
+    let nestedChildRejected = false;
+    try {
+      validateSupervisorGameChatSingleMainTopology(
+        nestedChildPersistence,
+        bindings,
+        routeEvidence,
+      );
+    } catch {
+      nestedChildRejected = true;
+    }
+    const outOfScopeArtifactPersistence = structuredClone(persistence);
+    outOfScopeArtifactPersistence.deliveries[0].structuredResult.artifacts[0] =
+      { path: 'game/index.html', sha256: '4'.repeat(64) };
+    let outOfScopeArtifactRejected = false;
+    try {
+      validateSupervisorGameChatSingleMainTopology(
+        outOfScopeArtifactPersistence,
+        bindings,
+        routeEvidence,
+      );
+    } catch {
+      outOfScopeArtifactRejected = true;
+    }
+    assert(
+      topology.uniqueRootRunCount === 1 &&
+        topology.recursiveDescendantCount === 3 &&
+        topology.completedDescendantCount === 3 &&
+        topology.artChildCount === 2 &&
+        topology.artDeliveryClaimCount === 2 &&
+        topology.assetListBeforeArtDelegation === true &&
+        failedDescendantRejected &&
+        duplicateRootRejected &&
+        nestedChildRejected &&
+        outOfScopeArtifactRejected,
+      'agent-runtime-real-e2e-self-test-game-chat-topology-invalid',
+    );
+    return {
+      gameChatUniqueSupervisorRootValidated: true,
+      gameChatUniqueFixedCodePrototypeChildValidated: true,
+      gameChatRecursiveChildTopologyValidated: true,
+      gameChatAllDescendantsCompletedValidated: true,
+      gameChatNestedFailureRejected: true,
+      gameChatAssetListBeforeDelegationValidated: true,
+      gameChatArtDeliveryClaimValidated: true,
+      gameChatAssetsWriteBoundaryValidated: true,
+    };
+  } finally {
+    state.initialRunId = previousRunId;
+    state.suite = previousSuite;
+  }
+}
+
+async function waitForSelfTestChildSpawn(child) {
+  if (Number.isSafeInteger(child.pid) && child.pid > 1) return;
+  await new Promise((resolve, reject) => {
+    child.once('spawn', resolve);
+    child.once('error', reject);
+  });
+}
+
+async function stopSelfTestChild(child) {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  child.kill('SIGKILL');
+  await waitForChildClose(child, 10_000);
+}
+
+async function validateWaitForChildCloseHardTimeout(killBehavior) {
+  const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], {
+    stdio: 'ignore',
+    windowsHide: true,
+  });
+  await waitForSelfTestChildSpawn(child);
+  const originalKill = child.kill.bind(child);
+  child.kill = () => {
+    if (killBehavior === 'false') return false;
+    const error = new Error('synthetic-child-kill-failure');
+    error.code = 'EPERM';
+    throw error;
+  };
+  const startedAt = Date.now();
+  let failure = null;
+  try {
+    await waitForChildClose(child, 25, 75);
+  } catch (error) {
+    failure = error;
+  } finally {
+    child.kill = originalKill;
+    await stopSelfTestChild(child);
+  }
+  assert(
+    failure?.code ===
+      'isolated-runner-stable-kill-handle-helper-reap-timeout' &&
+      Date.now() - startedAt < 2_000,
+    `agent-runtime-real-e2e-self-test-child-close-${killBehavior}-kill-hard-timeout-invalid`,
+  );
+  return true;
+}
+
+async function validateStableKillHandleCommandFailureCleanup() {
+  const victim = spawn(
+    process.execPath,
+    ['-e', 'setInterval(() => {}, 1000)'],
+    { stdio: 'ignore', windowsHide: true },
+  );
+  await waitForSelfTestChildSpawn(victim);
+  const handle = await openOwnedRunnerKillHandle(victim.pid);
+  const originalEnd = handle.child.stdin.end.bind(handle.child.stdin);
+  const originalKill = handle.child.kill.bind(handle.child);
+  let helperClosedWhenCleanupKillStarted = null;
+  let failure = null;
+  handle.child.stdin.end = () => {
+    const error = new Error('synthetic-stable-handle-epipe');
+    error.code = 'EPIPE';
+    throw error;
+  };
+  handle.child.kill = (...args) => {
+    helperClosedWhenCleanupKillStarted ??= handle.closed;
+    return originalKill(...args);
+  };
+  try {
+    await closeOwnedRunnerKillHandle(handle);
+  } catch (error) {
+    failure = error;
+  } finally {
+    handle.child.stdin.end = originalEnd;
+    handle.child.kill = originalKill;
+  }
+  try {
+    assert(
+      failure?.code === 'isolated-runner-stable-kill-handle-stdin-failed' &&
+        handle.command === 'CLOSE' &&
+        helperClosedWhenCleanupKillStarted === false &&
+        handle.closed === true &&
+        (handle.child.exitCode !== null || handle.child.signalCode !== null) &&
+        !activeCommandChildren.has(handle.child) &&
+        isProcessAlive(victim.pid),
+      'agent-runtime-real-e2e-self-test-stable-handle-command-failure-cleanup-invalid',
+    );
+    return true;
+  } finally {
+    await closeOwnedRunnerKillHandle(handle).catch(() => {});
+    await stopSelfTestChild(victim);
+  }
+}
+
+async function validateInteractiveCliInheritedStdioLifecycle() {
+  const expectedReport = {
+    schemaVersion: 'game-creator-swarm-turn-report.v1',
+    outcome: 'settled',
+    parentAgentId: 'project-supervisor',
+    sessionId: 'interactive-cli-fd3-self-test-session',
+    parentRunId: 'interactive-cli-fd3-self-test-run',
+    runtimeCount: 1,
+    busyRuntimeCount: 0,
+    pendingTaskCount: 0,
+    runningTaskCount: 0,
+    waitingForConfirmationCount: 0,
+    waitingForUserInputCount: 0,
+    newAssistantMessageCount: 1,
+    finalReplyChars: 1,
+    reconciliationAgentCount: 0,
+  };
+  const stderrMarker = 'interactive-cli-fd3-holder-stderr-marker';
+  const previousProjectPathScanner = state.projectPathTranscriptScanner;
+  const projectPathScanner = new StreamingSecretScanner([stderrMarker]);
+  state.projectPathTranscriptScanner = projectPathScanner;
+  const reportLine = `[turn.report] ${JSON.stringify(expectedReport)}\n`;
+  const splitIndex = Math.max(1, Math.floor(reportLine.length / 2));
+  const holderSource = `
+process.stdin.setEncoding('utf8');
+let input = '';
+const safetyTimer = setTimeout(() => process.exit(74), 15_000);
+process.stdin.on('data', (chunk) => {
+  input += chunk;
+  if (!input.includes('CLOSE\\n')) return;
+  clearTimeout(safetyTimer);
+  process.exit(0);
+});
+process.stdin.on('end', () => process.exit(75));
+process.stdin.resume();
+`;
+  const wrapperSource = `
+const { spawn } = require('node:child_process');
+const holder = spawn(
+  process.execPath,
+  ['--input-type=commonjs', '-e', ${JSON.stringify(holderSource)}],
+  { stdio: [3, 'inherit', 'inherit'], windowsHide: true },
+);
+holder.once('error', () => {
+  process.exitCode = 73;
+});
+holder.unref();
+const reportLine = ${JSON.stringify(reportLine)};
+process.stdout.write(reportLine.slice(0, ${splitIndex}), () => {
+  setImmediate(() => {
+    process.stdout.write(reportLine.slice(${splitIndex}), () => {
+      process.stderr.write(${JSON.stringify(`${stderrMarker}\n`)}, () => {
+        process.exit(process.exitCode ?? 0);
+      });
+    });
+  });
+});
+`;
+  const wrapper = spawn(
+    process.execPath,
+    ['--input-type=commonjs', '-e', wrapperSource],
+    {
+      stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+    },
+  );
+  const session = createInteractiveCliSession(wrapper);
+  const originalKill = wrapper.kill.bind(wrapper);
+  let killCallCount = 0;
+  wrapper.kill = (...args) => {
+    killCallCount += 1;
+    return originalKill(...args);
+  };
+  let controlStreamError = null;
+  wrapper.stdio[3].on('error', (error) => {
+    controlStreamError ??= error;
+  });
+  try {
+    await waitForInteractiveCliExit(session, 10_000);
+    assert(
+      session.exited && !session.stdioClosed,
+      'agent-runtime-real-e2e-self-test-interactive-cli-two-phase-not-observed',
+    );
+    const parsedReport =
+      await waitForSupervisorAutonomousPlayableCliExit(session);
+    await waitForInteractiveCliOutput(
+      session,
+      () => session.stderr.toString('utf8').includes(`${stderrMarker}\n`),
+      'agent-runtime-real-e2e-self-test-interactive-cli-output-timeout',
+      10_000,
+      { allowAfterProcessExit: true },
+    );
+    assert(
+      JSON.stringify(canonicalJsonValue(parsedReport)) ===
+        JSON.stringify(canonicalJsonValue(expectedReport)),
+      'agent-runtime-real-e2e-self-test-interactive-cli-report-mismatch',
+    );
+    await closeInteractiveCli(session);
+    assert(
+      killCallCount === 0 && !session.stdioClosed,
+      'agent-runtime-real-e2e-self-test-interactive-cli-exit-cleanup-killed',
+    );
+    wrapper.stdio[3].end('CLOSE\n');
+    await waitForInteractiveCliStdioClose(session, 10_000);
+    assert(
+      controlStreamError === null &&
+        session.stdioClosed &&
+        projectPathScanner.count === 1,
+      'agent-runtime-real-e2e-self-test-interactive-cli-stdio-close-invalid',
+    );
+    return {
+      interactiveCliExitBeforeStdioCloseValidated: true,
+      interactiveCliPostExitReportValidated: true,
+      interactiveCliExitCleanupDidNotKillValidated: true,
+      interactiveCliStdioCloseAfterHolderReleaseValidated: true,
+      interactiveCliProjectPathScannerValidated: true,
+    };
+  } finally {
+    if (!wrapper.stdio[3].destroyed && !wrapper.stdio[3].writableEnded) {
+      wrapper.stdio[3].end('CLOSE\n');
+    }
+    if (!session.stdioClosed) {
+      await waitForInteractiveCliStdioClose(session, 10_000).catch(() => {
+        destroyInteractiveCliOutputStreams(session);
+      });
+    }
+    state.projectPathTranscriptScanner = previousProjectPathScanner;
+  }
+}
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-autonomous-playable.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-autonomous-playable.mjs
index 3fbdfb34a..18289737e 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-autonomous-playable.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-autonomous-playable.mjs
@@ -15,6 +15,7 @@ import {
   duplicateCount,
   finalMessageId,
   isNonEmptyString,
+  runtimePublicStatusMessageId,
 } from '../assertions/runtime.mjs';
 import { fs, path } from '../dependencies.mjs';
 import {
@@ -29,10 +30,18 @@ import {
   interactiveCliOutput,
   prepareCliBinary,
   startInteractiveCli,
+  waitForInteractiveCliOutput,
 } from '../harness/process.mjs';
-import { seedDisposableProject } from '../harness/project.mjs';
+import {
+  productionDefaultGameIndexHtml,
+  seedDisposableProject,
+} from '../harness/project.mjs';
 import { decodeUtf8Fatal } from '../harness/reporting.mjs';
-import { findPendingActions, readRuntime } from '../harness/runtime.mjs';
+import {
+  countLureLeaks,
+  findPendingActions,
+  readRuntime,
+} from '../harness/runtime.mjs';
 import {
   autonomousCompletionContractSchemaVersion,
   autonomousGameBuildRunProfile,
@@ -42,6 +51,8 @@ import {
   providerRequestLifecycleSchemaVersion,
   runProfileBindingSchemaVersion,
   state,
+  staticDelegateClaimSchemaVersion,
+  staticDelegateDeliverySchemaVersion,
   supervisorAutonomousPlayableLaneDefenseSuite,
   supervisorAutonomousPlayableLaneDefenseTask,
   supervisorAutonomousPlayableRunTimeoutMs,
@@ -68,7 +79,63 @@ import {
 
 const projectSupervisorCliSource = 'project-supervisor-cli';
 const projectSupervisorGameChatSource = 'project-supervisor-game-chat';
+const projectSupervisorAcceptedPublicStatus = 'accepted';
+const projectSupervisorAcceptedPublicStatusContent =
+  '任务已接收，项目总控 Agent 正在启动处理。';
 const gameChatMainAgentId = 'code-prototype';
+const gameChatArtAgentIds = ['art-director', 'art-asset-plan'];
+const gameChatArtSlotToAgent = new Map([
+  ['art-spec', 'art-director'],
+  ['core-spritesheet', 'art-asset-plan'],
+]);
+const gameChatArtExpectedArtifact = new Map([
+  ['art-director', 'assets/art-spec.png'],
+  ['art-asset-plan', 'assets/art-spritesheet.png'],
+]);
+
+export function isSupervisorAutonomousPlayableAcceptedPublicStatus(
+  message,
+  runId,
+) {
+  return (
+    isPlainObject(message) &&
+    message.role === 'assistant' &&
+    message.agentId == null &&
+    message.sessionId == null &&
+    message.messageId ===
+      runtimePublicStatusMessageId(
+        projectSupervisorAgentId,
+        supervisorSwarmSessionId,
+        runId,
+        projectSupervisorAcceptedPublicStatus,
+      ) &&
+    message.content === projectSupervisorAcceptedPublicStatusContent
+  );
+}
+
+export function inspectSupervisorAutonomousPlayableConversationBoundary(
+  legacyConversation,
+  userFacing,
+  runId,
+) {
+  const legacyUserFacingMessages = legacyConversation.filter((message) =>
+    ['user', 'assistant'].includes(message.role),
+  );
+  const acceptedPublicStatuses = legacyUserFacingMessages.filter((message) =>
+    isSupervisorAutonomousPlayableAcceptedPublicStatus(message, runId),
+  );
+  const wrongAgentFinalAssistants = userFacing.filter(
+    (message) =>
+      message.role === 'assistant' &&
+      message.agentId !== projectSupervisorAgentId &&
+      !isSupervisorAutonomousPlayableAcceptedPublicStatus(message, runId),
+  );
+  return {
+    legacyUserFacingMessageCount: legacyUserFacingMessages.length,
+    acceptedPublicStatusCount: acceptedPublicStatuses.length,
+    wrongAgentFinalAssistantCount: wrongAgentFinalAssistants.length,
+  };
+}
 
 export function supervisorAutonomousPlayableMode() {
   if (state.suite === supervisorGameChatSingleMainPlayableSuite) {
@@ -157,22 +224,33 @@ export async function waitForSupervisorAutonomousPlayableCliExit(session) {
   });
   let result;
   try {
-    result = await Promise.race([session.closePromise, timeout]);
+    result = await Promise.race([session.exitPromise, timeout]);
   } finally {
     clearTimeout(timeoutHandle);
   }
   if (!result) {
     throw codedError('supervisor-autonomous-playable-cli-timeout');
   }
-  const output = interactiveCliOutput(session);
-  state.supervisorAutonomousPlayable.cliOutput = output;
   if (result.error || result.code !== 0 || result.signal !== null) {
+    state.supervisorAutonomousPlayable.cliOutput =
+      interactiveCliOutput(session);
     throw codedProcessError('supervisor-autonomous-playable-cli-failed', {
       ...result,
       stdout: session.stdout,
       stderr: session.stderr,
     });
   }
+  const output = await waitForInteractiveCliOutput(
+    session,
+    () =>
+      /(?:^|\r?\n)\[turn\.report\] [^\r\n]+\r?\n/u.test(
+        session.stdout.toString('utf8'),
+      ),
+    'supervisor-autonomous-playable-turn-report-timeout',
+    10_000,
+    { allowAfterProcessExit: true },
+  );
+  state.supervisorAutonomousPlayable.cliOutput = output;
   const report = parseSingleSwarmTurnReport(
     output,
     'supervisor-autonomous-playable',
@@ -291,6 +369,9 @@ export function buildSupervisorAutonomousPlayablePartialEvidence(
     partialEvidenceReadErrorCount = 0,
   } = {},
 ) {
+  const productionDefaultGameIndexSha256 = hashValue(
+    Buffer.from(productionDefaultGameIndexHtml(), 'utf8'),
+  );
   const parentTask = persistence.taskSnapshot.latest.find(
     (task) =>
       task.agentId === projectSupervisorAgentId &&
@@ -410,6 +491,9 @@ export function buildSupervisorAutonomousPlayablePartialEvidence(
     summarizeSupervisorAutonomousPlayableSourcePayloadAudits(
       persistence.agentDb,
     );
+  const providerBinding =
+    state.supervisorAutonomousPlayable.effectiveProviderBinding ??
+    state.supervisorAutonomousPlayable.expectedProviderBinding;
 
   return {
     evidenceCompleteness: 'partial',
@@ -481,6 +565,20 @@ export function buildSupervisorAutonomousPlayablePartialEvidence(
     stdinEndedAfterTask: state.supervisorAutonomousPlayable.stdinEnded,
     stdinBytes: state.supervisorAutonomousPlayable.stdinBytes,
     taskSha256: state.initialTask?.sha256 ?? null,
+    providerAgentMode: providerBinding?.providerAgentMode ?? null,
+    providerModel: providerBinding?.providerModel ?? null,
+    providerApiKind: providerBinding?.providerApiKind ?? null,
+    providerReasoningEffort: providerBinding?.providerReasoningEffort ?? null,
+    providerBaseUrlSha256: providerBinding?.providerBaseUrlSha256 ?? null,
+    providerBoundAgentCount: providerBinding?.boundAgentIds?.length ?? 0,
+    providerBindingMatched:
+      state.supervisorAutonomousPlayable.effectiveProviderBinding != null &&
+      JSON.stringify(
+        state.supervisorAutonomousPlayable.effectiveProviderBinding,
+      ) ===
+        JSON.stringify(
+          state.supervisorAutonomousPlayable.expectedProviderBinding,
+        ),
     turnReportCaptured,
     turnReportParentIdentityStable,
     turnReportNewAssistantMessageCount:
@@ -587,6 +685,11 @@ export function buildSupervisorAutonomousPlayablePartialEvidence(
     finalizationJournalCount: residualSidecars.finalizations ?? 0,
     reconciliationResidueCount:
       supervisorAutonomousPlayableReconciliationResidueCount(persistence),
+    freshInitBaselineUsed:
+      state.supervisorAutonomousPlayable.freshInitBaselineUsed,
+    initialGameIndexMatchesProductionDefault:
+      state.supervisorAutonomousPlayable.initialGameIndexSha256 ===
+      productionDefaultGameIndexSha256,
     initialGameIndexSha256:
       state.supervisorAutonomousPlayable.initialGameIndexSha256,
   };
@@ -795,12 +898,383 @@ export async function waitForSupervisorAutonomousPlayableDurableQuiescence() {
   throw codedError('supervisor-autonomous-playable-residue-timeout');
 }
 
+export function validateSupervisorGameChatSingleMainTopology(
+  persistence,
+  runProfileBindings,
+  { workflowDecision, assetCoverage, assetRoute },
+) {
+  const tasks = persistence.taskSnapshot.latest;
+  const runtimes = persistence.runtimeStates;
+  const runKey = (record) => `${record.agentId}\0${record.runId}`;
+  const parentKey = (record) =>
+    isNonEmptyString(record.parentAgentId) &&
+    isNonEmptyString(record.parentRunId)
+      ? `${record.parentAgentId}\0${record.parentRunId}`
+      : null;
+  const rootKey = `${projectSupervisorAgentId}\0${state.initialRunId}`;
+  const rootTasks = tasks.filter(
+    (candidate) =>
+      candidate.agentId === projectSupervisorAgentId &&
+      candidate.parentAgentId == null &&
+      candidate.parentRunId == null,
+  );
+  const rootRuntimes = runtimes.filter(
+    (candidate) =>
+      candidate.agentId === projectSupervisorAgentId &&
+      candidate.parentAgentId == null &&
+      candidate.parentRunId == null,
+  );
+  assert(
+    rootTasks.length === 1 &&
+      rootRuntimes.length === 1 &&
+      runKey(rootTasks[0]) === rootKey &&
+      runKey(rootRuntimes[0]) === rootKey,
+    'supervisor-game-chat-single-main-root-run-not-unique',
+  );
+
+  const tasksByKey = new Map();
+  const runtimesByKey = new Map();
+  for (const task of tasks) {
+    assert(
+      isNonEmptyString(task.agentId) &&
+        isNonEmptyString(task.runId) &&
+        !tasksByKey.has(runKey(task)),
+      'supervisor-game-chat-single-main-task-identity-duplicate',
+    );
+    tasksByKey.set(runKey(task), task);
+  }
+  for (const runtime of runtimes) {
+    assert(
+      isNonEmptyString(runtime.agentId) &&
+        isNonEmptyString(runtime.runId) &&
+        !runtimesByKey.has(runKey(runtime)),
+      'supervisor-game-chat-single-main-runtime-identity-duplicate',
+    );
+    runtimesByKey.set(runKey(runtime), runtime);
+  }
+  const childrenByParent = new Map();
+  for (const task of tasks) {
+    const parent = parentKey(task);
+    if (!parent) continue;
+    const children = childrenByParent.get(parent) ?? [];
+    children.push(task);
+    childrenByParent.set(parent, children);
+  }
+  const reachableKeys = new Set();
+  const queue = [rootTasks[0]];
+  const artTasks = [];
+  while (queue.length > 0) {
+    const task = queue.shift();
+    const key = runKey(task);
+    assert(
+      !reachableKeys.has(key),
+      'supervisor-game-chat-single-main-task-cycle-detected',
+    );
+    reachableKeys.add(key);
+    const runtime = runtimesByKey.get(key);
+    assert(
+      task.status === 'completed' &&
+        task.phase === 'completed' &&
+        runtime?.phase === 'completed' &&
+        runtime.pendingToolAction == null &&
+        runtime.pendingAction == null,
+      'supervisor-game-chat-single-main-descendant-not-completed',
+    );
+    const children = childrenByParent.get(key) ?? [];
+    if (task.agentId === projectSupervisorAgentId) {
+      assert(
+        children.length === 1 &&
+          children[0].agentId === gameChatMainAgentId &&
+          children[0].source === 'agent-ready-task-scheduler',
+        'supervisor-game-chat-single-main-code-child-invalid',
+      );
+    } else if (task.agentId === gameChatMainAgentId) {
+      assert(
+        children.length <= gameChatArtAgentIds.length &&
+          children.every(
+            (child) =>
+              gameChatArtAgentIds.includes(child.agentId) &&
+              child.source === 'agent-delegate',
+          ) &&
+          new Set(children.map((child) => child.agentId)).size ===
+            children.length,
+        'supervisor-game-chat-single-main-art-child-topology-invalid',
+      );
+      artTasks.push(...children);
+    } else {
+      assert(
+        gameChatArtAgentIds.includes(task.agentId) && children.length === 0,
+        'supervisor-game-chat-single-main-nested-child-forbidden',
+      );
+    }
+    queue.push(...children);
+  }
+  assert(
+    reachableKeys.size === tasks.length &&
+      reachableKeys.size === runtimes.length &&
+      [...runtimesByKey].every(
+        ([key, runtime]) =>
+          reachableKeys.has(key) &&
+          parentKey(runtime) === parentKey(tasksByKey.get(key)),
+      ),
+    'supervisor-game-chat-single-main-unreachable-run-detected',
+  );
+
+  const bindingGroups = new Map();
+  for (const binding of runProfileBindings) {
+    const key = runKey(binding);
+    const group = bindingGroups.get(key) ?? [];
+    group.push(binding);
+    bindingGroups.set(key, group);
+  }
+  assert(
+    runProfileBindings.length === reachableKeys.size &&
+      bindingGroups.size === reachableKeys.size &&
+      [...bindingGroups.keys()].every((key) => reachableKeys.has(key)),
+    'supervisor-game-chat-single-main-binding-set-invalid',
+  );
+  for (const key of reachableKeys) {
+    const task = tasksByKey.get(key);
+    const binding = bindingGroups.get(key)?.[0];
+    const parentTask = parentKey(task) ? tasksByKey.get(parentKey(task)) : null;
+    const parentBinding = parentTask
+      ? bindingGroups.get(runKey(parentTask))?.[0]
+      : null;
+    assert(
+      bindingGroups.get(key)?.length === 1 &&
+        isNonEmptyString(binding?.bindingFingerprint) &&
+        binding.source === task.source &&
+        binding?.profile === autonomousGameBuildRunProfile &&
+        binding.rootAgentId === projectSupervisorAgentId &&
+        binding.rootRunId === state.initialRunId &&
+        (parentTask
+          ? isNonEmptyString(parentBinding?.bindingFingerprint) &&
+            binding.parentAgentId === parentTask.agentId &&
+            binding.parentRunId === parentTask.runId &&
+            binding.parentBindingFingerprint ===
+              parentBinding?.bindingFingerprint
+          : binding.parentAgentId == null &&
+            binding.parentRunId == null &&
+            binding.parentBindingFingerprint == null),
+      'supervisor-game-chat-single-main-binding-chain-invalid',
+    );
+  }
+
+  const codeTask = tasks.find(
+    (task) =>
+      task.agentId === gameChatMainAgentId &&
+      task.parentAgentId === projectSupervisorAgentId &&
+      task.parentRunId === state.initialRunId,
+  );
+  assert(
+    workflowDecision?.rootAgentId === projectSupervisorAgentId &&
+      workflowDecision.rootRunId === state.initialRunId &&
+      workflowDecision.strategy === 'audit-existing-first' &&
+      assetCoverage?.rootRunId === state.initialRunId &&
+      assetCoverage.auditedByAgentId === gameChatMainAgentId &&
+      assetCoverage.auditedByRunId === codeTask.runId &&
+      JSON.stringify(assetCoverage.requiredSlots) ===
+        JSON.stringify([...gameChatArtSlotToAgent.keys()]) &&
+      Array.isArray(assetCoverage.missingSlots) &&
+      new Set(assetCoverage.missingSlots).size ===
+        assetCoverage.missingSlots.length &&
+      assetCoverage.missingSlots.every((slot) =>
+        gameChatArtSlotToAgent.has(slot),
+      ) &&
+      assetRoute?.rootRunId === state.initialRunId,
+    'supervisor-game-chat-single-main-asset-route-binding-invalid',
+  );
+  const expectedGeneratedAgentIds = assetCoverage.missingSlots.map((slot) =>
+    gameChatArtSlotToAgent.get(slot),
+  );
+  const expectedReusedAgentIds = [...gameChatArtSlotToAgent]
+    .filter(([slot]) => !assetCoverage.missingSlots.includes(slot))
+    .map(([, agentId]) => agentId);
+  assert(
+    assetRoute.strategy ===
+      (expectedGeneratedAgentIds.length === 0
+        ? 'use-existing-art'
+        : 'generate-missing-art') &&
+      JSON.stringify(assetRoute.generatedTaskIds) ===
+        JSON.stringify(expectedGeneratedAgentIds) &&
+      JSON.stringify(assetRoute.reusedTaskIds) ===
+        JSON.stringify(expectedReusedAgentIds) &&
+      JSON.stringify(artTasks.map((task) => task.agentId).sort()) ===
+        JSON.stringify([...expectedGeneratedAgentIds].sort()),
+    'supervisor-game-chat-single-main-art-gap-mismatch',
+  );
+
+  const actionReceiptIndexes = new Map();
+  persistence.agentDb.forEach((record, index) => {
+    if (
+      record.recordType === 'agent.runtime.action_receipt' &&
+      record.agentId === gameChatMainAgentId &&
+      record.runId === codeTask.runId &&
+      isNonEmptyString(record.actionId)
+    ) {
+      actionReceiptIndexes.set(record.actionId, { record, index });
+    }
+  });
+  const assetListIndexes = [...actionReceiptIndexes.values()]
+    .filter(
+      ({ record }) => record.tool === 'asset.list' && record.status === 'ok',
+    )
+    .map(({ index }) => index);
+  assert(
+    assetListIndexes.length >= 1,
+    'supervisor-game-chat-single-main-asset-list-evidence-missing',
+  );
+  const artDeliveryByAgent = new Map();
+  for (const artTask of artTasks) {
+    const expectedArtifact = gameChatArtExpectedArtifact.get(artTask.agentId);
+    const deliveries = persistence.deliveries.filter(
+      (delivery) =>
+        delivery.parentAgentId === gameChatMainAgentId &&
+        delivery.parentRunId === codeTask.runId &&
+        delivery.targetAgentId === artTask.agentId &&
+        delivery.targetRunId === artTask.runId &&
+        delivery.delegationId === artTask.delegationId,
+    );
+    const delivery = deliveries[0];
+    const delegateReceipt = actionReceiptIndexes.get(delivery?.parentActionId);
+    const claims = persistence.claims.filter((claim) =>
+      (claim.receipts ?? []).some(
+        (receipt) => receipt.delegationId === delivery?.delegationId,
+      ),
+    );
+    const claim = claims[0];
+    const claimReceipt = actionReceiptIndexes.get(claim?.actionId);
+    const claimedReceipt = claim?.receipts?.find(
+      (candidate) => candidate.delegationId === delivery?.delegationId,
+    );
+    const resultArtifacts = delivery?.structuredResult?.artifacts;
+    assert(
+      deliveries.length === 1 &&
+        delivery.schemaVersion === staticDelegateDeliverySchemaVersion &&
+        delivery.status === 'claimed-by-parent' &&
+        delivery.terminalStatus === 'completed' &&
+        delivery.repairOfDelegationId == null &&
+        JSON.stringify(delivery.expectedArtifacts) ===
+          JSON.stringify([expectedArtifact]) &&
+        delivery.structuredResult?.contractStatus === 'evidence-ready' &&
+        Array.isArray(resultArtifacts) &&
+        resultArtifacts.length > 0 &&
+        resultArtifacts.some(
+          (artifact) => artifact.path === expectedArtifact,
+        ) &&
+        resultArtifacts.every(
+          (artifact) =>
+            isNonEmptyString(artifact.path) &&
+            !path.isAbsolute(artifact.path) &&
+            artifact.path.startsWith('assets/') &&
+            !artifact.path.split('/').includes('..') &&
+            /^[0-9a-f]{64}$/u.test(artifact.sha256),
+        ) &&
+        delegateReceipt?.record.tool === 'agent.delegate' &&
+        delegateReceipt.record.status === 'ok' &&
+        assetListIndexes.some((index) => index < delegateReceipt.index) &&
+        claims.length === 1 &&
+        claim.schemaVersion === staticDelegateClaimSchemaVersion &&
+        claim.parentAgentId === gameChatMainAgentId &&
+        claim.parentRunId === codeTask.runId &&
+        claim.status === 'observed' &&
+        claimReceipt?.record.tool === 'agent.run_status' &&
+        claimReceipt.record.status === 'ok' &&
+        delivery.claimedByActionId === claim.actionId &&
+        claimedReceipt?.targetAgentId === artTask.agentId &&
+        claimedReceipt.status === delivery.terminalStatus,
+      'supervisor-game-chat-single-main-art-delivery-invalid',
+    );
+    artDeliveryByAgent.set(artTask.agentId, {
+      delivery,
+      delegateReceiptIndex: delegateReceipt.index,
+      claimReceiptIndex: claimReceipt.index,
+    });
+  }
+  if (
+    artDeliveryByAgent.has('art-director') &&
+    artDeliveryByAgent.has('art-asset-plan')
+  ) {
+    assert(
+      artDeliveryByAgent.get('art-director').claimReceiptIndex >= 0 &&
+        artDeliveryByAgent.get('art-director').claimReceiptIndex <
+          artDeliveryByAgent.get('art-asset-plan').delegateReceiptIndex,
+      'supervisor-game-chat-single-main-art-order-invalid',
+    );
+  }
+  return {
+    uniqueRootRunCount: rootTasks.length,
+    recursiveDescendantCount: reachableKeys.size - 1,
+    completedDescendantCount: reachableKeys.size - 1,
+    artChildCount: artTasks.length,
+    artDeliveryClaimCount: artDeliveryByAgent.size,
+    assetListBeforeArtDelegation: true,
+  };
+}
+
+export function supervisorAutonomousPlayableStaticSmokeMatchesFinalIndex(
+  gate,
+  revision,
+  finalGameIndexSha256,
+) {
+  return (
+    gate?.lastVerificationStatus === 'passed' &&
+    gate.verifiedRevision === revision &&
+    gate.staticSmokeVerifiedRevision === revision &&
+    gate.staticSmokeVerifiedGameIndexSha256 === finalGameIndexSha256
+  );
+}
+
+export function supervisorGameChatFreshInitAcceptanceEvidence({
+  freshInitBaselineUsed,
+  initialGameIndexSha256,
+  productionDefaultGameIndexSha256,
+  uniqueFixedChildCodePrototype,
+  finalGameIndexSha256,
+  gate,
+  revision,
+  viewportResults,
+}) {
+  return {
+    freshInitBaselineUsed: freshInitBaselineUsed === true,
+    initialGameIndexMatchesProductionDefault:
+      /^[0-9a-f]{64}$/u.test(initialGameIndexSha256 ?? '') &&
+      initialGameIndexSha256 === productionDefaultGameIndexSha256,
+    uniqueFixedChildCodePrototype: uniqueFixedChildCodePrototype === true,
+    finalGameIndexDiffersFromBaseline:
+      /^[0-9a-f]{64}$/u.test(finalGameIndexSha256 ?? '') &&
+      finalGameIndexSha256 !== initialGameIndexSha256,
+    staticSmokeGameIndexSha256Matched:
+      supervisorAutonomousPlayableStaticSmokeMatchesFinalIndex(
+        gate,
+        revision,
+        finalGameIndexSha256,
+      ),
+    desktopPlaytestPassed:
+      viewportResults?.find((entry) => entry.viewport === 'desktop')?.passed ===
+      true,
+    mobilePlaytestPassed:
+      viewportResults?.find((entry) => entry.viewport === 'mobile')?.passed ===
+      true,
+  };
+}
+
 export async function validateSupervisorAutonomousPlayableEvidence(
   persistence,
   residualSidecars,
 ) {
   const task = supervisorAutonomousPlayableLaneDefenseTask;
   const mode = supervisorAutonomousPlayableMode();
+  const productionDefaultGameIndex = Buffer.from(
+    productionDefaultGameIndexHtml(),
+    'utf8',
+  );
+  const productionDefaultGameIndexSha256 = hashValue(
+    productionDefaultGameIndex,
+  );
+  const initialGameIndexMatchesProductionDefault =
+    state.supervisorAutonomousPlayable.initialGameIndexSha256 ===
+    productionDefaultGameIndexSha256;
   const report = state.supervisorAutonomousPlayable.turnReport;
   assert(
     report?.schemaVersion === 'game-creator-swarm-turn-report.v1' &&
@@ -886,6 +1360,12 @@ export async function validateSupervisorAutonomousPlayableEvidence(
     ...persistence.supervisorConversation,
     ...persistence.legacyConversation,
   ];
+  const conversationBoundary =
+    inspectSupervisorAutonomousPlayableConversationBoundary(
+      persistence.legacyConversation,
+      userFacing,
+      state.initialRunId,
+    );
   const allMessages = [
     ...userFacing,
     ...professionalMessages,
@@ -919,14 +1399,9 @@ export async function validateSupervisorAutonomousPlayableEvidence(
           supervisorSwarmSessionId,
           state.initialRunId,
         ) &&
-      persistence.legacyConversation.filter((message) =>
-        ['user', 'assistant'].includes(message.role),
-      ).length === 0 &&
-      userFacing.filter(
-        (message) =>
-          message.role === 'assistant' &&
-          message.agentId !== projectSupervisorAgentId,
-      ).length === 0 &&
+      conversationBoundary.legacyUserFacingMessageCount === 1 &&
+      conversationBoundary.acceptedPublicStatusCount === 1 &&
+      conversationBoundary.wrongAgentFinalAssistantCount === 0 &&
       parentAssistantAudits.length === 1 &&
       parentCompletedAudits.length === 1 &&
       duplicateMessageCount === 0,
@@ -1046,6 +1521,8 @@ export async function validateSupervisorAutonomousPlayableEvidence(
   const receipt = receipts[0];
   let evidenceBinding = binding;
   let evidenceRunId = state.initialRunId;
+  let gameChatTopologyEvidence = {};
+  let uniqueFixedChildCodePrototype = false;
   if (mode.gameChatSingleMain) {
     const manifest = JSON.parse(
       decodeUtf8Fatal(
@@ -1103,7 +1580,32 @@ export async function validateSupervisorAutonomousPlayableEvidence(
       codeBindings.length === 1,
       'supervisor-game-chat-single-main-binding-invalid',
     );
+    uniqueFixedChildCodePrototype = true;
     evidenceBinding = codeBindings[0];
+    const [workflowDecisions, assetCoverages, assetRoutes] = await Promise.all([
+      readSupervisorSwarmJsonDirectory(
+        '.agent/runtime/game-chat-workflow-decisions',
+      ),
+      readSupervisorSwarmJsonDirectory(
+        '.agent/runtime/game-chat-asset-coverage',
+      ),
+      readSupervisorSwarmJsonDirectory('.agent/runtime/game-chat-asset-routes'),
+    ]);
+    assert(
+      workflowDecisions.length === 1 &&
+        assetCoverages.length === 1 &&
+        assetRoutes.length === 1,
+      'supervisor-game-chat-single-main-asset-sidecar-count-invalid',
+    );
+    gameChatTopologyEvidence = validateSupervisorGameChatSingleMainTopology(
+      persistence,
+      runProfileBindings,
+      {
+        workflowDecision: workflowDecisions[0],
+        assetCoverage: assetCoverages[0],
+        assetRoute: assetRoutes[0],
+      },
+    );
   }
   const contractIdentity = {
     schemaVersion: contract.schemaVersion,
@@ -1134,6 +1636,11 @@ export async function validateSupervisorAutonomousPlayableEvidence(
         state.supervisorAutonomousPlayable.initialGameIndexSha256 &&
       Number.isInteger(contract.baselineArtifacts[0]?.sizeBytes) &&
       contract.baselineArtifacts[0].sizeBytes > 0 &&
+      (!mode.gameChatSingleMain ||
+        (state.supervisorAutonomousPlayable.freshInitBaselineUsed === true &&
+          initialGameIndexMatchesProductionDefault &&
+          contract.baselineArtifacts[0].sizeBytes ===
+            productionDefaultGameIndex.length)) &&
       contract.playtestScenario === 'lane-defense-v1' &&
       contract.contractFingerprint === hashJsonValue(contractIdentity),
     'supervisor-autonomous-playable-completion-contract-invalid',
@@ -1171,9 +1678,11 @@ export async function validateSupervisorAutonomousPlayableEvidence(
   );
   assert(
     gates.length === 1 &&
-      gate.lastVerificationStatus === 'passed' &&
-      gate.verifiedRevision === revision.revision &&
-      gate.staticSmokeVerifiedRevision === revision.revision &&
+      supervisorAutonomousPlayableStaticSmokeMatchesFinalIndex(
+        gate,
+        revision.revision,
+        finalGameIndexSha256,
+      ) &&
       staticSmokeAudits.length >= 1,
     'supervisor-autonomous-playable-static-smoke-invalid',
   );
@@ -1269,6 +1778,12 @@ export async function validateSupervisorAutonomousPlayableEvidence(
   const mobile = screenshotEntries.find(({ digest }) =>
     digest.path.endsWith('/mobile.png'),
   );
+  const desktopViewport = browserReport.viewportResults?.find(
+    (entry) => entry.viewport === 'desktop',
+  );
+  const mobileViewport = browserReport.viewportResults?.find(
+    (entry) => entry.viewport === 'mobile',
+  );
   const playtest = browserReport.playtest;
   const assertionNames = new Set(
     (playtest?.assertions ?? []).map((entry) => entry.name),
@@ -1283,7 +1798,8 @@ export async function validateSupervisorAutonomousPlayableEvidence(
       JSON.stringify(
         browserReport.viewportResults.map((entry) => entry.viewport).sort(),
       ) === JSON.stringify(['desktop', 'mobile']) &&
-      browserReport.viewportResults.every((entry) => entry.passed === true) &&
+      desktopViewport?.passed === true &&
+      mobileViewport?.passed === true &&
       playtest?.scenario === 'lane-defense-v1' &&
       playtest.passed === true &&
       playtest.scenarioFingerprint === receipt.scenarioFingerprint &&
@@ -1293,6 +1809,26 @@ export async function validateSupervisorAutonomousPlayableEvidence(
       ),
     'supervisor-autonomous-playable-lane-defense-playtest-invalid',
   );
+  const gameChatFreshInitAcceptance =
+    supervisorGameChatFreshInitAcceptanceEvidence({
+      freshInitBaselineUsed:
+        state.supervisorAutonomousPlayable.freshInitBaselineUsed,
+      initialGameIndexSha256:
+        state.supervisorAutonomousPlayable.initialGameIndexSha256,
+      productionDefaultGameIndexSha256,
+      uniqueFixedChildCodePrototype,
+      finalGameIndexSha256,
+      gate,
+      revision: revision.revision,
+      viewportResults: browserReport.viewportResults,
+    });
+  assert(
+    !mode.gameChatSingleMain ||
+      Object.values(gameChatFreshInitAcceptance).every(
+        (value) => value === true,
+      ),
+    'supervisor-game-chat-fresh-init-acceptance-evidence-invalid',
+  );
 
   const lifecycle = persistence.agentDb.filter(
     (record) =>
@@ -1385,6 +1921,13 @@ export async function validateSupervisorAutonomousPlayableEvidence(
   const publicLeaks = collectSupervisorSwarmPublicLeakEvidence(persistence, {
     requireZero: true,
   });
+  const projectLureLeakCount = await countLureLeaks();
+  const cliLureLeakCount = countExactSecrets(
+    Buffer.from(state.supervisorAutonomousPlayable.cliOutput),
+    state.lures,
+  );
+  state.lureLeakCount = projectLureLeakCount + cliLureLeakCount;
+  assert(state.lureLeakCount === 0, 'sensitive-lure-leak-detected');
   state.supervisorAutonomousPlayable.privateValues = [
     ...new Set(state.supervisorSwarm.privateValues),
   ];
@@ -1438,6 +1981,22 @@ export async function validateSupervisorAutonomousPlayableEvidence(
       turnReport: report,
     },
   );
+  const providerBinding =
+    state.supervisorAutonomousPlayable.effectiveProviderBinding;
+  assert(
+    providerBinding &&
+      JSON.stringify(providerBinding) ===
+        JSON.stringify(
+          state.supervisorAutonomousPlayable.expectedProviderBinding,
+        ) &&
+      (!isSupervisorGameChatSingleMainPlayableSuite() ||
+        providerBinding.providerAgentMode === 'provider') &&
+      isNonEmptyString(providerBinding.providerModel) &&
+      isNonEmptyString(providerBinding.providerApiKind) &&
+      isNonEmptyString(providerBinding.providerReasoningEffort) &&
+      /^[0-9a-f]{64}$/u.test(providerBinding.providerBaseUrlSha256),
+    'supervisor-autonomous-playable-provider-binding-invalid',
+  );
 
   return {
     ...emptySupervisorAutonomousPlayableEvidence(),
@@ -1450,6 +2009,14 @@ export async function validateSupervisorAutonomousPlayableEvidence(
     stdinEndedAfterTask: state.supervisorAutonomousPlayable.stdinEnded,
     stdinBytes: state.supervisorAutonomousPlayable.stdinBytes,
     taskSha256: hashValue(task),
+    providerAgentMode: providerBinding.providerAgentMode,
+    providerModel: providerBinding.providerModel,
+    providerApiKind: providerBinding.providerApiKind,
+    providerReasoningEffort: providerBinding.providerReasoningEffort,
+    providerBaseUrlSha256: providerBinding.providerBaseUrlSha256,
+    providerBoundAgentCount: providerBinding.boundAgentIds.length,
+    providerBindingMatched: true,
+    ...gameChatTopologyEvidence,
     turnReportCaptured: true,
     turnReportParentIdentityStable: true,
     turnReportNewAssistantMessageCount: report.newAssistantMessageCount,
@@ -1520,6 +2087,7 @@ export async function validateSupervisorAutonomousPlayableEvidence(
     baselineRevision: contract.baselineRevision,
     projectRevision: revision.revision,
     projectRevisionDelta: revision.revision - contract.baselineRevision,
+    ...gameChatFreshInitAcceptance,
     initialGameIndexSha256:
       state.supervisorAutonomousPlayable.initialGameIndexSha256,
     finalGameIndexSha256,
@@ -1578,12 +2146,37 @@ export async function validateSupervisorAutonomousPlayableEvidence(
 
 export async function runSupervisorAutonomousPlayableLaneDefenseE2e() {
   await ensureOwnedRunnerStableKillSupport();
-  await seedDisposableProject();
-  const initialGameIndex = await fs.readFile(
-    path.join(state.projectRoot, 'game/index.html'),
-  );
-  state.supervisorAutonomousPlayable.initialGameIndexSha256 =
-    hashValue(initialGameIndex);
+  const mode = supervisorAutonomousPlayableMode();
+  state.supervisorAutonomousPlayable.freshInitBaselineUsed =
+    mode.gameChatSingleMain;
+  await seedDisposableProject({
+    preserveProductionInitBaseline: mode.gameChatSingleMain,
+  });
+  if (mode.gameChatSingleMain) {
+    const generatedBaselinePaths = [
+      'package.json',
+      'verify-e2e.mjs',
+      'game/index.html',
+    ];
+    const generatedBaselineMetadata = await Promise.all(
+      generatedBaselinePaths.map((relativePath) =>
+        fs.lstat(path.join(state.projectRoot, relativePath)).catch(() => null),
+      ),
+    );
+    assert(
+      generatedBaselineMetadata.every((metadata) => metadata === null),
+      'supervisor-game-chat-fresh-init-project-not-empty',
+    );
+    state.supervisorAutonomousPlayable.initialGameIndexSha256 = hashValue(
+      Buffer.from(productionDefaultGameIndexHtml(), 'utf8'),
+    );
+  } else {
+    const initialGameIndex = await fs.readFile(
+      path.join(state.projectRoot, 'game/index.html'),
+    );
+    state.supervisorAutonomousPlayable.initialGameIndexSha256 =
+      hashValue(initialGameIndex);
+  }
   state.cliBinary = await prepareCliBinary();
   await prepareIsolatedSuiteAppData();
   state.isolatedRunner.launchAttempted = true;
@@ -1597,7 +2190,6 @@ export async function runSupervisorAutonomousPlayableLaneDefenseE2e() {
   state.supervisorAutonomousPlayable.privateValues = [task];
   state.supervisorSwarm.userTask = task;
   state.supervisorSwarm.privateValues = [task];
-  const mode = supervisorAutonomousPlayableMode();
   state.supervisorAutonomousPlayableCliSession = startInteractiveCli([
     '--swarm-chat',
     '--init',
@@ -1617,7 +2209,6 @@ export async function runSupervisorAutonomousPlayableLaneDefenseE2e() {
   const report = await waitForSupervisorAutonomousPlayableCliExit(
     state.supervisorAutonomousPlayableCliSession,
   );
-  state.supervisorAutonomousPlayableCliSession = null;
   assert(
     report.outcome === 'settled',
     'supervisor-autonomous-playable-turn-not-settled',
@@ -1649,6 +2240,13 @@ export function emptySupervisorAutonomousPlayableEvidence() {
     stdinEndedAfterTask: false,
     stdinBytes: 0,
     taskSha256: null,
+    providerAgentMode: null,
+    providerModel: null,
+    providerApiKind: null,
+    providerReasoningEffort: null,
+    providerBaseUrlSha256: null,
+    providerBoundAgentCount: 0,
+    providerBindingMatched: false,
     evidenceCompleteness: 'none',
     partialEvidenceCollected: false,
     partialEvidenceReadErrorCount: 0,
@@ -1694,6 +2292,12 @@ export function emptySupervisorAutonomousPlayableEvidence() {
     childTaskCount: 0,
     runtimeCount: 0,
     childRuntimeCount: 0,
+    uniqueRootRunCount: 0,
+    recursiveDescendantCount: 0,
+    completedDescendantCount: 0,
+    artChildCount: 0,
+    artDeliveryClaimCount: 0,
+    assetListBeforeArtDelegation: false,
     finalSupervisorAssistantCount: 0,
     supervisorUserMessageCount: 0,
     professionalAssistantCount: 0,
@@ -1724,11 +2328,16 @@ export function emptySupervisorAutonomousPlayableEvidence() {
     baselineRevision: 0,
     projectRevision: 0,
     projectRevisionDelta: 0,
+    freshInitBaselineUsed: false,
+    initialGameIndexMatchesProductionDefault: false,
     initialGameIndexSha256: null,
     finalGameIndexSha256: null,
     gameIndexChanged: false,
+    finalGameIndexDiffersFromBaseline: false,
+    uniqueFixedChildCodePrototype: false,
     gameIndexBytes: 0,
     staticSmokePassed: false,
+    staticSmokeGameIndexSha256Matched: false,
     staticSmokeAuditCount: 0,
     autonomousCompletionContractCount: 0,
     autonomousPlaytestReceiptCount: 0,
@@ -1737,6 +2346,8 @@ export function emptySupervisorAutonomousPlayableEvidence() {
     laneDefenseAssertionCount: 0,
     laneDefensePassedAssertionCount: 0,
     browserValidationPassed: false,
+    desktopPlaytestPassed: false,
+    mobilePlaytestPassed: false,
     desktopScreenshotSha256: null,
     desktopScreenshotBytes: 0,
     mobileScreenshotSha256: null,
@@ -1770,6 +2381,20 @@ export function emptySupervisorAutonomousPlayableEvidence() {
     supervisorAutonomousPlayableReportLeakCount: 0,
     supervisorAutonomousPlayableRunnerStopped: false,
     supervisorAutonomousPlayableAppDataCleanupPerformed: false,
+    ownedProcessIdentityCaptured: false,
+    ownedRunnerObservedCount: 0,
+    ownedHelperObservedCount: 0,
+    ownedNodeDescendantObservedCount: 0,
+    ownedBrowserDescendantObservedCount: 0,
+    ownedCommandDescendantObservedCount: 0,
+    ownedRunnerResidualCount: 0,
+    ownedHelperResidualCount: 0,
+    ownedNodeDescendantResidualCount: 0,
+    ownedBrowserDescendantResidualCount: 0,
+    ownedCommandDescendantResidualCount: 0,
+    activeCommandChildrenAfterCleanup: 0,
+    activeInteractiveCliSessionsAfterCleanup: 0,
+    ownedProcessCleanupPassed: false,
     secretLeakCount: 0,
     lureLeakCount: 0,
     paths: [],
diff --git a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-swarm/persistence.mjs b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-swarm/persistence.mjs
index 877a8aa70..278c7acf3 100644
--- a/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-swarm/persistence.mjs
+++ b/apps/ai-game-creator-shell/scripts/agent-runtime-real-e2e/suites/supervisor-swarm/persistence.mjs
@@ -90,6 +90,37 @@ export async function listOptionalSupervisorSwarmFile(file) {
   return [file];
 }
 
+export function supervisorSwarmProfessionalSessions({
+  deliveries = [],
+  latestTasks = [],
+  rootAgentId,
+  rootRunId,
+}) {
+  const sessions = new Map();
+  const registerSession = (agentId, sessionId) => {
+    if (!isNonEmptyString(agentId) || !isNonEmptyString(sessionId)) return;
+    sessions.set(`${agentId}\0${sessionId}`, { agentId, sessionId });
+  };
+  for (const delivery of deliveries) {
+    registerSession(delivery.targetAgentId, delivery.targetSessionId);
+  }
+  if (!isNonEmptyString(rootAgentId) || !isNonEmptyString(rootRunId)) {
+    return [...sessions.values()];
+  }
+  for (const task of latestTasks) {
+    if (
+      task.source !== 'agent-ready-task-scheduler' ||
+      task.agentId === rootAgentId ||
+      task.parentAgentId !== rootAgentId ||
+      task.parentRunId !== rootRunId
+    ) {
+      continue;
+    }
+    registerSession(task.agentId, task.sessionId);
+  }
+  return [...sessions.values()];
+}
+
 export async function readSupervisorSwarmPersistence({
   tolerateErrors = false,
 } = {}) {
@@ -274,25 +305,15 @@ export async function readSupervisorSwarmPersistence({
       ),
   );
   const supervisorConversation = supervisorConversationSurface.records;
-  const professionalSessions = new Map();
-  for (const delivery of deliveries) {
-    if (
-      !isNonEmptyString(delivery.targetAgentId) ||
-      !isNonEmptyString(delivery.targetSessionId)
-    ) {
-      continue;
-    }
-    professionalSessions.set(
-      `${delivery.targetAgentId}\0${delivery.targetSessionId}`,
-      {
-        agentId: delivery.targetAgentId,
-        sessionId: delivery.targetSessionId,
-      },
-    );
-  }
+  const professionalSessions = supervisorSwarmProfessionalSessions({
+    deliveries,
+    latestTasks: taskSnapshot.latest,
+    rootAgentId: projectSupervisorAgentId,
+    rootRunId: state.initialRunId,
+  });
   const professionalConversations = [];
   const professionalConversationErrors = [];
-  for (const session of professionalSessions.values()) {
+  for (const session of professionalSessions) {
     const conversationSurface = await readJsonlSurface(
       'professional-conversation',
       () =>
diff --git a/apps/ai-game-creator-shell/scripts/check-config.mjs b/apps/ai-game-creator-shell/scripts/check-config.mjs
index a541abce3..560d8ee6f 100644
--- a/apps/ai-game-creator-shell/scripts/check-config.mjs
+++ b/apps/ai-game-creator-shell/scripts/check-config.mjs
@@ -1186,6 +1186,7 @@ const allowedLlmReasoningEfforts = new Set([
   'low',
   'medium',
   'high',
+  'max',
 ]);
 
 if (defaultAppConfig.llm?.reasoningEffort !== 'high') {
diff --git a/apps/ai-game-creator-shell/scripts/deterministic-lane-defense-provider.mjs b/apps/ai-game-creator-shell/scripts/deterministic-lane-defense-provider.mjs
index 7cd45583a..4289684ec 100644
--- a/apps/ai-game-creator-shell/scripts/deterministic-lane-defense-provider.mjs
+++ b/apps/ai-game-creator-shell/scripts/deterministic-lane-defense-provider.mjs
@@ -43,7 +43,6 @@ export const deterministicManifestReadyAgentIds = Object.freeze([
 const deterministicReadOnlyReadyAgentIds = new Set([
   'design-director',
   'balance-director',
-  'art-director',
   'art-polish',
   'audio-director',
   'code-director',
@@ -82,7 +81,11 @@ function pngChunk(type, data) {
   return Buffer.concat([length, typeBytes, data, crc]);
 }
 
-function deterministicPng(width, height) {
+function deterministicPng(
+  width,
+  height,
+  { variant = 0, transparent = false } = {},
+) {
   const stride = width * 4 + 1;
   const pixels = Buffer.alloc(stride * height);
   for (let y = 0; y < height; y += 1) {
@@ -91,10 +94,11 @@ function deterministicPng(width, height) {
     for (let x = 0; x < width; x += 1) {
       const offset = row + 1 + x * 4;
       const tile = (Math.floor(x / 48) + Math.floor(y / 48)) % 6;
-      pixels[offset] = (42 + x + tile * 29) % 256;
-      pixels[offset + 1] = (86 + y * 2 + tile * 17) % 256;
-      pixels[offset + 2] = (118 + x + y + tile * 31) % 256;
-      pixels[offset + 3] = 255;
+      pixels[offset] = (42 + x + tile * 29 + variant * 13) % 256;
+      pixels[offset + 1] = (86 + y * 2 + tile * 17 + variant * 19) % 256;
+      pixels[offset + 2] = (118 + x + y + tile * 31 + variant * 23) % 256;
+      pixels[offset + 3] =
+        transparent && (x + y + variant) % 11 === 0 ? 0 : 255;
     }
   }
   const ihdr = Buffer.alloc(13);
@@ -120,7 +124,7 @@ export function deterministicLaneDefenseInitialHtml() {
 *{box-sizing:border-box}body{margin:0;min-height:100vh;background:#f4f8ee;color:#18351f;font:16px system-ui,sans-serif}main{width:min(960px,100%);margin:auto;padding:18px}h1{margin:0 0 4px;font-size:clamp(28px,7vw,46px)}p{margin:4px 0 14px}.toolbar,.plants{display:flex;flex-wrap:wrap;gap:8px;margin:10px 0}button{min-height:44px;border:1px solid #315d35;background:#fff;color:#18351f;padding:9px 14px;font:inherit;font-weight:700;cursor:pointer}button:hover{background:#e6f3dc}.board{display:grid;gap:10px;background:#d9edc8;border:2px solid #315d35;padding:10px}.lane{display:grid;grid-template-columns:repeat(5,1fr);gap:6px}.cell{min-height:54px;background:#eef8e7}.status{font-weight:700;min-height:24px}#game{display:none;width:100%;height:auto;aspect-ratio:20/9;background:#18351f;border:2px solid #315d35}@media(max-width:520px){main{padding:12px}button{flex:1 1 44%}.cell{min-height:44px}}
 </style>
 </head>
-<body><main><img src="assets/art-spritesheet.png" alt="Garden defenders" width="96" height="96">
+<body><main><img src="../assets/art-spritesheet.png" alt="Garden defenders" width="96" height="96">
 <h1>灵露花园</h1><p>GENARRATIVE_REAL_E2E_VISIBLE</p><p>Goal: defend the garden and win every wave.</p>
 <div class="toolbar"><button data-playtest-id="start">Start Game</button><button data-playtest-id="speed-up">Speed Up</button><button data-playtest-id="next-level">Next Level</button><button data-playtest-id="restart">Restart</button></div>
 <div class="plants"><button data-playtest-id="defender-option">露华花</button><button id="thorn">棘刺芽</button></div>
@@ -128,6 +132,7 @@ export function deterministicLaneDefenseInitialHtml() {
 <script id="playable-web-game-state" type="application/json">{"schemaVersion":"playable-web-game-state.v1","sequence":1,"phase":"ready","level":1,"selectedDefenderId":null,"defenders":[],"enemies":[]}</script>
 <script>
 const surface=document.getElementById('playable-web-game-state'),statusEl=document.getElementById('status'),canvas=document.getElementById('game'),ctx=canvas.getContext('2d');
+const atlasArt=new Image(),playerArt=new Image(),targetArt=new Image(),sceneArt=new Image(),feedbackArt=new Image();atlasArt.src='../assets/art-spritesheet.png';playerArt.src='../assets/art-spritesheet-slices/player.png';targetArt.src='../assets/art-spritesheet-slices/blocks-and-targets.png';sceneArt.src='../assets/art-spritesheet-slices/obstacles-and-scene.png';feedbackArt.src='../assets/art-spritesheet-slices/feedback-effects.png';
 let state={schemaVersion:'playable-web-game-state.v1',sequence:1,phase:'ready',level:1,selectedDefenderId:null,defenders:[],enemies:[]},timers=[];
 function publish(label){state.sequence+=1;surface.textContent=JSON.stringify(state);statusEl.textContent=label||('Level '+state.level+' '+state.phase);}
 function stopTimers(){timers.forEach(clearTimeout);timers=[];}
@@ -139,7 +144,7 @@ document.querySelector('[data-playtest-id="lane-cell"]').onclick=()=>{if(!state.
 document.querySelector('[data-playtest-id="speed-up"]').onclick=()=>{if(state.phase!=='playing')return;stopTimers();timers.push(setTimeout(()=>{state.enemies[0].position=72;state.enemies[0].health=65;publish('Battle in progress');},120));timers.push(setTimeout(()=>{state.enemies[0].position=48;state.enemies[0].health=20;publish('Gloomling nearly defeated');},300));timers.push(setTimeout(()=>{state.enemies=[];state.phase='won';publish('Level '+state.level+' complete');},560));};
 document.querySelector('[data-playtest-id="next-level"]').onclick=()=>{stopTimers();state.level+=1;state.phase='ready';state.selectedDefenderId=null;state.defenders=[];state.enemies=[];publish('Level '+state.level+' ready');};
 document.querySelector('[data-playtest-id="restart"]').onclick=()=>reset(true);
-function draw(time){ctx.fillStyle='#173b23';ctx.fillRect(0,0,800,360);for(let i=0;i<5;i++){ctx.fillStyle=i%2?'#75ad52':'#86bf5f';ctx.fillRect(i*160,0,158,360)}ctx.fillStyle='#ffe66d';ctx.beginPath();ctx.arc(90,80,30,0,Math.PI*2);ctx.fill();ctx.fillStyle='#fafafa';ctx.font='bold 28px system-ui';ctx.fillText('灵露花园',230,60);ctx.fillStyle='#dbeafe';ctx.fillRect(230+Math.sin(time/350)*30,130,90,100);requestAnimationFrame(draw)}requestAnimationFrame(draw);
+function draw(time){ctx.fillStyle='#173b23';ctx.fillRect(0,0,800,360);for(let i=0;i<5;i++){ctx.fillStyle=i%2?'#75ad52':'#86bf5f';ctx.fillRect(i*160,0,158,360)}ctx.fillStyle='#ffe66d';ctx.beginPath();ctx.arc(90,80,30,0,Math.PI*2);ctx.fill();ctx.fillStyle='#fafafa';ctx.font='bold 28px system-ui';ctx.fillText('灵露花园',230,60);ctx.fillStyle='#dbeafe';ctx.fillRect(230+Math.sin(time/350)*30,130,90,100);if(atlasArt.complete&&atlasArt.naturalWidth>0)ctx.drawImage(atlasArt,0,0,256,256,18,220,96,96);if(playerArt.complete&&playerArt.naturalWidth>0)ctx.drawImage(playerArt,140,220,64,64);if(targetArt.complete&&targetArt.naturalWidth>0)ctx.drawImage(targetArt,220,220,64,64);if(sceneArt.complete&&sceneArt.naturalWidth>0)ctx.drawImage(sceneArt,300,220,64,64);if(feedbackArt.complete&&feedbackArt.naturalWidth>0)ctx.drawImage(feedbackArt,380,220,64,64);requestAnimationFrame(draw)}requestAnimationFrame(draw);
 </script></main></body></html>
 `;
 }
@@ -374,12 +379,12 @@ function isUiPrototypeInspectionRequest(payload, context) {
     : false;
   return (
     hasInputImage &&
-    context.includes('resourceBar') &&
-    context.includes('unitCardTray') &&
-    context.includes('battlefieldGrid') &&
-    context.includes('enemyEntryDirection') &&
-    context.includes('waveStatus') &&
+    context.includes('informationHud') &&
+    context.includes('gameplaySurface') &&
+    context.includes('objectiveEntities') &&
     context.includes('primaryControls') &&
+    context.includes('failureRestartFlow') &&
+    context.includes('responsiveLayout') &&
     context.includes('implementationClarity') &&
     context.includes('originalTheme')
   );
@@ -397,6 +402,152 @@ function nativeResponse(response) {
   return { name: 'respond_to_user', arguments: { response } };
 }
 
+function goalContractCall() {
+  return nativeAction(
+    'agent.goal_contract',
+    '冻结本轮可玩游戏交付目标与验收标准',
+    {
+      outcome:
+        '交付一个可完整游玩的原创植物塔防网页游戏，并让当前最终 revision 通过自动静态检查和桌面、移动双视口真实试玩。',
+      nonNegotiables: [
+        '必须形成从开始、放置防御单位、敌人移动与受伤到胜利、下一关和重开的完整闭环',
+        '必须在无人确认、无人补充输入和无人 steer 的条件下完成',
+      ],
+      preferences: ['保持单页自包含并提供清晰的桌面与移动端操作反馈'],
+      forbiddenAssumptions: [
+        '不得把静态页面、占位素材或未执行的试玩声明为完成',
+      ],
+      openQuestions: [],
+      acceptanceNodes: [
+        {
+          criterionId: 'static-current-revision',
+          criterion:
+            '当前最终 revision 的游戏入口通过可执行 JavaScript、Canvas 与完整玩法合同静态检查',
+          required: true,
+          requiredEvidence: ['tool:command.run_limited'],
+          dependsOn: [],
+        },
+        {
+          criterionId: 'playable-current-revision',
+          criterion:
+            '当前最终 revision 的完整塔防循环在桌面与移动视口均通过真实浏览器试玩',
+          required: true,
+          requiredEvidence: ['tool:preview.validate'],
+          dependsOn: ['static-current-revision'],
+        },
+      ],
+    },
+  );
+}
+
+function actionHistoryCall() {
+  return nativeAction(
+    'agent.action_history',
+    '读取当前根 Run 的最终静态检查与真实试玩动作回执',
+    {
+      runId: null,
+      actionId: null,
+      tool: null,
+      status: 'ok',
+      limit: 10,
+    },
+  );
+}
+
+function goalContractFingerprint(context) {
+  const marker = '[Root Goal Contract]';
+  const start = context.lastIndexOf(marker);
+  if (start < 0) return null;
+  const tail = context.slice(start);
+  const end = tail.indexOf('\n\n');
+  const goalContractContext = end < 0 ? tail : tail.slice(0, end);
+  const matches = new Set(
+    [
+      ...goalContractContext.matchAll(
+        /"contractFingerprint"\s*:\s*"([0-9a-f]{64})"/giu,
+      ),
+    ].map((match) => match[1].toLowerCase()),
+  );
+  return matches.size === 1 ? [...matches][0] : null;
+}
+
+function finalAcceptanceEvidence(context, expectedRunId) {
+  const observation = latestToolObservation(context);
+  if (
+    observation?.tool !== 'agent.action_history' ||
+    observation?.status !== 'ok' ||
+    typeof observation.detail !== 'string'
+  ) {
+    throw providerError('provider-final-action-history-observation-invalid');
+  }
+  let detail;
+  try {
+    detail = JSON.parse(observation.detail);
+  } catch {
+    throw providerError('provider-final-action-history-detail-invalid');
+  }
+  if (
+    detail?.runId !== expectedRunId ||
+    !Array.isArray(detail?.actions) ||
+    detail?.count !== detail.actions.length
+  ) {
+    throw providerError('provider-final-action-history-identity-invalid');
+  }
+  const evidenceByTool = new Map();
+  for (const action of detail.actions) {
+    if (
+      action?.agentId !== 'project-supervisor' ||
+      action?.runId !== expectedRunId ||
+      action?.status !== 'ok' ||
+      typeof action?.actionId !== 'string' ||
+      !/^action-[0-9a-f]{24}$/iu.test(action.actionId) ||
+      !['command.run_limited', 'preview.validate'].includes(action?.tool)
+    ) {
+      continue;
+    }
+    evidenceByTool.set(action.tool, {
+      agentId: action.agentId,
+      runId: action.runId,
+      actionId: action.actionId,
+    });
+  }
+  const staticSmoke = evidenceByTool.get('command.run_limited');
+  const preview = evidenceByTool.get('preview.validate');
+  if (!staticSmoke || !preview) {
+    throw providerError('provider-final-acceptance-evidence-missing');
+  }
+  return { staticSmoke, preview };
+}
+
+function acceptanceUpdateCall(context, runId) {
+  const contractFingerprint = goalContractFingerprint(context);
+  if (!contractFingerprint) {
+    throw providerError('provider-goal-contract-fingerprint-missing');
+  }
+  const evidence = finalAcceptanceEvidence(context, runId);
+  return nativeAction(
+    'agent.acceptance_update',
+    '提交当前最终 revision 的静态检查与双视口试玩验收证据',
+    {
+      contractFingerprint,
+      evaluations: [
+        {
+          criterionId: 'static-current-revision',
+          status: 'passed',
+          evidence: [evidence.staticSmoke],
+          summary: '当前最终 revision 已通过 game.static_smoke。',
+        },
+        {
+          criterionId: 'playable-current-revision',
+          status: 'passed',
+          evidence: [evidence.preview],
+          summary: '当前最终 revision 已通过桌面与移动双视口真实试玩。',
+        },
+      ],
+    },
+  );
+}
+
 function completedPlanCall(explanation, steps) {
   return {
     name: 'update_agent_plan',
@@ -463,17 +614,6 @@ function chatTextResponse(sequence, model, content) {
   };
 }
 
-function delegateCall(agentId, task, acceptanceCriteria, expectedArtifacts) {
-  return nativeAction('agent.delegate', `把独立工作交给 ${agentId}`, {
-    agentId,
-    task,
-    acceptanceCriteria,
-    expectedArtifacts,
-    repairOfDelegationId: null,
-    runId: null,
-  });
-}
-
 const projectMutationFunctionNames = new Set(
   [
     'blackboard.write',
@@ -492,22 +632,6 @@ const projectMutationFunctionNames = new Set(
   ].map(runtimeFunction),
 );
 
-function isGameIndexArtifactContract(expectedArtifacts) {
-  return (
-    Array.isArray(expectedArtifacts) &&
-    expectedArtifacts.length === 1 &&
-    expectedArtifacts[0] === 'game/index.html'
-  );
-}
-
-function isExplicitReadOnlyQualityTask(task) {
-  return (
-    typeof task === 'string' &&
-    task.includes('只读验收') &&
-    task.includes('不要修改任何文件')
-  );
-}
-
 function staticSmokeCall(reason) {
   return nativeAction('command.run_limited', reason, {
     commandId: 'game.static_smoke',
@@ -540,15 +664,6 @@ function runStatusCall(reason) {
   });
 }
 
-function repairPatchCall(reason) {
-  return nativeAction('file.patch', reason, {
-    path: 'game/index.html',
-    oldText: hiddenCanvasCss,
-    newText: visibleCanvasCss,
-    expectedReplacements: 1,
-  });
-}
-
 function fileReadCall(path, reason) {
   return nativeAction('file.read', reason, {
     path,
@@ -566,6 +681,18 @@ function assetListCall(reason) {
 }
 
 function canvasAssetCall(agentId) {
+  if (agentId === 'art-director') {
+    return nativeAction('canvas.asset_generate', '生成统一视觉规范图', {
+      prompt:
+        '原创明亮花园植物塔防游戏的方形图标规范图。统一展示露华花守卫、棘刺芽守卫、雾影兽入侵者、晶苔地块、灵露资源和主要 UI 图标的轮廓、配色、材质与尺寸关系；纯色分区背景，适合后续角色、场景和 UI 共用，不使用任何现有游戏角色、Logo 或受保护视觉语言。',
+      outputPath: 'assets/art-spec.png',
+      aspectRatio: '1:1',
+      imageSize: '1K',
+      assetKind: 'icon-spec',
+      assetLabel: '游戏统一视觉规范图',
+      replaceExisting: false,
+    });
+  }
   if (agentId === 'design-foundation') {
     return nativeAction('canvas.asset_generate', '生成横屏游戏界面原型', {
       prompt:
@@ -635,6 +762,67 @@ function revisionBlockedObservation(context) {
   );
 }
 
+function projectRevisionDriftObservation(context, tool) {
+  const observation = latestToolObservation(context);
+  const detail =
+    typeof observation?.detail === 'string' ? observation.detail : '';
+  const hasStructuredDetail =
+    detail.includes('projectRevisionDrift=true') &&
+    detail.includes('expectedRevision=') &&
+    detail.includes('currentRevision=') &&
+    detail.includes('replanRequired=true');
+  const detailUnavailable =
+    observation?.detail == null || detail === '[redacted sensitive context]';
+  return (
+    observation?.tool === tool &&
+    observation?.status === 'blocked' &&
+    observation?.summary === '并行项目变更使旧动作过期，旧动作未执行' &&
+    (hasStructuredDetail || detailUnavailable)
+  );
+}
+
+function visualAssetBlockedObservation(context) {
+  const observation = latestToolObservation(context);
+  return (
+    observation?.tool === 'runtime.visual_asset' &&
+    observation?.status === 'blocked' &&
+    typeof observation?.detail === 'string' &&
+    observation.detail.includes('expectedPath=assets/ui-prototype.png') &&
+    observation.detail.includes('requiredInspection=image.inspect')
+  );
+}
+
+function missingGeneratedVisualAssetObservation(context, agentId) {
+  const expected = {
+    'art-director': {
+      path: 'assets/art-spec.png',
+      kind: 'icon-spec',
+      summary: '统一视觉规范图尚未按正式视觉流程生成并登记，不能完成任务',
+    },
+    'design-foundation': {
+      path: 'assets/ui-prototype.png',
+      kind: 'ui-prototype',
+      summary: '策划界面原型图尚未按正式视觉流程生成并登记，不能完成任务',
+    },
+    'art-asset-plan': {
+      path: 'assets/art-spritesheet.png',
+      kind: 'art-spritesheet',
+      summary: '首版美术素材图尚未按正式视觉流程生成并登记，不能完成任务',
+    },
+  }[agentId];
+  if (!expected) return false;
+  const observation = latestToolObservation(context);
+  return (
+    observation?.tool === 'runtime.visual_asset' &&
+    observation?.status === 'blocked' &&
+    observation?.summary === expected.summary &&
+    typeof observation?.detail === 'string' &&
+    (observation.detail === '[redacted sensitive context]' ||
+      (observation.detail.includes(`expectedPath=${expected.path}`) &&
+        observation.detail.includes(`expectedKind=${expected.kind}`)))
+  );
+}
+
 function specialistVerificationRepairContext(context) {
   return (
     context.includes(
@@ -646,17 +834,27 @@ function specialistVerificationRepairContext(context) {
   );
 }
 
+function verifiedDeliveryRepairContext(context) {
+  return (
+    context.includes('当前 revision 已通过验证') &&
+    context.includes('本次修复的原生工具目录只保留 respond_to_user')
+  );
+}
+
 function transientCommandObservation(context) {
   const observation = latestToolObservation(context);
-  const detail = observation?.detail;
+  const detail =
+    typeof observation?.detail === 'string'
+      ? observation.detail.replaceAll('\\', '/')
+      : '';
   return (
     observation?.tool === 'command.run_limited' &&
     ((observation?.status === 'blocked' &&
-      (detail?.includes('repositoryContextDrift=true') ||
-        (detail?.includes('projectRevisionDrift=true') &&
+      (detail.includes('repositoryContextDrift=true') ||
+        (detail.includes('projectRevisionDrift=true') &&
           detail.includes('replanRequired=true')))) ||
       (observation?.status === 'failed' &&
-        detail?.includes('.agent/project.lock')))
+        detail.includes('.agent/project.lock')))
   );
 }
 
@@ -668,13 +866,6 @@ function successfulProjectMutationObservation(context) {
   );
 }
 
-function successfulCommandObservation(context) {
-  const observation = latestToolObservation(context);
-  return (
-    observation?.tool === 'command.run_limited' && observation?.status === 'ok'
-  );
-}
-
 function observationsIncludeAsset(context, path) {
   const observations = observationContext(context);
   return observations.includes('# 本地项目资产') && observations.includes(path);
@@ -722,36 +913,20 @@ export function createDeterministicLaneDefenseRouter({
   const readyTaskCompletionRetryCounts = new Map();
   const readyTaskPreCompletionRetryCounts = new Map();
   const readyTaskReplayAvailableRuns = new Set();
-  const terminalRetryCounts = new Map();
-  const terminalVerificationPendingRuns = new Set();
-  const terminalReplayAvailableRuns = new Set();
-  const terminalObservationFingerprints = new Map();
   const agentCounts = new Map();
   const stats = {
     requestCount: 0,
     contextCompactionRequestCount: 0,
     planningRequestCount: 0,
     finalReplyRequestCount: 0,
-    initialDelegationCount: 0,
-    followupDelegationCount: 0,
+    goalContractCount: 0,
+    actionHistoryCount: 0,
+    acceptanceUpdateCount: 0,
+    delegateActionCount: 0,
     runStatusCount: 0,
     sourceWriteCount: 0,
-    sourcePatchCount: 0,
     staticSmokeCount: 0,
     previewValidationCount: 0,
-    supervisorDirectMutationAttemptCount: 0,
-    delegationContractCount: 0,
-    delegationContractViolationCount: 0,
-    codePrototypeDelegationCount: 0,
-    codePrototypeExpectedArtifactCount: 0,
-    codePrototypeGameIndexArtifactDelegationCount: 0,
-    qualityReviewDelegationCount: 0,
-    qualityReviewReadOnlyDelegationCount: 0,
-    qualityReviewExpectedArtifactCount: 0,
-    artAssetPlanDelegationCount: 0,
-    artAssetPlanExpectedArtifactCount: 0,
-    artAssetPlanArtifactContractCount: 0,
-    qualityRevisionReplanCount: 0,
     manifestReadyTaskRunCount: 0,
     manifestReadyTaskCompletionCount: 0,
     manifestReadyTaskFileReadCount: 0,
@@ -760,6 +935,7 @@ export function createDeterministicLaneDefenseRouter({
     manifestReadyTaskPreviewValidationCount: 0,
     manifestReadyTaskCanvasGenerationCount: 0,
     canonicalCodeRunCount: 0,
+    canonicalCodeAssetListCount: 0,
     imageInspectionRequestCount: 0,
     interactionExecuteCount: 0,
     readyTaskRunsByAgent: {},
@@ -771,9 +947,7 @@ export function createDeterministicLaneDefenseRouter({
     byAgent: {},
   };
   let responseSequence = 0;
-  let parentStage = 'initial-delegation';
-  let initialBuilderRunId = null;
-  let repairBuilderRunId = null;
+  let parentStage = 'goal-contract';
 
   function updateReadyTaskCounts(agentId, kind) {
     const current = stats.readyTaskCountsByAgent[agentId] ?? {
@@ -784,53 +958,6 @@ export function createDeterministicLaneDefenseRouter({
     stats.readyTaskCountsByAgent[agentId] = current;
   }
 
-  function consumeTerminalRetry(agentId, runId) {
-    const retryCount = terminalRetryCounts.get(runId) ?? 0;
-    if (retryCount >= 16) {
-      throw providerError(`provider-terminal-retry-exhausted:${agentId}`);
-    }
-    terminalRetryCounts.set(runId, retryCount + 1);
-  }
-
-  function retryTerminalStaticVerification(agentId, runId, tools, reason) {
-    if (!tools.has(runtimeFunction('command.run_limited'))) {
-      throw providerError(
-        `provider-terminal-retry-verification-tool-missing:${agentId}`,
-      );
-    }
-    consumeTerminalRetry(agentId, runId);
-    terminalReplayAvailableRuns.delete(runId);
-    terminalVerificationPendingRuns.add(runId);
-    stats.staticSmokeCount += 1;
-    return callsResponse(agentId, tools, [staticSmokeCall(reason)]);
-  }
-
-  function consumeTerminalReplayAuthorization(agentId, runId) {
-    if (terminalVerificationPendingRuns.delete(runId)) return;
-    if (terminalReplayAvailableRuns.delete(runId)) return;
-    throw providerError(`provider-terminal-replay-unarmed:${agentId}`);
-  }
-
-  function consumeUniqueTerminalObservation(agentId, runId, context) {
-    const observation = latestToolObservation(context);
-    const repairFingerprint = context.includes('当前专业合同明确要求只读交付')
-      ? 'read-only-delivery-repair'
-      : null;
-    if (!observation && !repairFingerprint) {
-      throw providerError(`provider-terminal-observation-missing:${agentId}`);
-    }
-    const fingerprint = observation
-      ? JSON.stringify(observation)
-      : repairFingerprint;
-    const seen = terminalObservationFingerprints.get(runId) ?? new Set();
-    if (seen.has(fingerprint)) {
-      throw providerError(`provider-terminal-observation-duplicate:${agentId}`);
-    }
-    consumeTerminalRetry(agentId, runId);
-    seen.add(fingerprint);
-    terminalObservationFingerprints.set(runId, seen);
-  }
-
   function recordReadyTaskRun(agentId, runId) {
     if (!deterministicManifestReadyAgentIds.includes(agentId)) {
       throw providerError(`provider-ready-agent-unsupported:${agentId}`);
@@ -893,6 +1020,21 @@ export function createDeterministicLaneDefenseRouter({
         (agentId === 'preview-playtest'
           ? 'preview.validate'
           : 'command.run_limited');
+      if (
+        tools.size === 1 &&
+        tools.has('respond_to_user') &&
+        verifiedDeliveryRepairContext(context)
+      ) {
+        readyTaskCompletionRetryArmedRuns.delete(runId);
+        readyTaskCompletionVerificationTools.delete(runId);
+        readyTaskReplayAvailableRuns.delete(runId);
+        return readyCallsResponse(
+          agentId,
+          runId,
+          tools,
+          readyTaskFinalizationCalls(context, agentId, tools),
+        );
+      }
       if (readyTaskCompletionRetryArmedRuns.has(runId)) {
         const observation = latestToolObservation(context);
         if (
@@ -914,6 +1056,22 @@ export function createDeterministicLaneDefenseRouter({
             readyTaskFinalizationCalls(context, agentId, tools),
           );
         }
+        if (
+          expectedVerificationTool === 'image.inspect' &&
+          observation?.tool === 'image.inspect' &&
+          ['blocked', 'failed'].includes(observation?.status) &&
+          tools.has(runtimeFunction('image.inspect'))
+        ) {
+          if (retryCount >= 16) {
+            throw providerError(
+              `provider-ready-retry-verification-exhausted:${agentId}`,
+            );
+          }
+          readyTaskCompletionRetryCounts.set(runId, retryCount + 1);
+          return readyCallsResponse(agentId, runId, tools, [
+            imageInspectCall(),
+          ]);
+        }
         const transientCommandFailure = transientCommandObservation(context);
         if (
           transientCommandFailure &&
@@ -936,6 +1094,36 @@ export function createDeterministicLaneDefenseRouter({
         );
       }
       const latestObservation = latestToolObservation(context);
+      if (
+        missingGeneratedVisualAssetObservation(context, agentId) &&
+        tools.has(runtimeFunction('canvas.asset_generate'))
+      ) {
+        if (retryCount >= 16) {
+          throw providerError(
+            `provider-ready-retry-verification-exhausted:${agentId}`,
+          );
+        }
+        readyTaskCompletionRetryCounts.set(runId, retryCount + 1);
+        stats.manifestReadyTaskCanvasGenerationCount += 1;
+        return readyCallsResponse(agentId, runId, tools, [
+          canvasAssetCall(agentId),
+        ]);
+      }
+      if (
+        agentId === 'design-foundation' &&
+        visualAssetBlockedObservation(context) &&
+        tools.has(runtimeFunction('image.inspect'))
+      ) {
+        if (retryCount >= 16) {
+          throw providerError(
+            `provider-ready-retry-verification-exhausted:${agentId}`,
+          );
+        }
+        readyTaskCompletionRetryCounts.set(runId, retryCount + 1);
+        readyTaskCompletionRetryArmedRuns.add(runId);
+        readyTaskCompletionVerificationTools.set(runId, 'image.inspect');
+        return readyCallsResponse(agentId, runId, tools, [imageInspectCall()]);
+      }
       const successfulProjectMutation =
         successfulProjectMutationObservation(context);
       const standaloneSuccessfulVerification =
@@ -1120,52 +1308,20 @@ export function createDeterministicLaneDefenseRouter({
     publishAgentCounts();
 
     for (const call of calls) {
-      if (call.name !== runtimeFunction('agent.delegate')) continue;
-      stats.delegationContractCount += 1;
-      const input = call.arguments?.input;
-      const hasExplicitExpectedArtifacts = Array.isArray(
-        input?.expectedArtifacts,
-      );
-      const expectedArtifacts = hasExplicitExpectedArtifacts
-        ? input.expectedArtifacts
-        : [];
-      if (input?.agentId === 'code-prototype') {
-        stats.codePrototypeDelegationCount += 1;
-        stats.codePrototypeExpectedArtifactCount += expectedArtifacts.length;
-        if (isGameIndexArtifactContract(expectedArtifacts)) {
-          stats.codePrototypeGameIndexArtifactDelegationCount += 1;
-        } else {
-          stats.delegationContractViolationCount += 1;
-        }
-      } else if (input?.agentId === 'quality-review') {
-        stats.qualityReviewDelegationCount += 1;
-        stats.qualityReviewExpectedArtifactCount += expectedArtifacts.length;
-        if (
-          hasExplicitExpectedArtifacts &&
-          expectedArtifacts.length === 0 &&
-          isExplicitReadOnlyQualityTask(input.task)
-        ) {
-          stats.qualityReviewReadOnlyDelegationCount += 1;
-        } else {
-          stats.delegationContractViolationCount += 1;
-        }
-      } else if (input?.agentId === 'art-asset-plan') {
-        stats.artAssetPlanDelegationCount += 1;
-        stats.artAssetPlanExpectedArtifactCount += expectedArtifacts.length;
-        if (
-          hasExplicitExpectedArtifacts &&
-          expectedArtifacts.length === 2 &&
-          expectedArtifacts.includes('assets/manifest.art.json') &&
-          expectedArtifacts.includes('assets/art-spritesheet.png') &&
-          typeof input?.task === 'string' &&
-          input.task.includes('生成')
-        ) {
-          stats.artAssetPlanArtifactContractCount += 1;
-        } else {
-          stats.delegationContractViolationCount += 1;
-        }
-      } else {
-        stats.delegationContractViolationCount += 1;
+      if (call.name === runtimeFunction('agent.goal_contract')) {
+        stats.goalContractCount += 1;
+      } else if (call.name === runtimeFunction('agent.action_history')) {
+        stats.actionHistoryCount += 1;
+      } else if (call.name === runtimeFunction('agent.acceptance_update')) {
+        stats.acceptanceUpdateCount += 1;
+      } else if (call.name === runtimeFunction('agent.delegate')) {
+        stats.delegateActionCount += 1;
+      }
+      if (
+        agentId === 'code-prototype' &&
+        call.name === runtimeFunction('asset.list')
+      ) {
+        stats.canonicalCodeAssetListCount += 1;
       }
     }
   }
@@ -1178,177 +1334,134 @@ export function createDeterministicLaneDefenseRouter({
   }
 
   function parentCalls(context, tools) {
-    const manifestDagWaitPrompt =
-      context.includes('当前正式 manifest DAG 仍有专业 task 在运行') &&
-      tools.has(runtimeFunction('task.list')) &&
-      tools.has(runtimeFunction('agent.run_status'));
-    if (manifestDagWaitPrompt) {
-      parentStage = 'await-manifest';
-      stats.runStatusCount += 1;
-      return callsResponse('project-supervisor', tools, [
-        nativeAction('task.list', '检查正式产物任务图是否已经收敛', {}),
-        runStatusCall('等待并读取并行专业任务的最新状态'),
-      ]);
-    }
-    const delegateRepairPrompt =
-      (context.includes('当前父 run 已进入只编排模式') &&
-        context.includes('只保留 agent.delegate')) ||
-      (parentStage === 'await-delegation-repair' &&
-        tools.has(runtimeFunction('agent.delegate')));
-    if (delegateRepairPrompt) {
-      if (parentStage !== 'await-delegation-repair') {
-        throw providerError('provider-repair-prompt-out-of-order');
+    const goalContractTool = runtimeFunction('agent.goal_contract');
+    if (tools.size === 1 && tools.has(goalContractTool)) {
+      if (parentStage !== 'goal-contract') {
+        throw providerError('provider-goal-contract-out-of-order');
       }
-      parentStage = 'verify-repair';
-      stats.followupDelegationCount += 1;
-      return callsResponse('project-supervisor', tools, [
-        delegateCall(
-          'code-prototype',
-          '修复最近一次真实浏览器验证证明的 canvas 不可见问题；保持现有 lane-defense-v1 交互、状态面、关卡推进和重开行为不变，并在修改后通过静态自检。',
-          [
-            'game/index.html 的 canvas 在桌面与移动视口可见且有非空像素',
-            'lane-defense-v1 全部固定试玩断言继续通过',
-            '修改后的当前 revision 通过 game.static_smoke',
-          ],
-          ['game/index.html'],
-        ),
-      ]);
+      parentStage = 'await-manifest';
+      return callsResponse('project-supervisor', tools, [goalContractCall()]);
+    }
+
+    const advertisedProjectMutation = [...tools].some((tool) =>
+      projectMutationFunctionNames.has(tool),
+    );
+    const advertisedSafeExecution = [
+      'agent.goal_contract',
+      'task.list',
+      'agent.run_status',
+      'command.run_limited',
+      'preview.validate',
+      'agent.action_history',
+      'agent.acceptance_update',
+    ].some((tool) => tools.has(runtimeFunction(tool)));
+    if (advertisedProjectMutation && !advertisedSafeExecution) {
+      if (
+        tools.has('respond_to_user') &&
+        context.includes('当前父 run 已进入只编排模式')
+      ) {
+        return callsResponse('project-supervisor', tools, [
+          nativeResponse('专业任务尚未收敛，继续等待 Runtime 完成门复核。'),
+        ]);
+      }
+      throw providerError('provider-supervisor-direct-mutation-denied');
     }
 
     switch (parentStage) {
-      case 'initial-delegation': {
-        parentStage = 'claim-initial';
-        stats.initialDelegationCount += 3;
-        return callsResponse('project-supervisor', tools, [
-          delegateCall(
-            'code-prototype',
-            '生成一个紧凑但完整的植物塔防网页游戏：支持开始、选择植物、放置防御单位、敌人移动和受伤、胜利、下一关与重开；写入 game/index.html，并在修改后通过静态自检。',
-            [
-              'game/index.html 提供完整 lane-defense-v1 状态面和六个可点击控件',
-              '敌人会移动并受伤，关卡可胜利、进入下一关并重开',
-              '修改后的当前 revision 通过 game.static_smoke',
-            ],
-            ['game/index.html'],
-          ),
-          delegateCall(
-            'quality-review',
-            '执行只读验收：独立核对塔防交付合同是否覆盖植物选择、战斗、胜利、下一关、重开、桌面和移动视口；只返回合同验收重点，不要修改任何文件，也不要读取或依赖并行 code-prototype 尚未完成的项目产物。',
-            [
-              '验收结论覆盖完整可玩循环和双视口',
-              '只读返回合同重点且项目 mutation 为零',
-            ],
-            [],
-          ),
-          delegateCall(
-            'art-asset-plan',
-            '生成原创首版核心美术素材并写入正式资产清单；必须调用 canvas.asset_generate 生成 assets/art-spritesheet.png，并写入可解析的 assets/manifest.art.json，不得用占位文件代替。',
-            [
-              'assets/art-spritesheet.png 是可解码的原创 1:1 PNG',
-              'assets/manifest.art.json 可解析并登记该图片',
-              '生成结果已通过资产列表核对',
-            ],
-            ['assets/manifest.art.json', 'assets/art-spritesheet.png'],
-          ),
-        ]);
-      }
-      case 'claim-initial':
-        parentStage = 'static-initial';
-        stats.runStatusCount += 1;
-        return callsResponse('project-supervisor', tools, [
-          runStatusCall('认领两份首轮专业回执'),
-        ]);
-      case 'static-initial':
-        parentStage = 'preview-initial';
-        stats.staticSmokeCount += 1;
-        return callsResponse('project-supervisor', tools, [
-          staticSmokeCall('验证初版当前 revision'),
-        ]);
-      case 'preview-initial':
-        parentStage = 'attempt-forbidden-repair';
-        stats.previewValidationCount += 1;
-        return callsResponse('project-supervisor', tools, [
-          previewCall('真实试玩并检查桌面与移动视口'),
-        ]);
-      case 'attempt-forbidden-repair':
-        if (observationContext(context).includes('浏览器验证已通过')) {
-          parentStage = 'respond';
-          return parentCalls(context, tools);
-        }
-        parentStage = 'await-delegation-repair';
-        stats.supervisorDirectMutationAttemptCount += 1;
-        return callsResponse('project-supervisor', tools, [
-          repairPatchCall('根据浏览器失败诊断直接修复不可见 canvas'),
-        ]);
-      case 'verify-repair':
-        parentStage = 'await-manifest';
-        stats.runStatusCount += 1;
-        return callsResponse('project-supervisor', tools, [
-          runStatusCall('先认领返工后的专业交付，再验证最新 revision'),
-        ]);
       case 'await-manifest':
-        if (!tools.has(runtimeFunction('task.list'))) {
-          if (tools.has(runtimeFunction('command.run_limited'))) {
-            stats.staticSmokeCount += 1;
-            return callsResponse('project-supervisor', tools, [
-              staticSmokeCall('刷新并行产物修改后的当前 revision 验证凭证'),
-            ]);
-          }
-          if (tools.has(runtimeFunction('preview.validate'))) {
-            parentStage = 'respond';
-            stats.previewValidationCount += 1;
-            return callsResponse('project-supervisor', tools, [
-              previewCall('对最终 current revision 完成双视口交互试玩'),
-            ]);
-          }
-        }
         if (!manifestTasksCompleted(context)) {
+          if (
+            !tools.has(runtimeFunction('task.list')) ||
+            !tools.has(runtimeFunction('agent.run_status'))
+          ) {
+            throw providerError('provider-manifest-wait-tools-invalid');
+          }
           stats.runStatusCount += 1;
           return callsResponse('project-supervisor', tools, [
             nativeAction('task.list', '检查正式产物任务图是否已经收敛', {}),
             runStatusCall('等待并读取并行专业任务的最新状态'),
           ]);
         }
-        parentStage = 'verify-final';
+        parentStage = 'final-static-smoke';
         return parentCalls(context, tools);
-      case 'verify-final':
-        parentStage = 'respond';
+      case 'final-static-smoke':
+        if (!tools.has(runtimeFunction('command.run_limited'))) {
+          throw providerError('provider-final-static-smoke-tool-missing');
+        }
+        parentStage = 'final-preview';
         stats.staticSmokeCount += 1;
-        stats.previewValidationCount += 1;
         return callsResponse('project-supervisor', tools, [
           staticSmokeCall('验证全部正式产物整合后的当前 revision'),
+        ]);
+      case 'final-preview': {
+        const observation = latestToolObservation(context);
+        if (
+          observation?.tool !== 'command.run_limited' ||
+          observation?.status !== 'ok'
+        ) {
+          throw providerError(
+            'provider-final-static-smoke-observation-invalid',
+          );
+        }
+        if (!tools.has(runtimeFunction('preview.validate'))) {
+          throw providerError('provider-final-preview-tool-missing');
+        }
+        parentStage = 'final-action-history';
+        stats.previewValidationCount += 1;
+        return callsResponse('project-supervisor', tools, [
           previewCall('对最终 current revision 重跑完整真实试玩和双视口检查'),
         ]);
-      case 'respond':
+      }
+      case 'final-action-history': {
+        const observation = latestToolObservation(context);
+        if (
+          observation?.tool !== 'preview.validate' ||
+          observation?.status !== 'ok'
+        ) {
+          throw providerError('provider-final-preview-observation-invalid');
+        }
+        if (!tools.has(runtimeFunction('agent.action_history'))) {
+          throw providerError('provider-final-action-history-tool-missing');
+        }
+        parentStage = 'final-acceptance-update';
+        return callsResponse('project-supervisor', tools, [
+          actionHistoryCall(),
+        ]);
+      }
+      case 'final-acceptance-update':
+        if (!tools.has(runtimeFunction('agent.acceptance_update'))) {
+          throw providerError('provider-final-acceptance-update-tool-missing');
+        }
+        {
+          const call = acceptanceUpdateCall(
+            context,
+            extractIdentity(context).runId,
+          );
+          parentStage = 'final-respond';
+          return callsResponse('project-supervisor', tools, [call]);
+        }
+      case 'final-respond': {
+        const observation = latestToolObservation(context);
+        if (
+          observation?.tool !== 'agent.acceptance_update' ||
+          observation?.status !== 'ok'
+        ) {
+          throw providerError('provider-final-acceptance-observation-invalid');
+        }
+        if (!tools.has('respond_to_user')) {
+          throw providerError('provider-final-respond-tool-missing');
+        }
         parentStage = 'done';
         return callsResponse('project-supervisor', tools, [
-          ...completedPlanCallsForContext(
-            context,
-            '可试玩项目和全部验证已经完成',
-          ),
           nativeResponse(
-            '可试玩塔防版本已经完成，并通过静态检查、完整交互试玩以及桌面和移动视口验证。',
+            '可试玩塔防版本已经完成，并通过当前 revision 静态检查、完整交互试玩以及桌面和移动视口验证。',
           ),
         ]);
+      }
       case 'done':
-        if (tools.has(runtimeFunction('task.list'))) {
-          parentStage = 'await-manifest';
-          return parentCalls(context, tools);
-        }
-        if (
-          tools.has(runtimeFunction('command.run_limited')) &&
-          tools.has(runtimeFunction('preview.validate'))
-        ) {
-          parentStage = 'verify-final';
-          return parentCalls(context, tools);
-        }
-        if (tools.has('respond_to_user')) {
-          return callsResponse('project-supervisor', tools, [
-            nativeResponse(
-              '可试玩塔防版本已经完成，并通过正式产物检查、静态检查和双视口交互试玩。',
-            ),
-          ]);
-        }
-        throw providerError('provider-parent-done-tools-invalid');
+        throw providerError('provider-parent-terminal-duplicate');
+      case 'goal-contract':
+        throw providerError('provider-goal-contract-required-first');
       default:
         throw providerError(`provider-parent-stage-invalid:${parentStage}`);
     }
@@ -1369,12 +1482,6 @@ export function createDeterministicLaneDefenseRouter({
           fileReadCall('memory/project.md', '读取长期项目约束'),
         ],
       ],
-      'art-director': [
-        [
-          fileReadCall('game/game_design.md', '读取玩法规格以确定视觉方向'),
-          assetListCall('核对当前已有美术资产'),
-        ],
-      ],
       'art-polish': [
         [
           fileReadCall(
@@ -1428,6 +1535,43 @@ export function createDeterministicLaneDefenseRouter({
     );
   }
 
+  function artDirectorReadyCalls(runId, tools, context) {
+    const agentId = 'art-director';
+    const phase = ensureReadyTaskRun(runId, agentId);
+    if (phase === 0) {
+      return readyCallsResponse(agentId, runId, tools, [
+        assetListCall('核对当前已有美术资产'),
+      ]);
+    }
+    if (phase === 1) {
+      if (!tools.has(runtimeFunction('canvas.asset_generate'))) {
+        throw providerError('provider-ready-art-director-canvas-tool-missing');
+      }
+      stats.manifestReadyTaskCanvasGenerationCount += 1;
+      return readyCallsResponse(agentId, runId, tools, [
+        canvasAssetCall(agentId),
+      ]);
+    }
+    if (phase === 2) {
+      if (
+        tools.has('respond_to_user') &&
+        !tools.has(runtimeFunction('asset.list'))
+      ) {
+        return readyTaskCompleteResponse(agentId, runId, tools, context);
+      }
+      return readyCallsResponse(agentId, runId, tools, [
+        assetListCall('核对统一视觉规范图已经生成并登记'),
+      ]);
+    }
+    if (phase === 3) {
+      return readyTaskCompleteResponse(agentId, runId, tools, context);
+    }
+    if (phase >= 4) {
+      return readyTaskCompleteResponse(agentId, runId, tools, context);
+    }
+    throw providerError(`provider-ready-art-director-stage-invalid:${phase}`);
+  }
+
   function designFoundationReadyCalls(runId, tools, context) {
     const agentId = 'design-foundation';
     const phase = ensureReadyTaskRun(runId, agentId);
@@ -1590,93 +1734,6 @@ export function createDeterministicLaneDefenseRouter({
     );
   }
 
-  function initialArtDelegationCalls(runId, tools, context) {
-    const agentId = 'art-asset-plan';
-    const existingKind = runKinds.get(runId);
-    if (!existingKind) {
-      runKinds.set(runId, 'initial-art-delegation');
-      runPhases.set(runId, 0);
-    } else if (existingKind !== 'initial-art-delegation') {
-      throw providerError(`provider-initial-art-run-kind-invalid:${runId}`);
-    }
-    const phase = runPhases.get(runId) ?? 0;
-    const respond = (calls) => {
-      runPhases.set(runId, phase + 1);
-      return callsResponse(agentId, tools, calls);
-    };
-    if (phase === 0) {
-      return respond([assetListCall('核对首版核心美术是否已经生成')]);
-    }
-    if (phase === 1) {
-      stats.sourceWriteCount += 1;
-      return respond([
-        fileWriteCall(
-          'assets/manifest.art.json',
-          `${JSON.stringify(deterministicArtManifest(true), null, 2)}\n`,
-          '写入登记首版核心图片的正式美术资产清单',
-        ),
-      ]);
-    }
-    if (phase === 2) {
-      if (!tools.has(runtimeFunction('canvas.asset_generate'))) {
-        throw providerError('provider-initial-art-canvas-tool-missing');
-      }
-      return respond([canvasAssetCall(agentId)]);
-    }
-    if (phase === 3) {
-      return respond([
-        fileReadCall('assets/manifest.art.json', '回读并核对正式美术清单'),
-        assetListCall('确认核心美术图片已生成并登记'),
-      ]);
-    }
-    if (phase === 4) {
-      terminalReplayAvailableRuns.add(runId);
-      return respond([
-        ...completedPlanCallsForContext(
-          context,
-          '首版核心美术和正式资产清单已经完成',
-        ),
-        nativeResponse('首版核心美术图片与正式资产清单已经生成并核对。'),
-      ]);
-    }
-    if (successfulCommandObservation(context) && tools.has('respond_to_user')) {
-      consumeTerminalReplayAuthorization(agentId, runId);
-      return respond([
-        ...completedPlanCallsForContext(
-          context,
-          '首版核心美术和正式资产清单已经完成并通过验证',
-        ),
-        nativeResponse('首版核心美术图片与正式资产清单已经生成并验证。'),
-      ]);
-    }
-    if (
-      specialistVerificationRepairContext(context) ||
-      revisionBlockedObservation(context) ||
-      transientCommandObservation(context)
-    ) {
-      return retryTerminalStaticVerification(
-        agentId,
-        runId,
-        tools,
-        '补充验证首版核心美术和正式资产清单的当前 revision',
-      );
-    }
-    if (
-      tools.has('respond_to_user') &&
-      context.includes('当前 revision 已通过验证')
-    ) {
-      consumeTerminalReplayAuthorization(agentId, runId);
-      return respond([
-        ...completedPlanCallsForContext(
-          context,
-          '首版核心美术和正式资产清单已经完成并通过验证',
-        ),
-        nativeResponse('首版核心美术图片与正式资产清单已经生成并验证。'),
-      ]);
-    }
-    throw providerError('provider-initial-art-terminal-duplicate');
-  }
-
   function artAssetReadyCalls(runId, tools, context) {
     const agentId = 'art-asset-plan';
     const phase = ensureReadyTaskRun(runId, agentId);
@@ -1693,21 +1750,16 @@ export function createDeterministicLaneDefenseRouter({
       const hasCanvas = tools.has(runtimeFunction('canvas.asset_generate'));
       const willGenerate = hasCanvas && !existing;
       const hasVisualAsset = existing || willGenerate;
-      const calls = [
+      stats.sourceWriteCount += 1;
+      stats.manifestReadyTaskFileWriteCount += 1;
+      runData.set(runId, { existing, hasCanvas, willGenerate });
+      return readyCallsResponse(agentId, runId, tools, [
         fileWriteCall(
           'assets/manifest.art.json',
           `${JSON.stringify(deterministicArtManifest(hasVisualAsset, 'manifest-ready'), null, 2)}\n`,
           '写入可解析的首版美术资产清单',
         ),
-      ];
-      stats.sourceWriteCount += 1;
-      stats.manifestReadyTaskFileWriteCount += 1;
-      if (willGenerate) {
-        calls.push(canvasAssetCall(agentId));
-        stats.manifestReadyTaskCanvasGenerationCount += 1;
-      }
-      runData.set(runId, { existing, hasCanvas, willGenerate });
-      return readyCallsResponse(agentId, runId, tools, calls);
+      ]);
     }
     if (phase === 2) {
       const data = runData.get(runId) ?? {
@@ -1715,11 +1767,17 @@ export function createDeterministicLaneDefenseRouter({
         hasCanvas: false,
         willGenerate: false,
       };
+      if (data.willGenerate) {
+        stats.manifestReadyTaskCanvasGenerationCount += 1;
+        return readyCallsResponse(agentId, runId, tools, [
+          canvasAssetCall(agentId),
+        ]);
+      }
       const calls = [
         fileReadCall('assets/manifest.art.json', '回读并核对美术清单 JSON'),
       ];
       stats.manifestReadyTaskFileReadCount += 1;
-      if (data.willGenerate) {
+      if (data.existing) {
         calls.push(assetListCall('核对新图片已登记到项目资产清单'));
       } else {
         calls.push(staticSmokeCall('验证美术清单写入后的当前 revision'));
@@ -1728,11 +1786,9 @@ export function createDeterministicLaneDefenseRouter({
       }
       return readyCallsResponse(agentId, runId, tools, calls);
     }
-    if (phase === 3) {
-      return readyTaskCompleteResponse(agentId, runId, tools, context);
-    }
-    if (phase >= 4) {
+    if (phase >= 3) {
       if (
+        phase >= 5 &&
         !tools.has('respond_to_user') &&
         !tools.has(runtimeFunction('command.run_limited')) &&
         tools.has(runtimeFunction('file.write'))
@@ -1747,6 +1803,51 @@ export function createDeterministicLaneDefenseRouter({
           ),
         ]);
       }
+      if (completedReadyTaskRuns.has(runId)) {
+        return readyTaskCompleteResponse(agentId, runId, tools, context);
+      }
+      const data = runData.get(runId) ?? {
+        existing: false,
+        hasCanvas: false,
+        willGenerate: false,
+      };
+      if (
+        data.willGenerate &&
+        projectRevisionDriftObservation(context, 'canvas.asset_generate')
+      ) {
+        if (!tools.has(runtimeFunction('canvas.asset_generate'))) {
+          throw providerError('provider-ready-art-canvas-tool-missing');
+        }
+        const retryCount = readyTaskPreCompletionRetryCounts.get(runId) ?? 0;
+        if (retryCount >= 16) {
+          throw providerError('provider-ready-art-canvas-retry-exhausted');
+        }
+        readyTaskPreCompletionRetryCounts.set(runId, retryCount + 1);
+        stats.manifestReadyTaskCanvasGenerationCount += 1;
+        return readyCallsResponse(agentId, runId, tools, [
+          canvasAssetCall(agentId),
+        ]);
+      }
+      if (data.willGenerate) {
+        const observation = latestToolObservation(context);
+        if (
+          observation?.tool === 'canvas.asset_generate' &&
+          observation?.status === 'ok'
+        ) {
+          stats.manifestReadyTaskFileReadCount += 1;
+          return readyCallsResponse(agentId, runId, tools, [
+            fileReadCall('assets/manifest.art.json', '回读并核对美术清单 JSON'),
+            assetListCall('核对新图片已登记到项目资产清单'),
+          ]);
+        }
+        if (phase === 3) {
+          stats.manifestReadyTaskFileReadCount += 1;
+          return readyCallsResponse(agentId, runId, tools, [
+            fileReadCall('assets/manifest.art.json', '回读并核对美术清单 JSON'),
+            assetListCall('核对新图片已登记到项目资产清单'),
+          ]);
+        }
+      }
       return readyTaskCompleteResponse(agentId, runId, tools, context);
     }
     throw providerError(`provider-ready-art-stage-invalid:${phase}`);
@@ -1770,6 +1871,7 @@ export function createDeterministicLaneDefenseRouter({
         fileReadCall('assets/manifest.art.json', '读取美术资产清单'),
         fileReadCall('assets/manifest.audio.json', '读取声音事件清单'),
         fileReadCall('game/index.html', '读取当前入口以保留既有试玩行为'),
+        assetListCall('核对 Canvas 登记、图集与四类切片的权威资产身份'),
       ]);
     }
     if (phase === 2) {
@@ -1859,7 +1961,6 @@ export function createDeterministicLaneDefenseRouter({
       [
         'design-director',
         'balance-director',
-        'art-director',
         'art-polish',
         'audio-director',
         'code-director',
@@ -1868,6 +1969,9 @@ export function createDeterministicLaneDefenseRouter({
     ) {
       return readOnlyReadyCalls(agentId, runId, tools, context);
     }
+    if (agentId === 'art-director') {
+      return artDirectorReadyCalls(runId, tools, context);
+    }
     if (agentId === 'design-foundation') {
       return designFoundationReadyCalls(runId, tools, context);
     }
@@ -1907,223 +2011,6 @@ export function createDeterministicLaneDefenseRouter({
     throw providerError(`provider-ready-agent-unsupported:${agentId}`);
   }
 
-  function codeCalls(runId, tools, context) {
-    if (!runKinds.has(runId)) {
-      if (!initialBuilderRunId) {
-        initialBuilderRunId = runId;
-        runKinds.set(runId, 'initial-builder');
-      } else if (!repairBuilderRunId) {
-        repairBuilderRunId = runId;
-        runKinds.set(runId, 'repair-builder');
-      } else {
-        throw providerError('provider-extra-builder-run');
-      }
-      runPhases.set(runId, 0);
-    }
-    const kind = runKinds.get(runId);
-    const phase = runPhases.get(runId);
-    if (kind === 'initial-builder') {
-      if (phase === 0) {
-        runPhases.set(runId, 1);
-        stats.sourceWriteCount += 1;
-        return callsResponse('code-prototype', tools, [
-          nativeAction('file.write', '写入完整可玩的塔防初版', {
-            path: 'game/index.html',
-            content: deterministicLaneDefenseInitialHtml(),
-          }),
-        ]);
-      }
-      if (phase === 1) {
-        runPhases.set(runId, 2);
-        stats.staticSmokeCount += 1;
-        return callsResponse('code-prototype', tools, [
-          staticSmokeCall('验证初版源码与状态面'),
-        ]);
-      }
-      if (phase === 2) {
-        runPhases.set(runId, 3);
-        terminalReplayAvailableRuns.add(runId);
-        return callsResponse('code-prototype', tools, [
-          ...completedPlanCallsForContext(
-            context,
-            '初版实现和静态验证已经完成',
-          ),
-          nativeResponse('初版塔防玩法与交互状态面已经生成，并通过静态自检。'),
-        ]);
-      }
-      if (phase >= 3) {
-        if (
-          successfulCommandObservation(context) &&
-          tools.has('respond_to_user')
-        ) {
-          consumeTerminalReplayAuthorization('code-prototype', runId);
-          return callsResponse('code-prototype', tools, [
-            ...completedPlanCallsForContext(
-              context,
-              '初版实现和静态验证已经完成',
-            ),
-            nativeResponse(
-              '初版塔防玩法与交互状态面已经生成，并通过静态自检。',
-            ),
-          ]);
-        }
-        if (
-          specialistVerificationRepairContext(context) ||
-          revisionBlockedObservation(context) ||
-          transientCommandObservation(context)
-        ) {
-          return retryTerminalStaticVerification(
-            'code-prototype',
-            runId,
-            tools,
-            '重试验证初版源码与状态面',
-          );
-        }
-        if (
-          tools.has('respond_to_user') &&
-          context.includes('当前 revision 已通过验证')
-        ) {
-          consumeTerminalReplayAuthorization('code-prototype', runId);
-          return callsResponse('code-prototype', tools, [
-            ...completedPlanCallsForContext(
-              context,
-              '初版实现和静态验证已经完成',
-            ),
-            nativeResponse(
-              '初版塔防玩法与交互状态面已经生成，并通过静态自检。',
-            ),
-          ]);
-        }
-      }
-    }
-    if (kind === 'repair-builder') {
-      if (phase === 0) {
-        runPhases.set(runId, 1);
-        stats.sourcePatchCount += 1;
-        return callsResponse('code-prototype', tools, [
-          repairPatchCall('修复真实浏览器发现的 canvas 可见性'),
-        ]);
-      }
-      if (phase === 1) {
-        runPhases.set(runId, 2);
-        stats.staticSmokeCount += 1;
-        return callsResponse('code-prototype', tools, [
-          staticSmokeCall('验证返工后的源码'),
-        ]);
-      }
-      if (phase === 2) {
-        runPhases.set(runId, 3);
-        terminalReplayAvailableRuns.add(runId);
-        return callsResponse('code-prototype', tools, [
-          ...completedPlanCallsForContext(
-            context,
-            '画布可见性返工和静态验证已经完成',
-          ),
-          nativeResponse(
-            '画布可见性已修复，原有完整试玩行为保持不变并通过静态自检。',
-          ),
-        ]);
-      }
-      if (phase >= 3) {
-        if (
-          successfulCommandObservation(context) &&
-          tools.has('respond_to_user')
-        ) {
-          consumeTerminalReplayAuthorization('code-prototype', runId);
-          return callsResponse('code-prototype', tools, [
-            ...completedPlanCallsForContext(
-              context,
-              '画布可见性返工和静态验证已经完成',
-            ),
-            nativeResponse(
-              '画布可见性已修复，原有完整试玩行为保持不变并通过静态自检。',
-            ),
-          ]);
-        }
-        if (
-          specialistVerificationRepairContext(context) ||
-          revisionBlockedObservation(context) ||
-          transientCommandObservation(context)
-        ) {
-          return retryTerminalStaticVerification(
-            'code-prototype',
-            runId,
-            tools,
-            '重试验证返工后的源码',
-          );
-        }
-        if (
-          tools.has('respond_to_user') &&
-          context.includes('当前 revision 已通过验证')
-        ) {
-          consumeTerminalReplayAuthorization('code-prototype', runId);
-          return callsResponse('code-prototype', tools, [
-            ...completedPlanCallsForContext(
-              context,
-              '画布可见性返工和静态验证已经完成',
-            ),
-            nativeResponse(
-              '画布可见性已修复，原有完整试玩行为保持不变并通过静态自检。',
-            ),
-          ]);
-        }
-      }
-    }
-    throw providerError(`provider-builder-stage-invalid:${kind}:${phase}`);
-  }
-
-  function qualityCalls(runId, tools, context) {
-    const phase = runPhases.get(runId) ?? 0;
-    if (phase === 0) {
-      runKinds.set(runId, 'quality-review');
-      runPhases.set(runId, 1);
-      return callsResponse('quality-review', tools, [
-        ...completedPlanCallsForContext(context, '独立验收重点已经核对'),
-        nativeResponse(
-          '验收必须以真实植物选择、放置、战斗推进、胜利、下一关、重开和双视口可见性为准。',
-        ),
-      ]);
-    }
-    if (phase === 1) {
-      if (
-        !revisionBlockedObservation(context) &&
-        !context.includes('当前专业合同明确要求只读交付')
-      ) {
-        throw providerError('provider-quality-terminal-duplicate');
-      }
-      consumeUniqueTerminalObservation('quality-review', runId, context);
-      runPhases.set(runId, 2);
-      stats.qualityRevisionReplanCount += 1;
-      return callsResponse('quality-review', tools, [
-        ...completedPlanCallsForContext(
-          context,
-          '项目 revision 更新后已重新核对独立验收重点',
-        ),
-        nativeResponse(
-          '已基于最新项目 revision 复核验收重点，仍需以真实植物选择、放置、战斗推进、胜利、下一关、重开和双视口可见性为准。',
-        ),
-      ]);
-    }
-    if (
-      phase >= 2 &&
-      tools.has('respond_to_user') &&
-      (revisionBlockedObservation(context) ||
-        context.includes('当前专业合同明确要求只读交付'))
-    ) {
-      consumeUniqueTerminalObservation('quality-review', runId, context);
-      return callsResponse('quality-review', tools, [
-        ...completedPlanCallsForContext(
-          context,
-          '项目 revision 更新后已重新核对独立验收重点',
-        ),
-        nativeResponse(
-          '已基于最新项目 revision 复核验收重点，仍需以真实植物选择、放置、战斗推进、胜利、下一关、重开和双视口可见性为准。',
-        ),
-      ]);
-    }
-    throw providerError(`provider-quality-stage-invalid:${phase}`);
-  }
-
   function finalReply(identity, context) {
     const key = `${identity.agentId}\0${identity.runId}`;
     if (finalReplyRuns.has(key)) {
@@ -2135,6 +2022,9 @@ export function createDeterministicLaneDefenseRouter({
     ) {
       throw providerError('provider-unexpected-text-request');
     }
+    if (identity.agentId === 'project-supervisor' && parentStage !== 'done') {
+      throw providerError('provider-parent-final-reply-before-acceptance');
+    }
     finalReplyRuns.add(key);
     const content =
       identity.agentId === 'project-supervisor'
@@ -2175,6 +2065,18 @@ export function createDeterministicLaneDefenseRouter({
         context.includes('用户这轮输入：') &&
         tools.has('runtime_execute')
       ) {
+        if (payload.reasoning_effort !== 'max') {
+          throw providerError('provider-interaction-reasoning-effort-invalid');
+        }
+        if (stats.interactionExecuteCount !== 0) {
+          throw providerError('provider-interaction-execute-duplicate');
+        }
+        if (
+          stats.manifestReadyTaskRunCount !== 0 ||
+          stats.manifestReadyTaskCompletionCount !== 0
+        ) {
+          throw providerError('provider-interaction-execute-out-of-order');
+        }
         stats.planningRequestCount += 1;
         stats.interactionExecuteCount += 1;
         recordAgent('project-supervisor', 'planning');
@@ -2190,17 +2092,17 @@ export function createDeterministicLaneDefenseRouter({
           model,
           JSON.stringify({
             checks: {
-              resourceBar: true,
-              unitCardTray: true,
-              battlefieldGrid: true,
-              enemyEntryDirection: true,
-              waveStatus: true,
+              informationHud: true,
+              gameplaySurface: true,
+              objectiveEntities: true,
               primaryControls: true,
+              failureRestartFlow: true,
+              responsiveLayout: true,
               implementationClarity: true,
               originalTheme: true,
             },
             issues: [],
-            summary: '确定性 UI 原型覆盖完整横屏塔防实现合同。',
+            summary: '确定性 UI 原型覆盖完整玩法界面实现合同。',
           }),
         );
       }
@@ -2253,15 +2155,6 @@ export function createDeterministicLaneDefenseRouter({
       if (identity.agentId === 'project-supervisor') {
         return parentCalls(context, tools);
       }
-      if (identity.agentId === 'code-prototype') {
-        return codeCalls(identity.runId, tools, context);
-      }
-      if (identity.agentId === 'quality-review') {
-        return qualityCalls(identity.runId, tools, context);
-      }
-      if (identity.agentId === 'art-asset-plan') {
-        return initialArtDelegationCalls(identity.runId, tools, context);
-      }
       throw providerError(`provider-agent-unsupported:${identity.agentId}`);
     } catch (error) {
       stats.unexpectedRequestCount += 1;
@@ -2376,6 +2269,7 @@ function createDeterministicCanvasFixture(apiKey) {
     canvasApiRequestCount: 0,
     canvasGenerationRequestCount: 0,
     canvasDownloadRequestCount: 0,
+    canvasSliceDownloadRequestCount: 0,
     canvasGeneratedAspectRatios: {},
   };
   let projectTitle = null;
@@ -2473,6 +2367,137 @@ function createDeterministicCanvasFixture(apiKey) {
           : '未命名游戏原型';
       return json(200, { data: { folder: { folderId, label: folderLabel } } });
     }
+    if (
+      request.method === 'POST' &&
+      parsed.pathname ===
+        '/api/external/v1/editor/icon-spritesheets/generations'
+    ) {
+      const idempotencyKey = request.headers['idempotency-key'];
+      if (
+        typeof idempotencyKey !== 'string' ||
+        !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+          idempotencyKey,
+        )
+      ) {
+        request.resume();
+        return json(400, { error: { message: 'invalid idempotency key' } });
+      }
+      const body = await readJsonBody(request);
+      const aspectRatio = body?.aspectRatio === '16:9' ? '16:9' : '1:1';
+      const width = aspectRatio === '16:9' ? 1280 : 1024;
+      const height = aspectRatio === '16:9' ? 720 : 1024;
+      generationSequence += 1;
+      stats.canvasGenerationRequestCount += 1;
+      stats.canvasGeneratedAspectRatios[aspectRatio] =
+        (stats.canvasGeneratedAspectRatios[aspectRatio] ?? 0) + 1;
+      const imageId = `deterministic-${generationSequence}`;
+      const objectKey = `generated/deterministic/${imageId}.png`;
+      const assetObjectId = `asset-object-${imageId}`;
+      const resourceId = `resource-${imageId}`;
+      const taskId = `task-${imageId}`;
+      images.set(imageId, {
+        aspectRatio,
+        width,
+        height,
+        bytes: deterministicPng(width, height, {
+          variant: generationSequence,
+          transparent: true,
+        }),
+        objectKey,
+        downloadKind: 'generation',
+      });
+      const sliceNames = ['玩家主体', '目标与危险物', '场景与资源', '反馈特效'];
+      const iconImageSrcs = sliceNames.map((name, index) => {
+        const sliceImageId = `${imageId}-slice-${index + 1}`;
+        const sliceObjectKey = `generated/deterministic/${sliceImageId}.png`;
+        const sliceResourceId = `resource-${sliceImageId}`;
+        const sliceAssetObjectId = `asset-object-${sliceImageId}`;
+        images.set(sliceImageId, {
+          aspectRatio: '1:1',
+          width: 256,
+          height: 256,
+          bytes: deterministicPng(256, 256, {
+            variant: generationSequence * 10 + index + 1,
+          }),
+          objectKey: sliceObjectKey,
+          downloadKind: 'slice',
+        });
+        return {
+          name,
+          imageSrc: `/${sliceObjectKey}`,
+          width: 256,
+          height: 256,
+          projectId,
+          taskId,
+          sourceResourceId: resourceId,
+          resource: {
+            resourceId: sliceResourceId,
+            projectId,
+            imageSrc: `/${sliceObjectKey}`,
+            objectKey: sliceObjectKey,
+            assetObjectId: sliceAssetObjectId,
+            taskId,
+            sourceResourceId: resourceId,
+          },
+          asset: {
+            assetId: `asset-${sliceImageId}`,
+            assetObjectId: sliceAssetObjectId,
+            assetKind: 'art-spritesheet-slice',
+            projectId,
+            taskId,
+          },
+        };
+      });
+      const operationId = `task-${imageId}`;
+      generationOperations.set(operationId, {
+        spritesheetImageSrc: `/${objectKey}`,
+        objectKey,
+        assetObjectId,
+        resourceId,
+        projectId,
+        taskId,
+        width,
+        height,
+        sourceType: 'generated',
+        prompt:
+          body?.iconDescriptions?.join('\n') ??
+          'deterministic spritesheet fixture',
+        actualPrompt:
+          body?.iconDescriptions?.join('\n') ??
+          'deterministic spritesheet fixture',
+        model: 'deterministic-canvas-v1',
+        provider: 'deterministic-loopback',
+        spritesheetResource: {
+          resourceId,
+          projectId,
+          imageSrc: `/${objectKey}`,
+          objectKey,
+          assetObjectId,
+          width,
+          height,
+          sourceType: 'generated',
+          taskId,
+        },
+        spritesheetAsset: {
+          assetId: `asset-${imageId}`,
+          assetObjectId,
+          assetKind: 'art-spritesheet',
+          projectId,
+          taskId,
+        },
+        iconImageSrcs,
+      });
+      return json(202, {
+        data: {
+          operationId,
+          kind: 'editor_icon_spritesheet_generation',
+          status: 'queued',
+          statusUrl: `/api/external/v1/generations/${operationId}`,
+          pollAfterMs: 1,
+          updatedAtMicros: generationSequence,
+        },
+      });
+    }
     if (
       request.method === 'POST' &&
       parsed.pathname === '/api/external/v1/editor/images/generations'
@@ -2499,7 +2524,11 @@ function createDeterministicCanvasFixture(apiKey) {
       const resourceId = `resource-${imageId}`;
       const assetKind =
         typeof body?.assetKind === 'string' ? body.assetKind : 'game-art';
-      images.set(imageId, { ...image, objectKey });
+      images.set(imageId, {
+        ...image,
+        objectKey,
+        downloadKind: 'generation',
+      });
       const operationId = `task-${imageId}`;
       generationOperations.set(operationId, {
         imageSrc: `/${objectKey}`,
@@ -2555,7 +2584,8 @@ function createDeterministicCanvasFixture(apiKey) {
         '/api/external/v1/generations/'.length,
       );
       const result = generationOperations.get(operationId);
-      if (!result) return json(404, { error: { message: 'operation not found' } });
+      if (!result)
+        return json(404, { error: { message: 'operation not found' } });
       return json(200, {
         data: {
           operationId,
@@ -2600,7 +2630,11 @@ function createDeterministicCanvasFixture(apiKey) {
       const imageId = parsed.pathname.slice('/signed/'.length, -'.png'.length);
       const image = images.get(imageId);
       if (!image) return json(404, { error: { message: 'image not found' } });
-      stats.canvasDownloadRequestCount += 1;
+      if (image.downloadKind === 'slice') {
+        stats.canvasSliceDownloadRequestCount += 1;
+      } else {
+        stats.canvasDownloadRequestCount += 1;
+      }
       return {
         statusCode: 200,
         contentType: 'image/png',
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs
index ede836cf6..66982a3a4 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs
@@ -450,6 +450,15 @@ fn game_creator_codex_app_server_validate_llm_config(
     Ok(())
 }
 
+fn apply_game_creator_codex_app_server_reasoning_effort(
+    params: &mut serde_json::Value,
+    request: &LlmRunRequest,
+) {
+    if let Some(effort) = game_creator_codex_cli_reasoning_effort(request) {
+        params["effort"] = serde_json::Value::String(effort.to_string());
+    }
+}
+
 fn quoted_toml_string(value: &str) -> Result<String, platform_llm::LlmError> {
     serde_json::to_string(value).map_err(|error| {
         platform_llm::LlmError::InvalidConfig(format!("序列化 Codex app-server 配置失败：{error}"))
@@ -970,9 +979,7 @@ impl CodexAppServerConnection {
             "approvalPolicy": "never",
             "sandboxPolicy": { "type": "readOnly", "networkAccess": false },
         });
-        if let Some(effort) = game_creator_codex_cli_reasoning_effort(&request) {
-            params["effort"] = serde_json::Value::String(effort.to_string());
-        }
+        apply_game_creator_codex_app_server_reasoning_effort(&mut params, &request);
         if let Some(schema) = game_creator_codex_cli_tool_output_schema(&request) {
             params["outputSchema"] = schema;
         }
@@ -1646,6 +1653,15 @@ mod tests {
         ])
     }
 
+    #[test]
+    fn codex_app_server_reasoning_effort_preserves_max_wire_value() {
+        let request = LlmRunRequest::single_turn("系统", "任务")
+            .with_response_reasoning_effort(platform_llm::LlmResponseReasoningEffort::Max);
+        let mut params = serde_json::json!({});
+        apply_game_creator_codex_app_server_reasoning_effort(&mut params, &request);
+        assert_eq!(params["effort"], "max");
+    }
+
     #[test]
     fn codex_app_server_maps_structured_output_to_runtime_tool_calls() {
         let text = r#"{"toolCalls":[{"name":"runtime_tool_file_read","arguments":"{\"path\":\"game/index.html\"}"}]}"#;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_cli.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_cli.rs
index ca5ce15c3..8155044a6 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_cli.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_cli.rs
@@ -144,6 +144,7 @@ pub(in crate::agent) fn game_creator_codex_cli_reasoning_effort(
             platform_llm::LlmResponseReasoningEffort::Low => "low",
             platform_llm::LlmResponseReasoningEffort::Medium => "medium",
             platform_llm::LlmResponseReasoningEffort::High => "high",
+            platform_llm::LlmResponseReasoningEffort::Max => "max",
         })
 }
 
@@ -666,6 +667,16 @@ mod tests {
         ])
     }
 
+    #[test]
+    fn codex_cli_reasoning_effort_preserves_max_wire_value() {
+        let request = LlmRunRequest::single_turn("系统", "任务")
+            .with_response_reasoning_effort(platform_llm::LlmResponseReasoningEffort::Max);
+        assert_eq!(
+            game_creator_codex_cli_reasoning_effort(&request),
+            Some("max")
+        );
+    }
+
     #[cfg(windows)]
     #[test]
     fn codex_cli_candidates_prefer_sorted_native_npm_targets_before_path() {
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/interaction.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/interaction.rs
index 1c3ef53a9..db6594659 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/interaction.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/interaction.rs
@@ -279,21 +279,12 @@ fn agent_interaction_system_prompt(agent_id: &str) -> String {
     )
 }
 
-fn build_agent_interaction_request_for_session(
-    root: &Path,
+fn build_agent_interaction_llm_request(
     agent_id: &str,
-    session_id: &str,
     prompt: &str,
-) -> Result<(GameCreatorLlmConfig, String, LlmRunRequest), String> {
-    let prompt = prompt.trim();
-    if prompt.is_empty() {
-        return Err("交互内容不能为空".to_string());
-    }
-    if !game_creator_agent_uses_interaction_kernel(agent_id) {
-        return Err(format!("Agent 不启用交互决策层：{agent_id}"));
-    }
-    let (llm, config_path, context) =
-        build_game_creator_role_agent_context_for_session(root, agent_id, Some(session_id))?;
+    context: &str,
+    llm: &GameCreatorLlmConfig,
+) -> Result<LlmRunRequest, String> {
     let api_kind = parse_game_creator_llm_api_kind(&llm.api_kind)?;
     let user_prompt = if context.trim().is_empty() {
         format!("用户这轮输入：\n{prompt}")
@@ -311,6 +302,25 @@ fn build_agent_interaction_request_for_session(
     .with_max_output_tokens(AGENT_INTERACTION_MAX_OUTPUT_TOKENS)
     .with_function_tools(function_tools)
     .with_tool_choice(platform_llm::LlmToolChoice::Auto);
+    apply_game_creator_llm_reasoning_effort(request, llm)
+}
+
+fn build_agent_interaction_request_for_session(
+    root: &Path,
+    agent_id: &str,
+    session_id: &str,
+    prompt: &str,
+) -> Result<(GameCreatorLlmConfig, String, LlmRunRequest), String> {
+    let prompt = prompt.trim();
+    if prompt.is_empty() {
+        return Err("交互内容不能为空".to_string());
+    }
+    if !game_creator_agent_uses_interaction_kernel(agent_id) {
+        return Err(format!("Agent 不启用交互决策层：{agent_id}"));
+    }
+    let (llm, config_path, context) =
+        build_game_creator_role_agent_context_for_session(root, agent_id, Some(session_id))?;
+    let request = build_agent_interaction_llm_request(agent_id, prompt, &context, &llm)?;
     Ok((llm, config_path, request))
 }
 
@@ -626,12 +636,16 @@ mod tests {
 
     #[test]
     fn interaction_request_crosses_neutral_provider_contract_without_shape_drift() {
-        let request =
-            LlmRunRequest::new(vec![LlmMessage::system("system"), LlmMessage::user("user")])
-                .with_api_kind(LlmApiKind::OpenAiResponses)
-                .with_max_output_tokens(AGENT_INTERACTION_MAX_OUTPUT_TOKENS)
-                .with_function_tools(agent_interaction_function_tools().expect("interaction tools"))
-                .with_tool_choice(platform_llm::LlmToolChoice::Auto);
+        let mut llm = GameCreatorLlmConfig::default();
+        llm.api_kind = "openai_responses".to_string();
+        llm.reasoning_effort = "max".to_string();
+        let request = build_agent_interaction_llm_request(
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            "制作一个三消经营游戏",
+            "",
+            &llm,
+        )
+        .expect("build interaction request");
         let request = platform_llm::provider_request_from_llm_request("agent-interaction", request)
             .expect("neutral request");
         assert_eq!(
@@ -639,6 +653,10 @@ mod tests {
             Some(AGENT_INTERACTION_MAX_OUTPUT_TOKENS)
         );
         assert_eq!(request.tools().len(), 3);
+        assert_eq!(
+            request.reasoning_effort(),
+            Some(agent_runtime_core::ProviderReasoningEffort::Max)
+        );
         assert!(request.tools().iter().all(|tool| tool.strict()));
         assert_eq!(
             request.tool_choice(),
@@ -646,6 +664,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn interaction_request_propagates_invalid_reasoning_effort() {
+        let mut llm = GameCreatorLlmConfig::default();
+        llm.reasoning_effort = "maximum".to_string();
+        let error = build_agent_interaction_llm_request(
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            "制作一个三消经营游戏",
+            "",
+            &llm,
+        )
+        .expect_err("invalid reasoning effort must fail before Provider request");
+        assert!(error.contains("reasoning_effort"));
+    }
+
     #[test]
     fn interaction_stream_sink_preserves_accumulation_delta_and_finish_reason() {
         let mut observed = Vec::new();
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs
index 06dc6cc0d..71f601ca4 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs
@@ -61,6 +61,11 @@ pub(crate) async fn execute_game_creator_agent_runtime_tool_action_with_pending_
     if let Some(blocker) = supervisor_orchestrator_mutation_block_at(root, agent_id, run_id, tool) {
         return blocker;
     }
+    if let Some(blocker) =
+        agent_runtime_autonomous_art_director_canvas_only_action_block(agent_id, task, tool)
+    {
+        return blocker;
+    }
     if let Some(blocker) = game_chat_delegated_art_agent_input_mutation_block(
         root,
         agent_id,
@@ -640,3 +645,172 @@ pub(in crate::agent) fn agent_runtime_pending_reconciliation_observation(
         detail: Some(redact_agent_runtime_project_paths(root, error, 500)),
     }
 }
+
+#[cfg(test)]
+mod canvas_only_execution_tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn art_director_canvas_only_execution_rejects_file_write_and_mixed_batch_without_side_effects(
+    ) {
+        const PARENT_RUN_ID: &str = "canvas-only-execution-parent";
+        const CHILD_ID: &str = "art-director";
+        let _config_guard = crate::tests::write_test_local_config(
+            r#"{"editorApi":{"apiKey":"canvas-only-execution-test-key"}}"#.to_string(),
+        );
+        let temporary = tempfile::tempdir().expect("create canvas-only execution root");
+        let root = temporary.path().join("project");
+        init_local_game_project_at(
+            &root,
+            "canvas-only-execution-project",
+            "生成带统一视觉规范的完整游戏",
+        )
+        .expect("init canvas-only execution project");
+
+        let parent_session = resolve_agent_conversation_session_id_at(
+            &root,
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            None,
+            true,
+        )
+        .expect("resolve canvas-only parent session");
+        let parent = append_unique_game_creator_agent_runtime_pending_task(
+            &root,
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            &parent_session,
+            "生成带统一视觉规范的完整游戏",
+            PARENT_RUN_ID,
+            AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+            Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+            None,
+        )
+        .expect("queue canvas-only parent");
+        let mut parent_state = agent_runtime_state_from_task_record(&parent);
+        parent_state.status = "running".to_string();
+        parent_state.phase = "planning".to_string();
+        append_game_creator_agent_runtime_task(&root, &parent_state)
+            .expect("persist running canvas-only parent");
+
+        let task = format!(
+            "生成统一视觉规范图。{AGENT_RUNTIME_AUTONOMOUS_ART_DIRECTOR_CANVAS_ONLY_TASK_MARKER}"
+        );
+        let child_session = resolve_agent_conversation_session_id_at(&root, CHILD_ID, None, true)
+            .expect("resolve canvas-only child session");
+        let child_run_id = autonomous_manifest_ready_task_run_id(PARENT_RUN_ID, CHILD_ID);
+        let child = append_unique_game_creator_agent_runtime_pending_task(
+            &root,
+            CHILD_ID,
+            &child_session,
+            &task,
+            &child_run_id,
+            "agent-ready-task-scheduler",
+            Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+            Some(&AgentRuntimeTaskLink {
+                parent_agent_id: Some(parent.agent_id.clone()),
+                parent_run_id: Some(parent.run_id.clone()),
+                delegation_id: None,
+            }),
+        )
+        .expect("queue canvas-only child");
+        let mut runtime = agent_runtime_state_from_task_record(&child);
+        runtime.status = "running".to_string();
+        runtime.phase = "planning".to_string();
+        write_game_creator_agent_runtime_state(&root, &runtime)
+            .expect("persist canvas-only child runtime");
+        append_game_creator_agent_runtime_task(&root, &runtime)
+            .expect("persist running canvas-only child");
+        update_manifest_task_status_at(&root, CHILD_ID, GameCreationAppTaskStatus::Running)
+            .expect("mark canvas-only child running");
+
+        let forbidden_path = "game/art-director-forbidden.txt";
+        let forbidden_action = AgentRuntimeToolAction {
+            tool: "file.write".to_string(),
+            reason: Some("尝试写入非 Canvas 文件".to_string()),
+            input: serde_json::json!({
+                "path": forbidden_path,
+                "content": "forbidden"
+            }),
+        };
+        let revision_before = read_game_creator_agent_runtime_project_revision(&root)
+            .expect("read revision before canvas-only rejection");
+        let observation = execute_game_creator_agent_runtime_tool_action(
+            &root,
+            CHILD_ID,
+            &child_run_id,
+            &task,
+            &forbidden_action,
+        )
+        .await;
+        assert_eq!(observation.status, "rejected", "{observation:?}");
+        assert_eq!(
+            observation.summary,
+            "art-director 受控视觉任务拒绝非 Canvas 项目动作"
+        );
+        assert!(!root.join(forbidden_path).exists());
+        assert_eq!(
+            read_game_creator_agent_runtime_project_revision(&root)
+                .expect("read revision after direct canvas-only rejection")
+                .revision,
+            revision_before.revision
+        );
+
+        let mixed_plan = AgentRuntimeToolPlan {
+            thinking_summary: "尝试混合文件写入与 Canvas 生成".to_string(),
+            plan_update: None,
+            plan: vec!["写入文件".to_string(), "生成视觉规范图".to_string()],
+            actions: vec![
+                forbidden_action,
+                AgentRuntimeToolAction {
+                    tool: "canvas.asset_generate".to_string(),
+                    reason: Some("生成统一视觉规范图".to_string()),
+                    input: serde_json::json!({
+                        "prompt": "生成统一视觉规范图",
+                        "outputPath": AGENT_RUNTIME_ART_SPEC_PATH,
+                        "assetKind": "icon-spec",
+                        "aspectRatio": "1:1",
+                        "imageSize": "1K",
+                        "replaceExisting": false
+                    }),
+                },
+            ],
+            response: String::new(),
+        };
+        let repository_fingerprint = build_repository_startup_context_at(&root)
+            .expect("build canvas-only repository context")
+            .fingerprint;
+        let prepared = prepare_game_creator_agent_runtime_provider_action_batch(
+            &root,
+            &runtime,
+            &task,
+            &mixed_plan,
+            &[],
+            &revision_before,
+            &repository_fingerprint,
+        )
+        .await
+        .expect("prepare mixed canvas-only provider batch");
+        assert!(
+            matches!(
+                &prepared,
+                AgentRuntimeProviderActionBatchPreparation::Aborted {
+                    observation: AgentRuntimeToolObservation {
+                        status,
+                        summary,
+                        ..
+                    },
+                    ..
+                } if status == "blocked"
+                    && summary == "art-director 受控视觉任务拒绝非 Canvas 项目动作"
+            ),
+            "mixed file.write + canvas batch must abort before execution: {prepared:?}"
+        );
+        assert!(!root.join(forbidden_path).exists());
+        assert!(!root.join(AGENT_RUNTIME_ART_SPEC_PATH).exists());
+        assert_eq!(
+            read_game_creator_agent_runtime_project_revision(&root)
+                .expect("read revision after mixed canvas-only rejection")
+                .revision,
+            revision_before.revision
+        );
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/autonomous_policy.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/autonomous_policy.rs
index 25a208d6c..f0bc0f716 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/autonomous_policy.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/autonomous_policy.rs
@@ -271,6 +271,8 @@ pub(super) const AGENT_RUNTIME_AUTONOMOUS_SPECIALIST_VERIFICATION_ONLY_REPAIR_ER
     "自主构建非只读专业 Agent 必须先验证本人 run 的项目修改";
 pub(super) const AGENT_RUNTIME_AUTONOMOUS_READ_ONLY_MUTATION_ERROR_PREFIX: &str =
     "自主构建只读专业 Agent 禁止执行写入或副作用动作";
+pub(in crate::agent) const AGENT_RUNTIME_AUTONOMOUS_ART_DIRECTOR_CANVAS_ONLY_TASK_MARKER: &str =
+    "唯一允许的项目写动作是 canvas.asset_generate";
 
 fn autonomous_initial_collaboration_contract_error(detail: impl AsRef<str>) -> String {
     format!(
@@ -486,6 +488,49 @@ fn is_agent_runtime_autonomous_supervisor_delivery_convergence_plan(
             && action.input.get("delegation_id").is_none_or(serde_json::Value::is_null))
 }
 
+fn is_agent_runtime_autonomous_supervisor_request_bound_manifest_wait_plan(
+    plan: &AgentRuntimeToolPlan,
+) -> bool {
+    let [task_list, run_status] = plan.actions.as_slice() else {
+        return false;
+    };
+    let Some(task_list_input) = task_list.input.as_object() else {
+        return false;
+    };
+    let Some(run_status_input) = run_status.input.as_object() else {
+        return false;
+    };
+    plan.response.trim().is_empty()
+        && plan.plan_update.is_none()
+        && plan.plan.is_empty()
+        && task_list.tool.trim() == "task.list"
+        && task_list_input.is_empty()
+        && run_status.tool.trim() == "agent.run_status"
+        && run_status_input.len() == 3
+        && run_status_input
+            .get("agentId")
+            .is_some_and(serde_json::Value::is_null)
+        && run_status_input
+            .get("scope")
+            .and_then(serde_json::Value::as_str)
+            == Some("all")
+        && run_status_input
+            .get("delegationId")
+            .is_some_and(serde_json::Value::is_null)
+}
+
+fn is_agent_runtime_autonomous_supervisor_acceptance_control_plan(
+    plan: &AgentRuntimeToolPlan,
+) -> bool {
+    plan.response.trim().is_empty()
+        && plan.plan_update.is_none()
+        && plan.actions.len() == 1
+        && matches!(
+            plan.actions[0].tool.trim(),
+            "agent.action_history" | "agent.acceptance_update"
+        )
+}
+
 fn is_agent_runtime_autonomous_preview_validation_plan(plan: &AgentRuntimeToolPlan) -> bool {
     matches!(plan.actions.as_slice(), [action] if action.tool.trim() == "preview.validate")
 }
@@ -504,6 +549,35 @@ fn agent_runtime_autonomous_supervisor_plan_prepares_repair(plan: &AgentRuntimeT
     })
 }
 
+fn agent_runtime_game_chat_code_safe_default_repair_plan_matches(
+    plan: &AgentRuntimeToolPlan,
+    delivery: &StaticDelegateDeliveryRecord,
+) -> bool {
+    let [action] = plan.actions.as_slice() else {
+        return false;
+    };
+    plan.response.trim().is_empty()
+        && plan.plan_update.is_none()
+        && plan.plan.is_empty()
+        && action.tool.trim() == "agent.delegate"
+        && agent_runtime_tool_input_text(&action.input, &["agentId", "agent_id"])
+            == delivery.target_agent_id
+        && agent_runtime_tool_input_text(
+            &action.input,
+            &["repairOfDelegationId", "repair_of_delegation_id"],
+        ) == delivery.delegation_id
+        && agent_runtime_tool_input_text(&action.input, &["runId", "run_id"]).is_empty()
+        && !agent_runtime_tool_input_text(&action.input, &["task"]).is_empty()
+        && agent_runtime_tool_input_string_list(
+            &action.input,
+            &["acceptanceCriteria", "acceptance_criteria", "criteria"],
+        ) == delivery.acceptance_criteria
+        && agent_runtime_tool_input_string_list(
+            &action.input,
+            &["expectedArtifacts", "expected_artifacts", "artifacts"],
+        ) == delivery.expected_artifacts
+}
+
 pub(crate) fn refresh_agent_runtime_autonomous_convergence_snapshot_after_provider_at(
     root: &Path,
     agent_id: &str,
@@ -542,6 +616,7 @@ pub(super) fn validate_agent_runtime_autonomous_plan_liveness_at(
     observations: &[AgentRuntimeToolObservation],
     plan: &AgentRuntimeToolPlan,
     supervisor_requires_delegated_repair: bool,
+    supervisor_manifest_dag_in_progress_at_request: bool,
 ) -> Result<(), String> {
     if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
         && autonomous_manifest_dag_in_progress_at(root)?
@@ -601,6 +676,7 @@ pub(super) fn validate_agent_runtime_autonomous_plan_liveness_at(
             ));
         }
     }
+    validate_game_chat_code_safe_default_repair_liveness_at(root, agent_id, run_id, plan)?;
 
     let has_current_playtest_receipt = if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
         let contract = read_autonomous_completion_contract(root, agent_id, run_id)?;
@@ -621,19 +697,56 @@ pub(super) fn validate_agent_runtime_autonomous_plan_liveness_at(
         observations,
         plan,
         supervisor_requires_delegated_repair,
+        supervisor_manifest_dag_in_progress_at_request,
         has_current_playtest_receipt,
     )
 }
 
-pub(in crate::agent) fn autonomous_manifest_dag_in_progress_at(
+pub(in crate::agent) fn validate_game_chat_code_safe_default_repair_liveness_at(
     root: &Path,
-) -> Result<bool, String> {
+    agent_id: &str,
+    run_id: &str,
+    plan: &AgentRuntimeToolPlan,
+) -> Result<(), String> {
+    if agent_id != "code-prototype"
+        || !static_delegate_parent_can_manage_receipts_at(root, agent_id, run_id)?
+    {
+        return Ok(());
+    }
+    if let Some(delivery) =
+        game_chat_code_parent_safe_default_repair_delivery_at(root, agent_id, run_id)?
+    {
+        if agent_runtime_game_chat_code_safe_default_repair_plan_matches(plan, &delivery) {
+            return Ok(());
+        }
+        return Err(format!(
+            "game-chat code-prototype 必须立即推进唯一安全默认返工；本轮只能对 delegationId={}、targetAgentId={} 提交同合同 agent.delegate，不得重复 route、读取、查询或请求 Provider 空转",
+            delivery.delegation_id, delivery.target_agent_id
+        ));
+    }
+    Ok(())
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(in crate::agent) enum AutonomousManifestDagState {
+    NotStartedOrStalled,
+    InProgress,
+    Completed,
+    Failed {
+        failed_task_ids: Vec<String>,
+        has_active_children: bool,
+    },
+}
+
+pub(in crate::agent) fn autonomous_manifest_dag_state_at(
+    root: &Path,
+) -> Result<AutonomousManifestDagState, String> {
     let manifest = read_manifest_for_project(root)?;
     let current_root = current_autonomous_game_build_root_task_at(root)?.ok_or_else(|| {
         "无法解析当前自主构建根 Run 的可信 source，拒绝按 GUI 完整 DAG 回退".to_string()
     })?;
     if !autonomous_game_build_root_task_is_active(&current_root) {
-        return Ok(false);
+        return Ok(AutonomousManifestDagState::NotStartedOrStalled);
     }
     let seed_task_ids = autonomous_manifest_seed_tasks_for_source(&current_root.source)
         .into_iter()
@@ -647,15 +760,43 @@ pub(in crate::agent) fn autonomous_manifest_dag_in_progress_at(
     let running = seed_tasks
         .iter()
         .any(|task| task.status == GameCreationAppTaskStatus::Running);
-    let failed = seed_tasks
+    let mut failed_task_ids = seed_tasks
         .iter()
-        .any(|task| task.status == GameCreationAppTaskStatus::Failed);
+        .filter(|task| task.status == GameCreationAppTaskStatus::Failed)
+        .map(|task| task.id.clone())
+        .collect::<Vec<_>>();
+    failed_task_ids.sort();
     let active_child = autonomous_manifest_parent_has_active_ready_task_at(
         root,
         &current_root.run_id,
         &seed_task_ids,
     )?;
-    Ok((running || active_child) && !failed)
+    if !failed_task_ids.is_empty() {
+        return Ok(AutonomousManifestDagState::Failed {
+            failed_task_ids,
+            has_active_children: running || active_child,
+        });
+    }
+    if running || active_child {
+        return Ok(AutonomousManifestDagState::InProgress);
+    }
+    if seed_tasks.len() == seed_task_ids.len()
+        && seed_tasks
+            .iter()
+            .all(|task| task.status == GameCreationAppTaskStatus::Completed)
+    {
+        return Ok(AutonomousManifestDagState::Completed);
+    }
+    Ok(AutonomousManifestDagState::NotStartedOrStalled)
+}
+
+pub(in crate::agent) fn autonomous_manifest_dag_in_progress_at(
+    root: &Path,
+) -> Result<bool, String> {
+    Ok(matches!(
+        autonomous_manifest_dag_state_at(root)?,
+        AutonomousManifestDagState::InProgress
+    ))
 }
 
 fn autonomous_manifest_parent_has_active_ready_task_at(
@@ -706,6 +847,7 @@ pub(crate) fn validate_agent_runtime_autonomous_plan_liveness(
     observations: &[AgentRuntimeToolObservation],
     plan: &AgentRuntimeToolPlan,
     supervisor_requires_delegated_repair: bool,
+    supervisor_manifest_dag_in_progress_at_request: bool,
     has_current_playtest_receipt: bool,
 ) -> Result<(), String> {
     let has_mutation = plan
@@ -734,9 +876,18 @@ pub(crate) fn validate_agent_runtime_autonomous_plan_liveness(
         observations[index].status == "failed"
             && observations[index].summary == "浏览器验证未通过，请根据诊断修复后重试"
     });
+    let has_current_playtest_acceptance_control = agent_id
+        == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+        && has_current_playtest_receipt
+        && is_agent_runtime_autonomous_supervisor_acceptance_control_plan(plan);
+    let has_request_bound_manifest_wait = agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+        && supervisor_manifest_dag_in_progress_at_request
+        && is_agent_runtime_autonomous_supervisor_request_bound_manifest_wait_plan(plan);
     // A Supervisor without a mutation must still hit the same first-mutation
-    // liveness gate as every other autonomous Agent. A concrete failed
-    // playtest is more specific and must reach its repair gate below.
+    // liveness gate as every other autonomous Agent. The only exception is
+    // the single-action evidence/update sequence after the current revision
+    // already owns a durable playtest receipt. A concrete failed playtest is
+    // more specific and must reach its repair gate below.
     if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
         && loop_index > AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT
         && verification_gate.mutation_revision.is_none()
@@ -746,6 +897,8 @@ pub(crate) fn validate_agent_runtime_autonomous_plan_liveness(
         && plan.response.trim().is_empty()
         && !has_specialist_delegation
         && !latest_playtest_is_failed
+        && !has_current_playtest_acceptance_control
+        && !has_request_bound_manifest_wait
     {
         return Err(format!(
             "{AGENT_RUNTIME_AUTONOMOUS_LIVENESS_ERROR_PREFIX}；Supervisor 尚未提交首次项目 mutation 或有效协作动作，禁止继续只规划、读取、验证或空转"
@@ -954,6 +1107,86 @@ pub(in crate::agent) fn validate_agent_runtime_autonomous_read_only_delivery_pla
     ))
 }
 
+fn agent_runtime_autonomous_art_director_canvas_only_tool_allowed(tool: &str) -> bool {
+    matches!(
+        tool,
+        "memory.read"
+            | "conversation.read"
+            | "asset.list"
+            | "project.index"
+            | "project.search"
+            | "project.diff"
+            | "git.inspect"
+            | "file.list"
+            | "file.read"
+            | "task.list"
+            | "agent.action_history"
+            | "agent.run_status"
+            | "command.output_read"
+            | "command.poll"
+            | "image.inspect"
+            | "canvas.asset_generate"
+    )
+}
+
+pub(in crate::agent) fn agent_runtime_autonomous_art_director_canvas_only_task(
+    agent_id: &str,
+    task: &str,
+) -> bool {
+    agent_id == "art-director"
+        && task.contains(AGENT_RUNTIME_AUTONOMOUS_ART_DIRECTOR_CANVAS_ONLY_TASK_MARKER)
+}
+
+pub(in crate::agent) fn validate_agent_runtime_autonomous_art_director_canvas_only_plan(
+    agent_id: &str,
+    task: &str,
+    plan: &AgentRuntimeToolPlan,
+) -> Result<(), String> {
+    if !agent_runtime_autonomous_art_director_canvas_only_task(agent_id, task) {
+        return Ok(());
+    }
+    if let Some(forbidden) = plan.actions.iter().find(|action| {
+        !agent_runtime_autonomous_art_director_canvas_only_tool_allowed(action.tool.trim())
+    }) {
+        return Err(format!(
+            "autonomous art-director 受控视觉任务拒绝动作 {}；只允许读取、image.inspect 与唯一 canvas.asset_generate 素材事务",
+            forbidden.tool.trim()
+        ));
+    }
+    let canvas_count = plan
+        .actions
+        .iter()
+        .filter(|action| action.tool.trim() == "canvas.asset_generate")
+        .count();
+    if canvas_count > 1 {
+        return Err(format!(
+            "autonomous art-director 受控视觉任务单轮包含 {canvas_count} 个 canvas.asset_generate，最多允许 1 个"
+        ));
+    }
+    Ok(())
+}
+
+pub(in crate::agent) fn agent_runtime_autonomous_art_director_canvas_only_action_block(
+    agent_id: &str,
+    task: &str,
+    tool: &str,
+) -> Option<AgentRuntimeToolObservation> {
+    if !agent_runtime_autonomous_art_director_canvas_only_task(agent_id, task)
+        || agent_runtime_autonomous_art_director_canvas_only_tool_allowed(tool.trim())
+    {
+        return None;
+    }
+    Some(AgentRuntimeToolObservation {
+        tool: tool.trim().to_string(),
+        status: "rejected".to_string(),
+        summary: "art-director 受控视觉任务拒绝非 Canvas 项目动作".to_string(),
+        detail: Some(format!(
+            "tool={} · allowed=read,image.inspect,canvas.asset_generate",
+            tool.trim()
+        )),
+    })
+}
+
 pub(in crate::agent) fn validate_agent_runtime_autonomous_specialist_response_delivery(
     agent_id: &str,
     run_id: &str,
@@ -1973,6 +2206,7 @@ mod tests {
             &route_manifest,
             false,
             false,
+            false,
         )
         .is_ok());
         for (agent_id, plan) in [
@@ -1988,6 +2222,85 @@ mod tests {
         }
     }
 
+    #[test]
+    fn autonomous_art_director_visual_task_allows_one_canvas_and_rejects_other_actions() {
+        let task = format!(
+            "生成视觉规范。{AGENT_RUNTIME_AUTONOMOUS_ART_DIRECTOR_CANVAS_ONLY_TASK_MARKER}"
+        );
+        let action = |tool: &str| AgentRuntimeToolAction {
+            tool: tool.to_string(),
+            reason: None,
+            input: serde_json::json!({}),
+        };
+        let allowed = AgentRuntimeToolPlan {
+            actions: vec![action("asset.list"), action("canvas.asset_generate")],
+            ..AgentRuntimeToolPlan::default()
+        };
+        assert!(
+            validate_agent_runtime_autonomous_art_director_canvas_only_plan(
+                "art-director",
+                &task,
+                &allowed,
+            )
+            .is_ok()
+        );
+        assert!(
+            agent_runtime_autonomous_art_director_canvas_only_action_block(
+                "art-director",
+                &task,
+                "canvas.asset_generate",
+            )
+            .is_none()
+        );
+
+        for tool in [
+            "file.write",
+            "file.patch",
+            "file.delete",
+            "project.patchset",
+            "project.restore",
+            "command.run_limited",
+            "agent.delegate",
+        ] {
+            let rejected = AgentRuntimeToolPlan {
+                actions: vec![action(tool)],
+                ..AgentRuntimeToolPlan::default()
+            };
+            assert!(
+                validate_agent_runtime_autonomous_art_director_canvas_only_plan(
+                    "art-director",
+                    &task,
+                    &rejected,
+                )
+                .is_err()
+            );
+            assert!(
+                agent_runtime_autonomous_art_director_canvas_only_action_block(
+                    "art-director",
+                    &task,
+                    tool,
+                )
+                .is_some()
+            );
+        }
+
+        let duplicate_canvas = AgentRuntimeToolPlan {
+            actions: vec![
+                action("canvas.asset_generate"),
+                action("canvas.asset_generate"),
+            ],
+            ..AgentRuntimeToolPlan::default()
+        };
+        assert!(
+            validate_agent_runtime_autonomous_art_director_canvas_only_plan(
+                "art-director",
+                &task,
+                &duplicate_canvas,
+            )
+            .is_err()
+        );
+    }
+
     #[test]
     fn autonomous_supervisor_without_playtest_still_hits_pre_mutation_liveness_gate() {
         let verification_gate = AgentRuntimeVerificationGate {
@@ -2019,6 +2332,7 @@ mod tests {
             &plan,
             false,
             false,
+            false,
         )
         .expect_err("Supervisor without a playtest must not bypass pre-mutation liveness");
         assert!(error.starts_with(AGENT_RUNTIME_AUTONOMOUS_LIVENESS_ERROR_PREFIX));
@@ -2069,8 +2383,190 @@ mod tests {
             &plan,
             false,
             false,
+            false,
         )
         .expect_err("latest successful playtest must not retain an earlier failure exemption");
         assert!(error.starts_with(AGENT_RUNTIME_AUTONOMOUS_LIVENESS_ERROR_PREFIX));
     }
+
+    #[test]
+    fn autonomous_supervisor_current_playtest_allows_only_acceptance_control_actions() {
+        let verification_gate = AgentRuntimeVerificationGate {
+            schema_version: "test".to_string(),
+            project_id: "test".to_string(),
+            agent_id: GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID.to_string(),
+            run_id: "supervisor-current-playtest-acceptance".to_string(),
+            requires_verification: false,
+            mutation_revision: None,
+            verified_revision: None,
+            last_mutation_tool: None,
+            last_verification_tool: None,
+            last_verification_status: None,
+            static_smoke_verified_revision: None,
+            static_smoke_verified_game_index_sha256: None,
+            failed_playtest_revision: None,
+            updated_at: 0,
+        };
+        let action = |tool: &str| AgentRuntimeToolAction {
+            tool: tool.to_string(),
+            reason: None,
+            input: serde_json::json!({}),
+        };
+
+        for tool in ["agent.action_history", "agent.acceptance_update"] {
+            let plan = AgentRuntimeToolPlan {
+                actions: vec![action(tool)],
+                ..AgentRuntimeToolPlan::default()
+            };
+            validate_agent_runtime_autonomous_plan_liveness(
+                GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+                AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 1,
+                11,
+                &verification_gate,
+                &[],
+                &plan,
+                false,
+                false,
+                true,
+            )
+            .unwrap_or_else(|error| {
+                panic!("{tool} should remain available for final acceptance: {error}")
+            });
+        }
+
+        let mixed_read = AgentRuntimeToolPlan {
+            actions: vec![action("agent.action_history"), action("file.read")],
+            ..AgentRuntimeToolPlan::default()
+        };
+        let error = validate_agent_runtime_autonomous_plan_liveness(
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 1,
+            11,
+            &verification_gate,
+            &[],
+            &mixed_read,
+            false,
+            false,
+            true,
+        )
+        .expect_err("final acceptance exemption must not permit a mixed read batch");
+        assert!(error.starts_with(AGENT_RUNTIME_AUTONOMOUS_LIVENESS_ERROR_PREFIX));
+    }
+
+    #[test]
+    fn autonomous_supervisor_accepts_one_request_bound_manifest_wait_when_live_predicate_closes() {
+        let verification_gate = AgentRuntimeVerificationGate {
+            schema_version: "test".to_string(),
+            project_id: "test".to_string(),
+            agent_id: GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID.to_string(),
+            run_id: "supervisor-stale-manifest-wait".to_string(),
+            requires_verification: false,
+            mutation_revision: None,
+            verified_revision: None,
+            last_mutation_tool: None,
+            last_verification_tool: None,
+            last_verification_status: None,
+            static_smoke_verified_revision: None,
+            static_smoke_verified_game_index_sha256: None,
+            failed_playtest_revision: None,
+            updated_at: 0,
+        };
+        let plan = AgentRuntimeToolPlan {
+            actions: vec![
+                AgentRuntimeToolAction {
+                    tool: "task.list".to_string(),
+                    reason: None,
+                    input: serde_json::json!({}),
+                },
+                AgentRuntimeToolAction {
+                    tool: "agent.run_status".to_string(),
+                    reason: None,
+                    input: serde_json::json!({
+                        "agentId": null,
+                        "scope": "all",
+                        "delegationId": null,
+                    }),
+                },
+            ],
+            ..AgentRuntimeToolPlan::default()
+        };
+        assert!(is_agent_runtime_autonomous_supervisor_request_bound_manifest_wait_plan(&plan));
+
+        validate_agent_runtime_autonomous_plan_liveness(
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 1,
+            0,
+            &verification_gate,
+            &[],
+            &plan,
+            false,
+            true,
+            false,
+        )
+        .expect("request-bound wait should survive the live predicate closing once");
+
+        let wait_without_request_binding = validate_agent_runtime_autonomous_plan_liveness(
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 1,
+            0,
+            &verification_gate,
+            &[],
+            &plan,
+            false,
+            false,
+            false,
+        )
+        .expect_err("a request without a bound active observation must not keep waiting");
+        assert!(wait_without_request_binding
+            .starts_with(AGENT_RUNTIME_AUTONOMOUS_LIVENESS_ERROR_PREFIX));
+
+        for invalid_plan in [
+            AgentRuntimeToolPlan {
+                actions: vec![plan.actions[0].clone()],
+                ..AgentRuntimeToolPlan::default()
+            },
+            AgentRuntimeToolPlan {
+                actions: vec![plan.actions[1].clone(), plan.actions[0].clone()],
+                ..AgentRuntimeToolPlan::default()
+            },
+            AgentRuntimeToolPlan {
+                actions: vec![
+                    plan.actions[0].clone(),
+                    AgentRuntimeToolAction {
+                        input: serde_json::json!({
+                            "agentId": null,
+                            "scope": "all",
+                            "delegationId": null,
+                            "extra": true,
+                        }),
+                        ..plan.actions[1].clone()
+                    },
+                ],
+                ..AgentRuntimeToolPlan::default()
+            },
+        ] {
+            let error = validate_agent_runtime_autonomous_plan_liveness(
+                GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+                AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 1,
+                0,
+                &verification_gate,
+                &[],
+                &invalid_plan,
+                false,
+                true,
+                false,
+            )
+            .expect_err("request-bound wait exemption must reject any broader plan");
+            assert!(error.starts_with(AGENT_RUNTIME_AUTONOMOUS_LIVENESS_ERROR_PREFIX));
+        }
+        let response_plan = AgentRuntimeToolPlan {
+            response: "已经完成".to_string(),
+            ..plan.clone()
+        };
+        assert!(
+            !is_agent_runtime_autonomous_supervisor_request_bound_manifest_wait_plan(
+                &response_plan
+            )
+        );
+    }
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs
index 94616c992..b87a1e16a 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs
@@ -845,8 +845,17 @@ pub(in crate::agent) fn static_delegate_completion_blocker_at_locked(
     agent_id: &str,
     run_id: &str,
 ) -> Option<AgentRuntimeToolObservation> {
-    if agent_id != GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
-        return None;
+    match static_delegate_parent_can_manage_receipts_at(root, agent_id, run_id) {
+        Ok(true) => {}
+        Ok(false) => return None,
+        Err(error) => {
+            return Some(AgentRuntimeToolObservation {
+                tool: "runtime.delegate_receipts".to_string(),
+                status: "blocked".to_string(),
+                summary: "无法确认当前父 Run 的专业 Agent 委派权限，不能收束当前任务".to_string(),
+                detail: Some(redact_agent_runtime_project_paths(root, &error, 500)),
+            });
+        }
     }
     match static_delegate_completion_barrier_at(root, agent_id, run_id) {
         Ok(barrier) if barrier.is_clear() => None,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_action_batch.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_action_batch.rs
index 905b8038e..80108596a 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_action_batch.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_action_batch.rs
@@ -473,6 +473,13 @@ pub(crate) async fn prepare_game_creator_agent_runtime_provider_action_batch(
             None,
         )?;
         let command_id = game_creator_agent_runtime_tool_command_id(action.tool.trim());
+        let art_director_canvas_only_block =
+            agent_runtime_autonomous_art_director_canvas_only_action_block(
+                &runtime.agent_id,
+                task,
+                action.tool.trim(),
+            )
+            .map(|observation| AgentRuntimeToolPolicyBlock::Denied(observation.summary));
         let game_chat_art_scope_block = game_chat_delegated_art_agent_input_mutation_block(
             root,
             &runtime.agent_id,
@@ -493,7 +500,8 @@ pub(crate) async fn prepare_game_creator_agent_runtime_provider_action_batch(
         } else {
             None
         };
-        let local_policy_block = game_chat_art_scope_block
+        let local_policy_block = art_director_canvas_only_block
+            .or(game_chat_art_scope_block)
             .or(isolated_scope_block)
             .or_else(|| {
                 command_id
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
index 0ed74be4c..d42d96c2a 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
@@ -9,6 +9,63 @@ enum AgentBackgroundContextMode {
     FinalReply,
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(in crate::agent) struct AgentRuntimeToolPlanRequestSnapshot {
+    pub(super) supervisor_manifest_dag_in_progress: bool,
+}
+
+fn parse_manifest_seed_task_counts(detail: &str) -> Option<[u64; 6]> {
+    let counts = detail
+        .lines()
+        .find_map(|line| line.strip_prefix("seedTaskCounts: "))?;
+    let mut parsed = std::collections::BTreeMap::new();
+    for field in counts.split_ascii_whitespace() {
+        let (key, value) = field.split_once('=')?;
+        if parsed.insert(key, value.parse::<u64>().ok()?).is_some() {
+            return None;
+        }
+    }
+    let completed = *parsed.get("completed")?;
+    let running = *parsed.get("running")?;
+    let pending = *parsed.get("pending")?;
+    let waiting = *parsed.get("waiting")?;
+    let failed = *parsed.get("failed")?;
+    let total = *parsed.get("total")?;
+    if parsed.len() != 6
+        || completed
+            .checked_add(running)?
+            .checked_add(pending)?
+            .checked_add(waiting)?
+            .checked_add(failed)?
+            != total
+    {
+        return None;
+    }
+    Some([completed, running, pending, waiting, failed, total])
+}
+
+fn prompt_observations_report_manifest_dag_in_progress(
+    observations: &[AgentRuntimeToolObservation],
+) -> bool {
+    let Some(observation) = observations
+        .iter()
+        .rfind(|observation| observation.tool == "task.list")
+    else {
+        return false;
+    };
+    if observation.status != "ok" || observation.summary != "已读取 manifest 任务图" {
+        return false;
+    }
+    let Some([_completed, running, _pending, _waiting, _failed, total]) = observation
+        .detail
+        .as_deref()
+        .and_then(parse_manifest_seed_task_counts)
+    else {
+        return false;
+    };
+    total > 0 && running > 0
+}
+
 #[cfg(target_os = "linux")]
 fn provider_command_exec_contract() -> &'static str {
     "command.exec 使用 {\"program\":\"受信任 PATH 中的裸可执行名\",\"args\":[\"逐项 argv\"],\"cwd\":\"可选项目内相对目录\",\"timeoutSeconds\":120}；Linux 命令固定运行在 bubblewrap workspace-write、network-disabled 沙箱内，允许 bash -lc、管道、重定向和项目脚本，但不接受环境变量、宿主 executable 路径、mount 或网络策略输入"
@@ -72,7 +129,16 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
     observations: &[AgentRuntimeToolObservation],
     loop_index: usize,
     mcp_catalog: &GameCreatorMcpCatalog,
-) -> Result<(GameCreatorLlmConfig, String, LlmRunRequest, String), String> {
+) -> Result<
+    (
+        GameCreatorLlmConfig,
+        String,
+        LlmRunRequest,
+        String,
+        AgentRuntimeToolPlanRequestSnapshot,
+    ),
+    String,
+> {
     let effective_task = autonomous_effective_root_task_at(root, agent_id, run_id, task)?;
     let (llm, config_path, context, repository_context_fingerprint, prompt_observations) =
         build_game_creator_background_agent_context(
@@ -113,6 +179,11 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
     let goal_contract_participant = root_control_authority || root_goal_contract_context != "null";
     let autonomous_game_build =
         tool_policy.run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD;
+    let request_snapshot = AgentRuntimeToolPlanRequestSnapshot {
+        supervisor_manifest_dag_in_progress: autonomous_game_build
+            && agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+            && prompt_observations_report_manifest_dag_in_progress(&prompt_observations),
+    };
     let autonomous_project_verify_available =
         !autonomous_game_build || agent_runtime_autonomous_project_verify_available(root);
     let mut allowed_tools = tool_policy.allowed_tools.clone();
@@ -215,7 +286,7 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
             "file.list 使用 {{\"path\":\"\"}}，path 为空字符串时列出项目摘要；file.read 使用 {{\"path\":\"项目内相对路径\",\"startLine\":1,\"maxLines\":120}}；file.write 使用 {{\"path\":\"项目内相对路径\",\"content\":\"完整文件内容\"}}；file.patch 使用 {{\"path\":\"项目内相对路径\",\"oldText\":\"必须精确匹配的原文\",\"newText\":\"替换后的文本\",\"expectedReplacements\":1}}；file.delete 使用 {{\"path\":\"项目内相对路径\"}}，只删除项目内普通文件，不删除目录或任何 .agent 控制面文件。\n",
             "task.create 使用 {{\"taskId\":null,\"title\":\"任务标题\",\"group\":\"design|art|code|balance|audio|publishing\",\"role\":\"角色名\",\"dependencies\":[],\"artifacts\":[],\"acceptanceCriteria\":[\"验收标准\"],\"status\":\"pending|running|waiting-for-confirmation|completed|failed\"}}，需要自定义 taskId 时把 null 替换为合法 ID；task.update 使用 {{\"taskId\":\"manifest taskId\",\"status\":\"pending|running|waiting-for-confirmation|completed|failed\"}}；command.run_limited 使用 {{\"commandId\":\"game.static_smoke\"}}。\n",
             "canvas.asset_generate 使用 {{\"prompt\":\"图片描述\",\"outputPath\":null,\"aspectRatio\":null,\"imageSize\":null,\"assetKind\":null,\"assetLabel\":null,\"replaceExisting\":false}}；需要指定时，aspectRatio 只允许 1:1|2:3|3:2|9:16|16:9，imageSize 只允许 0.5K|1K|2K，assetKind 只允许 {canvas_asset_kind_catalog}。replaceExisting 只能在带 repairOfDelegationId 的唯一返工委派中设为 true，普通生成必须为 false，并通过配置的 External Editor API 同时写入画布、同名素材库目录和本地 assets。\n",
-            "blackboard.write 使用 {{\"title\":\"标题\",\"content\":\"要共享给所有 Agent 的稳定结论\"}}；agent.message 使用 {{\"agentId\":\"目标 taskId\",\"content\":\"给目标 Agent 的定向消息\"}}；agent.delegate 使用 {{\"agentId\":\"目标 taskId\",\"task\":\"要委派的后台任务\",\"acceptanceCriteria\":[\"可核对的语义验收条件\"],\"expectedArtifacts\":[],\"repairOfDelegationId\":null,\"runId\":null}}，expectedArtifacts 无产物时传空数组且不接受 glob；返工时 repairOfDelegationId 指向已认领原 delivery 且 runId 必须为 null；agent.schedule_ready 使用 {{\"limit\":1}}；agent.route_manifest 使用 {{\"strategy\":\"audit-existing-first|use-existing-art|generate-missing-art\",\"intentSummary\":\"Supervisor 自行理解的用户意图，仅 Supervisor 提交\",\"missingAssetSlots\":[]}}；Supervisor 必须自行概括非空 intentSummary，并以 audit-existing-first 提交执行安全策略；code-prototype 先 asset.list 后只能按权威缺口提交 use-existing-art 或 generate-missing-art，且无需提交 intentSummary；agent.run_status 使用 {{\"agentId\":null,\"scope\":\"all\",\"delegationId\":null}}，指定目标 Agent 或已认领 delegation 时把对应 null 替换为实际 ID；Project Supervisor 传 delegationId 时读取当前父 run 的未截断权威返工合同。\n",
+            "blackboard.write 使用 {{\"title\":\"标题\",\"content\":\"要共享给所有 Agent 的稳定结论\"}}；agent.message 使用 {{\"agentId\":\"目标 taskId\",\"content\":\"给目标 Agent 的定向消息\"}}；agent.delegate 使用 {{\"agentId\":\"目标 taskId\",\"task\":\"要委派的后台任务\",\"acceptanceCriteria\":[\"可核对的语义验收条件\"],\"expectedArtifacts\":[],\"repairOfDelegationId\":null,\"runId\":null}}，expectedArtifacts 无产物时传空数组且不接受 glob；返工时 repairOfDelegationId 指向已认领原 delivery 且 runId 必须为 null；agent.schedule_ready 使用 {{\"limit\":1}}；agent.route_manifest 使用 {{\"strategy\":\"audit-existing-first|use-existing-art|generate-missing-art\",\"intentSummary\":\"Supervisor 自行理解的用户意图，仅 Supervisor 提交\",\"missingAssetSlots\":[]}}；Supervisor 必须自行概括非空 intentSummary，并以 audit-existing-first 提交执行安全策略；code-prototype 先 asset.list 后只能按权威缺口提交 use-existing-art 或 generate-missing-art，且无需提交 intentSummary；agent.run_status 使用 {{\"agentId\":null,\"scope\":\"all\",\"delegationId\":null}}，指定目标 Agent 或已认领 delegation 时把对应 null 替换为实际 ID；当前可信父 Run 传 delegationId 时读取自己已认领的未截断权威返工合同。\n",
             "当前请求中的每个 MCP 工具都以单独的动态函数广告；必须从实际广告函数中选择，并严格按该函数的 input schema 提交 arguments.input。server、tool、catalogFingerprint 和 toolFingerprint 由 Runtime 注入，禁止构造目录外包装调用。\n",
             "只有 conversation.read、asset.list、project.index、project.checkpoint、task.list、preview.start 的 arguments.input 使用空对象 {{}}；其他函数必须提交实际广告 schema 的全部 required 字段。如果已有观察足够，必须调用 respond_to_user 交付最终回复。"
         ),
@@ -392,7 +463,13 @@ pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
         &llm,
         true,
     )?;
-    Ok((llm, config_path, request, repository_context_fingerprint))
+    Ok((
+        llm,
+        config_path,
+        request,
+        repository_context_fingerprint,
+        request_snapshot,
+    ))
 }
 
 pub(in crate::agent) fn build_game_creator_agent_background_final_reply_request(
@@ -571,12 +648,13 @@ fn build_game_creator_background_agent_context(
 #[cfg(test)]
 mod tests {
     use crate::agent::{
-        cancel_game_creator_agent_runtime_task_at,
+        autonomous_manifest_dag_in_progress_at, cancel_game_creator_agent_runtime_task_at,
         persist_game_chat_supervisor_workflow_decision_at,
         start_game_creator_supervisor_background_task_for_session_at,
         try_acquire_game_creator_agent_runtime_task_lock,
         GAME_CHAT_WORKFLOW_STRATEGY_AUDIT_EXISTING_FIRST,
     };
+    use crate::{update_manifest_task_status_at, GameCreationAppTaskStatus};
 
     use super::{
         agent_runtime_root_source_at, append_unique_game_creator_agent_runtime_pending_task,
@@ -590,6 +668,7 @@ mod tests {
         start_game_creator_agent_runtime_task_at, AgentRuntimeGoalContractAcceptanceNodeDraft,
         AgentRuntimeGoalContractDraft, AgentRuntimeTaskLink, AgentRuntimeToolObservation,
         AgentRuntimeToolPlan, GameCreatorMcpCatalog, GameCreatorMcpCatalogTool,
+        AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT,
         AGENT_RUNTIME_COMPLETION_BLOCKER_TOOL_PLAN_PROTOCOL, AGENT_RUNTIME_RESPOND_FUNCTION_NAME,
         AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD, AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
         AGENT_RUNTIME_SUPERVISOR_GAME_CHAT_SOURCE, AGENT_RUNTIME_SUPERVISOR_GUI_SOURCE,
@@ -672,7 +751,7 @@ mod tests {
             summary: "结构化计划更新被 Runtime 拒绝".to_string(),
             detail: Some("计划状态回退".to_string()),
         };
-        let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -783,7 +862,7 @@ mod tests {
             servers: Vec::new(),
             tools: Vec::new(),
         };
-        let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             agent_id,
             &state.session_id,
@@ -841,7 +920,7 @@ mod tests {
             servers: Vec::new(),
             tools: Vec::new(),
         };
-        let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -910,17 +989,18 @@ mod tests {
             vec!["核对预加载说明".to_string()],
         )
         .expect("start supervisor runtime state");
-        let (_, _, supervisor_request, _) = build_game_creator_agent_background_tool_plan_request(
-            &root,
-            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
-            &supervisor_state.session_id,
-            &supervisor_state.run_id,
-            &supervisor_state.current_task,
-            &[],
-            0,
-            &catalog,
-        )
-        .expect("build supervisor planning request");
+        let (_, _, supervisor_request, _, _) =
+            build_game_creator_agent_background_tool_plan_request(
+                &root,
+                GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+                &supervisor_state.session_id,
+                &supervisor_state.run_id,
+                &supervisor_state.current_task,
+                &[],
+                0,
+                &catalog,
+            )
+            .expect("build supervisor planning request");
         let supervisor_system_prompt = &supervisor_request.messages[0].content;
         let supervisor_prompt = &supervisor_request.messages[1].content;
         let supervisor_identity_contract =
@@ -1065,7 +1145,7 @@ mod tests {
             vec!["核对普通说明".to_string()],
         )
         .expect("start ordinary runtime state");
-        let (_, _, ordinary_request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, ordinary_request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             "code-prototype",
             &ordinary_state.session_id,
@@ -1194,7 +1274,7 @@ mod tests {
             vec!["核对 MCP 调用协议".to_string()],
         )
         .expect("start runtime state");
-        let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             "code-prototype",
             &state.session_id,
@@ -1348,7 +1428,7 @@ mod tests {
             servers: Vec::new(),
             tools: Vec::new(),
         };
-        let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
             &state.session_id,
@@ -1370,6 +1450,135 @@ mod tests {
         assert!(!user_prompt.contains("Graph reset 才保留"));
     }
 
+    #[test]
+    fn supervisor_request_snapshot_preserves_prompt_visible_running_sibling_after_manifest_failure()
+    {
+        let temporary =
+            crate::tests::canonical_test_tempdir("provider-running-sibling-after-failure-");
+        let root = temporary.path().join("project");
+        init_local_game_project_at(
+            &root,
+            "running-sibling-after-failure",
+            "失败兄弟任务后的活跃观察绑定测试",
+        )
+        .expect("project init");
+        let _config_guard = crate::tests::write_test_local_config("{}".to_string());
+        let run_id = "provider-stale-manifest-observation-run";
+        bind_game_creator_agent_runtime_run_profile_at(
+            &root,
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            run_id,
+            AGENT_RUNTIME_SUPERVISOR_GUI_SOURCE,
+            Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+            None,
+        )
+        .expect("bind autonomous supervisor");
+        let state = start_game_creator_agent_runtime_task_at(
+            &root,
+            GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+            "生成一版可玩的游戏",
+            run_id,
+            AGENT_RUNTIME_SUPERVISOR_GUI_SOURCE,
+            "等待专业任务图完成",
+            vec!["读取专业任务图状态".to_string()],
+        )
+        .expect("start autonomous supervisor");
+        for task_id in [
+            "design-director",
+            "design-foundation",
+            "balance-director",
+            "balance-seed",
+            "art-director",
+            "art-polish",
+            "audio-director",
+        ] {
+            update_manifest_task_status_at(&root, task_id, GameCreationAppTaskStatus::Completed)
+                .expect("complete manifest fixture task");
+        }
+        update_manifest_task_status_at(&root, "art-asset-plan", GameCreationAppTaskStatus::Failed)
+            .expect("fail manifest fixture task");
+        update_manifest_task_status_at(
+            &root,
+            "audio-asset-plan",
+            GameCreationAppTaskStatus::Running,
+        )
+        .expect("keep sibling manifest fixture task running");
+        assert!(
+            !autonomous_manifest_dag_in_progress_at(&root)
+                .expect("read failure-closed live DAG predicate"),
+            "the regression requires a failed task to close the live predicate while a sibling remains running"
+        );
+        let mut observations = vec![
+            AgentRuntimeToolObservation {
+                tool: "task.list".to_string(),
+                status: "ok".to_string(),
+                summary: "已读取 manifest 任务图".to_string(),
+                detail: Some(
+                    "readyTaskIds: (none)\nseedTaskCounts: completed=7 running=1 pending=7 waiting=0 failed=1 total=16\ntaskCounts: completed=7 running=1 pending=7 waiting=0 failed=1 total=16"
+                        .to_string(),
+                ),
+            },
+            AgentRuntimeToolObservation {
+                tool: "agent.run_status".to_string(),
+                status: "ok".to_string(),
+                summary: "已读取 2 个 Agent 状态".to_string(),
+                detail: Some(
+                    "agentId: project-supervisor\nstatus: running\n\nagentId: code-prototype\nstatus: running"
+                        .to_string(),
+                ),
+            },
+        ];
+        let catalog = GameCreatorMcpCatalog {
+            fingerprint: String::new(),
+            servers: Vec::new(),
+            tools: Vec::new(),
+        };
+
+        let (_, _, request, _, request_snapshot) =
+            build_game_creator_agent_background_tool_plan_request(
+                &root,
+                GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+                &state.session_id,
+                &state.run_id,
+                &state.current_task,
+                &observations,
+                AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 1,
+                &catalog,
+            )
+            .expect("build request from the provider-visible running sibling observation");
+
+        assert!(request.messages[1].content.contains(
+            "seedTaskCounts: completed=7 running=1 pending=7 waiting=0 failed=1 total=16"
+        ));
+        assert!(request_snapshot.supervisor_manifest_dag_in_progress);
+
+        observations.push(AgentRuntimeToolObservation {
+            tool: "task.list".to_string(),
+            status: "ok".to_string(),
+            summary: "已读取 manifest 任务图".to_string(),
+            detail: Some(
+                "readyTaskIds: (none)\nseedTaskCounts: completed=15 running=0 pending=0 waiting=0 failed=1 total=16\ntaskCounts: completed=15 running=0 pending=0 waiting=0 failed=1 total=16"
+                    .to_string(),
+            ),
+        });
+        let (_, _, _, _, settled_request_snapshot) =
+            build_game_creator_agent_background_tool_plan_request(
+                &root,
+                GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+                &state.session_id,
+                &state.run_id,
+                &state.current_task,
+                &observations,
+                AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT + 2,
+                &catalog,
+            )
+            .expect("build successor request from the terminal provider-visible observation");
+        assert!(
+            !settled_request_snapshot.supervisor_manifest_dag_in_progress,
+            "a successor request must not inherit an older active observation"
+        );
+    }
+
     #[test]
     fn game_chat_code_prototype_receives_the_persisted_supervisor_workflow_authority() {
         let temporary = crate::tests::canonical_test_tempdir("provider-game-chat-authority-");
@@ -1432,7 +1641,7 @@ mod tests {
             servers: Vec::new(),
             tools: Vec::new(),
         };
-        let (_, _, request, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
             &root,
             "code-prototype",
             &code_state.session_id,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_tool_plan.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_tool_plan.rs
index 3754f1f80..2229daef8 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_tool_plan.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_tool_plan.rs
@@ -174,12 +174,16 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
     let (run_profile, _) =
         agent_runtime_run_profile_identity_at(root, agent_id, run_id, None, None)?;
     let mcp_catalog = read_game_creator_mcp_catalog_at(root).await?;
-    let mut built_request = {
+    let (mut built_request, mut supervisor_manifest_dag_in_progress_at_request) = {
         let _lock = acquire_game_creator_agent_provider_plan_project_write_lock_with_wait(
             root,
             "runtime.provider_request.build.tool_plan",
         )?;
-        build_game_creator_agent_background_tool_plan_request(
+        let live_manifest_dag_in_progress_before = run_profile
+            == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
+            && agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+            && autonomous_manifest_dag_in_progress_at(root)?;
+        let request = build_game_creator_agent_background_tool_plan_request(
             root,
             agent_id,
             session_id,
@@ -188,7 +192,15 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
             observations,
             loop_index,
             &mcp_catalog,
-        )?
+        )?;
+        let live_manifest_dag_in_progress_after = run_profile
+            == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
+            && agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+            && autonomous_manifest_dag_in_progress_at(root)?;
+        let request_bound_manifest_dag_in_progress = live_manifest_dag_in_progress_before
+            || live_manifest_dag_in_progress_after
+            || request.4.supervisor_manifest_dag_in_progress;
+        (request, request_bound_manifest_dag_in_progress)
     };
     let mut estimated_input_tokens = estimate_game_creator_llm_request_tokens(&built_request.2)?;
     let mut compaction = None;
@@ -224,12 +236,19 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
                 return Ok(RequestedAgentRuntimeToolPlanOutcome::Superseded);
             }
         }
-        built_request = {
+        (
+            built_request,
+            supervisor_manifest_dag_in_progress_at_request,
+        ) = {
             let _lock = acquire_game_creator_agent_provider_plan_project_write_lock_with_wait(
                 root,
                 "runtime.provider_request.rebuild.tool_plan",
             )?;
-            build_game_creator_agent_background_tool_plan_request(
+            let live_manifest_dag_in_progress_before = run_profile
+                == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
+                && agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+                && autonomous_manifest_dag_in_progress_at(root)?;
+            let request = build_game_creator_agent_background_tool_plan_request(
                 root,
                 agent_id,
                 session_id,
@@ -238,7 +257,15 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
                 observations,
                 loop_index,
                 &mcp_catalog,
-            )?
+            )?;
+            let live_manifest_dag_in_progress_after = run_profile
+                == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD
+                && agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID
+                && autonomous_manifest_dag_in_progress_at(root)?;
+            let request_bound_manifest_dag_in_progress = live_manifest_dag_in_progress_before
+                || live_manifest_dag_in_progress_after
+                || request.4.supervisor_manifest_dag_in_progress;
+            (request, request_bound_manifest_dag_in_progress)
         };
         estimated_input_tokens = estimate_game_creator_llm_request_tokens(&built_request.2)?;
         if estimated_input_tokens > built_request.0.auto_compact_token_limit {
@@ -275,7 +302,7 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
             applied_steer_cursor,
         )?
     };
-    let (llm, config_path, mut request, repository_context_fingerprint) = built_request;
+    let (llm, config_path, mut request, repository_context_fingerprint, _) = built_request;
     let auto_compact_token_limit = llm.auto_compact_token_limit;
     let format_repair_attempts = if run_profile == AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD {
         AGENT_RUNTIME_AUTONOMOUS_TOOL_PLAN_FORMAT_REPAIR_ATTEMPTS
@@ -471,6 +498,17 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
                         error,
                     )
                 })?;
+                validate_agent_runtime_autonomous_art_director_canvas_only_plan(
+                    agent_id,
+                    task,
+                    &parsed.plan,
+                )
+                .map_err(|error| {
+                    AgentRuntimeToolPlanProtocolError::new(
+                        AgentRuntimeToolPlanProtocolErrorKind::PlanSemantics,
+                        error,
+                    )
+                })?;
                 if autonomous_scaffold_repair_active
                     && source_payload.max_field_chars
                         > AGENT_RUNTIME_AUTONOMOUS_SCAFFOLD_SOURCE_MAX_CHARS
@@ -534,6 +572,7 @@ pub(in crate::agent) async fn request_game_creator_agent_background_tool_plan_at
                     observations,
                     &parsed.plan,
                     supervisor_requires_delegated_repair,
+                    supervisor_manifest_dag_in_progress_at_request && repair_attempt == 0,
                 ) {
                     Ok(()) => Ok((parsed, source_payload)),
                     Err(error) => Err(AgentRuntimeToolPlanProtocolError::new(
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/run_status_observation.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/run_status_observation.rs
index 2a150f911..7ac22121c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/run_status_observation.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/run_status_observation.rs
@@ -12,7 +12,7 @@ pub(in crate::agent) fn mark_supervisor_delivery_claims_observed_for_pending_act
         observed_delegate_receipt_ids_from_run_status(observation.detail.as_deref())?;
     let observed_isolated_groups =
         observed_isolated_join_group_ids_from_run_status(observation.detail.as_deref())?;
-    if pending.agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
+    if static_delegate_parent_can_manage_receipts_at(root, &pending.agent_id, &pending.run_id)? {
         mark_static_delegate_claim_observed_for_receipts_at(
             root,
             &pending.agent_id,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/structured_plan.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/structured_plan.rs
index d938862f3..0617863b5 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/structured_plan.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/structured_plan.rs
@@ -120,8 +120,9 @@ pub(crate) fn apply_agent_runtime_plan_update(
     update: &AgentRuntimePlanUpdate,
 ) -> Result<bool, String> {
     let update = sanitize_agent_runtime_plan_update(update)?;
+    let had_structured_plan = agent_runtime_has_structured_plan(runtime);
     let mut terminal_steps = std::collections::BTreeMap::new();
-    if agent_runtime_has_structured_plan(runtime) {
+    if had_structured_plan {
         for step in &runtime.plan_steps {
             if matches!(
                 step.status.as_str(),
@@ -155,10 +156,12 @@ pub(crate) fn apply_agent_runtime_plan_update(
         .plan_steps
         .iter()
         .filter(|step| {
-            matches!(
-                step.status.as_str(),
-                AGENT_RUNTIME_PLAN_STATUS_COMPLETED | AGENT_RUNTIME_PLAN_STATUS_FAILED
-            ) && !incoming_titles.contains(step.title.as_str())
+            had_structured_plan
+                && matches!(
+                    step.status.as_str(),
+                    AGENT_RUNTIME_PLAN_STATUS_COMPLETED | AGENT_RUNTIME_PLAN_STATUS_FAILED
+                )
+                && !incoming_titles.contains(step.title.as_str())
         })
         .map(|step| (step.title.clone(), step.status.clone()))
         .collect::<Vec<_>>();
@@ -175,7 +178,7 @@ pub(crate) fn apply_agent_runtime_plan_update(
         ));
     }
 
-    let unchanged = agent_runtime_has_structured_plan(runtime)
+    let unchanged = had_structured_plan
         && runtime.plan_explanation == update.explanation
         && runtime.plan_steps.len() == merged.len()
         && runtime
@@ -190,11 +193,15 @@ pub(crate) fn apply_agent_runtime_plan_update(
     }
 
     let now = unix_timestamp();
-    let previous_steps = runtime
-        .plan_steps
-        .iter()
-        .map(|step| (step.title.clone(), step.clone()))
-        .collect::<std::collections::BTreeMap<_, _>>();
+    let previous_steps = if had_structured_plan {
+        runtime
+            .plan_steps
+            .iter()
+            .map(|step| (step.title.clone(), step.clone()))
+            .collect::<std::collections::BTreeMap<_, _>>()
+    } else {
+        std::collections::BTreeMap::new()
+    };
     runtime.plan_steps = merged
         .into_iter()
         .enumerate()
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/game_chat_fast_path.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/game_chat_fast_path.rs
index 03750a4dc..08522fbf4 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/game_chat_fast_path.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/game_chat_fast_path.rs
@@ -165,6 +165,22 @@ fn game_chat_fast_path_action(tool: &str, input: serde_json::Value) -> AgentRunt
     }
 }
 
+fn game_chat_fast_path_safe_default_repair_plan(
+    delivery: &StaticDelegateDeliveryRecord,
+) -> AgentRuntimeToolPlan {
+    game_chat_fast_path_action(
+        "agent.delegate",
+        serde_json::json!({
+            "agentId": delivery.target_agent_id,
+            "task": "不要追问用户；采用原回执中已授权的安全默认值，严格按原合同完成唯一一次返工。",
+            "acceptanceCriteria": delivery.acceptance_criteria,
+            "expectedArtifacts": delivery.expected_artifacts,
+            "repairOfDelegationId": delivery.delegation_id,
+            "runId": null,
+        }),
+    )
+}
+
 fn game_chat_fast_path_fallback_write_plan_for_root(
     root: &Path,
     task: &str,
@@ -2231,6 +2247,50 @@ pub(crate) fn game_chat_fast_path_plan_at(
             }
         }
         "code-prototype" => {
+            if !static_delegate_parent_can_manage_receipts_at(
+                root,
+                &runtime.agent_id,
+                &runtime.run_id,
+            )? {
+                return Err(
+                    "game-chat code-prototype 父 Run 身份链不可信，拒绝管理专业美术回执"
+                        .to_string(),
+                );
+            }
+            let delegate_barrier =
+                static_delegate_completion_barrier_at(root, &runtime.agent_id, &runtime.run_id)?;
+            if delegate_barrier.ready_unclaimed_count > 0 {
+                return Ok(Some(game_chat_fast_path_action(
+                    "agent.run_status",
+                    serde_json::json!({
+                        "agentId": null,
+                        "scope": "self",
+                        "delegationId": null,
+                    }),
+                )));
+            }
+            if delegate_barrier.unobserved_claim_count > 0 {
+                return Err(
+                    "game-chat 专业美术回执 claim 尚未由原 agent.run_status action 完整观察；拒绝发起新的 Provider 请求"
+                        .to_string(),
+                );
+            }
+            if let Some(error) = game_chat_code_parent_terminal_delivery_error_at(
+                root,
+                &runtime.agent_id,
+                &runtime.run_id,
+            )? {
+                return Err(error);
+            }
+            if let Some(delivery) = game_chat_code_parent_safe_default_repair_delivery_at(
+                root,
+                &runtime.agent_id,
+                &runtime.run_id,
+            )? {
+                return Ok(Some(game_chat_fast_path_safe_default_repair_plan(
+                    &delivery,
+                )));
+            }
             if agent_runtime_has_structured_plan(runtime)
                 && runtime
                     .plan_steps
@@ -2309,8 +2369,11 @@ pub(crate) fn game_chat_fast_path_plan_at(
             {
                 return Ok(None);
             }
-            if runtime.loop_iteration > 1
-                || budget.elapsed_seconds >= GAME_CHAT_FIRST_PLAYABLE_SOFT_BUDGET_SECONDS
+            if budget.elapsed_seconds >= GAME_CHAT_FIRST_PLAYABLE_SOFT_BUDGET_SECONDS
+                || (runtime.loop_iteration > 1
+                    && current_route.is_some()
+                    && game_chat_fast_path_has_visual_asset(root, "art-asset-plan")
+                    && game_chat_fast_path_art_slice_paths(root).is_ok())
             {
                 return Ok(Some(game_chat_fast_path_fallback_write_plan_for_budget_at(
                     root, &budget, task,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs
index e6389adbd..f868e2241 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs
@@ -992,35 +992,59 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
                 && static_delegate_completion_blocker_at(&root, &agent_id, &runtime.run_id)
                     .is_none();
             if autonomous_manifest_parent_can_wait {
+                let manifest_state_before_schedule = match autonomous_manifest_dag_state_at(&root) {
+                    Ok(value) => value,
+                    Err(error) => {
+                        return fail_game_creator_agent_background_context_at(
+                            &root,
+                            &agent_id,
+                            &session_id,
+                            runtime,
+                            &format!("读取自主构建 manifest 等待屏障失败：{error}"),
+                        );
+                    }
+                };
                 // 已登记但损坏的派生视觉需要先由父 Run 规划修复，因此此时不再调度新的
                 // manifest child；但已经持久化并运行的 child 仍是当前 DAG 的活跃工作，
                 // 父 Run 必须继续等待，不能提前落入 game-chat fixed-graph-stalled。
-                let scheduled_ready_tasks =
-                    if autonomous_registered_derived_visuals_block_manifest_scheduler_at(
+                // 同理，已有失败任务时只能等待已在途 child 收束或立即安全失败，不能再
+                // 启动新的 pending sibling 并用它遮蔽原始失败。
+                let manifest_scheduler_blocked = matches!(
+                    &manifest_state_before_schedule,
+                    AutonomousManifestDagState::Completed
+                        | AutonomousManifestDagState::Failed { .. }
+                )
+                    || autonomous_registered_derived_visuals_block_manifest_scheduler_at(
                         &root, &runtime,
+                    );
+                let scheduled_ready_tasks = if manifest_scheduler_blocked {
+                    Vec::new()
+                } else {
+                    match schedule_autonomous_game_build_ready_tasks_at(
+                        &root,
+                        &agent_id,
+                        &runtime.run_id,
+                        3,
                     ) {
-                        Vec::new()
-                    } else {
-                        match schedule_autonomous_game_build_ready_tasks_at(
-                            &root,
-                            &agent_id,
-                            &runtime.run_id,
-                            3,
-                        ) {
-                            Ok(tasks) => tasks,
-                            Err(error) => {
-                                return fail_game_creator_agent_background_context_at(
-                                    &root,
-                                    &agent_id,
-                                    &session_id,
-                                    runtime,
-                                    &format!("调度自主构建 manifest 任务失败：{error}"),
-                                );
-                            }
+                        Ok(tasks) => tasks,
+                        Err(error) => {
+                            return fail_game_creator_agent_background_context_at(
+                                &root,
+                                &agent_id,
+                                &session_id,
+                                runtime,
+                                &format!("调度自主构建 manifest 任务失败：{error}"),
+                            );
                         }
-                    };
-                let manifest_in_progress = if scheduled_ready_tasks.is_empty() {
-                    match autonomous_manifest_dag_in_progress_at(&root) {
+                    }
+                };
+                let manifest_state = if matches!(
+                    &manifest_state_before_schedule,
+                    AutonomousManifestDagState::Failed { .. }
+                ) {
+                    manifest_state_before_schedule
+                } else if scheduled_ready_tasks.is_empty() {
+                    match autonomous_manifest_dag_state_at(&root) {
                         Ok(value) => value,
                         Err(error) => {
                             return fail_game_creator_agent_background_context_at(
@@ -1033,9 +1057,17 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
                         }
                     }
                 } else {
-                    true
+                    AutonomousManifestDagState::InProgress
                 };
-                if manifest_in_progress {
+                let manifest_parent_must_wait = matches!(
+                    &manifest_state,
+                    AutonomousManifestDagState::InProgress
+                        | AutonomousManifestDagState::Failed {
+                            has_active_children: true,
+                            ..
+                        }
+                );
+                if manifest_parent_must_wait {
                     let blocker =
                         autonomous_game_build_completion_blocker_at_locked(&root, &runtime)
                             .unwrap_or_else(|| AgentRuntimeToolObservation {
@@ -1064,6 +1096,21 @@ async fn run_game_creator_agent_background_task_pass_without_deadline(
                     }
                     return AgentBackgroundTaskOutcome::WaitingForManifestTasks;
                 }
+                if let AutonomousManifestDagState::Failed {
+                    failed_task_ids, ..
+                } = manifest_state
+                {
+                    return fail_game_creator_agent_background_context_at(
+                        &root,
+                        &agent_id,
+                        &session_id,
+                        runtime,
+                        &format!(
+                            "自主构建 manifest 专业任务失败；failedTaskIds={}",
+                            failed_task_ids.join(",")
+                        ),
+                    );
+                }
             }
             match prepare_game_chat_single_round_convergence_at(
                 &root,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop_tests.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop_tests.rs
index 67856863f..cc12e1f9b 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop_tests.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop_tests.rs
@@ -202,11 +202,7 @@ fn queue_game_chat_fast_path_child(
     )
 }
 
-fn persist_game_chat_main_asset_audit_and_route(
-    root: &Path,
-    root_state: &AgentRuntimeState,
-    main_state: &mut AgentRuntimeState,
-) {
+fn persist_game_chat_main_asset_audit(root: &Path, main_state: &mut AgentRuntimeState) {
     assert_eq!(main_state.agent_id, "code-prototype");
     main_state
         .recent_tool_calls
@@ -225,6 +221,14 @@ fn persist_game_chat_main_asset_audit_and_route(
         .expect("persist game-chat main asset audit task");
     write_game_creator_agent_runtime_state(root, main_state)
         .expect("persist game-chat main asset audit runtime");
+}
+
+fn persist_game_chat_main_asset_audit_and_route(
+    root: &Path,
+    root_state: &AgentRuntimeState,
+    main_state: &mut AgentRuntimeState,
+) {
+    persist_game_chat_main_asset_audit(root, main_state);
     persist_game_chat_supervisor_workflow_decision_at(
         root,
         &root_state.agent_id,
@@ -369,6 +373,49 @@ fn game_chat_main_art_child_fixture(
     (main, child, delegation_id)
 }
 
+fn claim_game_chat_main_ready_deliveries_with_run_status(
+    root: &Path,
+    main: &AgentRuntimeState,
+) -> (AgentRuntimePendingToolAction, AgentRuntimeToolObservation) {
+    let plan = game_chat_fast_path_plan_at(root, main, &main.current_task, unix_timestamp())
+        .expect("build deterministic game-chat receipt claim plan")
+        .expect("ready game-chat delivery must produce a deterministic claim plan");
+    assert_eq!(plan.actions.len(), 1);
+    assert_eq!(plan.actions[0].tool, "agent.run_status");
+    let action = plan.actions[0].clone();
+    let revision = read_game_creator_agent_runtime_project_revision(root)
+        .expect("read game-chat receipt claim revision");
+    let repository_context_fingerprint = build_repository_startup_context_at(root)
+        .expect("build game-chat receipt claim repository context")
+        .fingerprint;
+    let pending = build_game_creator_agent_runtime_pending_tool_action(
+        root,
+        main,
+        &main.current_task,
+        &plan,
+        &[],
+        &revision,
+        &repository_context_fingerprint,
+        &action,
+        0,
+        AGENT_RUNTIME_ACTION_EXECUTION_MODE_AUTO,
+        AGENT_RUNTIME_PENDING_ACTION_STATUS_EXECUTING,
+        None,
+    )
+    .expect("build game-chat receipt claim pending action");
+    let observation = observe_agent_runtime_run_status(
+        root,
+        &main.agent_id,
+        &main.run_id,
+        Some(&pending.action_id),
+        &action.input,
+    );
+    assert_eq!(observation.status, "ok", "{observation:?}");
+    mark_supervisor_delivery_claims_observed_for_pending_action_at(root, &pending, &observation)
+        .expect("mark game-chat parent receipt claim observed");
+    (pending, observation)
+}
+
 fn game_chat_main_without_asset_audit_fixture(root: &Path) -> String {
     init_local_game_project_at(root, "game-chat-no-audit", "缺失审计的单主任务")
         .expect("init no-audit project");
@@ -843,6 +890,492 @@ async fn game_chat_art_receipt_wakes_the_same_code_prototype_run() {
     );
 }
 
+#[test]
+fn game_chat_code_prototype_ignores_suppressed_delivery_without_child_task() {
+    let _config_guard = crate::tests::write_test_local_config("{}".to_string());
+    let temporary = tempfile::tempdir().expect("create suppressed delivery recovery root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(
+        &root,
+        "game-chat-suppressed-delivery",
+        "忽略未启动 child 的 suppressed delivery 后重试",
+    )
+    .expect("init suppressed delivery recovery project");
+    let (root_state, mut main) = queue_game_chat_fast_path_child(
+        &root,
+        "game-chat-suppressed-delivery-root",
+        "审计已有美术并补齐真实缺口",
+        "code-prototype",
+    );
+    main.status = "running".to_string();
+    main.phase = "planning".to_string();
+    main.current_task = "审计现有素材并按真实缺口委派美术".to_string();
+    main.current_action = "恢复失败的美术委派".to_string();
+    persist_game_chat_main_asset_audit_and_route(&root, &root_state, &mut main);
+
+    let suppressed = new_static_delegate_delivery_with_contract(
+        &main.agent_id,
+        &main.session_id,
+        &main.run_id,
+        "game-chat-suppressed-before-child-action",
+        "delegation-game-chat-suppressed-before-child",
+        "art-director",
+        "game-chat-suppressed-missing-child-session",
+        "game-chat-suppressed-missing-child-run",
+        &["只写入受委派的 assets 产物并回执".to_string()],
+        &[AGENT_RUNTIME_ART_SPEC_PATH.to_string()],
+        None,
+    );
+    let suppressed = create_or_read_static_delegate_delivery_at(&root, &suppressed)
+        .expect("create delivery before child startup failure");
+    let suppressed = suppress_static_delegate_delivery_at(&root, &suppressed)
+        .expect("suppress delivery whose child never started");
+    assert_eq!(suppressed.status, StaticDelegateDeliveryStatus::Suppressed);
+    assert!(
+        read_latest_game_creator_agent_runtime_task_by_run_id(
+            &root,
+            "art-director",
+            "game-chat-suppressed-missing-child-run",
+        )
+        .expect("check missing suppressed child")
+        .is_none(),
+        "fixture must preserve the dispatch-before-child-start failure window"
+    );
+
+    assert!(
+        static_delegate_parent_can_manage_receipts_at(&root, &main.agent_id, &main.run_id)
+            .expect("suppressed delivery must not invalidate the trusted parent"),
+        "trusted game-chat code parent must retain receipt capability"
+    );
+    assert!(
+        static_delegate_completion_barrier_at(&root, &main.agent_id, &main.run_id)
+            .expect("read barrier with suppressed delivery")
+            .is_clear(),
+        "suppressed delivery must not block retry or completion"
+    );
+    game_chat_fast_path_plan_at(&root, &main, &main.current_task, unix_timestamp())
+        .expect("suppressed delivery without child must not fail the fast path");
+
+    let child_lane = try_acquire_game_creator_agent_runtime_task_lock(&root, "art-director")
+        .expect("acquire retried art child lane")
+        .expect("retried art child lane available");
+    let retry_action_id = "game-chat-retry-after-suppressed-action";
+    let retry = observe_agent_runtime_agent_delegate(
+        &root,
+        &main.agent_id,
+        &main.run_id,
+        Some(retry_action_id),
+        &serde_json::json!({
+            "agentId": "art-director",
+            "task": "只补齐审计确认缺失的美术资产",
+            "acceptanceCriteria": ["只写入受委派的 assets 产物并回执"],
+            "expectedArtifacts": [AGENT_RUNTIME_ART_SPEC_PATH],
+            "repairOfDelegationId": null,
+            "runId": null
+        }),
+    );
+    assert_eq!(retry.status, "ok", "{retry:?}");
+    let retry_delegation_id = agent_runtime_delegation_id(
+        &main.agent_id,
+        &main.run_id,
+        "art-director",
+        retry_action_id,
+    );
+    let retried_child = read_latest_game_creator_agent_runtime_task_by_delegation_id(
+        &root,
+        "art-director",
+        &retry_delegation_id,
+    )
+    .expect("read retried art child")
+    .expect("retried art child exists");
+    cancel_game_creator_agent_runtime_task_at(
+        &root,
+        &retried_child.agent_id,
+        &retried_child.run_id,
+    )
+    .expect("cancel retried art child fixture");
+    drop(child_lane);
+}
+
+#[test]
+fn game_chat_code_prototype_missing_parent_task_with_active_delivery_blocks_completion() {
+    let _config_guard = crate::tests::write_test_local_config("{}".to_string());
+    let temporary = tempfile::tempdir().expect("create missing parent task root");
+    let root = temporary.path().join("project");
+    let (main, child, _delegation_id, child_lane) = game_chat_main_art_child_fixture_with_lane(
+        &root,
+        "art-director",
+        &["art-spec", "core-spritesheet"],
+        true,
+    );
+    let child_lane = child_lane.expect("delegated child lane is held");
+    fs::remove_file(game_creator_agent_runtime_task_path(&root, &main.agent_id))
+        .expect("remove code-prototype task journal fixture");
+
+    let capability =
+        static_delegate_parent_can_manage_receipts_at(&root, &main.agent_id, &main.run_id);
+    assert!(
+        capability
+            .as_ref()
+            .is_err_and(|error| error.contains("存在未收束静态委派")),
+        "missing parent task with an active delivery must fail closed: {capability:?}"
+    );
+    let blocker = static_delegate_completion_blocker_at_locked(&root, &main.agent_id, &main.run_id)
+        .expect("missing parent task must block completion");
+    assert_eq!(blocker.status, "blocked");
+    assert!(blocker.summary.contains("无法确认当前父 Run"));
+
+    cancel_game_creator_agent_runtime_task_at(&root, &child.agent_id, &child.run_id)
+        .expect("cancel missing-parent child fixture");
+    drop(child_lane);
+}
+
+#[test]
+fn game_chat_code_prototype_claims_own_failed_art_delivery_and_fails_closed() {
+    let _config_guard = crate::tests::write_test_local_config("{}".to_string());
+    let temporary = tempfile::tempdir().expect("create game-chat failed art receipt root");
+    let root = temporary.path().join("project");
+    let (main, child, delegation_id, child_lane) = game_chat_main_art_child_fixture_with_lane(
+        &root,
+        "art-director",
+        &["art-spec", "core-spritesheet"],
+        true,
+    );
+    let child_lane = child_lane.expect("delegated art child lane is held");
+    let dispatched = read_static_delegate_delivery_at(&root, &delegation_id)
+        .expect("read dispatched failed-art delivery")
+        .expect("failed-art delivery exists");
+    let failed_result = build_static_delegate_structured_result_at(
+        &root,
+        "failed",
+        &dispatched.expected_artifacts,
+        false,
+        None,
+        None,
+        None,
+        Some("External Editor 配置缺失，无法生成平台美术资源"),
+    )
+    .expect("build failed art structured result");
+    let ready = mark_static_delegate_delivery_ready_with_result_at(
+        &root,
+        &child.agent_id,
+        &child.session_id,
+        &child.run_id,
+        &delegation_id,
+        "failed",
+        "External Editor 配置缺失，无法生成平台美术资源",
+        failed_result,
+    )
+    .expect("mark failed art delivery ready");
+    assert_eq!(ready.status, StaticDelegateDeliveryStatus::Ready);
+
+    let deterministic_claim =
+        game_chat_fast_path_plan_at(&root, &main, &main.current_task, unix_timestamp())
+            .expect("build deterministic failed-art claim plan")
+            .expect("ready art delivery must be claimed before another Provider request");
+    assert_eq!(deterministic_claim.actions.len(), 1);
+    assert_eq!(deterministic_claim.actions[0].tool, "agent.run_status");
+    assert_eq!(deterministic_claim.actions[0].input["scope"], "self");
+
+    let claim_action = deterministic_claim.actions[0].clone();
+    let project_revision_before = read_game_creator_agent_runtime_project_revision(&root)
+        .expect("read failed-art claim revision");
+    let repository_context_fingerprint = build_repository_startup_context_at(&root)
+        .expect("build failed-art claim repository context")
+        .fingerprint;
+    let pending = build_game_creator_agent_runtime_pending_tool_action(
+        &root,
+        &main,
+        &main.current_task,
+        &deterministic_claim,
+        &[],
+        &project_revision_before,
+        &repository_context_fingerprint,
+        &claim_action,
+        0,
+        AGENT_RUNTIME_ACTION_EXECUTION_MODE_AUTO,
+        AGENT_RUNTIME_PENDING_ACTION_STATUS_EXECUTING,
+        None,
+    )
+    .expect("build failed-art run_status pending action");
+    let observation = observe_agent_runtime_run_status(
+        &root,
+        &main.agent_id,
+        &main.run_id,
+        Some(&pending.action_id),
+        &claim_action.input,
+    );
+    assert_eq!(observation.status, "ok", "{observation:?}");
+    let receipt_payload =
+        run_status_prefixed_payload(observation.detail.as_deref(), "readyDelegateReceipts: ")
+            .expect("parse failed art receipt prefix")
+            .expect("failed art receipt payload exists");
+    let receipt_payload: serde_json::Value =
+        serde_json::from_str(receipt_payload).expect("parse failed art receipt JSON");
+    let receipts = receipt_payload["receipts"]
+        .as_array()
+        .expect("failed art receipt array");
+    assert_eq!(receipts.len(), 1);
+    assert_eq!(receipts[0]["delegationId"], delegation_id);
+    assert_eq!(receipts[0]["status"], "failed");
+    mark_supervisor_delivery_claims_observed_for_pending_action_at(&root, &pending, &observation)
+        .expect("mark trusted game-chat parent claim observed");
+    let barrier = static_delegate_completion_barrier_at(&root, &main.agent_id, &main.run_id)
+        .expect("read failed art delivery barrier");
+    assert_eq!(barrier.ready_unclaimed_count, 0);
+    assert_eq!(barrier.unobserved_claim_count, 0);
+    assert_eq!(barrier.repair_required_count, 1);
+
+    let claimed_contract = observe_agent_runtime_run_status(
+        &root,
+        &main.agent_id,
+        &main.run_id,
+        Some("game-chat-code-failed-art-contract"),
+        &serde_json::json!({"delegationId": delegation_id}),
+    );
+    assert_eq!(claimed_contract.status, "ok", "{claimed_contract:?}");
+    let contract = claimed_contract
+        .detail
+        .as_deref()
+        .expect("claimed failed art contract detail");
+    let contract: serde_json::Value =
+        serde_json::from_str(contract).expect("parse claimed failed art contract");
+    assert_eq!(
+        contract["claimedDelegateContract"]["terminalStatus"],
+        "failed"
+    );
+    assert_eq!(
+        contract["claimedDelegateContract"]["contractStatus"],
+        "needs-repair"
+    );
+
+    for (agent_id, run_id, rejected_delegation_id) in [
+        (
+            "quality-review",
+            main.run_id.as_str(),
+            delegation_id.as_str(),
+        ),
+        (
+            main.agent_id.as_str(),
+            "game-chat-code-other-run",
+            delegation_id.as_str(),
+        ),
+        (
+            main.agent_id.as_str(),
+            main.run_id.as_str(),
+            "delegation-000000000000000000000000",
+        ),
+    ] {
+        let rejected = observe_agent_runtime_run_status(
+            &root,
+            agent_id,
+            run_id,
+            Some("game-chat-code-cross-scope-contract"),
+            &serde_json::json!({"delegationId": rejected_delegation_id}),
+        );
+        assert_eq!(rejected.status, "failed", "{rejected:?}");
+        assert!(rejected.detail.is_none());
+        assert!(rejected.summary.contains("当前可信父 run 或尚未认领"));
+    }
+    let unchanged = read_static_delegate_delivery_at(&root, &delegation_id)
+        .expect("read unchanged failed-art delivery")
+        .expect("failed-art delivery still exists");
+    assert_eq!(
+        unchanged.status,
+        StaticDelegateDeliveryStatus::ClaimedByParent
+    );
+    assert_eq!(
+        unchanged.claimed_by_action_id.as_deref(),
+        Some(pending.action_id.as_str())
+    );
+
+    let terminal_error =
+        game_chat_fast_path_plan_at(&root, &main, &main.current_task, unix_timestamp())
+            .expect_err("non-safe-default failed art delivery must stop before Provider planning");
+    assert!(terminal_error.contains("专业美术子任务失败且不能自动返工"));
+    assert!(terminal_error.contains("art-director"));
+
+    cancel_game_creator_agent_runtime_task_at(&root, &child.agent_id, &child.run_id)
+        .expect("cancel blocked art child fixture");
+    drop(child_lane);
+}
+
+#[tokio::test]
+async fn game_chat_failed_art_delivery_stops_main_loop_without_provider_request() {
+    let _config_guard = crate::tests::write_test_local_config("{}".to_string());
+    let temporary = tempfile::tempdir().expect("create failed art main-loop root");
+    let root = temporary.path().join("project");
+    let (main, mut child, delegation_id, child_lane) = game_chat_main_art_child_fixture_with_lane(
+        &root,
+        "art-director",
+        &["art-spec", "core-spritesheet"],
+        true,
+    );
+    let child_lane = child_lane.expect("failed art child lane is held");
+    child.status = "failed".to_string();
+    child.phase = "failed".to_string();
+    child.current_action = "External Editor 配置缺失，无法生成平台美术资源".to_string();
+    child.error = Some(child.current_action.clone());
+    append_game_creator_agent_runtime_task(&root, &child)
+        .expect("persist failed art child terminal task");
+    write_game_creator_agent_runtime_state(&root, &child)
+        .expect("persist failed art child terminal runtime");
+    let dispatched = read_static_delegate_delivery_at(&root, &delegation_id)
+        .expect("read main-loop failed art delivery")
+        .expect("main-loop failed art delivery exists");
+    let failed_result = build_static_delegate_structured_result_at(
+        &root,
+        "failed",
+        &dispatched.expected_artifacts,
+        false,
+        None,
+        None,
+        None,
+        Some("External Editor 配置缺失，无法生成平台美术资源"),
+    )
+    .expect("build main-loop failed art result");
+    mark_static_delegate_delivery_ready_with_result_at(
+        &root,
+        &child.agent_id,
+        &child.session_id,
+        &child.run_id,
+        &delegation_id,
+        "failed",
+        "External Editor 配置缺失，无法生成平台美术资源",
+        failed_result,
+    )
+    .expect("mark main-loop failed art delivery ready");
+
+    let outcome = run_game_creator_agent_background_task_pass_with_context(
+        root.clone(),
+        main.agent_id.clone(),
+        main.current_task.clone(),
+        main.clone(),
+        AgentRuntimeContinuationContext::default(),
+    )
+    .await;
+    assert!(
+        matches!(outcome, AgentBackgroundTaskOutcome::Finished),
+        "failed art delivery must terminate the main Run without Provider planning: {outcome:?}"
+    );
+    let terminal = read_game_creator_agent_runtime_for_session_at(
+        &root,
+        &main.agent_id,
+        Some(&main.session_id),
+    )
+    .expect("read terminal failed game-chat main Run")
+    .state;
+    assert_eq!(terminal.run_id, main.run_id);
+    assert_eq!(terminal.status, "failed");
+    assert_eq!(terminal.phase, "failed");
+    assert!(terminal.error.as_deref().is_some_and(|error| {
+        error.contains("专业美术子任务失败且不能自动返工") && error.contains("art-director")
+    }));
+    let records =
+        fs::read_to_string(root.join(".agent/agent.db")).expect("read failed art main-loop audit");
+    assert!(!records.lines().any(|line| {
+        serde_json::from_str::<serde_json::Value>(line)
+            .ok()
+            .is_some_and(|record| {
+                record["recordType"] == "agent.runtime.provider_request.lifecycle"
+                    && record["runId"] == main.run_id
+            })
+    }));
+
+    drop(child_lane);
+    crate::tests::wait_for_agent_runtime_terminal_and_lane_release_async(
+        &root,
+        &child.agent_id,
+        &child.run_id,
+        "failed",
+        "failed",
+    )
+    .await;
+}
+
+#[test]
+fn game_chat_code_prototype_rejects_tampered_art_delivery_identity_before_claim() {
+    let _config_guard = crate::tests::write_test_local_config("{}".to_string());
+    let temporary = tempfile::tempdir().expect("create tampered art binding root");
+    let root = temporary.path().join("project");
+    let (main, child, delegation_id, child_lane) = game_chat_main_art_child_fixture_with_lane(
+        &root,
+        "art-director",
+        &["art-spec", "core-spritesheet"],
+        true,
+    );
+    let child_lane = child_lane.expect("delegated tampered child lane is held");
+    let dispatched = read_static_delegate_delivery_at(&root, &delegation_id)
+        .expect("read tampered child delivery")
+        .expect("tampered child delivery exists");
+    let failed_result = build_static_delegate_structured_result_at(
+        &root,
+        "failed",
+        &dispatched.expected_artifacts,
+        false,
+        None,
+        None,
+        None,
+        Some("专业美术子任务失败"),
+    )
+    .expect("build tampered child failed result");
+    mark_static_delegate_delivery_ready_with_result_at(
+        &root,
+        &child.agent_id,
+        &child.session_id,
+        &child.run_id,
+        &delegation_id,
+        "failed",
+        "专业美术子任务失败",
+        failed_result,
+    )
+    .expect("mark tampered child delivery ready");
+    let mut tampered = read_static_delegate_delivery_at(&root, &delegation_id)
+        .expect("read ready delivery before identity tampering")
+        .expect("ready delivery exists before identity tampering");
+    tampered.parent_session_id = "tampered-parent-session".to_string();
+    fs::write(
+        root.join(format!(
+            ".agent/runtime/delegation-deliveries/{delegation_id}.json"
+        )),
+        serde_json::to_vec_pretty(&tampered).expect("serialize tampered delivery fixture"),
+    )
+    .expect("persist tampered delivery fixture");
+
+    let error = game_chat_fast_path_plan_at(&root, &main, &main.current_task, unix_timestamp())
+        .expect_err("tampered delivery identity must fail before receipt claim");
+    assert!(error.contains("delivery 与可信父责任链不一致"), "{error}");
+    assert!(
+        static_delegate_parent_can_manage_receipts_at(&root, &main.agent_id, &main.run_id).is_err(),
+        "tampered delivery must not degrade to an ordinary unauthorized parent"
+    );
+    let blocker = static_delegate_completion_blocker_at_locked(&root, &main.agent_id, &main.run_id)
+        .expect("tampered delivery must block task completion");
+    assert_eq!(blocker.status, "blocked");
+    assert!(blocker.summary.contains("无法确认当前父 Run"));
+    let claim = observe_agent_runtime_run_status(
+        &root,
+        &main.agent_id,
+        &main.run_id,
+        Some("game-chat-tampered-delivery-claim"),
+        &serde_json::json!({
+            "agentId": null,
+            "scope": "self",
+            "delegationId": null,
+        }),
+    );
+    assert_eq!(claim.status, "failed", "{claim:?}");
+    let delivery = read_static_delegate_delivery_at(&root, &delegation_id)
+        .expect("read unclaimed tampered delivery")
+        .expect("unclaimed tampered delivery exists");
+    assert_eq!(delivery.status, StaticDelegateDeliveryStatus::Ready);
+    assert!(delivery.claimed_by_action_id.is_none());
+
+    cancel_game_creator_agent_runtime_task_at(&root, &child.agent_id, &child.run_id)
+        .expect("cancel tampered child fixture");
+    drop(child_lane);
+}
+
 #[test]
 fn game_chat_main_agent_allows_only_one_same_contract_safe_default_repair() {
     let temporary = tempfile::tempdir().expect("create game-chat safe-default repair root");
@@ -881,13 +1414,15 @@ fn game_chat_main_agent_allows_only_one_same_contract_safe_default_repair() {
     .expect("read completed clarification child")
     .expect("completed clarification child exists");
     publish_game_creator_agent_delegate_result(&root, &child_task, Some(&needs_input));
-    claim_ready_static_delegate_receipts_at(
-        &root,
-        "code-prototype",
-        &main.run_id,
-        "game-chat-safe-default-claim",
-    )
-    .expect("claim converted safe-default delivery");
+    let (_claim_pending, claim_observation) =
+        claim_game_chat_main_ready_deliveries_with_run_status(&root, &main);
+    assert!(
+        claim_observation
+            .detail
+            .as_deref()
+            .is_some_and(|detail| detail.contains(&delegation_id)),
+        "{claim_observation:?}"
+    );
     let original = read_static_delegate_delivery_at(&root, &delegation_id)
         .expect("read original safe-default delivery")
         .expect("original safe-default delivery exists");
@@ -907,6 +1442,53 @@ fn game_chat_main_agent_allows_only_one_same_contract_safe_default_repair() {
         .as_ref()
         .and_then(|result| result.error.as_deref())
         .is_some_and(|error| error.contains("game-chat-safe-default-repair.v1")));
+    let repeated_route_plan = AgentRuntimeToolPlan {
+        thinking_summary: "重复提交既有资产路由".to_string(),
+        plan_update: None,
+        plan: Vec::new(),
+        actions: vec![AgentRuntimeToolAction {
+            tool: "agent.route_manifest".to_string(),
+            reason: Some("重复路由不应绕过返工门".to_string()),
+            input: serde_json::json!({
+                "strategy": GAME_CHAT_ASSET_ROUTE_GENERATE_MISSING,
+                "missingAssetSlots": ["art-spec", "core-spritesheet"],
+            }),
+        }],
+        response: String::new(),
+    };
+    let liveness_error = validate_game_chat_code_safe_default_repair_liveness_at(
+        &root,
+        &main.agent_id,
+        &main.run_id,
+        &repeated_route_plan,
+    )
+    .expect_err("safe-default repair must reject repeated route/read plans");
+    assert!(
+        liveness_error.contains("必须立即推进唯一安全默认返工"),
+        "{liveness_error}"
+    );
+
+    let deterministic_repair =
+        game_chat_fast_path_plan_at(&root, &main, &main.current_task, unix_timestamp())
+            .expect("build trusted safe-default repair plan")
+            .expect("valid safe-default marker must produce a deterministic repair action");
+    assert_eq!(deterministic_repair.actions.len(), 1);
+    assert_eq!(deterministic_repair.actions[0].tool, "agent.delegate");
+    assert_eq!(
+        deterministic_repair.actions[0].input["agentId"].as_str(),
+        Some(original.target_agent_id.as_str())
+    );
+    assert_eq!(
+        deterministic_repair.actions[0].input["repairOfDelegationId"].as_str(),
+        Some(delegation_id.as_str())
+    );
+    validate_game_chat_code_safe_default_repair_liveness_at(
+        &root,
+        &main.agent_id,
+        &main.run_id,
+        &deterministic_repair,
+    )
+    .expect("deterministic same-contract repair must pass the liveness gate");
 
     let repair_action_id = "game-chat-safe-default-repair-action";
     let repair = observe_agent_runtime_agent_delegate(
@@ -914,14 +1496,7 @@ fn game_chat_main_agent_allows_only_one_same_contract_safe_default_repair() {
         "code-prototype",
         &main.run_id,
         Some(repair_action_id),
-        &serde_json::json!({
-            "agentId": "art-director",
-            "task": "不要追问用户，采用安全默认视觉偏好继续交付",
-            "acceptanceCriteria": original.acceptance_criteria,
-            "expectedArtifacts": original.expected_artifacts,
-            "repairOfDelegationId": delegation_id,
-            "runId": null
-        }),
+        &deterministic_repair.actions[0].input,
     );
     assert_eq!(repair.status, "ok", "{repair:?}");
     let repair_delegation_id = agent_runtime_delegation_id(
@@ -968,13 +1543,15 @@ fn game_chat_main_agent_allows_only_one_same_contract_safe_default_repair() {
         &repair_child_task,
         Some("已采用安全默认视觉偏好完成规范图"),
     );
-    claim_ready_static_delegate_receipts_at(
-        &root,
-        "code-prototype",
-        &main.run_id,
-        "game-chat-safe-default-repair-claim",
-    )
-    .expect("claim completed safe-default repair delivery");
+    let (_repair_claim_pending, repair_claim_observation) =
+        claim_game_chat_main_ready_deliveries_with_run_status(&root, &main);
+    assert!(
+        repair_claim_observation
+            .detail
+            .as_deref()
+            .is_some_and(|detail| detail.contains(&repair_delegation_id)),
+        "{repair_claim_observation:?}"
+    );
 
     let duplicate = observe_agent_runtime_agent_delegate(
         &root,
@@ -1069,6 +1646,176 @@ fn autonomous_parent_waits_for_active_child_while_registered_derived_visuals_nee
     assert_eq!(parent_state.phase, "waiting-for-manifest-tasks");
 }
 
+#[tokio::test]
+async fn autonomous_supervisor_terminal_manifest_failure_fails_before_provider_request() {
+    const RUN_ID: &str = "autonomous-terminal-manifest-failure-parent";
+    const TASK: &str = "生成完整小游戏并在专业任务失败时安全收口";
+    const FAILED_TASK_ID: &str = "art-asset-plan";
+    const READY_TASK_ID: &str = "design-director";
+    let temporary = tempfile::tempdir().expect("create terminal manifest failure root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(&root, "terminal-manifest-failure", TASK)
+        .expect("init terminal manifest failure project");
+    let session_id = resolve_agent_conversation_session_id_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        None,
+        true,
+    )
+    .expect("resolve terminal manifest failure Supervisor session");
+    let record = append_unique_game_creator_agent_runtime_pending_task(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        &session_id,
+        TASK,
+        RUN_ID,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+        None,
+    )
+    .expect("queue terminal manifest failure Supervisor");
+    let mut state = agent_runtime_state_from_task_record(&record);
+    state.status = "running".to_string();
+    state.phase = "planning".to_string();
+    append_game_creator_agent_runtime_task(&root, &state)
+        .expect("persist running terminal manifest failure Supervisor");
+    write_game_creator_agent_runtime_state(&root, &state)
+        .expect("persist terminal manifest failure Supervisor state");
+
+    let mut manifest = read_manifest_for_project(&root).expect("read terminal failure manifest");
+    for task in &mut manifest.tasks {
+        task.status = match task.id.as_str() {
+            FAILED_TASK_ID => GameCreationAppTaskStatus::Failed,
+            READY_TASK_ID => GameCreationAppTaskStatus::Pending,
+            _ => GameCreationAppTaskStatus::Completed,
+        };
+    }
+    write_manifest(&root.join(".agent/manifest.json"), &manifest)
+        .expect("persist terminal failed manifest fixture");
+
+    let outcome = run_game_creator_agent_background_task_pass_with_context(
+        root.clone(),
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID.to_string(),
+        TASK.to_string(),
+        state,
+        AgentRuntimeContinuationContext::default(),
+    )
+    .await;
+    assert!(
+        matches!(outcome, AgentBackgroundTaskOutcome::Finished),
+        "terminal manifest failure must finish before requesting the Provider; outcome={outcome:?}"
+    );
+
+    let failed =
+        read_game_creator_agent_runtime_at(&root, GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID)
+            .expect("read terminal failed Supervisor")
+            .state;
+    assert_eq!(failed.run_id, RUN_ID);
+    assert_eq!(failed.status, "failed");
+    assert_eq!(failed.phase, "failed");
+    assert!(failed.error.as_deref().is_some_and(|error| {
+        error.contains("自主构建 manifest 专业任务失败") && error.contains(FAILED_TASK_ID)
+    }));
+    let manifest = read_manifest_for_project(&root).expect("read terminal failed manifest");
+    assert_eq!(
+        manifest
+            .tasks
+            .iter()
+            .find(|task| task.id == READY_TASK_ID)
+            .map(|task| task.status.clone()),
+        Some(GameCreationAppTaskStatus::Pending),
+        "a terminal manifest failure must not start another pending sibling"
+    );
+    let records = fs::read_to_string(root.join(".agent/agent.db"))
+        .expect("read terminal manifest failure audit");
+    assert!(!records.lines().any(|line| {
+        serde_json::from_str::<serde_json::Value>(line)
+            .ok()
+            .is_some_and(|record| {
+                record["recordType"] == "agent.runtime.provider_request.lifecycle"
+                    && record["runId"] == RUN_ID
+            })
+    }));
+}
+
+#[tokio::test]
+async fn autonomous_supervisor_waits_for_running_sibling_after_manifest_failure() {
+    const RUN_ID: &str = "autonomous-manifest-failure-running-sibling-parent";
+    const TASK: &str = "生成完整小游戏并等待在途专业任务安全收束";
+    const FAILED_TASK_ID: &str = "art-asset-plan";
+    const RUNNING_TASK_ID: &str = "audio-asset-plan";
+    let temporary = tempfile::tempdir().expect("create failed manifest running sibling root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(&root, "manifest-failure-running-sibling", TASK)
+        .expect("init failed manifest running sibling project");
+    let session_id = resolve_agent_conversation_session_id_at(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        None,
+        true,
+    )
+    .expect("resolve failed manifest running sibling Supervisor session");
+    let record = append_unique_game_creator_agent_runtime_pending_task(
+        &root,
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
+        &session_id,
+        TASK,
+        RUN_ID,
+        AGENT_RUNTIME_SUPERVISOR_CLI_SOURCE,
+        Some(AGENT_RUNTIME_RUN_PROFILE_AUTONOMOUS_GAME_BUILD),
+        None,
+    )
+    .expect("queue failed manifest running sibling Supervisor");
+    let mut state = agent_runtime_state_from_task_record(&record);
+    state.status = "running".to_string();
+    state.phase = "planning".to_string();
+    append_game_creator_agent_runtime_task(&root, &state)
+        .expect("persist failed manifest running sibling Supervisor");
+    write_game_creator_agent_runtime_state(&root, &state)
+        .expect("persist failed manifest running sibling Supervisor state");
+
+    let mut manifest = read_manifest_for_project(&root).expect("read failed sibling manifest");
+    for task in &mut manifest.tasks {
+        task.status = match task.id.as_str() {
+            FAILED_TASK_ID => GameCreationAppTaskStatus::Failed,
+            RUNNING_TASK_ID => GameCreationAppTaskStatus::Running,
+            _ => GameCreationAppTaskStatus::Completed,
+        };
+    }
+    write_manifest(&root.join(".agent/manifest.json"), &manifest)
+        .expect("persist failed manifest with running sibling fixture");
+
+    let outcome = run_game_creator_agent_background_task_pass_with_context(
+        root.clone(),
+        GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID.to_string(),
+        TASK.to_string(),
+        state,
+        AgentRuntimeContinuationContext::default(),
+    )
+    .await;
+    assert!(matches!(
+        outcome,
+        AgentBackgroundTaskOutcome::WaitingForManifestTasks
+    ));
+    let waiting =
+        read_game_creator_agent_runtime_at(&root, GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID)
+            .expect("read Supervisor waiting for failed DAG sibling")
+            .state;
+    assert_eq!(waiting.run_id, RUN_ID);
+    assert_eq!(waiting.status, "running");
+    assert_eq!(waiting.phase, "waiting-for-manifest-tasks");
+    let records = fs::read_to_string(root.join(".agent/agent.db"))
+        .expect("read failed manifest running sibling audit");
+    assert!(!records.lines().any(|line| {
+        serde_json::from_str::<serde_json::Value>(line)
+            .ok()
+            .is_some_and(|record| {
+                record["recordType"] == "agent.runtime.provider_request.lifecycle"
+                    && record["runId"] == RUN_ID
+            })
+    }));
+}
+
 fn prepare_autonomous_completion_evidence(
     root: &Path,
     state: &AgentRuntimeState,
@@ -1517,6 +2264,32 @@ fn autonomous_visual_ready_tasks_only_require_images_when_editor_api_key_is_conf
         assert!(!autonomous_manifest_ready_task_requires_visual_asset(
             "art-asset-plan"
         ));
+        let art_director = new_game_creation_app_seed_tasks()
+            .into_iter()
+            .find(|task| task.id == "art-director")
+            .expect("art-director seed task");
+        let task_text = render_autonomous_manifest_ready_task_background_prompt(&art_director);
+        let read_only_delivery =
+            agent_runtime_task_requires_read_only_delivery("art-director", &task_text);
+        assert!(read_only_delivery);
+        let forbidden_file_write = AgentRuntimeToolPlan {
+            actions: vec![AgentRuntimeToolAction {
+                tool: "file.write".to_string(),
+                reason: Some("无 External Editor API 时不得写入项目".to_string()),
+                input: serde_json::json!({
+                    "path": "assets/art-spec.png",
+                    "content": "not-a-canvas-asset"
+                }),
+            }],
+            ..AgentRuntimeToolPlan::default()
+        };
+        let error = validate_agent_runtime_autonomous_read_only_delivery_plan(
+            "art-director",
+            read_only_delivery,
+            &forbidden_file_write,
+        )
+        .expect_err("art-director without External Editor API must remain read-only");
+        assert!(error.contains("自主构建只读专业 Agent 禁止执行写入或副作用动作"));
     }
     let _config_guard = crate::tests::write_test_local_config(
         r#"{"editorApi":{"apiKey":"visual-ready-task-test-key"}}"#.to_string(),
@@ -1533,6 +2306,18 @@ fn autonomous_visual_ready_tasks_only_require_images_when_editor_api_key_is_conf
     assert!(!autonomous_manifest_ready_task_requires_visual_asset(
         "code-prototype"
     ));
+    let art_director = new_game_creation_app_seed_tasks()
+        .into_iter()
+        .find(|task| task.id == "art-director")
+        .expect("art-director seed task");
+    let task_text = render_autonomous_manifest_ready_task_background_prompt(&art_director);
+    assert!(task_text.contains("非只读视觉规范生成任务"));
+    assert!(task_text.contains("唯一允许的项目写动作是 canvas.asset_generate"));
+    assert!(task_text.contains("assets/art-spec.png（assetKind=icon-spec、aspectRatio=1:1）"));
+    assert!(!agent_runtime_task_requires_read_only_delivery(
+        "art-director",
+        &task_text
+    ));
 }
 
 #[test]
@@ -2504,6 +3289,148 @@ fn game_chat_code_prototype_ignores_art_director_global_revision_before_its_own_
     );
 }
 
+#[test]
+fn game_chat_code_second_loop_waits_for_provider_before_asset_route() {
+    let temporary = tempfile::tempdir().expect("create unrouted game-chat code root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(&root, "game-chat-unrouted-code", "制作星河收集小游戏")
+        .expect("init unrouted game-chat code project");
+    register_game_chat_art_spec_fixture(&root);
+    register_game_chat_art_spritesheet_fixture(&root);
+    fs::write(
+        root.join("assets/manifest.art.json"),
+        game_chat_fast_path_art_manifest_content(),
+    )
+    .expect("write unrouted complete art manifest");
+    let (root_state, mut code_state) = queue_game_chat_fast_path_child(
+        &root,
+        "game-chat-unrouted-code-root",
+        "制作星河收集小游戏",
+        "code-prototype",
+    );
+    code_state.loop_iteration = 2;
+    persist_game_chat_main_asset_audit(&root, &mut code_state);
+    let bound_at = read_game_creator_agent_runtime_run_profile_binding(
+        &root,
+        &root_state.agent_id,
+        &root_state.run_id,
+    )
+    .expect("read unrouted game-chat root binding")
+    .expect("unrouted game-chat root binding exists")
+    .bound_at;
+
+    assert!(
+        game_chat_fast_path_plan_at(&root, &code_state, &code_state.current_task, bound_at)
+            .expect("evaluate unrouted second loop")
+            .is_none(),
+        "asset.list 后尚未形成资产路由时，第二轮必须交给 Provider 决策与委派"
+    );
+}
+
+#[test]
+fn game_chat_code_second_loop_waits_for_delegated_visual_contract() {
+    let temporary = tempfile::tempdir().expect("create routed game-chat code root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(&root, "game-chat-routed-code", "制作星河收集小游戏")
+        .expect("init routed game-chat code project");
+    let (root_state, mut code_state) = queue_game_chat_fast_path_child(
+        &root,
+        "game-chat-routed-code-root",
+        "制作星河收集小游戏",
+        "code-prototype",
+    );
+    code_state.loop_iteration = 2;
+    persist_game_chat_main_asset_audit_and_route(&root, &root_state, &mut code_state);
+    let bound_at = read_game_creator_agent_runtime_run_profile_binding(
+        &root,
+        &root_state.agent_id,
+        &root_state.run_id,
+    )
+    .expect("read routed game-chat root binding")
+    .expect("routed game-chat root binding exists")
+    .bound_at;
+
+    assert!(
+        game_chat_fast_path_plan_at(&root, &code_state, &code_state.current_task, bound_at)
+            .expect("evaluate routed second loop without art")
+            .is_none(),
+        "资产路由已持久化但美术 child 尚未交付时，第二轮必须继续交给 Provider 执行委派"
+    );
+}
+
+#[test]
+fn game_chat_code_second_loop_allows_fallback_after_visual_contract_is_ready() {
+    let temporary = tempfile::tempdir().expect("create ready game-chat code root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(&root, "game-chat-ready-code", "制作星河收集小游戏")
+        .expect("init ready game-chat code project");
+    register_game_chat_art_spec_fixture(&root);
+    register_game_chat_art_spritesheet_fixture(&root);
+    fs::write(
+        root.join("assets/manifest.art.json"),
+        game_chat_fast_path_art_manifest_content(),
+    )
+    .expect("write ready complete art manifest");
+    let (root_state, mut code_state) = queue_game_chat_fast_path_child(
+        &root,
+        "game-chat-ready-code-root",
+        "制作星河收集小游戏",
+        "code-prototype",
+    );
+    code_state.loop_iteration = 2;
+    persist_game_chat_main_asset_audit_and_route(&root, &root_state, &mut code_state);
+    let bound_at = read_game_creator_agent_runtime_run_profile_binding(
+        &root,
+        &root_state.agent_id,
+        &root_state.run_id,
+    )
+    .expect("read ready game-chat root binding")
+    .expect("ready game-chat root binding exists")
+    .bound_at;
+
+    let plan = game_chat_fast_path_plan_at(&root, &code_state, &code_state.current_task, bound_at)
+        .expect("evaluate ready second loop")
+        .expect("verified visual contract may use deterministic fallback");
+    assert_eq!(plan.actions.len(), 1);
+    assert_eq!(plan.actions[0].tool, "file.write");
+    assert_eq!(
+        plan.actions[0].input.get("path"),
+        Some(&serde_json::json!(AGENT_RUNTIME_GAME_INDEX_PATH))
+    );
+}
+
+#[test]
+fn game_chat_code_soft_budget_still_fails_closed_without_visual_contract() {
+    let temporary = tempfile::tempdir().expect("create budgeted game-chat code root");
+    let root = temporary.path().join("project");
+    init_local_game_project_at(&root, "game-chat-budgeted-code", "制作星河收集小游戏")
+        .expect("init budgeted game-chat code project");
+    let (root_state, mut code_state) = queue_game_chat_fast_path_child(
+        &root,
+        "game-chat-budgeted-code-root",
+        "制作星河收集小游戏",
+        "code-prototype",
+    );
+    persist_game_chat_main_asset_audit_and_route(&root, &root_state, &mut code_state);
+    let bound_at = read_game_creator_agent_runtime_run_profile_binding(
+        &root,
+        &root_state.agent_id,
+        &root_state.run_id,
+    )
+    .expect("read budgeted game-chat root binding")
+    .expect("budgeted game-chat root binding exists")
+    .bound_at;
+
+    let error = game_chat_fast_path_plan_at(
+        &root,
+        &code_state,
+        &code_state.current_task,
+        bound_at.saturating_add(GAME_CHAT_FIRST_PLAYABLE_SOFT_BUDGET_SECONDS),
+    )
+    .expect_err("soft budget must still fail closed when visual contracts are missing");
+    assert!(error.contains("assets/art-spritesheet.png"));
+}
+
 #[test]
 fn game_chat_existing_game_requires_code_mutation_and_full_completion_before_delivery() {
     let temporary = tempfile::tempdir().expect("create existing game code root");
@@ -2773,6 +3700,65 @@ fn game_chat_trusted_single_main_repairs_javascript_smoke_and_completes_without_
     )
     .expect("persist failed static smoke receipt");
 
+    update_agent_runtime_plan_steps(
+        &mut code_state,
+        vec!["记录开发者投递的后台任务".to_string()],
+    );
+    activate_agent_runtime_plan_step(&mut code_state, 0, "执行 game.static_smoke");
+    complete_agent_runtime_active_plan_step(
+        &mut code_state,
+        "failed",
+        &failed_smoke_observation.summary(),
+    );
+    assert_eq!(code_state.plan_revision, 0);
+    assert_eq!(
+        code_state.plan_steps[0].status,
+        AGENT_RUNTIME_PLAN_STATUS_FAILED
+    );
+
+    apply_agent_runtime_plan_update(
+        &mut code_state,
+        &AgentRuntimePlanUpdate {
+            explanation: "首版 smoke 已返回可修复诊断，保持同一主 Run 继续修复与复验".to_string(),
+            steps: vec![
+                AgentRuntimePlanUpdateStep {
+                    step: "完成资产审计与缺口路由".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_COMPLETED.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "写入可运行游戏 scaffold".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_COMPLETED.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "修复静态 smoke 阻断".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_IN_PROGRESS.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "重新执行静态 smoke".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_PENDING.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "完成浏览器试玩与视觉检查".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_PENDING.to_string(),
+                },
+                AgentRuntimePlanUpdateStep {
+                    step: "向父 Agent 交付证据回执".to_string(),
+                    status: AGENT_RUNTIME_PLAN_STATUS_PENDING.to_string(),
+                },
+            ],
+        },
+    )
+    .expect("replace failed legacy scaffold with first structured repair plan");
+    assert_eq!(code_state.plan_revision, 1);
+    assert!(code_state
+        .plan_steps
+        .iter()
+        .all(|step| step.status != AGENT_RUNTIME_PLAN_STATUS_FAILED));
+    assert!(code_state
+        .plan_steps
+        .iter()
+        .all(|step| step.title != "记录开发者投递的后台任务"));
+
     let (history, count, truncated, output_truncated) = read_agent_runtime_action_history(
         &root,
         &code_state.agent_id,
@@ -2857,6 +3843,27 @@ fn game_chat_trusted_single_main_repairs_javascript_smoke_and_completes_without_
     )
     .expect("persist same-run repair receipt");
 
+    let bound_at = read_game_creator_agent_runtime_run_profile_binding(
+        &root,
+        &root_state.agent_id,
+        &root_state.run_id,
+    )
+    .expect("read deterministic game-chat root binding")
+    .expect("deterministic game-chat root binding exists")
+    .bound_at;
+    let automatic_recheck =
+        game_chat_fast_path_plan_at(&root, &code_state, &code_state.current_task, bound_at)
+            .expect("evaluate repaired current revision")
+            .expect("same-run repair must automatically recheck current revision");
+    assert_eq!(automatic_recheck.actions.len(), 1);
+    assert_eq!(automatic_recheck.actions[0].tool, "command.run_limited");
+    assert_eq!(
+        automatic_recheck.actions[0].input.get("commandId"),
+        Some(&serde_json::json!("game.static_smoke"))
+    );
+    assert!(automatic_recheck.plan_update.is_none());
+    assert!(automatic_recheck.response.is_empty());
+
     let repaired_smoke = AgentRuntimeToolAction {
         tool: "command.run_limited".to_string(),
         reason: Some("重新验证已修复的当前 revision".to_string()),
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/task_start.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/task_start.rs
index 696410c77..0a9cd34ac 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/task_start.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/task_start.rs
@@ -1492,6 +1492,11 @@ pub(in crate::agent) fn render_autonomous_manifest_ready_task_background_prompt(
             "{base}\n\n这是 autonomous-game-build 的只读试玩验收任务，不要修改项目文件。固定核心动作是且只能是 preview.validate；完成当前 revision 的桌面与移动试玩后直接交付验收结论，不要调用项目 mutation、其它预览动作或 task.update，Runtime 会在子 Run 终态后幂等投影 manifest。"
         );
     }
+    if task.id == "art-director" && editor_api_key_is_configured() {
+        return format!(
+            "{base}\n\n这是 autonomous-game-build 的非只读视觉规范生成任务。{AGENT_RUNTIME_AUTONOMOUS_ART_DIRECTOR_CANVAS_ONLY_TASK_MARKER}；必须用固定合同生成并登记 assets/art-spec.png（assetKind=icon-spec、aspectRatio=1:1），该受控素材事务会同时提交当前 run 的 mutation 与验证凭证。禁止调用 file.write、file.patch、file.delete、project.patchset、project.restore 或写入其它路径。生成成功后直接交付视觉规范结论；不要调用 task.update，Runtime 会在子 Run 终态后幂等投影 manifest。"
+        );
+    }
     if autonomous_manifest_task_requires_project_mutation(&task.id) {
         let owner_prompt = render_autonomous_manifest_ready_task_owner_prompt(task);
         let code_visual_asset_requirement =
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion.rs
index 75ea76559..06825c6fc 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion.rs
@@ -580,8 +580,13 @@ fn rendered_html_markup_and_stylesheets(content: &str) -> (String, String) {
                 .unwrap_or(lower.len());
             continue;
         }
+        if !html_tag_like_start(&lower, tag_start) {
+            cursor = tag_start + 1;
+            continue;
+        }
         let Some(tag_after) = html_tag_end(&lower, tag_start) else {
-            break;
+            cursor = tag_start + 1;
+            continue;
         };
         let tag_end = tag_after - 1;
         let tag = &lower[tag_start..=tag_end];
@@ -7390,6 +7395,13 @@ pub(in crate::agent) fn validate_executable_inline_javascript_syntax(
     Ok(())
 }
 
+fn html_tag_like_start(content: &str, tag_start: usize) -> bool {
+    content
+        .as_bytes()
+        .get(tag_start + 1)
+        .is_some_and(|byte| byte.is_ascii_alphabetic() || matches!(byte, b'/' | b'!' | b'?'))
+}
+
 #[derive(Default)]
 struct JavascriptLiteralSpanCollector {
     strings: Vec<std::ops::Range<usize>>,
@@ -17818,3 +17830,35 @@ mod javascript_projection_reachability_tests {
         assert!(!javascript_position_is_reachable(content, &ranges, decoy));
     }
 }
+
+#[cfg(test)]
+mod executable_inline_javascript_syntax_tests {
+    use super::*;
+
+    #[test]
+    fn stray_unterminated_less_than_does_not_skip_later_inline_scripts() {
+        let html = r#"<!doctype html>
+<html>
+<body>
+<p>本关扣分规则：5 < 3 时按 3 计算</p>
+<script>function broken( { return 1; }</script>
+</body>
+</html>"#;
+        let error = validate_executable_inline_javascript_syntax(html)
+            .expect_err("a later script must still be syntax checked after a stray '<'");
+        assert!(error.contains("不是有效 JavaScript"), "{error}");
+    }
+
+    #[test]
+    fn unterminated_less_than_alone_still_allows_a_valid_inline_script() {
+        let html = r#"<!doctype html>
+<html>
+<body>
+<p>a < b</p>
+<script>function start() { return 1; }</script>
+</body>
+</html>"#;
+        validate_executable_inline_javascript_syntax(html)
+            .expect("stray '<' without '>' must not break valid syntax validation");
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion_contract_tests.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion_contract_tests.rs
index 0324f485f..ebdae7dbd 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion_contract_tests.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/autonomous_completion_contract_tests.rs
@@ -1066,7 +1066,7 @@ async fn game_chat_pure_continue_inherits_failed_root_semantics_and_manifest_pro
         servers: Vec::new(),
         tools: Vec::new(),
     };
-    let (_, _, provider_request, _) = build_game_creator_agent_background_tool_plan_request(
+    let (_, _, provider_request, _, _) = build_game_creator_agent_background_tool_plan_request(
         &root,
         &recovered.agent_id,
         &recovered.session_id,
@@ -1102,15 +1102,17 @@ async fn game_chat_pure_continue_inherits_failed_root_semantics_and_manifest_pro
     .expect("continued root must pass the scheduler contract gate");
     assert_eq!(scheduled.len(), 1);
     assert_eq!(scheduled[0].state.agent_id, "code-prototype");
-    // Scheduling starts the child worker asynchronously.  Wait for its
-    // durable terminal projection and lane release before mutating the same
-    // project; a lane release alone can precede a late manifest projection.
+    // Scheduling starts the child worker asynchronously. The deliberately
+    // empty Provider config now fails closed after the asset audit yields to
+    // Provider planning. Wait for that durable terminal projection and lane
+    // release before mutating the same project; a lane release alone can
+    // precede a late manifest projection.
     let _ = crate::tests::wait_for_agent_runtime_manifest_projection_async(
         &root,
         "code-prototype",
         &autonomous_manifest_ready_task_run_id(&continuation.run_id, "code-prototype"),
         "failed",
-        "budget-exhausted",
+        "failed",
         GameCreationAppTaskStatus::Failed,
     )
     .await;
@@ -6746,6 +6748,13 @@ fn active_game_chat_child_keeps_dag_in_progress_after_completed_manifest_drift()
     );
     update_manifest_task_status_at(&root, "code-prototype", GameCreationAppTaskStatus::Failed)
         .expect("fail the only game-chat manifest task");
+    assert_eq!(
+        autonomous_manifest_dag_state_at(&root).expect("read failed DAG state with active child"),
+        AutonomousManifestDagState::Failed {
+            failed_task_ids: vec!["code-prototype".to_string()],
+            has_active_children: true,
+        }
+    );
     assert!(
         !autonomous_manifest_dag_in_progress_at(&root).expect("read failed DAG with active child"),
         "a manifest failure must still fail closed"
@@ -8100,6 +8109,7 @@ fn autonomous_playtest_liveness_only_enforces_the_latest_preview_result() {
         &superseded_failure,
         &response_plan,
         true,
+        false,
         true,
     )
     .is_ok());
@@ -8122,6 +8132,7 @@ fn autonomous_playtest_liveness_only_enforces_the_latest_preview_result() {
         &response_plan,
         true,
         false,
+        false,
     )
     .expect_err("latest failed preview must still require delegated repair");
     assert!(
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/provider_retry.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/provider_retry.rs
index ef3faa7bc..0e898dc02 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/provider_retry.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/provider_retry.rs
@@ -301,6 +301,7 @@ pub(in crate::agent) fn game_creator_agent_runtime_llm_request_fingerprint(
         platform_llm::LlmResponseReasoningEffort::Low => "low",
         platform_llm::LlmResponseReasoningEffort::Medium => "medium",
         platform_llm::LlmResponseReasoningEffort::High => "high",
+        platform_llm::LlmResponseReasoningEffort::Max => "max",
     });
     let text_verbosity = request.response_text_verbosity.map(|value| match value {
         platform_llm::LlmResponseTextVerbosity::Low => "low",
@@ -1708,6 +1709,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn provider_request_fingerprint_keeps_max_distinct_from_high() {
+        let base = LlmRunRequest::single_turn("系统", "任务");
+        let high = game_creator_agent_runtime_llm_request_fingerprint(
+            &base
+                .clone()
+                .with_response_reasoning_effort(platform_llm::LlmResponseReasoningEffort::High),
+        )
+        .expect("high request fingerprint");
+        let max_request =
+            base.with_response_reasoning_effort(platform_llm::LlmResponseReasoningEffort::Max);
+        let max = game_creator_agent_runtime_llm_request_fingerprint(&max_request)
+            .expect("max request fingerprint");
+        let repeated_max = game_creator_agent_runtime_llm_request_fingerprint(&max_request)
+            .expect("repeated max request fingerprint");
+        assert_ne!(high, max);
+        assert_eq!(max, repeated_max);
+    }
+
     #[test]
     fn codex_app_server_unknown_terminal_enters_reconciliation_without_retry() {
         let error = platform_llm::LlmError::Transport(format!(
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/delivery.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/delivery.rs
index 4f0152312..ec82d5121 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/delivery.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/delivery.rs
@@ -245,6 +245,173 @@ fn trusted_game_chat_autonomous_parent_chain_at(
     Ok(Some(parent_binding))
 }
 
+fn trusted_game_chat_code_parent_task_at(
+    root: &Path,
+    parent_agent_id: &str,
+    parent_run_id: &str,
+) -> Result<Option<AgentRuntimeTaskRecord>, String> {
+    if parent_agent_id != "code-prototype" {
+        return Ok(None);
+    }
+    let Some(parent_task) = read_latest_game_creator_agent_runtime_task_by_run_id(
+        root,
+        parent_agent_id,
+        parent_run_id,
+    )?
+    else {
+        return Ok(None);
+    };
+    if parent_task.agent_id != parent_agent_id
+        || parent_task.run_id != parent_run_id
+        || trusted_game_chat_autonomous_parent_chain_at(root, &parent_task)?.is_none()
+    {
+        return Ok(None);
+    }
+    Ok(Some(parent_task))
+}
+
+pub(in crate::agent) fn static_delegate_parent_can_manage_receipts_at(
+    root: &Path,
+    parent_agent_id: &str,
+    parent_run_id: &str,
+) -> Result<bool, String> {
+    if parent_agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
+        return Ok(true);
+    }
+    let deliveries =
+        static_delegate_deliveries_for_parent_at(root, parent_agent_id, parent_run_id)?;
+    let active_deliveries = deliveries
+        .iter()
+        .filter(|delivery| delivery.status != StaticDelegateDeliveryStatus::Suppressed)
+        .collect::<Vec<_>>();
+    let Some(parent_task) =
+        trusted_game_chat_code_parent_task_at(root, parent_agent_id, parent_run_id)?
+    else {
+        if parent_agent_id == "code-prototype" && !active_deliveries.is_empty() {
+            return Err(
+                "game-chat code-prototype 存在未收束静态委派，但无法证明当前父 Run 身份链可信"
+                    .to_string(),
+            );
+        }
+        return Ok(false);
+    };
+    for delivery in active_deliveries {
+        if !trusted_game_chat_autonomous_child_delivery_at(root, &parent_task, delivery, None)? {
+            return Err(
+                "game-chat code-prototype 父 Run 的静态委派 delivery 身份链不可信".to_string(),
+            );
+        }
+    }
+    Ok(true)
+}
+
+pub(in crate::agent) fn static_delegate_parent_can_manage_delivery_at(
+    root: &Path,
+    parent_agent_id: &str,
+    parent_run_id: &str,
+    delivery: &StaticDelegateDeliveryRecord,
+) -> Result<bool, String> {
+    if delivery.parent_agent_id != parent_agent_id || delivery.parent_run_id != parent_run_id {
+        return Ok(false);
+    }
+    if parent_agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
+        return Ok(true);
+    }
+    let Some(parent_task) =
+        trusted_game_chat_code_parent_task_at(root, parent_agent_id, parent_run_id)?
+    else {
+        return Ok(false);
+    };
+    trusted_game_chat_autonomous_child_delivery_at(root, &parent_task, delivery, None)
+}
+
+pub(in crate::agent) fn game_chat_code_parent_terminal_delivery_error_at(
+    root: &Path,
+    parent_agent_id: &str,
+    parent_run_id: &str,
+) -> Result<Option<String>, String> {
+    let Some(parent_task) =
+        trusted_game_chat_code_parent_task_at(root, parent_agent_id, parent_run_id)?
+    else {
+        return Ok(None);
+    };
+    for delivery in claimed_static_delegate_deliveries_at(root, parent_agent_id, parent_run_id)? {
+        if !trusted_game_chat_autonomous_child_delivery_at(root, &parent_task, &delivery, None)? {
+            return Ok(Some(
+                "game-chat 专业美术回执不属于当前可信 code-prototype 父 Run，拒绝继续".to_string(),
+            ));
+        }
+        let Some(result) = delivery.structured_result.as_ref() else {
+            return Ok(Some(format!(
+                "game-chat 专业美术子任务 {} 缺少结构化终态合同，拒绝继续",
+                delivery.target_agent_id
+            )));
+        };
+        match result.contract_status {
+            StaticDelegateContractStatus::EvidenceReady => {}
+            StaticDelegateContractStatus::NeedsRepair
+                if delivery.repair_of_delegation_id.is_none()
+                    && trusted_game_chat_safe_default_repair_delivery_at(
+                        root,
+                        &parent_task,
+                        &delivery,
+                    )? => {}
+            StaticDelegateContractStatus::NeedsRepair => {
+                return Ok(Some(format!(
+                    "game-chat 专业美术子任务失败且不能自动返工：{}；仅合法安全默认 marker 允许唯一一层同合同返工",
+                    delivery.target_agent_id
+                )));
+            }
+            StaticDelegateContractStatus::NeedsUserInput => {
+                return Ok(Some(format!(
+                    "game-chat 专业美术子任务仍要求用户输入且未转换为安全默认返工：{}",
+                    delivery.target_agent_id
+                )));
+            }
+        }
+    }
+    Ok(None)
+}
+
+pub(in crate::agent) fn game_chat_code_parent_safe_default_repair_delivery_at(
+    root: &Path,
+    parent_agent_id: &str,
+    parent_run_id: &str,
+) -> Result<Option<StaticDelegateDeliveryRecord>, String> {
+    let Some(parent_task) =
+        trusted_game_chat_code_parent_task_at(root, parent_agent_id, parent_run_id)?
+    else {
+        return Ok(None);
+    };
+    let barrier = static_delegate_completion_barrier_at(root, parent_agent_id, parent_run_id)?;
+    if barrier.repair_required_count == 0 {
+        return Ok(None);
+    }
+    let mut candidates = Vec::new();
+    for delivery in claimed_static_delegate_deliveries_at(root, parent_agent_id, parent_run_id)? {
+        if delivery.repair_of_delegation_id.is_none()
+            && delivery.structured_result.as_ref().is_some_and(|result| {
+                result.contract_status == StaticDelegateContractStatus::NeedsRepair
+            })
+            && trusted_game_chat_safe_default_repair_delivery_at(root, &parent_task, &delivery)?
+        {
+            candidates.push(delivery);
+        }
+    }
+    if candidates.len() != barrier.repair_required_count {
+        return Err(
+            "game-chat code-prototype 存在待返工 delivery，但未全部通过安全默认 marker 与身份链校验"
+                .to_string(),
+        );
+    }
+    if candidates.len() != 1 {
+        return Err(
+            "game-chat code-prototype 一次必须且只能推进一个安全默认返工 delivery".to_string(),
+        );
+    }
+    Ok(candidates.pop())
+}
+
 pub(crate) fn trusted_game_chat_autonomous_root_parent_at(
     root: &Path,
     parent_task: &AgentRuntimeTaskRecord,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/run_status.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/run_status.rs
index b58d27a2b..71cca9f61 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/run_status.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/run_status.rs
@@ -7,16 +7,12 @@ pub(in crate::agent) fn observe_claimed_static_delegate_contract_at(
     delegation_id: &str,
 ) -> AgentRuntimeToolObservation {
     let result = (|| -> Result<String, String> {
-        if agent_id != GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
-            return Err("只有 Project Supervisor 可以读取已认领委派合同".to_string());
-        }
         let delivery = read_static_delegate_delivery_at(root, delegation_id)?
-            .ok_or_else(|| "指定委派合同不存在".to_string())?;
-        if delivery.parent_agent_id != agent_id
-            || delivery.parent_run_id != run_id
+            .ok_or_else(|| "指定委派合同不属于当前可信父 run 或尚未认领".to_string())?;
+        if !static_delegate_parent_can_manage_delivery_at(root, agent_id, run_id, &delivery)?
             || delivery.status != StaticDelegateDeliveryStatus::ClaimedByParent
         {
-            return Err("指定委派合同不属于当前 Supervisor 父 run 或尚未认领".to_string());
+            return Err("指定委派合同不属于当前可信父 run 或尚未认领".to_string());
         }
         let detail = serde_json::to_string(&serde_json::json!({
             "claimedDelegateContract": {
@@ -124,17 +120,15 @@ pub(crate) fn observe_agent_runtime_run_status(
             detail = format!("collaborationPolicy: {policy_status}\n\n{detail}");
         }
         let claim_action_id = action_id.map(str::trim).filter(|value| !value.is_empty());
-        let static_delegate_output_may_be_present =
-            if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
-                static_delegate_run_status_may_include_receipts_at(
-                    root,
-                    agent_id,
-                    run_id,
-                    claim_action_id,
-                )?
-            } else {
-                false
-            };
+        let can_manage_static_delegate_receipts =
+            static_delegate_parent_can_manage_receipts_at(root, agent_id, run_id)?;
+        let static_delegate_output_may_be_present = can_manage_static_delegate_receipts
+            && static_delegate_run_status_may_include_receipts_at(
+                root,
+                agent_id,
+                run_id,
+                claim_action_id,
+            )?;
         let isolated_join_payload_limit = if static_delegate_output_may_be_present {
             AGENT_RUNTIME_READY_ISOLATED_JOIN_MIXED_PAYLOAD_MAX_CHARS
         } else {
@@ -169,7 +163,7 @@ pub(crate) fn observe_agent_runtime_run_status(
             detail = format!("claimedIsolatedJoins: {payload}\n\n{detail}");
         }
 
-        let ready_delegate_receipts = if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
+        let ready_delegate_receipts = if can_manage_static_delegate_receipts {
             let barrier = static_delegate_completion_barrier_at(root, agent_id, run_id)?;
             if barrier.ready_unclaimed_count > 0 && claim_action_id.is_none() {
                 return Err("agent.run_status 认领专业 Agent 回执必须绑定 actionId".to_string());
@@ -219,7 +213,7 @@ pub(crate) fn observe_agent_runtime_run_status(
             })();
         }
 
-        let claimed_delegate_deliveries = if agent_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
+        let claimed_delegate_deliveries = if can_manage_static_delegate_receipts {
             claimed_static_delegate_deliveries_at(root, agent_id, run_id)?
         } else {
             Vec::new()
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs b/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs
index 6a9e44e4e..f373f8e80 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs
@@ -1059,7 +1059,7 @@ fn runtime_tool_description(tool: &str) -> &'static str {
             "为 game-chat 提交结构化条件任务图路由；Supervisor 自行概括并持久化用户 intentSummary，Runtime 采用审计优先策略，code-prototype 审计后再提交复用或真实缺口生成路由。"
         }
         "agent.action_history" => "查询当前 Agent 的持久终态动作历史。",
-        "agent.run_status" => "读取自己或其他 Agent 的 Runtime 状态摘要；Project Supervisor 可按 delegationId 取回已认领的权威返工合同。",
+        "agent.run_status" => "读取自己或其他 Agent 的 Runtime 状态摘要；当前可信父 Run 可按 delegationId 取回自己已认领的权威返工合同。",
         _ => "执行一个受 Runtime 白名单和项目策略保护的工具动作。",
     }
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/assets.rs b/apps/ai-game-creator-shell/src-tauri/src/assets.rs
index 1206f9714..8a4ac0483 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/assets.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/assets.rs
@@ -1050,7 +1050,7 @@ pub(crate) fn register_local_asset_entry(
 ) -> Result<UploadLocalAssetResult, String> {
     let normalized_path = normalize_relative_path(local_path)?;
     let absolute_path = resolve_local_project_path(root, &normalized_path)?;
-    let (manifest_path, mut manifest) = read_or_create_manifest(root)?;
+    let manifest_path = root.join(".agent/manifest.json");
     let kind = if kind.is_empty() { "asset" } else { kind };
     let media_type = if media_type.is_empty() {
         "application/octet-stream"
@@ -1060,31 +1060,32 @@ pub(crate) fn register_local_asset_entry(
     let mut source_for_record = source.clone();
     source_for_record.prompt = None;
 
-    let (id, record_type) = if let Some(existing) = manifest
-        .assets
-        .iter_mut()
-        .find(|asset| asset.local_path == normalized_path)
-    {
-        existing.kind = kind.to_string();
-        existing.media_type = media_type.to_string();
-        existing.source = source;
-        (existing.id.clone(), "asset.update")
-    } else {
-        let id = format!(
-            "{id_prefix}-{}-{}",
-            unix_millis(),
-            manifest.assets.len() + 1
-        );
-        manifest.assets.push(GameCreationAppAssetManifestEntry {
-            id: id.clone(),
-            kind: kind.to_string(),
-            media_type: media_type.to_string(),
-            local_path: normalized_path.clone(),
-            source,
-        });
-        (id, "asset.register")
-    };
-    write_manifest(&manifest_path, &manifest)?;
+    let (id, record_type) = mutate_manifest_at(root, |manifest| {
+        if let Some(existing) = manifest
+            .assets
+            .iter_mut()
+            .find(|asset| asset.local_path == normalized_path)
+        {
+            existing.kind = kind.to_string();
+            existing.media_type = media_type.to_string();
+            existing.source = source;
+            Ok((existing.id.clone(), "asset.update"))
+        } else {
+            let id = format!(
+                "{id_prefix}-{}-{}",
+                unix_millis(),
+                manifest.assets.len() + 1
+            );
+            manifest.assets.push(GameCreationAppAssetManifestEntry {
+                id: id.clone(),
+                kind: kind.to_string(),
+                media_type: media_type.to_string(),
+                local_path: normalized_path.clone(),
+                source,
+            });
+            Ok((id, "asset.register"))
+        }
+    })?;
     append_agent_db_record(
         root,
         serde_json::json!({
diff --git a/apps/ai-game-creator-shell/src-tauri/src/config.rs b/apps/ai-game-creator-shell/src-tauri/src/config.rs
index 4404da0e7..4b47ff186 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/config.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/config.rs
@@ -150,8 +150,9 @@ pub(crate) fn parse_game_creator_llm_reasoning_effort(
         "low" => Ok(Some(platform_llm::LlmResponseReasoningEffort::Low)),
         "medium" => Ok(Some(platform_llm::LlmResponseReasoningEffort::Medium)),
         "high" => Ok(Some(platform_llm::LlmResponseReasoningEffort::High)),
+        "max" => Ok(Some(platform_llm::LlmResponseReasoningEffort::Max)),
         value => Err(format!(
-            "LLM reasoning_effort 无效：{value}，请使用 default、low、medium 或 high"
+            "LLM reasoning_effort 无效：{value}，请使用 default、low、medium、high 或 max"
         )),
     }
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/delegation.rs b/apps/ai-game-creator-shell/src-tauri/src/delegation.rs
index 573cccd63..4817ac216 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/delegation.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/delegation.rs
@@ -1512,7 +1512,7 @@ pub(crate) fn suppress_static_delegate_deliveries_for_parent_terminal_at(
     Ok(())
 }
 
-pub(crate) fn claimed_static_delegate_deliveries_at(
+pub(crate) fn static_delegate_deliveries_for_parent_at(
     root: &Path,
     parent_agent_id: &str,
     parent_run_id: &str,
@@ -1522,15 +1522,26 @@ pub(crate) fn claimed_static_delegate_deliveries_at(
     let mut deliveries = list_static_delegate_deliveries_at(root)?
         .into_iter()
         .filter(|delivery| {
-            delivery.parent_agent_id == parent_agent_id
-                && delivery.parent_run_id == parent_run_id
-                && delivery.status == StaticDelegateDeliveryStatus::ClaimedByParent
+            delivery.parent_agent_id == parent_agent_id && delivery.parent_run_id == parent_run_id
         })
         .collect::<Vec<_>>();
     deliveries.sort_by(|left, right| left.delegation_id.cmp(&right.delegation_id));
     Ok(deliveries)
 }
 
+pub(crate) fn claimed_static_delegate_deliveries_at(
+    root: &Path,
+    parent_agent_id: &str,
+    parent_run_id: &str,
+) -> Result<Vec<StaticDelegateDeliveryRecord>, String> {
+    Ok(
+        static_delegate_deliveries_for_parent_at(root, parent_agent_id, parent_run_id)?
+            .into_iter()
+            .filter(|delivery| delivery.status == StaticDelegateDeliveryStatus::ClaimedByParent)
+            .collect(),
+    )
+}
+
 pub(crate) fn static_delegate_claim_exists_at(
     root: &Path,
     parent_agent_id: &str,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs b/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs
index a49f17b04..b25c26e32 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs
@@ -97,16 +97,42 @@ fn project_write_lock_open_error_is_contention(error: &std::io::Error) -> bool {
     false
 }
 
+#[cfg(all(test, windows))]
+#[test]
+fn project_write_lock_treats_windows_target_races_as_contention() {
+    for code in [5, 32, 33] {
+        assert!(
+            project_write_lock_open_error_is_contention(&std::io::Error::from_raw_os_error(code)),
+            "Windows project lock error {code} must enter the bounded contention wait"
+        );
+    }
+}
+
+fn resolve_project_write_lock_path(root: &Path) -> Result<PathBuf, String> {
+    let normalized = normalize_relative_path(PROJECT_WRITE_LOCK_PATH)?;
+    let (parent_relative, file_name) = normalized
+        .rsplit_once('/')
+        .ok_or_else(|| "项目写锁路径必须包含安全父目录".to_string())?;
+    let parent = resolve_local_project_path(root, parent_relative)?;
+    // create_new is the authority for the final lock component. On Windows a
+    // delete-pending lock can make a metadata preflight fail with ACCESS_DENIED
+    // before the existing bounded contention wait has a chance to run.
+    Ok(parent.join(file_name))
+}
+
 pub(crate) fn acquire_project_write_lock(
     root: &Path,
     command_id: &str,
 ) -> Result<ProjectWriteLock, String> {
     validate_project_root(root)?;
-    let path = resolve_local_project_path(root, PROJECT_WRITE_LOCK_PATH)?;
+    let mut path = resolve_project_write_lock_path(root)?;
     if let Some(parent) = path.parent() {
         fs::create_dir_all(parent)
             .map_err(|error| format!("创建项目锁目录失败：{}: {error}", parent.display()))?;
     }
+    // Re-check the parent after creation so skipping metadata only for the final
+    // create_new target cannot weaken the normal ancestor link/reparse checks.
+    path = resolve_project_write_lock_path(root)?;
     let payload = serde_json::json!({
         "commandId": command_id,
         "pid": std::process::id(),
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
index 85c449ad9..fd1d82f5e 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
@@ -356,9 +356,28 @@ pub(crate) fn record_command_run(
 
 pub(crate) fn read_manifest_for_project(root: &Path) -> Result<GameCreationAppManifest, String> {
     let (manifest_path, mut manifest) = read_or_create_manifest(root)?;
+    let canonical_manifest_installed = match fs::symlink_metadata(&manifest_path) {
+        Ok(metadata) if metadata.file_type().is_symlink() || !metadata.is_file() => {
+            return Err("manifest 必须是普通文件".to_string());
+        }
+        Ok(_) => true,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => false,
+        Err(error) => {
+            return Err(format!(
+                "读取 manifest 元数据失败：{}: {error}",
+                manifest_path.display()
+            ));
+        }
+    };
+    let original = manifest.clone();
     ensure_manifest_seed_tasks(root, &mut manifest);
-    write_manifest(&manifest_path, &manifest)?;
-    Ok(manifest)
+    if canonical_manifest_installed && manifest == original {
+        return Ok(manifest);
+    }
+    mutate_manifest_at(root, |current| {
+        ensure_manifest_seed_tasks(root, current);
+        Ok(current.clone())
+    })
 }
 
 pub(crate) fn read_existing_manifest_for_project(
@@ -422,13 +441,13 @@ pub(crate) fn ensure_manifest_has_seed_tasks(
     root: &Path,
     goal: Option<&str>,
 ) -> Result<GameCreationAppManifest, String> {
-    let (manifest_path, mut manifest) = read_or_create_manifest(root)?;
-    ensure_manifest_seed_tasks(root, &mut manifest);
-    if let Some(goal) = goal.map(str::trim).filter(|goal| !goal.is_empty()) {
-        manifest.goal = Some(goal.to_string());
-    }
-    write_manifest(&manifest_path, &manifest)?;
-    Ok(manifest)
+    mutate_manifest_at(root, |manifest| {
+        ensure_manifest_seed_tasks(root, manifest);
+        if let Some(goal) = goal.map(str::trim).filter(|goal| !goal.is_empty()) {
+            manifest.goal = Some(goal.to_string());
+        }
+        Ok(manifest.clone())
+    })
 }
 
 pub(crate) fn record_draft_task_progress(
@@ -643,15 +662,14 @@ pub(crate) fn update_manifest_task_status_at(
     if task_id.is_empty() {
         return Err("任务 ID 不能为空".to_string());
     }
-    let (manifest_path, mut manifest) = read_or_create_manifest(root)?;
-    ensure_manifest_seed_tasks(root, &mut manifest);
-    let Some(task) = manifest.tasks.iter_mut().find(|task| task.id == task_id) else {
-        return Err(format!("项目任务不存在：{task_id}"));
-    };
-    task.status = status;
-    let updated = task.clone();
-    write_manifest(&manifest_path, &manifest)?;
-    Ok(updated)
+    mutate_manifest_at(root, |manifest| {
+        ensure_manifest_seed_tasks(root, manifest);
+        let Some(task) = manifest.tasks.iter_mut().find(|task| task.id == task_id) else {
+            return Err(format!("项目任务不存在：{task_id}"));
+        };
+        task.status = status;
+        Ok(task.clone())
+    })
 }
 
 pub(crate) fn create_manifest_task_at(
@@ -821,6 +839,28 @@ pub(crate) fn read_or_create_manifest(
     Ok((manifest_path, manifest))
 }
 
+pub(crate) fn mutate_manifest_at<T>(
+    root: &Path,
+    mutate: impl FnOnce(&mut GameCreationAppManifest) -> Result<T, String>,
+) -> Result<T, String> {
+    if root.as_os_str().is_empty() {
+        return Err("项目目录不能为空".to_string());
+    }
+    if !root.is_absolute() {
+        return Err("项目目录必须是绝对路径".to_string());
+    }
+    let manifest_path = root.join(".agent/manifest.json");
+    if let Some(parent) = manifest_path.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|error| format!("创建 manifest 目录失败：{}: {error}", parent.display()))?;
+    }
+    let _write_lock = acquire_manifest_write_lock(&manifest_path)?;
+    let (_, mut manifest) = read_or_create_manifest(root)?;
+    let result = mutate(&mut manifest)?;
+    write_manifest_locked(&manifest_path, &manifest)?;
+    Ok(result)
+}
+
 fn manifest_backup_path(path: &Path) -> PathBuf {
     path.with_file_name(format!(
         ".{}.previous",
@@ -1008,16 +1048,20 @@ fn write_manifest_with_lock_hook<F>(
 where
     F: FnOnce(),
 {
-    validate_game_iteration_versions(&manifest.versions)
-        .map_err(|error| format!("校验 manifest 项目版本失败：{error}"))?;
-    let payload = serde_json::to_string_pretty(manifest)
-        .map_err(|error| format!("序列化 manifest 失败：{error}"))?;
     if let Some(parent) = path.parent() {
         fs::create_dir_all(parent)
             .map_err(|error| format!("创建 manifest 目录失败：{}: {error}", parent.display()))?;
     }
     let _write_lock = acquire_manifest_write_lock(path)?;
     after_lock();
+    write_manifest_locked(path, manifest)
+}
+
+fn write_manifest_locked(path: &Path, manifest: &GameCreationAppManifest) -> Result<(), String> {
+    validate_game_iteration_versions(&manifest.versions)
+        .map_err(|error| format!("校验 manifest 项目版本失败：{error}"))?;
+    let payload = serde_json::to_string_pretty(manifest)
+        .map_err(|error| format!("序列化 manifest 失败：{error}"))?;
     if manifest_storage_exists(path)? {
         let existing = read_manifest(path)?;
         if existing.versions.len() > manifest.versions.len()
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/manifest/recovery_tests.rs b/apps/ai-game-creator-shell/src-tauri/src/project/manifest/recovery_tests.rs
index 0e6bdd66e..e72d29970 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/manifest/recovery_tests.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/manifest/recovery_tests.rs
@@ -43,6 +43,116 @@ fn manifest_read_and_project_write_recover_previous_file() {
     fs::remove_dir_all(root).ok();
 }
 
+#[test]
+fn manifest_read_installs_a_canonical_file_when_storage_is_missing() {
+    let root = unique_manifest_test_root("install-missing-canonical");
+    let manifest_path = root.join(".agent/manifest.json");
+    let backup_path = root.join(".agent/.manifest.json.previous");
+
+    let manifest = read_manifest_for_project(&root).expect("create missing manifest");
+    assert_eq!(manifest.project_id, "local-project-draft");
+    assert!(manifest_path.is_file());
+    assert!(!backup_path.exists());
+    assert_eq!(
+        read_manifest(&manifest_path).expect("read installed manifest"),
+        manifest
+    );
+
+    fs::remove_dir_all(root).ok();
+}
+
+#[test]
+fn manifest_task_and_asset_mutations_are_serialized_across_the_full_transaction() {
+    let root = unique_manifest_test_root("serialized-task-asset-mutations");
+    ensure_manifest_has_seed_tasks(&root, None).expect("seed manifest tasks");
+    fs::create_dir_all(root.join("assets")).expect("create assets directory");
+    fs::write(root.join("assets/concurrent.png"), b"asset").expect("write asset fixture");
+
+    let (locked_tx, locked_rx) = std::sync::mpsc::channel();
+    let (release_tx, release_rx) = std::sync::mpsc::channel();
+    let first_root = root.clone();
+    let first = std::thread::spawn(move || {
+        mutate_manifest_at(&first_root, |manifest| {
+            let task = manifest
+                .tasks
+                .iter_mut()
+                .find(|task| task.id == "design-director")
+                .expect("design-director task");
+            task.status = GameCreationAppTaskStatus::Completed;
+            locked_tx.send(()).expect("announce held manifest lock");
+            release_rx.recv().expect("release held manifest lock");
+            Ok(())
+        })
+        .expect("commit task status transaction");
+    });
+
+    locked_rx.recv().expect("first transaction acquired lock");
+    let (started_tx, started_rx) = std::sync::mpsc::channel();
+    let second_root = root.clone();
+    let second = std::thread::spawn(move || {
+        started_tx
+            .send(())
+            .expect("announce asset transaction start");
+        crate::assets::register_local_asset_entry(
+            &second_root,
+            "assets/concurrent.png",
+            "ui-prototype",
+            "image/png",
+            "test",
+            GameCreationAppAssetSource {
+                kind: GameCreationAppAssetSourceKind::Generated,
+                canvas_project_id: None,
+                resource_id: None,
+                asset_object_id: None,
+                task_id: None,
+                prompt: None,
+                model: None,
+                generation_route: None,
+                generation_kind: None,
+                reference_resource_ids: Vec::new(),
+            },
+        )
+        .expect("register concurrent asset");
+    });
+    started_rx.recv().expect("asset transaction started");
+    release_tx.send(()).expect("release task transaction");
+    first.join().expect("join task transaction");
+    second.join().expect("join asset transaction");
+
+    let manifest = read_existing_manifest_for_project(&root).expect("read final manifest");
+    assert_eq!(
+        manifest
+            .tasks
+            .iter()
+            .find(|task| task.id == "design-director")
+            .map(|task| task.status.clone()),
+        Some(GameCreationAppTaskStatus::Completed)
+    );
+    assert!(manifest
+        .assets
+        .iter()
+        .any(|asset| asset.local_path == "assets/concurrent.png"));
+
+    fs::remove_dir_all(root).ok();
+}
+
+#[test]
+fn canonical_manifest_read_does_not_reenter_the_write_lock() {
+    let root = unique_manifest_test_root("canonical-read-with-write-lock-held");
+    ensure_manifest_has_seed_tasks(&root, None).expect("seed manifest tasks");
+    let manifest_path = root.join(".agent/manifest.json");
+    let _write_lock = acquire_manifest_write_lock(&manifest_path).expect("hold manifest lock");
+
+    let manifest = read_manifest_for_project(&root).expect("read canonical manifest");
+    assert_eq!(
+        manifest.tasks.len(),
+        new_game_creation_app_seed_tasks().len()
+    );
+
+    drop(_write_lock);
+    fs::remove_dir_all(root).ok();
+}
+
 fn version_fixture(
     version_id: &str,
     parent_version_id: Option<&str>,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/static_deliveries.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/static_deliveries.rs
index 1ebf3f0a2..0a9f01982 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/static_deliveries.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/static_deliveries.rs
@@ -2655,7 +2655,7 @@ fn project_supervisor_claimed_contract_query_is_exact_scoped_and_drives_repair()
     assert_eq!(wrong_parent.status, "failed");
     assert!(wrong_parent
         .summary
-        .contains("不属于当前 Supervisor 父 run"));
+        .contains("不属于当前可信父 run 或尚未认领"));
     assert!(wrong_parent.detail.is_none());
 
     let unclaimed_delegation_id = "project-supervisor-claimed-contract-unclaimed";
@@ -2704,7 +2704,9 @@ fn project_supervisor_claimed_contract_query_is_exact_scoped_and_drives_repair()
         &serde_json::json!({"delegationId": original_delegation_id}),
     );
     assert_eq!(specialist_query.status, "failed");
-    assert!(specialist_query.summary.contains("只有 Project Supervisor"));
+    assert!(specialist_query
+        .summary
+        .contains("不属于当前可信父 run 或尚未认领"));
     assert!(specialist_query.detail.is_none());
 
     let mut invalid_repair_criteria = observed_criteria.clone();
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/supervisor_planning.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/supervisor_planning.rs
index 3fead9ed2..ef285d0e7 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/supervisor_planning.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/collaboration/supervisor_planning.rs
@@ -894,6 +894,10 @@ async fn autonomous_supervisor_delegates_failed_playtest_repair_after_collaborat
         "自主构建总控委派试玩修复测试",
     )
     .expect("project init");
+    write_static_smoke_game_fixture_for_test(
+        &root,
+        "autonomous supervisor delegated playtest repair",
+    );
     let run_id = "autonomous-supervisor-delegated-playtest-repair-run";
     bind_game_creator_agent_runtime_run_profile_at(
         &root,
@@ -1081,6 +1085,7 @@ fn supervisor_preview_tracks_specialist_revision_without_fake_mutation() {
         "总控验收专业产物验证门测试",
     )
     .expect("project init");
+    write_static_smoke_game_fixture_for_test(&root, "supervisor specialist preview gate");
     let supervisor_run_id = "supervisor-specialist-preview-run";
     let first_revision = prepare_agent_runtime_project_mutation_locked(
         &root,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/configuration.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/configuration.rs
index 2b70787dc..4179467de 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/configuration.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/configuration.rs
@@ -1047,7 +1047,13 @@ fn llm_reasoning_effort_supports_provider_default_and_explicit_levels() {
         parse_game_creator_llm_reasoning_effort("high"),
         Ok(Some(platform_llm::LlmResponseReasoningEffort::High))
     );
-    assert!(parse_game_creator_llm_reasoning_effort("maximum").is_err());
+    assert_eq!(
+        parse_game_creator_llm_reasoning_effort("max"),
+        Ok(Some(platform_llm::LlmResponseReasoningEffort::Max))
+    );
+    let error = parse_game_creator_llm_reasoning_effort("maximum")
+        .expect_err("maximum is not the max wire value");
+    assert!(error.contains("max"));
 
     let mut llm = GameCreatorLlmConfig::default();
     llm.reasoning_effort = "default".to_string();
@@ -1056,13 +1062,13 @@ fn llm_reasoning_effort_supports_provider_default_and_explicit_levels() {
             .expect("provider default request");
     assert_eq!(request.response_reasoning_effort, None);
 
-    llm.reasoning_effort = "high".to_string();
+    llm.reasoning_effort = "max".to_string();
     let request =
         apply_game_creator_llm_reasoning_effort(LlmRunRequest::single_turn("system", "user"), &llm)
-            .expect("high reasoning request");
+            .expect("max reasoning request");
     assert_eq!(
         request.response_reasoning_effort,
-        Some(platform_llm::LlmResponseReasoningEffort::High)
+        Some(platform_llm::LlmResponseReasoningEffort::Max)
     );
 }
 
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/mod.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/mod.rs
index 0d66111ed..642927481 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/mod.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/mod.rs
@@ -1455,6 +1455,15 @@ fn fake_llm_game_draft() -> LlmGameDraft {
         }
 }
 
+fn write_static_smoke_game_fixture_for_test(root: &Path, marker: &str) {
+    let html = format!(
+        "{}\n<!-- static-smoke fixture: {marker} -->\n",
+        fake_llm_game_draft().game_html
+    );
+    fs::write(root.join("game/index.html"), html)
+        .expect("write complete static-smoke game fixture");
+}
+
 fn fake_agent_handoffs() -> Vec<LlmAgentHandoff> {
     vec![
         handoff(
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
index 7a8b75405..39fb4ea1c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
@@ -585,12 +585,8 @@ async fn background_agent_runtime_preview_start_respects_project_policy() {
     )));
     assert!(!root.join(".agent/logs/preview.log").exists());
 
-    cancel_game_creator_agent_runtime_task_at(
-        &root,
-        "code-prototype",
-        "code-preview-policy-run",
-    )
-    .expect("cancel waiting preview policy task");
+    cancel_game_creator_agent_runtime_task_at(&root, "code-prototype", "code-preview-policy-run")
+        .expect("cancel waiting preview policy task");
     wait_for_agent_runtime_terminal_and_lane_release(
         &root,
         "code-prototype",
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/project_tools.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/project_tools.rs
index 0855d3403..eacec8589 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/project_tools.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/project_tools.rs
@@ -5686,6 +5686,73 @@ fn runtime_parallel_read_projection_waits_across_a_manifest_wave_project_write()
     fs::remove_dir_all(root).ok();
 }
 
+#[cfg(windows)]
+#[test]
+fn runtime_project_write_lock_waits_for_delete_pending_target() {
+    use std::os::windows::fs::OpenOptionsExt;
+    use std::os::windows::io::AsRawHandle;
+    use windows_sys::Win32::Storage::FileSystem::{
+        FileDispositionInfo, SetFileInformationByHandle, FILE_DISPOSITION_INFO,
+    };
+
+    const DELETE_ACCESS: u32 = 0x0001_0000;
+    const GENERIC_READ: u32 = 0x8000_0000;
+    const FILE_SHARE_READ: u32 = 0x0000_0001;
+    const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+
+    let root = unique_project_path();
+    init_local_game_project_at(&root, "project-1", "delete pending project lock wait")
+        .expect("project init");
+    let lock_path = root.join(PROJECT_WRITE_LOCK_PATH);
+    fs::write(&lock_path, "delete-pending-project-lock").expect("write lock fixture");
+
+    let delete_pending = fs::OpenOptions::new()
+        .access_mode(GENERIC_READ | DELETE_ACCESS)
+        .share_mode(FILE_SHARE_READ)
+        .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
+        .open(&lock_path)
+        .expect("open delete-pending lock fixture");
+    let disposition = FILE_DISPOSITION_INFO { DeleteFile: true };
+    // SAFETY: delete_pending is live and disposition has the required layout.
+    assert_ne!(
+        unsafe {
+            SetFileInformationByHandle(
+                delete_pending.as_raw_handle().cast(),
+                FileDispositionInfo,
+                (&raw const disposition).cast(),
+                std::mem::size_of::<FILE_DISPOSITION_INFO>() as u32,
+            )
+        },
+        0,
+        "mark project lock delete-pending: {}",
+        std::io::Error::last_os_error()
+    );
+    let create_error = fs::OpenOptions::new()
+        .create_new(true)
+        .write(true)
+        .open(&lock_path)
+        .expect_err("delete-pending target must block the create_new contention path");
+    assert!(
+        create_error.kind() == std::io::ErrorKind::PermissionDenied
+            || create_error.raw_os_error() == Some(5),
+        "delete-pending create_new should reproduce ACCESS_DENIED: {create_error}"
+    );
+    let release = std::thread::spawn(move || {
+        std::thread::sleep(Duration::from_millis(50));
+        drop(delete_pending);
+    });
+
+    let acquired = acquire_game_creator_agent_runtime_project_write_lock_with_wait(
+        &root,
+        "runtime.parallel_read.project",
+    )
+    .expect("runtime projection should outwait a delete-pending project lock");
+    drop(acquired);
+    release.join().expect("release delete-pending lock fixture");
+    assert!(!lock_path.exists());
+    fs::remove_dir_all(root).ok();
+}
+
 #[tokio::test]
 async fn agent_runtime_file_write_waits_for_short_parallel_project_writer() {
     let root = unique_project_path();
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/provider.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/provider.rs
index fa253f251..e260cb1a2 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/provider.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/provider.rs
@@ -1625,6 +1625,10 @@ async fn autonomous_game_build_repairs_persisted_failed_playtest_after_context_c
         "自主构建总控持久试玩失败活性测试",
     )
     .expect("project init");
+    write_static_smoke_game_fixture_for_test(
+        &root,
+        "persisted failed playtest after context compaction",
+    );
     write_supervisor_collaboration_policy_at(&root, SupervisorCollaborationPolicy::default())
         .expect("disable unrelated collaboration preflight");
     let run_id = "autonomous-supervisor-persisted-playtest-liveness-run";
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/planning_strategy/autonomous_build.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/planning_strategy/autonomous_build.rs
index 40e30ae0a..78ce701e8 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/planning_strategy/autonomous_build.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/planning_strategy/autonomous_build.rs
@@ -1840,6 +1840,7 @@ async fn autonomous_game_build_repairs_new_revision_after_failed_playtest_with_v
         "自主构建总控新 revision 复验测试",
     )
     .expect("project init");
+    write_static_smoke_game_fixture_for_test(&root, "reverify new revision after failed playtest");
     write_supervisor_collaboration_policy_at(&root, SupervisorCollaborationPolicy::default())
         .expect("disable unrelated collaboration preflight");
     let run_id = "autonomous-supervisor-reverify-new-revision-run";
@@ -1992,6 +1993,7 @@ async fn autonomous_game_build_claims_ready_delivery_before_fourth_playtest_dele
         "自主构建总控 ready 回执收敛测试",
     )
     .expect("project init");
+    write_static_smoke_game_fixture_for_test(&root, "ready delivery initial revision");
     let run_id = "autonomous-supervisor-ready-delivery-convergence-run";
     bind_game_creator_agent_runtime_run_profile_at(
         &root,
@@ -2059,11 +2061,7 @@ async fn autonomous_game_build_claims_ready_delivery_before_fourth_playtest_dele
     )
     .expect("record specialist repair after failed playtest");
     assert_eq!(repaired_revision, failed_revision + 1);
-    fs::write(
-        root.join("game/index.html"),
-        "<!doctype html><html><body>ready delivery revision</body></html>\n",
-    )
-    .expect("write specialist repair fixture");
+    write_static_smoke_game_fixture_for_test(&root, "ready delivery repaired revision");
 
     let deliveries = [
         (
@@ -2368,6 +2366,7 @@ async fn autonomous_game_build_claims_ready_delivery_before_fourth_playtest_dele
         &preview_plan,
         true,
         false,
+        false,
     )
     .is_ok());
 
@@ -2395,6 +2394,7 @@ async fn autonomous_game_build_claims_ready_delivery_before_fourth_playtest_dele
         &stale_delegate_plan,
         true,
         false,
+        false,
     )
     .expect_err("static-verified revision must reject another stale delegate");
     assert!(stale_delegate_error
@@ -3211,6 +3211,7 @@ async fn autonomous_game_build_verified_revision_forces_response_only_delivery()
     .expect("persist verified delivery plan");
     write_game_creator_agent_runtime_state(&root, &runtime)
         .expect("write verified delivery runtime");
+    write_static_smoke_game_fixture_for_test(&root, "verified specialist delivery");
     advance_project_revision_for_test(&root, "code-prototype", child_run_id, "file.patch");
     persist_project_verification_for_test(
         &root,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/support.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/support.rs
index 0a9ca06bf..e3f8cf7fa 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/support.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_actions/support.rs
@@ -27,7 +27,7 @@ pub(super) use super::super::{
     wait_for_agent_runtime_confirmation, wait_for_agent_runtime_idle,
     wait_for_agent_runtime_terminal_and_lane_release, wait_for_captured_mock_request,
     write_agent_runtime_task_record_for_test, write_agent_runtime_verification_fixture,
-    write_test_local_config,
+    write_static_smoke_game_fixture_for_test, write_test_local_config,
 };
 
 pub(super) use crate::{
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_state.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_state.rs
index e6908bf47..39b8c96ad 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_state.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/runtime_state.rs
@@ -583,6 +583,104 @@ fn structured_plan_update_validates_and_advances_monotonically() {
     assert!(structured_plan_completion_blocker(&runtime).is_none());
 }
 
+#[test]
+fn first_structured_plan_replaces_terminal_legacy_scaffolding_steps() {
+    let mut runtime = default_game_creator_agent_runtime_state("code-prototype", "legacy-plan-run");
+    runtime.plan = vec![
+        "记录开发者投递的后台任务".to_string(),
+        "结构化修复步骤 2".to_string(),
+    ];
+    runtime.plan_steps = vec![
+        AgentRuntimePlanStep {
+            index: 0,
+            title: "记录开发者投递的后台任务".to_string(),
+            status: "active".to_string(),
+            detail: None,
+            updated_at: unix_timestamp(),
+        },
+        AgentRuntimePlanStep {
+            index: 1,
+            title: "结构化修复步骤 2".to_string(),
+            status: "pending".to_string(),
+            detail: Some("legacy-detail-canary".to_string()),
+            updated_at: 1,
+        },
+    ];
+    runtime.active_plan_step_index = Some(0);
+    complete_agent_runtime_active_plan_step(
+        &mut runtime,
+        "failed",
+        "command.run_limited：failed · game.static_smoke 执行失败",
+    );
+    assert_eq!(runtime.plan_revision, 0);
+    assert_eq!(runtime.plan_steps.len(), 2);
+    assert_eq!(runtime.plan_steps[0].status, "failed");
+
+    let first_structured_update = AgentRuntimePlanUpdate {
+        explanation: "根据 smoke 诊断进入同 Run 修复".to_string(),
+        steps: (1..=AGENT_RUNTIME_PLAN_STEP_LIMIT)
+            .map(|index| AgentRuntimePlanUpdateStep {
+                step: format!("结构化修复步骤 {index}"),
+                status: if index == 1 { "in_progress" } else { "pending" }.to_string(),
+            })
+            .collect(),
+    };
+
+    assert!(
+        apply_agent_runtime_plan_update(&mut runtime, &first_structured_update)
+            .expect("first structured plan replaces legacy scaffolding")
+    );
+    assert_eq!(runtime.plan_revision, 1);
+    assert_eq!(runtime.plan_steps.len(), AGENT_RUNTIME_PLAN_STEP_LIMIT);
+    assert_eq!(runtime.active_plan_step_index, Some(0));
+    assert!(runtime
+        .plan_steps
+        .iter()
+        .all(|step| step.title != "记录开发者投递的后台任务"));
+    assert!(runtime
+        .plan_steps
+        .iter()
+        .all(|step| step.status != "failed"));
+    let same_title_step = runtime
+        .plan_steps
+        .iter()
+        .find(|step| step.title == "结构化修复步骤 2")
+        .expect("same-title structured step exists");
+    assert_eq!(same_title_step.detail, None);
+    assert_ne!(same_title_step.updated_at, 1);
+}
+
+#[test]
+fn structured_plan_failed_step_remains_immutable_after_migration() {
+    let mut runtime = default_game_creator_agent_runtime_state("code-prototype", "failed-plan-run");
+    runtime.plan_revision = 1;
+    runtime.plan_explanation = "已进入结构化计划".to_string();
+    runtime.plan = vec!["不可改写的失败步骤".to_string()];
+    runtime.plan_steps = vec![AgentRuntimePlanStep {
+        index: 0,
+        title: "不可改写的失败步骤".to_string(),
+        status: "failed".to_string(),
+        detail: Some("非验证类动作失败".to_string()),
+        updated_at: unix_timestamp(),
+    }];
+
+    let error = apply_agent_runtime_plan_update(
+        &mut runtime,
+        &AgentRuntimePlanUpdate {
+            explanation: "尝试错误重开".to_string(),
+            steps: vec![AgentRuntimePlanUpdateStep {
+                step: "不可改写的失败步骤".to_string(),
+                status: "in_progress".to_string(),
+            }],
+        },
+    )
+    .expect_err("structured failed step must remain immutable");
+
+    assert!(error.contains("不能改写已失败步骤"));
+    assert_eq!(runtime.plan_revision, 1);
+    assert_eq!(runtime.plan_steps[0].status, "failed");
+}
+
 #[test]
 fn structured_plan_update_rejects_invalid_shapes_and_ignores_action_indexes() {
     let invalid_updates = [
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/sessions.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/sessions.rs
index 2b6dc6663..06d3209ce 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/sessions.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/sessions.rs
@@ -1247,9 +1247,7 @@ fn agent_conversation_sessions_preserve_legacy_and_isolate_new_history() {
     let legacy_history_path = legacy_history.path.replace('\\', "/");
     let new_history_path = new_history.path.replace('\\', "/");
     assert!(legacy_history_path.ends_with("design-director.jsonl"));
-    assert!(new_history_path.ends_with(&format!(
-        "design-director/sessions/{new_session_id}.jsonl"
-    )));
+    assert!(new_history_path.ends_with(&format!("design-director/sessions/{new_session_id}.jsonl")));
     let legacy_context = render_local_conversation_prompt_context_for_session(
         &root,
         Some("design-director"),
diff --git a/apps/ai-game-creator-shell/src/app/types.ts b/apps/ai-game-creator-shell/src/app/types.ts
index d97a3ca63..348bb4d54 100644
--- a/apps/ai-game-creator-shell/src/app/types.ts
+++ b/apps/ai-game-creator-shell/src/app/types.ts
@@ -449,6 +449,7 @@ export const gameCreatorLlmReasoningEfforts = [
   'low',
   'medium',
   'high',
+  'max',
 ] as const;
 export type GameCreatorLlmReasoningEffort =
   (typeof gameCreatorLlmReasoningEfforts)[number];
diff --git a/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts
index dbf21eed7..941667351 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts
@@ -862,9 +862,10 @@ export function registerPublishedRuntimeSettingsTests() {
       screen.getByLabelText('LLM API Key').getAttribute('autocomplete'),
     ).toBe('off');
     fireEvent.click(screen.getByRole('button', { name: /连接与工具/ }));
-    expect(
-      screen.getByLabelText('External Editor API Key'),
-    ).toHaveProperty('type', 'password');
+    expect(screen.getByLabelText('External Editor API Key')).toHaveProperty(
+      'type',
+      'password',
+    );
     expect(
       screen
         .getByLabelText('External Editor API Key')
@@ -913,6 +914,12 @@ export function registerPublishedRuntimeSettingsTests() {
       'value',
       '',
     );
+    expect(
+      within(screen.getByLabelText('Generator LLM 推理档')).getByRole(
+        'option',
+        { name: 'max' },
+      ),
+    ).not.toBeNull();
     expect(
       screen.getByLabelText('生成首版美术素材 (art/Asset) LLM 推理档'),
     ).toHaveProperty('value', '');
@@ -970,6 +977,11 @@ export function registerPublishedRuntimeSettingsTests() {
       'value',
       'medium',
     );
+    expect(
+      within(screen.getByLabelText('LLM 推理档')).getByRole('option', {
+        name: 'max',
+      }),
+    ).not.toBeNull();
     fireEvent.change(screen.getByLabelText('LLM API Key'), {
       target: { value: 'unit-new-secret-value' },
     });
@@ -1195,9 +1207,10 @@ export function registerPublishedRuntimeSettingsTests() {
       '12000',
     );
     fireEvent.click(screen.getByRole('button', { name: /连接与工具/ }));
-    expect(
-      screen.getByLabelText('External Editor Base URL'),
-    ).toHaveProperty('value', 'http://127.0.0.1:8082');
+    expect(screen.getByLabelText('External Editor Base URL')).toHaveProperty(
+      'value',
+      'http://127.0.0.1:8082',
+    );
     fireEvent.click(
       within(runtimeConfigDialog).getByRole('button', { name: '保存' }),
     );
diff --git a/docs/project-memory/plans/【实施计划】AGC无人值守游戏生成可靠性收口-2026-08-13.md b/docs/project-memory/plans/【实施计划】AGC无人值守游戏生成可靠性收口-2026-08-13.md
index ab91bdf12..c8365a73f 100644
--- a/docs/project-memory/plans/【实施计划】AGC无人值守游戏生成可靠性收口-2026-08-13.md
+++ b/docs/project-memory/plans/【实施计划】AGC无人值守游戏生成可靠性收口-2026-08-13.md
@@ -241,7 +241,18 @@ git diff --check
 - 相关定向测试、类型检查、编码检查和 diff 检查通过。
 - 使用真实 Provider 的空项目 smoke 成功；若现场外部服务不可用，则代码可以提交为“实现完成、真实现场验收未完成”，不得宣称目标已完全达成。
 
-## 9. 回滚边界
+## 9. 实施与验证记录（2026-08-15）
+
+在 `codex/agc-runtime-generation-reliability` 分支完成：
+
+- 可信 `code-prototype` 父 Run 可认领并观察直属美术 delivery、按 `delegationId` 精确读取合同；错误 Agent/Run、未知合同与身份篡改统一失败关闭。父 task/chain 无法证明但仍有活跃或已认领 delivery 时 completion 必须 blocked；Suppressed 且未形成 child 的失败前置记录不参与 capability、claim 与 completion barrier。
+- 普通失败或不合法安全默认 marker 认领后立即收束；合法 `game-chat-safe-default-repair.v1` marker 由 Runtime 直接生成唯一一层、同目标、同合同 `agent.delegate`，repairRequired 状态下重复 route/read/query 被 liveness 门拒绝。
+- Windows `.agent/project.lock` 不再对最终 `create_new` 目标做 metadata 预检，delete-pending 的 5/32/33 统一进入有界竞争等待；新增 delete-pending 回归，复现真实 `create_new` ACCESS_DENIED 后证明等待可收束。
+- 验证结果：`game_chat_` 113 通过、`autonomous_completion_contract` 107 通过、`safe_default` 4 通过、`static_smoke` 9 通过、`action_receipt` 10 通过、`project_execution_owner` 8 通过、runner 重启恢复与 Windows 锁回归通过；串行全量 Rust `1856 passed / 0 failed / 15 ignored`（含新增 HTML 内联语法 fail-open 回归）；`platform-llm` 与 `agent-runtime-core` 全绿；前端 typecheck、`check:encoding`、`git diff --check`、变更文件 `rustfmt --check` 通过。
+- 真实 `gpt-5.6-sol / reasoningEffort=max` 隔离轮次：14 个 Provider 请求全部完成并闭合，无确认、追问、steer、路径/密钥/正文泄漏，Runner 与后代进程清理为零残留；在未配置 External Editor 的边界下 art-director 失败后由主 Run 认领并快速明确收束，未再次空转。
+- 待完成：用有效 External Editor 配置跑一轮完整 playable 真实验收；当前结果不能宣称现场完整生成已通过。
+
+## 10. 回滚边界
 
 - 默认路由可回退到原 `project-supervisor-gui`，但不能同时保留两套普通入口形成随机分流。
 - 自动权限只由可信 source + root profile + binding fingerprint 共同启用；回滚时删除该窄例外，不修改全局策略默认值。
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 648c30f4c..93996e1f8 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -1,5 +1,28 @@
 # 决策记录
 
+## 2026-08-15 AGC game-chat 主代码 Run 接管直属美术 delivery
+
+- 背景：真实 `gpt-5.6-sol / max` 验收中，`art-director` 失败后已形成 `ready + needs-repair` delivery，但认领、合同读取、claim observation 和完成 blocker 均硬编码为 Supervisor-only；实际直属父 Run `code-prototype` 无法消费回执，随后又发起 29 次 Provider 请求。
+- 决策：保留原 Supervisor 能力，并把 delivery 管理权限窄扩展给身份链完整的当前可信 game-chat `code-prototype` 父 Run。Runtime 在存在 ready 回执时确定性执行 `agent.run_status(scope=self)`；claim 未完整 Observed 前不请求 Provider；普通失败或不合法 marker 认领后立即终止。完整 `game-chat-safe-default-repair.v1` marker 不再交回 Provider 决策，而是由 Runtime 按原 Agent、原合同和原 delegationId 直接生成唯一一层 `agent.delegate`；repairRequired 状态的重复 route/read/query 由 liveness 门拒绝。
+- 安全边界：权限必须同时证明 game-chat 根 source/profile、root/parent/child task、父 binding fingerprint、delivery parent/session/run、delegationId 和目标 Agent；Agent ID、任务正文或错误关键词不能授权。身份损坏时 capability、run status 和 completion gate 全部失败关闭；父 task/chain 无法证明但仍有活跃或已认领 delivery 时也必须 blocked，不能静默当作“不适用”。Suppressed 且未形成 child 的失败前置记录不再参与 capability、claim 或 completion barrier，以保留同 action reopen / 新 action 重试语义。`code-prototype` 只能管理内部 delivery，正式用户 assistant 与根 completed 投影仍只允许根 `project-supervisor`。
+- 验证方式：覆盖合法认领与合同精确读取、错误 Agent/Run/delegation 拒绝、delivery 身份篡改阻断、唯一安全默认返工、普通失败零后续 Provider lifecycle，以及新的真实 Provider 空项目轮次。顺带收紧 `validate_executable_inline_javascript_syntax`：正文游离 `<` 不再吞掉后续 `<script>`，未闭合或非标签状 `<` 继续扫描，避免后置脚本被静默跳过语法校验。
+- 关联文档：`docs/technical/【技术方案】AI游戏创作Agent Runtime V1.1-2026-07-12.md`、`docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md`。
+
+## 2026-08-14 AGC 将 reasoningEffort=max 作为独立强度贯通
+
+- 背景：`gpt-5.6-sol / max` 真实验收预检发现，AGC 与 `platform-llm` 只接受到 `high`；同时 canonical Agent 会先用角色默认强度覆盖全局值，空 `agentLlm` 不能证明实际请求使用 `max`。
+- 决策：新增独立 `max` 枚举和 wire 值，贯通配置、Provider 适配、Codex 映射、请求指纹、前端类型与配置检查；禁止把 `max` 静默映射成 `high` 或 `x-high`。本轮真实验收使用 `agentMode=provider`，并为 Supervisor、主代码 Agent 和两个条件美术 Agent 显式设置 `max` 覆盖。
+- 验证方式：定向验证配置解析、Responses 请求 JSON、Provider 双向适配和 Codex effort；真实 E2E 报告必须同时绑定 `providerModel=gpt-5.6-sol`、`providerReasoningEffort=max`、`providerApiKind=openai_responses` 与 endpoint SHA-256。
+- 关联文档：`docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md`。
+
+## 2026-08-14 首份结构化计划完整替换 legacy 计划脚手架
+
+- 背景：真实 Luna 无人值守轮次在 revision 2 的 `game.static_smoke` 失败后，于同一 `code-prototype` Run 成功 patch 到 revision 3，但没有重新验证。取证确认 smoke 失败发生在 `planRevision=0` 阶段，Runtime 先把 legacy 活动步骤标为 `failed`；随后首份结构化 `planUpdate` 错误保留该 legacy 终态，game-chat 快车道因“结构化计划含 failed 步骤”在读取当前 revision 门禁前终止。
+- 决策：`planRevision=0 -> 1` 是 legacy 到 structured 的一次性迁移边界。第一次有效结构化更新完整替换 legacy `plan / planSteps / activePlanStepIndex`，不继承任何 legacy `completed / failed` 脚手架步骤；只有函数入口处已经存在结构化计划时，才合并并保护历史终态。
+- 安全边界：已建立结构化计划后的 `completed / failed` 单调与不可改写语义保持不变，普通失败继续 fail-closed；不新增 smoke receipt 特判恢复通道，不放宽项目 revision、static smoke、desktop/mobile 试玩、身份绑定或最终完成门。
+- 验证方式：覆盖 legacy failed 被首份结构化计划替换、structured failed 仍不可改写，以及 `smoke failed -> structured repair plan -> same-run patch -> current revision smoke recheck`；运行 `structured_plan_`、`game_chat_` 分组和串行 Rust 全量，并以新的独立 `gpt-5.6-sol` / `max` 真实 Provider 空项目轮次取得完整最终证据。
+- 关联文档：`docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md`。
+
 ## 2026-08-12 Repository checks 采用 CI 与本地共用的单一门禁入口
 
 - 背景：master run 1037 的 Backend/Frontend 已通过，但 `Repository checks` 因 3 个 `simple-import-sort/imports` 错误失败。原 pre-commit 只运行 Prettier，Prettier 不处理 ESLint import 排序；推送前又未运行完整仓库 lint，因此本地与 CI 的覆盖范围长期存在漂移。
@@ -7166,6 +7189,12 @@
 - HTTP 传输边界：根 H5 包不得依赖 Tauri guest 插件；AGC 独立包保留 `@tauri-apps/plugin-http`。Rust 插件显式关闭默认特性，只启用 `charset`、`cookies`、`http2` 和 `rustls-tls`，避免 `reqwest/system-proxy` 通过 Cargo feature union 把画布、Provider、Runtime 与本地回环夹具统一接入 OS 自动系统代理；如未来产品要求正式客户端继承系统代理，必须按各客户端明确设计并单独完成跨平台验证。
 - 运行决策：Godot 项目提交给 Project Supervisor 时使用 `standard` Run Profile，避免触发 Web 专用 `game/index.html`、HTTP preview 与自主 Web 完成门。Godot 编辑器启动和内嵌运行预览不在本切片范围。
 
+## 2026-08-14 AGC Web game-chat fresh-init 真实验收基线
+
+- fresh-init 决策：`supervisor-game-chat-single-main-playable` 的 disposable 项目只预置 Git、`AGENTS.md`、三份隔离 evidence 与敏感诱饵，不再预写 `package.json`、`verify-e2e.mjs` 或 `game/index.html`；入口必须由正式 `--init` 写入生产 `DEFAULT_GAME_INDEX_HTML`。canonical 副本由无 Provider self-test 与 Rust 常量逐字节比对，防止验收基线静默漂移。
+- 报告门禁：同一真实 E2E 报告必须记录初始入口 SHA-256，并同时断言初始字节命中生产默认入口、根下唯一固定 child 为 `code-prototype`、最终入口不同于 baseline、`game.static_smoke` 凭证 SHA-256 等于最终入口，以及 desktop/mobile 两个 viewport 各自 passed；任一项不成立均失败关闭。
+- 范围边界：这条真实 Provider 验收仅覆盖普通 Web 工作台的 `project-supervisor-game-chat + autonomous-game-build` 单 Supervisor 链，不覆盖显式 `professional-dag` 或固定 16 节点 CLI/GUI 链。后者的 owner-artifact verify、产物所有权与 path-scope 仍是独立未解决项；seeded deterministic E2E、普通 self-test 和 game-chat 报告均不得据此声称该问题已修复或该链已通过真实验收。
+
 ## 2026-08-13 AGC 普通 Web 工作台默认单主无人值守生成
 
 - 决策：项目首页进入的普通 Web 工作台默认 `single-supervisor`，提交固定映射为 `project-supervisor-game-chat + autonomous-game-build`。该决策覆盖此前“普通 GUI autonomous 继续固定完整 DAG”的现行入口规则；固定专业 autonomous DAG 只保留给显式 `professional-dag` 和专业 CLI 验收，Supervisor 调试与 Godot 继续 `standard + project-supervisor-gui`。
diff --git a/docs/project-memory/shared-memory/development-workflow.md b/docs/project-memory/shared-memory/development-workflow.md
index 42f7732f4..9affa8214 100644
--- a/docs/project-memory/shared-memory/development-workflow.md
+++ b/docs/project-memory/shared-memory/development-workflow.md
@@ -99,6 +99,8 @@ game-chat 条件快车道采用单主口径。父 Run 与全部 child Run 共用
 
 失败续跑还必须覆盖同 Session 同 source 继承、跨 Session / 跨 source 不继承、首次与连续 successor 的 effective task / contract / scheduler 一致性，以及中英文纯继续短语使用同一识别函数。非占位入口的新 `code-prototype` 必须先产生本人 mutation 再 smoke；连续只读 smoke 不得收束。占位 fallback 只允许显式支持的真实玩法模板，俄罗斯方块必须验证棋盘、下落、旋转、锁定和消行语义，未知玩法必须失败关闭。
 
+legacy 计划迁移到结构化计划时以 `planRevision` 为唯一边界：`planRevision=0` 的 `planSteps` 只是 Runtime 脚手架，第一次有效 `planUpdate` 必须完整替换它，即使 legacy 活动步骤已因工具 observation 变成 `completed / failed`；不得把该脚手架终态合并进首份结构化计划。入口处已经存在结构化计划后，后续更新仍必须保留 `completed / failed` 终态，Provider 不得重开失败步骤。修改此边界至少运行 `first_structured_plan_replaces_terminal_legacy_scaffolding_steps`、`structured_plan_failed_step_remains_immutable_after_migration`、真实 smoke 修复序列回归，以及 `structured_plan_`、`game_chat_` 串行分组；最终无人值守结论仍必须来自新的独立真实 Provider 空项目轮次，不能由历史失败轮和本地单测拼接。
+
 game-chat GUI 恢复还要覆盖两类竞态：root Runtime 先终态、单主 Run 或其必要美术 child 后终态时，必须等到所有必要 delivery 的最终状态后仅持久化一条 `【Supervisor 阶段记录】`；页面初始 hydration 直接读到真实终态时也要补写缺失记录，但不得把 `idle` 当作完成。同时，GUI 启动的 `agent.resume` 自动扫描必须先做只读恢复工作预检：新项目或无 task / retry / handoff / finalization / pending / reconciliation 工作的已终态项目不弹确认，存在任何 durable recovery artifact 则仍必须命中 `agent.resume` policy。
 
 ```bash
diff --git a/docs/technical/【技术方案】AI游戏创作Agent Runtime V1.1-2026-07-12.md b/docs/technical/【技术方案】AI游戏创作Agent Runtime V1.1-2026-07-12.md
index 07a0e2467..6d556f1b9 100644
--- a/docs/technical/【技术方案】AI游戏创作Agent Runtime V1.1-2026-07-12.md	
+++ b/docs/technical/【技术方案】AI游戏创作Agent Runtime V1.1-2026-07-12.md	
@@ -1080,18 +1080,18 @@ Runtime 只在以下客观条件同时满足时写 `contractStatus=evidence-read
 
 ### 单层 repair
 
-Supervisor 只有在同一父 run 已认领原 delivery，且原回执为 `needs-repair` 或 Supervisor 明确判定语义未满足时，才能发出新的 `agent.delegate`，并把 `repairOfDelegationId` 指向该原 `delegationId`。被引用记录必须属于同一 `project-supervisor` 父 run、状态为 `claimed-by-parent`，且自身不是 repair；返工目标必须与原 delivery 的专业 Agent 完全一致。
+当前可信父 Run 只有在已认领同一父 Run 的原 delivery，且原回执为 `needs-repair` 或父 Run 明确判定语义未满足时，才能发出新的 `agent.delegate`，并把 `repairOfDelegationId` 指向该原 `delegationId`。可信父 Run 包括原 `project-supervisor`，以及通过 `project-supervisor-game-chat` 根绑定、父 binding fingerprint 和 task/session/run/delegation 身份链完整证明的唯一 `code-prototype` 主 Run；仅凭 Agent ID、task 文案或错误关键词不得获得该权限。被引用记录必须属于当前可信父 Run、状态为 `claimed-by-parent`，且自身不是 repair；返工目标必须与原 delivery 的专业 Agent 完全一致。
 
-repair 深度固定为 `1`；同一原 delivery 同时最多存在一个非 `suppressed` repair。相同 durable action/身份重放必须幂等复用已预留或已创建的 repair；不同 action 的重复或并发竞争必须在 delivery 锁内发现既有非 suppressed repair 后拒绝，不能创建第二个活跃目标 run、第二份可认领回执或 `-dup-*` repair。repair 结果继续唤醒、认领并收束到原 Supervisor Session/run；它不能创建第二条面向用户的 assistant。repair 再次 `needs-repair` 时不得继续嵌套委派，Supervisor 只能基于现有证据裁决或走用户输入门禁。`suppressed` repair 不视为已完成返工，原 `repairRequired` 门禁必须继续阻断 finalization；同一 durable action 可以在无终态字段时把原 delivery 恢复为 `dispatched`，若该 action 已持久失败，新 action 也只可在既有 repair 全部 suppressed 时创建替代的基础设施投递，不能形成第二轮语义返工。
+repair 深度固定为 `1`；同一原 delivery 同时最多存在一个非 `suppressed` repair。相同 durable action/身份重放必须幂等复用已预留或已创建的 repair；不同 action 的重复或并发竞争必须在 delivery 锁内发现既有非 suppressed repair 后拒绝，不能创建第二个活跃目标 run、第二份可认领回执或 `-dup-*` repair。repair 结果继续唤醒、认领并收束到原可信父 Session/run；它不能创建第二条面向用户的 assistant。repair 再次 `needs-repair` 时不得继续嵌套委派，当前可信父 Run 只能基于现有证据裁决或由根 Supervisor 走用户输入门禁。`suppressed` repair 不视为已完成返工，原 `repairRequired` 门禁必须继续阻断 finalization；同一 durable action 可以在无终态字段时把原 delivery 恢复为 `dispatched`，若该 action 已持久失败，新 action 也只可在既有 repair 全部 suppressed 时创建替代的基础设施投递，不能形成第二轮语义返工。已 suppressed 且未形成 child task 的旧 delivery 不再参与 capability、claim 或 completion barrier 的身份验证，避免恢复入口被失败前置记录永久堵死；所有非 suppressed delivery 仍必须逐条通过完整可信链校验。
 
-Supervisor 认领回执后必须能够再次从 durable delivery 取回权威返工合同，不能依赖首次 `agent.run_status` observation 或模型记忆。普通 `agent.run_status` 要返回有界的 `claimedDelegateContracts` 目录，至少包含 `delegationId / targetAgentId / repairOfDelegationId / contractStatus / acceptanceCriteriaCount / expectedArtifactsCount`；带可选 `delegationId` 查询时，只允许原 `project-supervisor` 父 run 读取属于自己且已 `claimed-by-parent` 的 delivery，并返回未截断的 `delegationId / targetAgentId / acceptanceCriteria / expectedArtifacts / repairOfDelegationId / deliveryStatus / terminalStatus / contractStatus`。该查询是只读、可幂等重放的私有 observation，不返回 task 正文、Provider payload、凭据或绝对路径；合同超过明确有界输出上限时失败关闭，不能截断后让模型猜测。返工被“合同未完整继承”拒绝时，失败 observation 必须携带同一 durable delivery 的完整 `claimedDelegateContract` 权威快照，Supervisor 可直接逐字段据此修正；该字段缺失或身份不确定时才必须按原 `delegationId` 重读，不得重复无目标地轮询状态或从 action history 的摘要反推。
+当前可信父 Run 认领回执后必须能够再次从 durable delivery 取回权威返工合同，不能依赖首次 `agent.run_status` observation 或模型记忆。普通 `agent.run_status` 要返回有界的 `claimedDelegateContracts` 目录，至少包含 `delegationId / targetAgentId / repairOfDelegationId / contractStatus / acceptanceCriteriaCount / expectedArtifactsCount`；带可选 `delegationId` 查询时，只允许当前可信父 Run 读取属于自己且已 `claimed-by-parent` 的 delivery，并返回未截断的 `delegationId / targetAgentId / acceptanceCriteria / expectedArtifacts / repairOfDelegationId / deliveryStatus / terminalStatus / contractStatus`。该查询是只读、可幂等重放的私有 observation，不返回 task 正文、Provider payload、凭据或绝对路径；合同超过明确有界输出上限时失败关闭，不能截断后让模型猜测。返工被“合同未完整继承”拒绝时，失败 observation 必须携带同一 durable delivery 的完整 `claimedDelegateContract` 权威快照，当前可信父 Run 可直接逐字段据此修正；该字段缺失或身份不确定时才必须按原 `delegationId` 重读，不得重复无目标地轮询状态或从 action history 的摘要反推。
 
 ### Prompt 与完成门禁
 
 - 专业 Agent 的 task prompt 必须带完整委派合同：`delegationId / task / acceptanceCriteria / expectedArtifacts / repairOfDelegationId`，以及当前 Agent/Session/run 与父 Supervisor 身份；同时明确它只提交内部回执和证据，不直接回答正式用户。
 - 结构化计划 checkpoint 只有在步骤或状态真实变化时才允许单独提交。当前 `in_progress` 步骤所需事实、权限和合同已经齐全时，Agent 必须在同一 Provider 响应附带具体 action；格式修复也必须保留原本可执行的动作意图，不能连续只改 `explanation` 或反复只调用 `update_agent_plan`。Runtime 的未完成计划 observation 和 `nextStep` 使用同一口径，真实 E2E 对 repair 创建另设有界父 loop 门禁。
-- Supervisor prompt 必须明确：不得把 `evidence-ready` 当作自动语义通过，不得忽略或吞掉 `needs-repair`；对无法自行裁决的冲突、缺失决策或用户偏好，只能汇总后通过既有 `user.input_request` 向用户提问，专业 Agent 与 child 不得各自直达用户。
-- finalization 在项目锁内必须确认所有必要 static delivery 已终态、ready 已认领、claim 已 Observed、允许的单次 repair 已收束；同时要求结构化计划全部完成，并清零 verification、pending confirmation、`user.input_request`、process/reconciliation、isolated join、Goal/steer 等既有 blocker。只有原 `project-supervisor` Session/run 可以随后写入唯一正式用户 assistant 和 completed 投影。
+- 当前可信父 Run 的 prompt 必须明确：不得把 `evidence-ready` 当作自动语义通过，不得忽略或吞掉 `needs-repair`。game-chat `code-prototype` 发现 ready delivery 时必须先以确定性 `agent.run_status(scope=self)` 认领并观察；普通失败或不合法安全默认 marker 在认领后立即失败收束，不得再发 Provider 请求。只有完整合法的 `game-chat-safe-default-repair.v1` marker 允许一次同合同返工；该返工由 Runtime 直接按原 `targetAgentId / acceptanceCriteria / expectedArtifacts / delegationId` 生成确定性 `agent.delegate`，不再请求 Provider 决策。repairRequired 存在时重复 route、读取、查询或其它计划全部由 liveness 门拒绝；第二层返工、目标 Agent 变化、合同扩大或身份漂移全部失败关闭。对无法自行裁决的冲突、缺失决策或用户偏好，只能由根 Supervisor 汇总后通过既有 `user.input_request` 向用户提问，专业 Agent 与 child 不得各自直达用户。
+- finalization 在项目锁内必须确认所有必要 static delivery 已终态、ready 已认领、claim 已 Observed、允许的单次 repair 已收束；同时要求结构化计划全部完成，并清零 verification、pending confirmation、`user.input_request`、process/reconciliation、isolated join、Goal/steer 等既有 blocker。可信 `code-prototype` 只能管理其绑定的内部 delivery 并收束自身 Run；只有根 `project-supervisor` Session/run 可以写入唯一正式用户 assistant 和根 completed 投影。
 
 ### Provider 多 action 原批次门禁
 
diff --git a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
index 47fe26bce..9379ada7d 100644
--- a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
+++ b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
@@ -8,6 +8,23 @@ Supervisor 认领该回执后，由父 run 自己为每个原 delivery 逐一创
 
 问题 envelope、问题数量、字段长度和 SHA 校验均 fail-closed；问题正文只在受保护的 Runtime sidecar / 父 run 上下文中流转，不写入公共审计。若合并后的问题超过用户输入上限，Runtime 停止自动提问并进入 reconciliation，等待人工核对。
 
+## 2026-08-14 真实 Provider 无人值守验收修复计划
+
+2026-08-14 使用 `gpt-5.6-luna` 的独立真实 Provider 轮次已经证明 Provider 链路可达：7 个唯一请求全部完成，confirmation、user-input、steer 和公开泄漏均为零；但该轮结果为 **FAIL**，不得作为无人值守验收通过证据。`code-prototype` 在 revision 2 的 `game.static_smoke` 得到可修复合同失败后，于同一 Run 成功 `file.patch` 到 revision 3；下一轮却在重跑 smoke 前被本地计划门禁终止，因此没有进入 desktop/mobile `preview.validate`。Supervisor 的 fixed-graph stalled 只是该 child 失败的下游结果。
+
+根因位于 legacy 计划向首份结构化计划的迁移边界。首轮 smoke 失败发生时 `planRevision=0`，Runtime 把 legacy 脚手架中的活动步骤标为 `failed`；旧 `apply_agent_runtime_plan_update` 又把这个 legacy 终态合并进首份结构化计划，导致修复 mutation 成功后仍被“结构化计划含 failed 步骤”失败关闭。该 `failed` 不属于 Provider 提交的结构化计划，也不应成为后续结构化计划的历史终态。
+
+本轮按以下最小边界修复，禁止通过增加 loop 预算、删除完成门或把失败步骤普遍视为成功来绕过：
+
+1. `planRevision=0` 表示尚未建立结构化计划。第一次有效 `planUpdate` 必须完整替换 legacy `plan / planSteps / activePlanStepIndex`，不得保留 legacy 的 `completed / failed` 脚手架步骤。
+2. 只有函数入口处已经存在结构化计划时，后续更新才保留 `completed / failed` 终态。结构化 `failed` 仍不可被 Provider 改写，普通工具失败和完成门失败继续 fail-closed；本修复不新增 receipt 特判恢复通道，也不放宽 static smoke、revision、desktop/mobile 试玩或最终交付门。
+3. 修复序列回归必须覆盖 `revision 2 smoke failed -> 首份结构化修复计划 -> 同 Run file.patch 到 revision 3 -> 自动重跑当前 revision smoke -> desktop/mobile preview`；同时单独证明已建立结构化计划后的 failed 步骤仍不可变。
+4. Windows real-E2E 把直属 CLI 终态与 stdio 完整关闭拆成两阶段：完整换行的 turn report 是输出边界；直属 CLI `exit/error` 后不再向其 PID 发信号；finally 先按 sentinel、endpoint、boot、进程指纹和稳定 Windows process HANDLE 停止 suite 自有 Runner，再有界等待继承管道关闭。临时 AppData 和 sentinel 必须归当前用户私有 ACL，稳定 HANDLE 自测必须同时证明 close 不杀目标、signal 终止原目标。
+5. 验收按“Rust 定向与分组回归 -> real-E2E self-test -> 串行 Rust 全量 -> 前端类型检查 -> 编码和差异门禁 -> 新的独立 `gpt-5.6-sol` / `max` 真实 Provider 空项目轮次”执行。真实轮次必须在同一父/子 Run 中取得当前 revision 的 static smoke、desktop/mobile 试玩和唯一 completed 终态；失败轮不得与后续轮拼接。
+6. professional DAG 的图片产物任务必须保持任务文案与计划门禁一致：External Editor 已配置时，`art-director` 是只允许 `canvas.asset_generate` 受控素材事务的非只读视觉任务，不得被通用“只读协调”文案拒绝；`assets/art-spec.png` 的固定 `icon-spec / 1:1` 合同、其它文件写入禁令、mutation revision 和验证凭证均不放宽。
+7. 真实 E2E 报告必须绑定 effective model、API kind 和 endpoint 指纹，并递归核验唯一 Supervisor 根链、全部后代终态、最终入口 SHA-256 与 static smoke 凭证、交互 CLI 与隔离 AppData 的路径泄漏，以及清理后本轮 Runner/helper/Node/browser/command 后代残留为零；任一项无法证明即 FAIL。
+8. `reasoningEffort=max` 必须作为独立强度贯通配置校验、`platform-llm` Responses 请求、Provider 适配、Codex 映射、请求指纹和前端配置类型，不得静默降级为 `high` 或 `x-high`。本轮真实验收固定使用 `agentMode=provider`；由于 canonical Agent 会先应用角色默认推理强度，隔离配置必须为 `project-supervisor`、`code-prototype`、`art-director`、`art-asset-plan` 分别显式覆盖 `max`，并由报告中的 effective binding 证明四者一致。
+
 ## 目标
 
 在 Genarrative 内建设独立桌面 App：普通用户通过项目开发工作台中的陶泥儿对话、资源画布、运行状态和确认操作，让平台生成保存在本地的可运行 Web 游戏原型，并通过本地 HTTP server 预览；主窗口提供运行时配置入口，用于保存发布版 AppData / Tauri 配置目录里的 LLM 配置及受控开发者 External Editor 配置。普通客户素材画布使用平台登录态调用内部编辑器 API，不展示或要求填写画板 Base URL / API Key。任务明细、原始文件、命令日志和专业 Agent 调试控制仍放到开发构建的独立开发窗口。v1 的生成闭环仍以 Web 小游戏为主，同时允许用户打开已有 Godot 项目：所选含 `project.godot` 的目录直接成为项目根，Agent 使用标准运行档在该目录内继续修改，只新增并保留 `.agent/` 作为运行元数据，不创建 `game/`、`assets/`、`memory/`、`exports/` 平行目录；本期不扩展 Unity、Godot 内嵌预览、云同步或插件市场。
@@ -1079,8 +1096,10 @@ game-project/
 
 - **入口覆盖**：本节取代本文更早“普通 GUI autonomous 继续固定完整 DAG”的现行含义。项目首页进入的普通 Web 工作台必须显式使用 `single-supervisor` 编排，提交映射为 `project-supervisor-game-chat + autonomous-game-build`；持久化 Supervisor 决策前零 child，决策后只启动唯一 `code-prototype` 主 Run，美术仅在该 Run 完成 `asset.list` 并形成可证实缺口后一次委派一个受限 child。独立 game-chat 入口沿用相同规则。显式 `professional-dag` 与 CLI 专业 autonomous 验收继续使用 `project-supervisor-gui|cli + autonomous-game-build` 的原有完整 DAG；Supervisor 调试与 Godot 继续 `project-supervisor-gui + standard`，不得被普通入口默认值误改。
 - **普通界面**：`single-supervisor` 工作台不展示固定专业 DAG、子 Agent Dock 或“严格审批”，只显示总控对话、生成状态与“自动执行”。这只是产品投影收敛，不删除开发诊断入口，也不放宽权限；项目外写入、任意 shell、发布、凭据、系统设置和未知外部副作用继续失败关闭。
-- **无人介入语义**：可信 game-chat autonomous 根链路及其绑定 child 不得停在普通 `waiting-for-confirmation` 或 `waiting-for-user-input`。child 的信息不足交付在严格身份校验后转为同一父链可执行的安全默认返工，问题正文与公开问题指纹清除，内部只保留不公开的 SHA-256 幂等 marker；standard、GUI/CLI 调试和非可信绑定继续保留人工澄清。可恢复失败必须回到同一 `code-prototype` Run，不能要求用户发送“继续”。
+- **无人介入语义**：可信 game-chat autonomous 根链路及其绑定 child 不得停在普通 `waiting-for-confirmation` 或 `waiting-for-user-input`。child 的信息不足交付在严格身份校验后转为同一父链可执行的安全默认返工，问题正文与公开问题指纹清除，内部只保留不公开的 SHA-256 幂等 marker；standard、GUI/CLI 调试和非可信绑定继续保留人工澄清。可信 `code-prototype` 主 Run 可以且只能认领 task/session/run/binding/delegation 身份全部匹配的直属美术 delivery：存在 ready 回执时由 Runtime 确定性执行 `agent.run_status(scope=self)`，claim 尚未完整 Observed 时禁止请求 Provider；普通失败或 marker 不完整时认领后立即失败，合法 `game-chat-safe-default-repair.v1` marker 则由 Runtime 直接生成唯一一层、同目标、同合同 `agent.delegate`，repairRequired 状态下的重复 route/read/query 被 liveness 门拒绝。父 task 或 binding 链丢失且仍有活跃 delivery 时完成门必须 blocked；只有 suppressed 记录不再参与 capability、claim 和 completion barrier。可恢复失败必须回到同一 `code-prototype` Run，不能要求用户发送“继续”，也不能在已知不可修复或返工已确定后继续消耗 Provider 轮次。
 - **验证反馈与完成门**：`game.static_smoke` 先校验 `<script>` 闭合和全部可执行内联 JavaScript 语法，再检查 Canvas、输入、状态、胜负与重开合同。失败回执的公共投影只包含 `commandId/passed/failureCode/check/path=game/index.html`；同一 owner 可额外读取经脱敏、有界的 `diagnostic`，以执行“诊断 → mutation → 当前 revision static smoke → desktop/mobile preview.validate”循环。根 Run 只有在正式 artifact、manifest、当前 revision 静态凭证和双视口试玩一致时才能唯一 completed；同 revision 同失败且无新 mutation 必须命中停滞门，不能无限猜测。
 - **Runner 接管**：新 boot 取得跨 boot `execution-owner` 后必须在释放 owner-map 锁后幂等触发既有 durable recovery scan。纯 Provider、项目内文件和验证动作按 checkpoint 续跑；结果未知的进程、付费生成或其它外部副作用进入 `needs-reconciliation`，禁止盲目重放。重复 hydration/read 或同 boot claim 不得重复 child、消息、action 或付费请求。
 - **验收层级**：确定性 loopback E2E 必须覆盖普通入口路由、唯一 `code-prototype`、首次语法 smoke 失败、同 Run 取得结构化诊断并修改、当前 revision 静态与桌面/移动试玩通过、根 Run 唯一 completed、确认/追问为零。该结果只证明 Runtime 控制面；使用真实 Provider 的空项目单输入 smoke 全程无人介入成功后，才能宣称现场目标完成。
 - **真实 Provider 开发验收入口**：`--game-chat-smoke` 是受限 CLI 标记，只允许与默认 `project-supervisor` 的 `--swarm-chat --autonomous-game-build` 组合，将新根 Run 绑定为 `project-supervisor-game-chat`，不作为产品 UI、公开 API 或通用 source 覆盖能力。现有 playable harness 通过 `npm run ai-game-creator-shell:agent-runtime:supervisor-game-chat-single-main-playable-real-e2e` 显式启动该模式，启动前同时校验 `project-supervisor` 与 `code-prototype` 的 Provider 配置，并在隔离 AppData 中验收唯一单主 child、当前 revision 的 static smoke 及 desktop/mobile 试玩回执。只有显式执行这条真实 E2E 命令才会发起 Provider 请求；普通 self-test 不读取凭据、不调用 Provider。现场 smoke 若在配置门因缺少 API Key 阻断，必须报告 `providerUsed=false`，只能证明入口、验收逻辑与无 Provider 自测已落地，不能宣称真实现场验收完成。
+- **fresh-init 取证边界**：`supervisor-game-chat-single-main-playable` 不再预写 `package.json`、`verify-e2e.mjs` 或 `game/index.html`，由正式 `--init` 生成生产 `DEFAULT_GAME_INDEX_HTML`。self-test 必须逐字节核对 harness 中的 canonical 默认入口与 Rust 生产常量，并证明空项目仍保留 Git、`AGENTS.md`、隔离 evidence 和敏感诱饵基线；真实报告必须同时证明初始 SHA-256 命中生产默认入口、根下唯一固定 child 为 `code-prototype`、最终入口已变化、static-smoke SHA-256 绑定最终入口且 desktop/mobile 各自通过。
+- **不外推范围**：上述真实 Provider 命令只验收普通 Web 工作台所采用的 `project-supervisor-game-chat + autonomous-game-build` 单 Supervisor 链。显式 `professional-dag` 与固定 16 节点 CLI/GUI 链的 owner-artifact verify、产物所有权和 path-scope 仍是独立未解决项；seeded deterministic E2E、普通 self-test 或本 game-chat 报告都不得冒充该链已修复或已完成真实验收。
diff --git a/server-rs/crates/agent-runtime-core/src/provider.rs b/server-rs/crates/agent-runtime-core/src/provider.rs
index a093045c0..0ad5c92ad 100644
--- a/server-rs/crates/agent-runtime-core/src/provider.rs
+++ b/server-rs/crates/agent-runtime-core/src/provider.rs
@@ -340,6 +340,7 @@ pub enum ProviderReasoningEffort {
     Medium,
     High,
     XHigh,
+    Max,
 }
 
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
diff --git a/server-rs/crates/agent-runtime-core/tests/provider_registry.rs b/server-rs/crates/agent-runtime-core/tests/provider_registry.rs
index c7f2a3e69..fb97e8a34 100644
--- a/server-rs/crates/agent-runtime-core/tests/provider_registry.rs
+++ b/server-rs/crates/agent-runtime-core/tests/provider_registry.rs
@@ -218,6 +218,24 @@ fn every_required_capability_mismatch_is_rejected_before_adapter_call() {
     assert_eq!(calls.load(Ordering::SeqCst), 0);
 }
 
+#[test]
+fn reasoning_effort_serialization_keeps_max_distinct_from_x_high() {
+    assert_eq!(
+        serde_json::to_value(ProviderReasoningEffort::Max).expect("serialize max effort"),
+        json!("max")
+    );
+    assert_eq!(
+        serde_json::from_value::<ProviderReasoningEffort>(json!("max"))
+            .expect("deserialize max effort"),
+        ProviderReasoningEffort::Max
+    );
+    assert_eq!(
+        serde_json::to_value(ProviderReasoningEffort::XHigh).expect("serialize x-high effort"),
+        json!("x-high")
+    );
+    assert_ne!(ProviderReasoningEffort::Max, ProviderReasoningEffort::XHigh);
+}
+
 #[test]
 fn fully_capable_arc_adapter_supports_invoke_and_stream() {
     let calls = Arc::new(AtomicUsize::new(0));
diff --git a/server-rs/crates/platform-llm/src/lib.rs b/server-rs/crates/platform-llm/src/lib.rs
index 3a76e4d3e..1422a0449 100644
--- a/server-rs/crates/platform-llm/src/lib.rs
+++ b/server-rs/crates/platform-llm/src/lib.rs
@@ -196,6 +196,7 @@ pub enum LlmResponseReasoningEffort {
     Low,
     Medium,
     High,
+    Max,
 }
 
 impl LlmResponseReasoningEffort {
@@ -204,6 +205,7 @@ impl LlmResponseReasoningEffort {
             Self::Low => "low",
             Self::Medium => "medium",
             Self::High => "high",
+            Self::Max => "max",
         }
     }
 }
@@ -5203,7 +5205,7 @@ mod tests {
                         .with_strict(true),
                     ])
                     .with_tool_choice(LlmToolChoice::Auto)
-                    .with_response_reasoning_effort(LlmResponseReasoningEffort::Low)
+                    .with_response_reasoning_effort(LlmResponseReasoningEffort::Max)
                     .with_response_text_verbosity(LlmResponseTextVerbosity::Low)
                     .with_max_output_tokens(128),
             )
@@ -5255,7 +5257,7 @@ mod tests {
         assert_eq!(request_json["tool_choice"], "auto");
         assert_eq!(
             request_json["reasoning"],
-            serde_json::json!({ "effort": "low" })
+            serde_json::json!({ "effort": "max" })
         );
         assert_eq!(
             request_json["text"],
diff --git a/server-rs/crates/platform-llm/src/provider_adapter.rs b/server-rs/crates/platform-llm/src/provider_adapter.rs
index 0b7990a38..23ccc5214 100644
--- a/server-rs/crates/platform-llm/src/provider_adapter.rs
+++ b/server-rs/crates/platform-llm/src/provider_adapter.rs
@@ -373,6 +373,7 @@ pub fn provider_request_from_llm_request(
                 agent_runtime_core::ProviderReasoningEffort::Medium
             }
             LlmResponseReasoningEffort::High => agent_runtime_core::ProviderReasoningEffort::High,
+            LlmResponseReasoningEffort::Max => agent_runtime_core::ProviderReasoningEffort::Max,
         });
     }
     if let Some(verbosity) = request.response_text_verbosity {
@@ -509,6 +510,7 @@ fn provider_request_to_llm_request(
                     "platform-llm 暂不支持 reasoningEffort=x-high",
                 ));
             }
+            agent_runtime_core::ProviderReasoningEffort::Max => LlmResponseReasoningEffort::Max,
         });
     }
     if let Some(verbosity) = request.text_verbosity() {
@@ -901,7 +903,7 @@ mod tests {
             .with_model("round-trip-model")
             .with_max_output_tokens(512)
             .with_request_timeout_ms(2_000)
-            .with_response_reasoning_effort(LlmResponseReasoningEffort::High)
+            .with_response_reasoning_effort(LlmResponseReasoningEffort::Max)
             .with_function_tools(vec![
                 LlmFunctionTool::new(
                     "lookup_weather",
@@ -913,12 +915,20 @@ mod tests {
             .with_tool_choice(LlmToolChoice::Required);
         let neutral =
             provider_request_from_llm_request("round-trip", request).expect("neutral request");
+        assert_eq!(
+            neutral.reasoning_effort(),
+            Some(ProviderReasoningEffort::Max)
+        );
         let mapped = provider_request_to_llm_request(&neutral, LlmApiKind::OpenAiResponses)
             .expect("mapped request");
         assert_eq!(mapped.model.as_deref(), Some("round-trip-model"));
         assert_eq!(mapped.max_output_tokens, Some(512));
         assert_eq!(mapped.request_timeout_ms, Some(2_000));
         assert_eq!(mapped.tool_choice, Some(LlmToolChoice::Required));
+        assert_eq!(
+            mapped.response_reasoning_effort,
+            Some(LlmResponseReasoningEffort::Max)
+        );
         assert!(mapped.function_tools[0].strict);
         assert!(
             mapped
@@ -928,6 +938,15 @@ mod tests {
         );
     }
 
+    #[test]
+    fn x_high_reasoning_effort_remains_unsupported_at_platform_llm_boundary() {
+        let request = core_request().with_reasoning_effort(ProviderReasoningEffort::XHigh);
+        let error = provider_request_to_llm_request(&request, LlmApiKind::OpenAiResponses)
+            .expect_err("x-high must remain unsupported");
+        assert_eq!(error.kind(), ProviderErrorKind::InvalidRequest);
+        assert!(error.to_string().contains("reasoningEffort=x-high"));
+    }
+
     #[test]
     fn llm_error_kinds_map_to_stable_provider_error_kinds() {
         for (error, expected) in [