抽离项目开发 DirectProject 聊天模块

将 DirectProject 表现与 controller 移到 view/project-development/chat

删除运行时 Direct feature flag 与 ProjectSupervisorView 的 Direct 行为分支

迁移 ts-rs 生成契约并删除无意义 generated/index.ts

将钱包入口提升到工作台布局并保留现有 Direct 测试覆盖

CONTEXT.md

@@ -174,6 +174,14 @@ _Avoid_: mock 先行堆积、前后端各自发散、先做排行榜 UI
 
 ## 项目开发对话（DirectProject）
 
+**DirectProject 专属聊天模块**:
+AGC 普通项目聊天的独立容器，拥有 DirectProject 的聊天状态、运行态订阅、历史读取、发送队列、附件和中止交互，并把聊天投影交给专属表现层渲染；它不承接 Supervisor、Design Agent 或 Planning V2 的运行态。
+_Avoid_: 把 DirectProject 作为项目总控聊天的一个布尔分支、把四种 Agent 会话抽象成同一事实源
+
+**项目工作台布局**:
+承载本地项目的资源工作区、项目级工具和独立聊天产品路径的外层界面；布局拥有跨面板的账户/钱包入口，聊天模块只负责项目对话，不嵌套账户展示。
+_Avoid_: 把钱包入口塞进聊天设置、让聊天组件拥有工作台级账户状态
+
 **项目对话历史**:
 AGC 本地项目内 Codex 原始对话条目的持久集合，是聊天展示、工具卡片和线程恢复注入的唯一持久事实源。
 _Avoid_: 会话缓存、展示态历史、按 UI 需要另存的对话副本

apps/ai-game-creator-shell/scripts/agent-swarm-test-chat.mjs

@@ -957,6 +957,9 @@ async function runInteractiveCargo(cliArguments, setActiveChild) {
   return result;
 }
 
+// 立项策划跑 standard 档，`agent.delegate` 这类动作按项目权限策略必须逐个确认，
+// 而确认和问询都只从 CLI 的 stdin 读。自主构建档没有这一步，所以只有 --plan 需要
+// 一个把「人坐在终端前敲 approve」自动化掉的应答器；判据本身仍然走后端确认命令。
 const swarmConfirmationPromptPattern = /输入 approve 或 reject：$/u;
 const swarmUserInputPromptPattern = /请选择 1-\d+，或直接输入其他答案：$/u;
 

apps/ai-game-creator-shell/scripts/check-config.mjs

@@ -1590,11 +1590,13 @@ if (!viteConfigSource.includes('allow: [repoRoot]')) {
   );
 }
 
-if (!(
+if (
-  tauriConfig.build?.beforeDevCommand?.includes(
+  !(
-    'run ai-game-creator-shell:dev-server',
+    tauriConfig.build?.beforeDevCommand?.includes(
-  ) || tauriConfig.build?.beforeDevCommand?.includes('run agc:serve')
+      'run ai-game-creator-shell:dev-server',
-)) {
+    ) || tauriConfig.build?.beforeDevCommand?.includes('run agc:serve')
+  )
+) {
   throw new Error(
     'AI game creator shell beforeDevCommand must start the selected Vite dev server',
   );

apps/ai-game-creator-shell/scripts/start-dev-stack.mjs

@@ -1192,7 +1192,7 @@ async function main() {
 function isDirectModuleExecution() {
   return Boolean(
     process.argv[1] &&
-    resolve(process.argv[1]) === fileURLToPath(import.meta.url),
+      resolve(process.argv[1]) === fileURLToPath(import.meta.url),
   );
 }
 

apps/ai-game-creator-shell/src-tauri/prompts/runtime/supervisor/playbook.md

@@ -2,4 +2,8 @@
 
 需要等待专业 Agent 时不得调用 respond_to_user；Runtime 会通过 delegate/all-join 完成屏障保持同一父 run，取得 readyDelegateReceipts 或 readyIsolatedJoins 后直接整合结果。readyDelegateReceipts 中 contractStatus=evidence-ready 只说明终态、产物和验证等客观证据齐全，你仍须按 acceptanceCriteria 判断语义是否满足；needs-repair 不得当作成功。contractStatus=needs-user-input 时，Runtime 会按原 delivery 逐一发起 user.input_request；每个请求答案收齐后，为对应原 delivery 仅创建一次 continuation 委派，repairOfDelegationId 与 continuationOfDelegationId 都指向该原 delivery，并提交 observation 给出的 questionsSha256、answersSha256；Runtime 自动派生稳定 continuation identity，禁止跨 delivery 混用指纹。客观或语义不满足时可以发起一次新 agent.delegate，并把 repairOfDelegationId 指向已认领原 delivery；不得对返工再返工或为同一原 delivery 创建第二个返工。专业结果冲突且无法依据用户目标裁决时，合并问题后用一次 user.input_request 询问用户。只有实现路径、产品取舍或缺失事实会实质改变结果时才调用 user.input_request；项目内可读取事实、权限确认和工具失败不得伪装成用户问题。
 
+委派 `project-planning` 时，acceptanceCriteria 只写产物形状、覆盖范围与红线（例如必须交付 `game/fast_gdd.md`、必须原创、必须只定义一个 MVP 闭环），**不得替用户预先裁定产品取舍**。用户没有指定的玩法规则、数值、关卡量级、美术方向和目标人群，一律留给策划子 Agent 按其 3 轮问询预算决定是提问还是按默认建议填写；不要写“未指定的标注为立项假设”“自行假设后继续”这类指令，那会把问询预算作废。平台事实（自包含 Web、desktop/mobile 双视口、keyboard/touch 双输入、本地 HTTP 预览）由 Runtime 固定注入，属于已定事实，不得要求标为待定、建议或开放项。
+
+对 `project-planning` 的澄清 continuation，必须按 A/B/“需要原型验证”三项合同原样转述；B 是用户确认的 `confirmed/user_option`，不能转成默认建议。若用户后续自由填写推翻已确认决定，保留用户答案原文逐字不改写、不拆分、不搬轮次，并在被推翻决定后注明“已被第 N 轮回答推翻，以后者为准”，在新决定 topic 中写明推翻关系。
+
 只在所有必要回执已认领、manifest 正式任务图已经完成、所有必要返工也已认领、项目副作用已验证且没有待确认动作或待回答请求时给用户最终回复。不要向用户暴露内部 task/event、工具计划、动态 child ID 或调试状态。

apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-web-game-development/SKILL.md

@@ -14,9 +14,6 @@ Implement the user's actual game request in the current project as an npm-manage
 3. Build with the project's npm script before previewing. The playable entry is the package directory's `dist/index.html`; never report an unbuilt bare-module page as playable. Import assets or configure public assets so all runtime media is included in dist; preview and exports cannot read outside it.
 4. Build a complete playable loop: visible objective, responsive input, meaningful state changes, success or failure feedback, and a reliable restart path where the game needs one.
 5. Fit the active game scene to desktop and mobile viewports without accidental page scrollbars. Reserve deliberate safe space for HUD elements instead of covering interactive content.
-   - **画布居中只能由一处负责。** 使用 `Phaser.Scale.FIT` 与 `autoCenter: Phaser.Scale.CENTER_BOTH` 时，canvas 的直接父容器应使用尺寸明确的普通块布局，不再对同一 canvas 叠加 Grid/Flex 居中、`place-items: center`、自动外边距或居中 transform。Phaser 自动计算的 margin 与 CSS 居中叠加会使竖屏画面向右偏移。
-   - 若决定由 CSS 居中，则显式使用 `autoCenter: Phaser.Scale.NO_CENTER`，由 CSS 独立完成定位；外围页面可以继续使用 Grid/Flex，限制只针对同一 canvas 的重复定位。
-   - 出现偏移先检查游戏自身的 CSS 与 Phaser scale 配置，不添加 AGC 预览容器固定偏移补偿。修改布局后重新构建 dist，在桌面、移动及窗口 resize 后检查 canvas 相对游戏父容器居中（误差不超过 1 CSS px）、画面完整且无意外滚动条；不能仅凭 build 成功宣称布局通过。
 6. Invoke `taonier-art-assets` for every new game brief that needs visual assets. First reuse suitable registered Taonier art; when the brief's required visual elements are missing or unsuitable, call the reviewed `agc_tools` generation/edit workflow in the same task. After the tool returns, wire its relative paths into the game and verify the rendered result. A game with unused generated assets or placeholder emoji/CSS where requested art should appear is not complete. Load media defensively only for genuinely optional effects, and never relabel a local placeholder as platform art.
 7. Let Phaser own the render loop and input dispatch. Avoid duplicate scenes, stale event listeners, and state that survives restart unintentionally.
 8. After a meaningful game change, use the browser playtest Skill and fix issues shown by real evidence before reporting completion.

apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-web-game-development/references/game-quality-checklist.md

@@ -7,7 +7,5 @@
 - Score, steps, health, timer, or other core state updates consistently.
 - Restart restores all state and does not duplicate timers, animation loops, or event listeners.
 - Desktop and mobile layouts keep the core scene visible without accidental document scrolling.
-- 画布的缩放与居中由 Phaser 或 CSS 中的一方独立负责。`FIT + CENTER_BOTH` 不与同一 canvas 父容器的 Grid/Flex 居中、自动外边距或居中 transform 叠加；使用 CSS 居中时关闭 Phaser 自动居中（`NO_CENTER`）。
-- 在构建后的实际页面检查桌面、移动和 resize：比较 canvas 与游戏父容器的中心，预期居中时水平/垂直误差不超过 1 CSS px，并检查画面没有溢出或意外滚动条。偏移先修游戏 CSS/scale 配置，不用修改 AGC 预览位置掩盖。
 - HUD and overlays reserve space and do not cover essential interactive content.
 - Requested Taonier art is visibly integrated into the core experience when available.

apps/ai-game-creator-shell/src-tauri/resources/agc-skills/manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "agc-skill-pack.v1",
-  "version": "2026-08-26.25",
+  "version": "2026-08-26.24",
   "skills": [
     {
       "name": "agc-game-production-workflow",
@@ -80,7 +80,7 @@
         "agents/openai.yaml",
         "references/game-quality-checklist.md"
       ],
-      "sha256": "e122d8f3a6d986b594b95c971754d68197bf7896912fa8267d44a7aa129a57ba"
+      "sha256": "05b5cfbf7a40fd303717491f5cea84ff339a73359c9678b283fd54d2b5c45efd"
     },
     {
       "name": "agc-browser-playtest",

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

@@ -797,16 +797,6 @@ fn direct_thread_visible_item(
     direct_thread_event_item(root, item)
 }
 
-/// AGC 预写的 canonical 用户条目 id：`direct-codex:{clientTurnId}:user`。
-///
-/// 与 `direct_project_history::is_direct_project_codex_user_item` 的判据同一份口径（前缀 +
-/// `:user` 后缀）。回合生命周期事件的 `userItemId` 只能来自这里或已落盘条目自身的 id；
-/// clientTurnId 缺失时不猜身份，返回 `None` 让前端按"未知归属"处理。
-fn direct_codex_user_item_id_for_client_turn_id(client_turn_id: &str) -> Option<String> {
-    let client_turn_id = client_turn_id.trim();
-    (!client_turn_id.is_empty()).then(|| format!("direct-codex:{client_turn_id}:user"))
-}
-
 fn direct_codex_command_is_game_verification(command: &str) -> bool {
     let command = command.to_ascii_lowercase();
     command.contains("game.static_smoke")
@@ -1143,7 +1133,6 @@ fn direct_codex_thread_delta_event(
 ) -> DirectThreadEvent {
     DirectThreadEvent::item_delta(item_id, kind, direct_thread_delta_text(root, delta))
 }
-
 /// 通知 → 回合事件的唯一分类函数：运行态读取器与单测共用这一份。
 ///
 /// 读取器只负责"必须有 turnId 才处理"的前置条件与节流（活动 / 正文），分类不在这里之外
@@ -2937,7 +2926,7 @@ impl CodexAppServerConnection {
                     None => direct_project_local_message_item(
                         "user",
                         current_prompt,
-                        direct_codex_user_item_id_for_client_turn_id(client_turn_id).as_deref(),
+                        Some(&format!("direct-codex:{client_turn_id}:user")),
                     )
                     .map_err(platform_llm::LlmError::InvalidRequest)?,
                 };
@@ -2971,8 +2960,22 @@ impl CodexAppServerConnection {
             codex_app_server_text_prompt(&request)
                 .map_err(platform_llm::LlmError::InvalidRequest)?
         };
-        let input =
+        let input = if self.inner.workspace_mode == CodexAppServerWorkspaceMode::DirectProject {
-            codex_app_server_turn_input(&request, &prompt, &self.inner.workspace_path).await?;
+            if let Some(item) = direct_user_item {
+                let canonical: DirectCodexUserItem = serde_json::from_value(item.clone())
+                    .map_err(|error| platform_llm::LlmError::InvalidRequest(error.to_string()))?;
+                direct_codex_user_item_to_codex_turn_input(
+                    &self.inner.workspace_path,
+                    &canonical,
+                    self.inner._skill_roots.as_deref().unwrap_or_default(),
+                )
+                .map_err(platform_llm::LlmError::InvalidRequest)?
+            } else {
+                codex_app_server_turn_input(&request, &prompt, &self.inner.workspace_path).await?
+            }
+        } else {
+            codex_app_server_turn_input(&request, &prompt, &self.inner.workspace_path).await?
+        };
         let _direct_tool_bridge_turn_guard =
             if self.inner.workspace_mode == CodexAppServerWorkspaceMode::DirectProject {
                 Some(
@@ -3056,30 +3059,13 @@ impl CodexAppServerConnection {
         };
         turn_start_guard.armed = false;
         let direct_thread_id = direct_thread_id_for_project(history_root);
-        // 回合边界的阶段时间：Turn 上游只有**秒**级 `startedAt` / `completedAt`，秒级截断
-        // 撑不起前端 0.1 秒粒度的展示，也可能让完成时刻落进该轮用户消息的同一秒、落在真实
-        // 发送时间之前，被判成无效边界后整轮新回合被吞掉。因此这里只在宿主处理对应阶段时取
-        // 毫秒钟（与条目侧"没有原生阶段时间就用宿主钟"同一口径），不再读上游秒字段。
-        let direct_turn_started_at_ms = direct_tool_call_now_ms();
-        // 本轮开口用户条目的 canonical id：只从已落盘的那条条目上读身份（`id`，工具条目才用
-        // `call_id`），不在事件侧重造一份。拿不到就留空，让前端按"归属不可证明"处理。
-        let direct_turn_user_item_id = direct_persisted_user_item
-            .as_ref()
-            .and_then(direct_thread_item_identity);
         if self.inner.workspace_mode == CodexAppServerWorkspaceMode::DirectProject {
-            append_direct_thread_event(
+            append_direct_thread_event(&direct_thread_id, DirectThreadEvent::turn_started());
-                &direct_thread_id,
-                DirectThreadEvent::turn_started(direct_turn_started_at_ms)
-                    .with_user_item_id(direct_turn_user_item_id.as_deref()),
-            );
             if let Some(user_item) = direct_persisted_user_item.as_ref() {
                 if let Some(entry_item) = direct_thread_event_item(history_root, user_item) {
-                    // 这里的条目时间可能是启动应答后的观测时间；前端按同一用户条目身份
-                    // 保留更早的真实发送时间，不用此事件时间覆盖它。
-                    let user_item_at = entry_item.at();
                     append_direct_thread_event(
                         &direct_thread_id,
-                        DirectThreadEvent::item_completed(entry_item, user_item_at),
+                        DirectThreadEvent::item_completed(entry_item),
                     );
                 }
             }
@@ -3218,14 +3204,9 @@ impl CodexAppServerConnection {
                             .map_err(platform_llm::LlmError::InvalidRequest)?;
                             direct_project_history.complete_item(&item);
                             if let Some(entry_item) = entry_item {
-                                // `rawResponseItem/completed` 不带阶段时间，宿主处理到这条
-                                // 通知的钟就是该阶段唯一可证明的时间。
                                 append_direct_thread_event(
                                     &direct_thread_id,
-                                    DirectThreadEvent::item_completed(
+                                    DirectThreadEvent::item_completed(entry_item),
-                                        entry_item,
-                                        direct_tool_call_now_ms(),
-                                    ),
                                 );
                             }
                         }
@@ -3354,19 +3335,9 @@ impl CodexAppServerConnection {
                                 if let Some(entry_item) =
                                     direct_thread_visible_item(history_root, item)
                                 {
-                                    // `item/started` 的通知层带 `startedAtMs`：这是工具真正
-                                    // 开始的阶段时间，优先于条目展示时间与宿主钟。
                                     append_direct_thread_event(
                                         &direct_thread_id,
-                                        DirectThreadEvent::item_started(
+                                        DirectThreadEvent::item_started(entry_item),
-                                            entry_item,
-                                            direct_thread_item_event_at_ms(
-                                                &params,
-                                                item,
-                                                false,
-                                                direct_tool_call_now_ms(),
-                                            ),
-                                        ),
                                     );
                                 }
                             }
@@ -3409,19 +3380,9 @@ impl CodexAppServerConnection {
                             && matches!(status, "completed" | "interrupted" | "failed")
                         {
                             terminal_recorded = true;
-                            // 终态时间：`durationMs` 与宿主记下的毫秒起点都可靠时才派生，
-                            // 否则取宿主处理这条终态的钟；上游秒级 `completedAt` 一律不用。
                             append_direct_thread_event(
                                 &direct_thread_id,
-                                DirectThreadEvent::turn_completed(
+                                DirectThreadEvent::turn_completed(status.to_string()),
-                                    status.to_string(),
-                                    direct_thread_turn_completed_at_ms(
-                                        turn,
-                                        Some(direct_turn_started_at_ms),
-                                        direct_tool_call_now_ms(),
-                                    ),
-                                )
-                                .with_user_item_id(direct_turn_user_item_id.as_deref()),
                             );
                         }
                         match status {
@@ -3478,11 +3439,7 @@ impl CodexAppServerConnection {
                         "failed"
                     }
                     .to_string(),
-                    // 这条兜底终态没有对应的 app-server 终态载荷，只能取宿主处理它的钟，
+                ),
-                    // 不能拿最后一次正文或工具更新时间当回合终点。
-                    direct_tool_call_now_ms(),
-                )
-                .with_user_item_id(direct_turn_user_item_id.as_deref()),
             );
         }
         let text = match collect_result {
@@ -3680,15 +3637,6 @@ enum DirectCodexTurnCancelTarget {
 /// 这时显式释放这条守卫并把可读原因返回给界面。释放条件见
 /// [`release_stale_direct_taonier_active_invocation`] 的注释；"正在跑的是另一轮"仍然
 /// 保持原拒绝语义，什么都不释放。
-///
-/// 兜底终态带 `userItemId`：身份取 `release_stale_direct_taonier_active_invocation` 返回的
-/// clientTurnId（客户端回合身份的唯一来源），与正常路径的开口条目 id 同一份 canonical 口径。
-/// 拿不到 clientTurnId 就留空——这一轮不会再有原生终态，猜一个身份会让前端把边界盖到别人身上。
-fn direct_stale_cancel_turn_completed_event(client_turn_id: &str) -> DirectThreadEvent {
-    DirectThreadEvent::turn_completed("aborted".to_string(), direct_tool_call_now_ms())
-        .with_user_item_id(direct_codex_user_item_id_for_client_turn_id(client_turn_id).as_deref())
-}
-
 pub(crate) fn cancel_direct_codex_turn_at(
     root: &Path,
     client_turn_id: Option<&str>,
@@ -3745,7 +3693,7 @@ pub(crate) fn cancel_direct_codex_turn_at(
             // 兜底补一条，否则前端的"最新回合是否在跑"会永远停在运行中。
             append_direct_thread_event(
                 &direct_thread_id_for_project(root),
-                direct_stale_cancel_turn_completed_event(&released),
+                DirectThreadEvent::turn_completed("aborted".to_string()),
             );
             Ok(DirectTurnCancelView {
                 outcome: DIRECT_TURN_CANCEL_OUTCOME_RELEASED.to_string(),
@@ -5071,109 +5019,6 @@ mod tests {
         ));
     }
 
-    /// 阶段时间取自**通知层**字段，形状照抄 codex-cli 0.147 / 0.155 的 v2 协议 schema：
-    /// `item/started` 带 `startedAtMs`、`item/completed` 带 `completedAtMs`（毫秒），
-    /// `turn/completed` 带 `turn.startedAt` / `turn.completedAt`（秒）与 `turn.durationMs`（毫秒）。
-    /// 分类函数把 params 原样交给事件级 `at` 的投影函数，所以字段位置必须在这里钉住；
-    /// 回合边界的秒字段按"不用"锁在这里，避免以后有人再把秒级截断当 0.1 秒精度。
-    #[test]
-    fn direct_lifecycle_stage_times_come_from_notification_params() {
-        let started = serde_json::json!({
-            "threadId": "thread-1",
-            "turnId": "turn-1",
-            "startedAtMs": 1_700_000_000_123u64,
-            "item": {"id": "call-1", "type": "commandExecution", "command": "ls"},
-        });
-        let completed = serde_json::json!({
-            "threadId": "thread-1",
-            "turnId": "turn-1",
-            "completedAtMs": 1_700_000_001_500u64,
-            "item": {"id": "call-1", "type": "commandExecution", "command": "ls"},
-        });
-        for (method, params, expected_at_ms) in [
-            ("item/started", &started, 1_700_000_000_123u64),
-            ("item/completed", &completed, 1_700_000_001_500u64),
-        ] {
-            let Some(CodexTurnEvent::Item {
-                completed,
-                params: event_params,
-            }) = direct_codex_notification_event(method, params, None, None, "turn-1")
-            else {
-                panic!("{method} 必须分类成条目生命周期事件");
-            };
-            let item = event_params.get("item").expect("item payload");
-            assert_eq!(
-                direct_thread_item_event_at_ms(&event_params, item, completed, 9_999),
-                expected_at_ms,
-                "{method} 必须用通知层的阶段时间，而不是宿主钟"
-            );
-        }
-
-        let terminal = serde_json::json!({
-            "threadId": "thread-1",
-            "turn": {
-                "id": "turn-1",
-                "items": [],
-                "status": "completed",
-                "startedAt": 1_700_000_000i64,
-                "completedAt": 1_700_000_042i64,
-            },
-        });
-        let Some(CodexTurnEvent::Terminal(params)) =
-            direct_codex_notification_event("turn/completed", &terminal, None, None, "turn-1")
-        else {
-            panic!("turn/completed 必须分类成终态事件");
-        };
-        let turn = params.get("turn").unwrap_or(&params);
-        assert_eq!(
-            direct_thread_turn_completed_at_ms(turn, Some(1_700_000_000_500), 9_999),
-            9_999,
-            "上游只有秒级 completedAt：不采用，取宿主处理终态的毫秒钟"
-        );
-        let with_duration = serde_json::json!({
-            "id": "turn-1",
-            "items": [],
-            "status": "completed",
-            "startedAt": 1_700_000_000i64,
-            "completedAt": 1_700_000_042i64,
-            "durationMs": 42_500u64,
-        });
-        assert_eq!(
-            direct_thread_turn_completed_at_ms(&with_duration, Some(1_700_000_000_500), 9_999),
-            1_700_000_043_000,
-            "durationMs + 宿主高精度起点才派生结束"
-        );
-    }
-
-    /// 取消兜底终态也要带开口用户条目身份，且身份只有一个来源：release 返回的 clientTurnId
-    /// 走与正常路径同一份 canonical 口径；拿不到（空 / 空白）就留空，不猜。
-    #[test]
-    fn stale_cancel_terminal_event_keeps_opener_user_item_id_from_client_turn_id() {
-        let event = direct_stale_cancel_turn_completed_event("turn-0001");
-        assert_eq!(event.user_item_id(), Some("direct-codex:turn-0001:user"));
-        assert!(event.at().is_some(), "兜底终态仍要带宿主观测时间");
-        assert!(matches!(
-            event,
-            DirectThreadEvent::TurnCompleted { ref status, .. } if status == "aborted"
-        ));
-
-        for missing in ["", "   "] {
-            let event = direct_stale_cancel_turn_completed_event(missing);
-            assert_eq!(
-                event.user_item_id(),
-                None,
-                "拿不到 clientTurnId 时不得编造开口条目身份"
-            );
-        }
-
-        // canonical 口径与落盘侧同一份：`direct-codex:{clientTurnId}:user`。
-        assert_eq!(
-            direct_codex_user_item_id_for_client_turn_id("  turn-0001  ").as_deref(),
-            Some("direct-codex:turn-0001:user")
-        );
-        assert_eq!(direct_codex_user_item_id_for_client_turn_id(""), None);
-    }
-
     fn test_llm() -> GameCreatorLlmConfig {
         GameCreatorLlmConfig {
             custom_enabled: false,
@@ -6908,33 +6753,12 @@ done
 
         let consumed = crate::agent::consume_direct_thread(&bootstrap.subscription_id)
             .expect("consume events");
-        // 回合起止必须与开口用户条目同源：前端在「只有锚点 + 历史、运行态为空」的回合里靠这个
-        // 身份把边界认领给同一条用户条目，缺了它就只能隐藏未知用时。
-        let lifecycle_user_item_ids = consumed
-            .events
-            .iter()
-            .filter(|event| {
-                matches!(
-                    event,
-                    DirectThreadEvent::TurnStarted { .. } | DirectThreadEvent::TurnCompleted { .. }
-                )
-            })
-            .map(DirectThreadEvent::user_item_id)
-            .collect::<Vec<_>>();
-        assert_eq!(
-            lifecycle_user_item_ids,
-            vec![
-                Some("direct-codex:turn-0001:user"),
-                Some("direct-codex:turn-0001:user"),
-            ],
-            "turn.started / turn.completed 都要带本轮开口用户条目的 canonical itemId"
-        );
         let mut user_items = Vec::new();
         let mut assistant_items = Vec::new();
         for event in &consumed.events {
             let item = match event {
-                DirectThreadEvent::ItemStarted { item, .. }
+                DirectThreadEvent::ItemStarted { item }
-                | DirectThreadEvent::ItemCompleted { item, .. } => item,
+                | DirectThreadEvent::ItemCompleted { item } => item,
                 _ => continue,
             };
             match item {

apps/ai-game-creator-shell/src-tauri/src/agent/design_runtime.rs

@@ -1069,10 +1069,15 @@ pub(crate) async fn continue_design_agent_at(
         .ok_or("策划 Agent 当前正在工作")?;
     let mut session = match read_design_session(root)? {
         Some(session) => session,
-        None => new_design_session(
+        None => {
-            &project_id,
+            if read_planning_session_v2(root)?.is_some() {
-            &load_game_creator_app_config()?.selected_model_id,
+                return Err("此项目包含旧策划会话，请查看原有记录或在新项目开始五阶段策划".into());
-        ),
+            }
+            new_design_session(
+                &project_id,
+                &load_game_creator_app_config()?.selected_model_id,
+            )
+        }
     };
     if session.project_id != project_id {
         return Err("策划会话与当前项目不匹配".into());

apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs

@@ -2,9 +2,9 @@
 //! 有项目路径或导入状态时输出路径映射；否则保持首页元数据文案。不灌正文。
 
 pub(crate) const MAX_DIRECT_CODEX_ATTACHMENTS: usize = 8;
-const MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS: usize = 160;
+pub(crate) const MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS: usize = 160;
-const MAX_DIRECT_CODEX_ATTACHMENT_MEDIA_TYPE_CHARS: usize = 96;
+pub(crate) const MAX_DIRECT_CODEX_ATTACHMENT_MEDIA_TYPE_CHARS: usize = 96;
-const MAX_DIRECT_CODEX_ATTACHMENT_LOCAL_PATH_CHARS: usize = 512;
+pub(crate) const MAX_DIRECT_CODEX_ATTACHMENT_LOCAL_PATH_CHARS: usize = 512;
 
 const HOME_ATTACHMENT_HEADER: &str =
     "[首页附件说明：当前尚未打开项目，以下仅为附件元数据，附件内容尚不可读取]";

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

@@ -5,11 +5,11 @@ mod validation;
 mod wire;
 
 pub(crate) use model::{
-    DirectCodexUserContentPart, DirectCodexUserItem, DirectCodexUserMessageItem,
+    DirectCodexUserAttachmentReferencePart, DirectCodexUserContentPart, DirectCodexUserItem,
-    DirectCodexUserRole, DirectCodexUserRuntimeRegionPart,
+    DirectCodexUserMessageItem, DirectCodexUserRole, DirectCodexUserRuntimeRegionPart,
 };
 pub(crate) use validation::validate_direct_codex_user_item;
 pub(crate) use wire::{
-    direct_codex_user_item_to_prompt, direct_codex_user_item_to_response_item,
+    direct_codex_user_item_to_codex_turn_input, direct_codex_user_item_to_prompt,
-    direct_codex_user_item_to_wire_input,
+    direct_codex_user_item_to_response_item, direct_codex_user_item_to_wire_input,
 };

apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_user_item/model.rs

@@ -34,8 +34,25 @@ pub(crate) enum DirectCodexUserContentPart {
     InputText { text: String },
     #[serde(rename = "agc_resource_reference")]
     AgcResourceReference { resource_id: String },
+    #[serde(rename = "agc_skill_reference")]
+    AgcSkillReference { name: String },
     #[serde(rename = "agc_runtime_region_reference")]
     AgcRuntimeRegionReference(DirectCodexUserRuntimeRegionPart),
+    /// Uploaded project attachment kept inline in canonical content.
+    #[serde(rename = "agc_attachment_reference")]
+    AgcAttachmentReference(DirectCodexUserAttachmentReferencePart),
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, TS)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+#[ts(export, export_to = concat!(env!("CARGO_MANIFEST_DIR"), "/../src/features/project-workspace/generated/"))]
+pub(crate) struct DirectCodexUserAttachmentReferencePart {
+    pub(crate) name: String,
+    pub(crate) media_type: String,
+    #[ts(type = "number")]
+    pub(crate) size: u64,
+    pub(crate) local_path: String,
+    pub(crate) status: String,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, TS)]

apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_user_item/validation.rs

@@ -4,6 +4,8 @@ use super::model::{
 };
 use crate::agent::{
     read_manifest_for_project, sanitize_attachment_local_path, GameCreationAppManifest,
+    MAX_DIRECT_CODEX_ATTACHMENTS, MAX_DIRECT_CODEX_ATTACHMENT_MEDIA_TYPE_CHARS,
+    MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS,
 };
 use std::path::Path;
 
@@ -12,7 +14,7 @@ pub(crate) const MAX_DIRECT_CODEX_REFERENCES: usize = 32;
 pub(crate) fn validate_direct_codex_user_item(
     root: &Path,
     item: &DirectCodexUserItem,
-) -> Result<(), String> {
+) -> Result<GameCreationAppManifest, String> {
     let DirectCodexUserItem::Message(message) = item;
     if !matches!(message.role, DirectCodexUserRole::User) {
         return Err("DirectProject 只接受 user message item".to_string());
@@ -20,32 +22,91 @@ pub(crate) fn validate_direct_codex_user_item(
     if message.id.trim().is_empty() {
         return Err("DirectProject user item 缺少稳定 id".to_string());
     }
-    if message.content.is_empty() {
+    // 有效输入只判一整条 content：单个纯空白 `input_text` 是合法 part —— 编辑器里的段落
+    // 分隔、软换行与 chip 后的分隔空格就是这样落进 canonical content 的，前端不为它过滤。
+    if !content_has_meaningful_input(&message.content) {
         return Err("DirectProject user item content 不能为空".to_string());
     }
     let manifest = read_manifest_for_project(root)?;
     let mut reference_count = 0usize;
+    let mut attachment_count = 0usize;
     for part in &message.content {
         match part {
-            DirectCodexUserContentPart::InputText { text } => {
+            DirectCodexUserContentPart::InputText { .. } => {}
-                if text.trim().is_empty() {
-                    return Err("DirectProject input_text 不能为空".to_string());
-                }
-            }
             DirectCodexUserContentPart::AgcResourceReference { resource_id } => {
                 reference_count = reference_count.saturating_add(1);
                 validate_resource_id_and_manifest(&manifest, resource_id)?;
             }
+            DirectCodexUserContentPart::AgcSkillReference { name } => {
+                let name = name.trim();
+                if name.is_empty()
+                    || name.chars().count() > 120
+                    || matches!(name, "." | "..")
+                    || name.chars().any(|character| {
+                        character.is_control()
+                            || character.is_whitespace()
+                            || matches!(character, '/' | '\\' | ':' | '$')
+                    })
+                {
+                    return Err("引用的 Skill 名称无效，请移除后重新选择".to_string());
+                }
+            }
             DirectCodexUserContentPart::AgcRuntimeRegionReference(reference) => {
                 reference_count = reference_count.saturating_add(1);
                 validate_runtime_region_reference(&manifest, reference)?;
             }
+            DirectCodexUserContentPart::AgcAttachmentReference(reference) => {
+                attachment_count = attachment_count.saturating_add(1);
+                if attachment_count > MAX_DIRECT_CODEX_ATTACHMENTS {
+                    return Err(format!(
+                        "一次最多携带 {MAX_DIRECT_CODEX_ATTACHMENTS} 个附件"
+                    ));
+                }
+                if reference.name.trim().is_empty() {
+                    return Err("附件缺少文件名".to_string());
+                }
+                let name = reference.name.trim();
+                if name.chars().count() > MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS
+                    || name.chars().any(char::is_control)
+                {
+                    return Err("附件文件名无效或过长".to_string());
+                }
+                let media_type = reference.media_type.trim();
+                if media_type.is_empty()
+                    || media_type.chars().count() > MAX_DIRECT_CODEX_ATTACHMENT_MEDIA_TYPE_CHARS
+                    || media_type.chars().any(|character| {
+                        !(character.is_ascii_alphanumeric()
+                            || matches!(character, '/' | '+' | '-' | '.' | '_'))
+                    })
+                {
+                    return Err("附件媒体类型无效或过长".to_string());
+                }
+                let status = reference.status.trim();
+                if status == "imported" && reference.local_path.trim().is_empty() {
+                    return Err("已导入附件缺少项目路径".to_string());
+                }
+                if !reference.local_path.trim().is_empty() {
+                    sanitize_attachment_local_path(&reference.local_path)
+                        .ok_or_else(|| "附件项目路径无效".to_string())?;
+                }
+                if !matches!(status, "imported" | "failed") {
+                    return Err("附件状态无效".to_string());
+                }
+            }
         }
     }
     if reference_count > MAX_DIRECT_CODEX_REFERENCES {
         return Err(format!("一次最多引用 {MAX_DIRECT_CODEX_REFERENCES} 个素材"));
     }
-    Ok(())
+    Ok(manifest)
+}
+
+/// 整条 content 是否还有有效输入：任何一段非空白文本、或任何一个非文本 part 都算。
+pub(crate) fn content_has_meaningful_input(content: &[DirectCodexUserContentPart]) -> bool {
+    content.iter().any(|part| match part {
+        DirectCodexUserContentPart::InputText { text } => !text.trim().is_empty(),
+        _ => true,
+    })
 }
 
 pub(crate) fn validate_resource_id_and_manifest(
@@ -86,3 +147,150 @@ fn validate_runtime_region_reference(
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{content_has_meaningful_input, validate_direct_codex_user_item};
+    use crate::agent::direct_codex_user_item::model::DirectCodexUserContentPart;
+    use serde_json::json;
+
+    fn input_text(text: &str) -> DirectCodexUserContentPart {
+        DirectCodexUserContentPart::InputText {
+            text: text.to_string(),
+        }
+    }
+
+    #[test]
+    fn only_all_blank_content_counts_as_empty_input() {
+        // 空数组与「整条只有空白」是同一种空输入。
+        assert!(!content_has_meaningful_input(&[]));
+        assert!(!content_has_meaningful_input(&[input_text(" \n ")]));
+        assert!(!content_has_meaningful_input(&[
+            input_text("\n"),
+            input_text("  "),
+        ]));
+    }
+
+    #[test]
+    fn whitespace_parts_are_valid_next_to_meaningful_input() {
+        // 段落分隔 / 软换行 / chip 后的分隔空格都是合法的单个 part。
+        assert!(content_has_meaningful_input(&[
+            input_text("\n"),
+            input_text("看"),
+        ]));
+        assert!(content_has_meaningful_input(&[
+            input_text("看"),
+            input_text("\n\n"),
+        ]));
+    }
+
+    #[test]
+    fn non_text_parts_always_count_as_input() {
+        assert!(content_has_meaningful_input(&[
+            DirectCodexUserContentPart::AgcResourceReference {
+                resource_id: "asset-hero".to_string(),
+            },
+        ]));
+    }
+
+    #[test]
+    fn inline_attachment_count_is_bounded_independently() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "validation-test", "校验测试")
+            .expect("init project");
+        let content = (0..=crate::agent::MAX_DIRECT_CODEX_ATTACHMENTS)
+            .map(|index| {
+                json!({
+                    "type": "agc_attachment_reference",
+                    "name": format!("attachment-{index}.txt"),
+                    "mediaType": "text/plain",
+                    "size": 1,
+                    "localPath": "",
+                    "status": "failed"
+                })
+            })
+            .collect::<Vec<_>>();
+        let item = serde_json::from_value(json!({
+            "type": "message",
+            "role": "user",
+            "content": content,
+            "id": "turn-1:user"
+        }))
+        .expect("deserialize user item");
+        let error = validate_direct_codex_user_item(root.path(), &item)
+            .expect_err("too many inline attachments must be rejected");
+        assert!(error.contains("最多携带"), "{error}");
+    }
+
+    #[test]
+    fn imported_attachment_requires_a_project_path() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "validation-test", "校验测试")
+            .expect("init project");
+        let item = serde_json::from_value(json!({
+            "type": "message",
+            "role": "user",
+            "content": [{
+                "type": "agc_attachment_reference",
+                "name": "attachment.txt",
+                "mediaType": "text/plain",
+                "size": 1,
+                "localPath": "",
+                "status": "imported"
+            }],
+            "id": "turn-1:user"
+        }))
+        .expect("deserialize user item");
+        let error = validate_direct_codex_user_item(root.path(), &item)
+            .expect_err("imported attachment without a project path must fail");
+        assert!(error.contains("缺少项目路径"), "{error}");
+    }
+
+    #[test]
+    fn attachment_name_and_media_type_are_bounded_and_well_formed() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "validation-test", "校验测试")
+            .expect("init project");
+        let long_name = "a".repeat(crate::agent::MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS + 1);
+        let cases = [
+            (
+                json!({
+                    "name": "bad\nname.txt",
+                    "mediaType": "text/plain"
+                }),
+                "文件名",
+            ),
+            (
+                json!({
+                    "name": "ok.txt",
+                    "mediaType": "text/plain\nsecret"
+                }),
+                "媒体类型",
+            ),
+            (
+                json!({
+                    "name": long_name,
+                    "mediaType": "text/plain"
+                }),
+                "文件名",
+            ),
+        ];
+        for (metadata, expected) in cases {
+            let mut value = metadata;
+            value["type"] = json!("agc_attachment_reference");
+            value["size"] = json!(1);
+            value["localPath"] = json!("");
+            value["status"] = json!("failed");
+            let item = serde_json::from_value(json!({
+                "type": "message",
+                "role": "user",
+                "content": [value],
+                "id": "turn-1:user"
+            }))
+            .expect("deserialize user item");
+            let error = validate_direct_codex_user_item(root.path(), &item)
+                .expect_err("invalid attachment metadata must fail");
+            assert!(error.contains(expected), "{error}");
+        }
+    }
+}

apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_user_item/wire.rs

@@ -1,6 +1,11 @@
-use super::model::{DirectCodexUserContentPart, DirectCodexUserItem};
+use super::model::{
+    DirectCodexUserContentPart, DirectCodexUserItem, DirectCodexUserRuntimeRegionPart,
+};
 use super::validation::validate_direct_codex_user_item;
-use crate::agent::{read_manifest_for_project, sanitize_attachment_local_path};
+use crate::agent::{
+    read_manifest_for_project, sanitize_attachment_local_path, sanitize_attachment_media_type,
+    sanitize_attachment_name,GameCreationAppManifest,
+};
 use serde_json::Value;
 use std::path::Path;
 
@@ -51,6 +56,47 @@ fn direct_codex_user_item_to_response_content(
         .collect()
 }
 
+fn resource_reference_summary(
+    manifest: &GameCreationAppManifest,
+    resource_id: &str,
+) -> Result<String, String> {
+    let resource_id = resource_id.trim();
+    let asset = manifest
+        .assets
+        .iter()
+        .find(|asset| asset.id == resource_id)
+        .ok_or_else(|| "引用的素材已不存在，请移除后重新选择".to_string())?;
+    let path = sanitize_attachment_local_path(&asset.local_path)
+        .ok_or_else(|| "引用的素材路径无效，请移除后重新选择".to_string())?;
+    Ok(format!(
+        "[素材引用 resourceId={resource_id}；项目路径={path}]"
+    ))
+}
+
+fn runtime_region_summary(reference: &DirectCodexUserRuntimeRegionPart) -> String {
+    let resources = reference
+        .resource_ids
+        .iter()
+        .map(|id| id.trim())
+        .collect::<Vec<_>>()
+        .join(",");
+    let mut summary = format!("[运行画面区域：名称={} ", reference.label.trim());
+    if let Some(run_id) = reference.run_id.as_deref() {
+        summary.push_str(&format!("运行标识={} ", run_id.trim()));
+    }
+    if let Some(role) = reference.element_role.as_deref() {
+        summary.push_str(&format!("角色={} ", role.trim()));
+    }
+    if let Some(text) = reference.text.as_deref() {
+        summary.push_str(&format!("文本={} ", text.trim()));
+    }
+    if !resources.is_empty() {
+        summary.push_str(&format!("关联素材={resources}"));
+    }
+    summary.push(']');
+    summary
+}
+
 /// 将 canonical user item 转为 app-server `turn/start.input` 可接受的文本数组。
 /// AGC 私有 part 只在这里投影为安全摘要，canonical item 本身不被修改。
 pub(crate) fn direct_codex_user_item_to_wire_input(
@@ -65,38 +111,26 @@ pub(crate) fn direct_codex_user_item_to_wire_input(
         let text = match part {
             DirectCodexUserContentPart::InputText { text } => text.clone(),
             DirectCodexUserContentPart::AgcResourceReference { resource_id } => {
-                let asset = manifest
+                resource_reference_summary(&manifest, resource_id)?
-                    .assets
+            }
-                    .iter()
+            DirectCodexUserContentPart::AgcSkillReference { name } => {
-                    .find(|asset| asset.id == resource_id.trim())
+                format!("${}", name.trim())
-                    .ok_or_else(|| "引用的素材已不存在，请移除后重新选择".to_string())?;
-                let path = sanitize_attachment_local_path(&asset.local_path)
-                    .ok_or_else(|| "引用的素材路径无效，请移除后重新选择".to_string())?;
-                format!(
-                    "[素材引用 resourceId={}；项目路径={path}]",
-                    resource_id.trim()
-                )
             }
             DirectCodexUserContentPart::AgcRuntimeRegionReference(reference) => {
-                let resources = reference
+                runtime_region_summary(reference)
-                    .resource_ids
+            }
-                    .iter()
+            DirectCodexUserContentPart::AgcAttachmentReference(reference) => {
-                    .map(|id| id.trim())
+                let name = sanitize_attachment_name(&reference.name);
-                    .collect::<Vec<_>>()
+                let media_type = sanitize_attachment_media_type(&reference.media_type);
-                    .join(",");
+                let local_path = sanitize_attachment_local_path(&reference.local_path);
-                let mut summary = format!("[运行画面区域：名称={} ", reference.label.trim());
+                let mut summary = format!(
-                if let Some(run_id) = reference.run_id.as_deref() {
+                    "[附件：名称={}；类型={}；大小={} 字节",
-                    summary.push_str(&format!("运行标识={} ", run_id.trim()));
+                    name, media_type, reference.size
-                }
+                );
-                if let Some(role) = reference.element_role.as_deref() {
+                if let Some(local_path) = local_path {
-                    summary.push_str(&format!("角色={} ", role.trim()));
+                    summary.push_str(&format!("；项目路径={local_path}"));
-                }
-                if let Some(text) = reference.text.as_deref() {
-                    summary.push_str(&format!("文本={} ", text.trim()));
-                }
-                if !resources.is_empty() {
-                    summary.push_str(&format!("关联素材={resources}"));
                 }
+                summary.push_str(&format!("；状态={}", reference.status.trim()));
                 summary.push(']');
                 summary
             }
@@ -106,6 +140,66 @@ pub(crate) fn direct_codex_user_item_to_wire_input(
     Ok(Value::Array(input))
 }
 
+pub(crate) fn direct_codex_user_item_to_codex_turn_input(
+    root: &Path,
+    item: &DirectCodexUserItem,
+    skill_roots: &[std::path::PathBuf],
+) -> Result<Value, String> {
+    let manifest = validate_direct_codex_user_item(root, item)?;
+    let DirectCodexUserItem::Message(message) = item;
+    let mut input = Vec::with_capacity(message.content.len());
+    for part in &message.content {
+        match part {
+            DirectCodexUserContentPart::InputText { text } => {
+                input.push(serde_json::json!({ "type": "text", "text": text }));
+            }
+            DirectCodexUserContentPart::AgcResourceReference { resource_id } => {
+                input.push(serde_json::json!({
+                    "type": "text",
+                    "text": resource_reference_summary(&manifest, resource_id)?,
+                }));
+            }
+            DirectCodexUserContentPart::AgcSkillReference { name } => {
+                let name = name.trim();
+                let path = skill_roots
+                    .iter()
+                    .map(|root| root.join(name).join("SKILL.md"))
+                    .find(|path| path.is_file())
+                    .ok_or_else(|| "引用的 Skill 当前不可用，请重新选择".to_string())?;
+                input.push(serde_json::json!({
+                    "type": "skill",
+                    "name": name,
+                    "path": path,
+                }));
+            }
+            DirectCodexUserContentPart::AgcRuntimeRegionReference(reference) => {
+                input.push(serde_json::json!({
+                    "type": "text",
+                    "text": runtime_region_summary(reference),
+                }));
+            }
+            DirectCodexUserContentPart::AgcAttachmentReference(reference) => {
+                let mut summary = format!(
+                    "[附件：名称={}；类型={}；大小={} 字节",
+                    reference.name.trim(),
+                    reference.media_type.trim(),
+                    reference.size
+                );
+                if !reference.local_path.trim().is_empty() {
+                    summary.push_str(&format!("；项目路径={}", reference.local_path.trim()));
+                }
+                summary.push_str(&format!("；状态={}", reference.status.trim()));
+                summary.push(']');
+                input.push(serde_json::json!({
+                    "type": "text",
+                    "text": summary,
+                }));
+            }
+        }
+    }
+    Ok(Value::Array(input))
+}
+
 pub(crate) fn direct_codex_user_item_to_prompt(
     root: &Path,
     item: &DirectCodexUserItem,
@@ -130,7 +224,8 @@ pub(crate) fn direct_codex_user_item_to_prompt(
 
 #[cfg(test)]
 mod tests {
-    use super::direct_codex_user_item_to_response_item;
+    use super::{direct_codex_user_item_to_response_item, direct_codex_user_item_to_wire_input};
+    use crate::agent::direct_codex_user_item::model::DirectCodexUserItem;
     use serde_json::json;
     use std::path::Path;
 
@@ -174,4 +269,99 @@ mod tests {
         .expect_err("history item without type must fail");
         assert!(error.contains("缺少 type"), "{error}");
     }
+
+    #[test]
+    fn attachment_parts_remain_in_canonical_order_when_projected() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "wire-test", "wire 投影测试")
+            .expect("init project");
+        let item = json!({
+            "type": "message",
+            "role": "user",
+            "id": "turn-1:user",
+            "content": [
+                {"type": "input_text", "text": "先看"},
+                {"type": "agc_attachment_reference", "name": "notes.txt", "mediaType": "text/plain", "size": 4, "localPath": "assets/notes.txt", "status": "imported"}
+            ]
+        });
+        let projected = direct_codex_user_item_to_response_item(root.path(), &item)
+            .expect("user response item should project");
+        let content = projected["content"].as_array().expect("content array");
+        assert_eq!(content.len(), 2);
+        assert!(content[0]["text"].as_str().unwrap().contains("先看"));
+        assert!(content[1]["text"].as_str().unwrap().contains("notes.txt"));
+    }
+
+    #[test]
+    fn attachment_metadata_is_sanitized_before_prompt_projection() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "wire-test", "wire 投影测试")
+            .expect("init project");
+        let item = json!({
+            "type": "message",
+            "role": "user",
+            "id": "turn-1:user",
+            "content": [{
+                "type": "agc_attachment_reference",
+                "name": "C:\\tmp\\notes.md",
+                "mediaType": "text/plain",
+                "size": 4,
+                "localPath": "assets\\.\\notes.txt",
+                "status": "imported"
+            }]
+        });
+        let wire = super::direct_codex_user_item_to_wire_input(
+            root.path(),
+            &serde_json::from_value(item).expect("deserialize user item"),
+        )
+        .expect("attachment metadata should project");
+        let text = wire[0]["text"].as_str().expect("wire text");
+        assert!(text.contains("名称=notes.md"), "{text}");
+        assert!(text.contains("类型=text/plain"), "{text}");
+        assert!(text.contains("项目路径=assets/notes.txt"), "{text}");
+    }
+
+    #[test]
+    fn whitespace_only_text_parts_survive_validation() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "wire-test", "wire 投影测试")
+            .expect("init project");
+        let item: DirectCodexUserItem = serde_json::from_value(json!({
+            "type": "message",
+            "role": "user",
+            "id": "turn-1:user",
+            "content": [
+                {"type": "input_text", "text": "先看"},
+                {"type": "input_text", "text": "\n"},
+                {"type": "input_text", "text": "   "}
+            ]
+        }))
+        .expect("deserialize user item");
+        let wire = direct_codex_user_item_to_wire_input(root.path(), &item)
+            .expect("whitespace-only part next to real text must pass");
+        let parts = wire.as_array().expect("wire input array");
+        assert_eq!(parts.len(), 3);
+        assert_eq!(parts[1]["text"].as_str(), Some("\n"));
+        assert_eq!(parts[2]["text"].as_str(), Some("   "));
+    }
+
+    #[test]
+    fn all_blank_content_is_rejected() {
+        let root = tempfile::tempdir().expect("temp project");
+        crate::init_local_game_project_at(root.path(), "wire-test", "wire 投影测试")
+            .expect("init project");
+        let item: DirectCodexUserItem = serde_json::from_value(json!({
+            "type": "message",
+            "role": "user",
+            "id": "turn-1:user",
+            "content": [
+                {"type": "input_text", "text": "\n"},
+                {"type": "input_text", "text": "  "}
+            ]
+        }))
+        .expect("deserialize user item");
+        let error = direct_codex_user_item_to_wire_input(root.path(), &item)
+            .expect_err("all-blank content must fail closed");
+        assert!(error.contains("不能为空"), "{error}");
+    }
 }

apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime/user_input.rs

@@ -31,10 +31,9 @@ pub(crate) fn normalize_direct_client_turn_id(
 pub(crate) async fn chat_with_game_creator_direct_codex(
     project_path: String,
     prompt: String,
-    mut user_item: DirectCodexUserItem,
+    user_item: DirectCodexUserItem,
     creation_type: Option<String>,
     client_turn_id: Option<String>,
-    attachments: Option<Vec<DirectCodexTurnAttachment>>,
 ) -> Result<String, String> {
     let root = Path::new(project_path.trim());
     let turn_id = normalize_direct_client_turn_id(client_turn_id.as_deref())?;
@@ -43,34 +42,9 @@ pub(crate) async fn chat_with_game_creator_direct_codex(
         redact_agent_runtime_error(root, &format!("恢复上一轮陶泥儿整包事务失败：{error}"), 500)
     })?;
     let turn_emitter = DirectGameCreatorTurnUpdateEmitter::new(root, turn_id.clone());
-    let mut audit = DirectCodexTurnAudit::start(
+    validate_direct_codex_user_item(root, &user_item)?;
-        root,
+    let user_prompt = direct_codex_user_item_to_prompt(root, &user_item)?;
-        &turn_id,
-        &prompt,
-        attachments.as_deref().unwrap_or_default(),
-    );
-    let attachments = attachments.unwrap_or_default();
-    if !attachments.is_empty() {
-        let attachment_context =
-            render_direct_codex_user_prompt("", &attachments).map_err(|error| {
-                audit.finish(false);
-                error
-            })?;
-        let DirectCodexUserItem::Message(message) = &mut user_item;
-        message.content.push(DirectCodexUserContentPart::InputText {
-            text: attachment_context,
-        });
-    }
-    validate_direct_codex_user_item(root, &user_item).map_err(|error| {
-        audit.finish(false);
-        error
-    })?;
-    let user_prompt = direct_codex_user_item_to_prompt(root, &user_item).map_err(|error| {
-        audit.finish(false);
-        error
-    })?;
     if user_prompt.trim().is_empty() {
-        audit.finish(false);
         return Err("聊天内容不能为空".to_string());
     }
     let canonical_user_item =
@@ -80,18 +54,15 @@ pub(crate) async fn chat_with_game_creator_direct_codex(
         &user_prompt,
         creation_type.as_deref(),
         Some(&turn_emitter),
-        Some(&mut audit),
+        // DirectProject 的完整回合权威已经落在 project.jsonl；不再创建平行审计日志。
+        None,
         canonical_user_item,
     )
     .await
     {
         Ok(reply) => reply,
-        Err(error) => {
+        Err(error) => return Err(error),
-            audit.finish(false);
-            return Err(error);
-        }
     };
-    audit.finish(true);
     turn_emitter.emit("completed", Some("none"), Some(reply.clone()), None);
     Ok(reply)
 }

apps/ai-game-creator-shell/src-tauri/src/agent/direct_thread_manager.rs

@@ -427,16 +427,12 @@ mod tests {
         }
     }
 
-    /// 事件级阶段时间只在重放稳定性用例里逐个指定；其余用例用一个固定值即可，
-    /// 它们断言的是队列 / 游标语义，不是时间本身。
-    const FIXED_AT_MS: u64 = 1_000;
-
     fn item_started(item_id: &str) -> DirectThreadEvent {
-        DirectThreadEvent::item_started(message(item_id), FIXED_AT_MS)
+        DirectThreadEvent::item_started(message(item_id))
     }
 
     fn item_completed(item_id: &str) -> DirectThreadEvent {
-        DirectThreadEvent::item_completed(message(item_id), FIXED_AT_MS)
+        DirectThreadEvent::item_completed(message(item_id))
     }
 
     fn item_delta(item_id: &str) -> DirectThreadEvent {
@@ -454,7 +450,7 @@ mod tests {
     #[test]
     fn subscribers_have_independent_cursors_on_one_global_queue() {
         let mut manager = DirectThreadManager::with_limits(100, 100_000);
-        manager.append("thread-1", DirectThreadEvent::turn_started(FIXED_AT_MS));
+        manager.append("thread-1", DirectThreadEvent::turn_started());
         let first = manager.subscribe("thread-1");
         let second = manager.subscribe("thread-1");
         manager.append("thread-1", item_started("item-1"));
@@ -478,7 +474,7 @@ mod tests {
     #[test]
     fn bootstrap_contains_lifecycle_anchor_and_unfinished_events_only() {
         let mut manager = DirectThreadManager::with_limits(100, 100_000);
-        manager.append("thread-1", DirectThreadEvent::turn_started(FIXED_AT_MS));
+        manager.append("thread-1", DirectThreadEvent::turn_started());
         manager.append("thread-1", item_started("item-1"));
         manager.append("thread-1", item_delta("item-1"));
         manager.append("thread-1", item_completed("item-1"));
@@ -488,7 +484,7 @@ mod tests {
         assert!(matches!(
             bootstrap.events.as_slice(),
             [
-                DirectThreadEvent::TurnStarted { .. },
+                DirectThreadEvent::TurnStarted {},
                 DirectThreadEvent::ItemStarted { item, .. },
             ] if item.item_id() == "item-2"
         ));
@@ -593,118 +589,15 @@ mod tests {
         let mut manager = DirectThreadManager::with_limits(100, 100_000);
         manager.append(
             "thread-1",
-            DirectThreadEvent::turn_completed("completed".to_string(), FIXED_AT_MS),
+            DirectThreadEvent::turn_completed("completed".to_string()),
         );
         let bootstrap = manager.subscribe("thread-1");
         assert!(matches!(
             bootstrap.events.as_slice(),
-            [DirectThreadEvent::TurnCompleted { status, at, .. }]
+            [DirectThreadEvent::TurnCompleted { status }] if status == "completed"
-                if status == "completed" && *at == Some(FIXED_AT_MS)
         ));
     }
 
-    /// 阶段时间必须随事件一起进队列：bootstrap 与重复订阅都拿到**原值**，
-    /// 重放不得重新取钟（否则每次重连都会把已固定的起止时间改掉）。
-    #[test]
-    fn replayed_events_keep_their_original_stage_time() {
-        let mut manager = DirectThreadManager::with_limits(100, 100_000);
-        manager.append("thread-1", DirectThreadEvent::turn_started(1_000));
-        manager.append(
-            "thread-1",
-            DirectThreadEvent::item_started(message("item-1"), 2_000),
-        );
-
-        let first = manager.subscribe("thread-1");
-        assert_eq!(
-            first
-                .events
-                .iter()
-                .map(DirectThreadEvent::at)
-                .collect::<Vec<_>>(),
-            vec![Some(1_000), Some(2_000)]
-        );
-
-        // 第二个订阅看到的是同一份事件，时间不因"又取了一次当前时间"而漂移。
-        let second = manager.subscribe("thread-1");
-        assert_eq!(second.events, first.events);
-
-        manager.append(
-            "thread-1",
-            DirectThreadEvent::item_completed(message("item-1"), 3_000),
-        );
-        let completion = manager
-            .consume(&first.subscription_id)
-            .expect("consume completion")
-            .events;
-        assert_eq!(
-            completion
-                .iter()
-                .map(DirectThreadEvent::at)
-                .collect::<Vec<_>>(),
-            vec![Some(3_000)]
-        );
-        // 重复消费不产生新事件，也不改写已下发过的时间。
-        assert!(manager
-            .consume(&first.subscription_id)
-            .expect("empty consume")
-            .events
-            .is_empty());
-        assert_eq!(
-            completion
-                .iter()
-                .map(DirectThreadEvent::at)
-                .collect::<Vec<_>>(),
-            vec![Some(3_000)]
-        );
-    }
-
-    /// 生命周期锚点重放时必须带上开口用户条目身份：前端在「只有锚点 + 历史切片、运行态一直空」
-    /// 的回合里也要能把边界认领给同一条用户条目，而不是按时间戳猜。
-    #[test]
-    fn bootstrap_replays_opener_user_item_id() {
-        let mut manager = DirectThreadManager::with_limits(100, 100_000);
-        manager.append(
-            "thread-1",
-            DirectThreadEvent::turn_started(1_000)
-                .with_user_item_id(Some("direct-codex:turn-1:user")),
-        );
-        let bootstrap = manager.subscribe("thread-1");
-        assert_eq!(
-            bootstrap
-                .events
-                .iter()
-                .map(DirectThreadEvent::user_item_id)
-                .collect::<Vec<_>>(),
-            vec![Some("direct-codex:turn-1:user")]
-        );
-        assert_eq!(bootstrap.events[0].at(), Some(1_000));
-
-        // 锚点是独立保存的副本：队列里那条事件被回收之后，新订阅仍拿到同一个身份。
-        manager
-            .consume(&bootstrap.subscription_id)
-            .expect("consume anchor");
-        manager.append(
-            "thread-1",
-            DirectThreadEvent::item_completed(message("item-1"), 2_000),
-        );
-        manager.append(
-            "thread-1",
-            DirectThreadEvent::turn_completed("completed".to_string(), 3_000)
-                .with_user_item_id(Some("direct-codex:turn-1:user")),
-        );
-        let second = manager.subscribe("thread-1");
-        assert_eq!(
-            second
-                .events
-                .iter()
-                .map(DirectThreadEvent::user_item_id)
-                .collect::<Vec<_>>(),
-            vec![Some("direct-codex:turn-1:user")],
-            "起止同源：终态锚点也带同一个开口用户条目身份"
-        );
-        assert_eq!(second.events[0].at(), Some(3_000));
-    }
-
     #[test]
     fn queue_cleanup_only_removes_a_cleanable_prefix() {
         let mut manager = DirectThreadManager::with_limits(100, 100_000);

apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs

@@ -2391,8 +2391,6 @@ async fn bridge_generate_image(state: &DirectToolBridgeState, arguments: &Value)
             slice_mode,
             grid_x,
             grid_y,
-            reference_asset_ids: Vec::new(),
-            target_category: None,
             screen_color,
         };
         let _generation_guard = state.image_generation_gate.lock().await;

apps/ai-game-creator-shell/src-tauri/src/agent/generation.rs

@@ -67,11 +67,10 @@ pub(crate) use canvas_generation::{
     generate_platform_art_asset_with_options_at,
     generate_platform_art_asset_with_required_slices_at, maybe_generate_platform_art_asset_step,
     needs_platform_art_asset_generation, normalize_platform_art_asset_generation_kind,
-    normalize_platform_art_reference_asset_ids, normalize_platform_art_target_category,
     platform_art_asset_art_spec, platform_art_asset_output_extension_matches,
-    platform_art_runtime_references_match_request_contract, prepare_platform_art_asset_output_path,
+    prepare_platform_art_asset_output_path, project_canvas_asset_media_types,
-    project_canvas_asset_media_types, role_has_canvas_assets, suggested_canvas_tool_call,
+    role_has_canvas_assets, suggested_canvas_tool_call, PlatformArtAssetGenerationOptions,
-    PlatformArtAssetGenerationOptions, PLATFORM_ART_ASSET_GENERATION_KINDS,
+    PLATFORM_ART_ASSET_GENERATION_KINDS,
 };
 #[allow(unused_imports)]
 pub(crate) use draft_validation::{

apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs

@@ -549,7 +549,7 @@ fn append_agent_runtime_file_read_evidence_ref(
     // 给的是**整个三元组**，不是一个碎片。`agent.acceptance_update` 的 evidence 引用
     // 要求 {agentId, runId, actionId} 三个字段，回执查找也按三元组整体做 key。早期
     // 只给 actionId，另外两个靠模型回忆——实测它第一次就把其中一个记错，白吃一次
-    // 拒绝。验收证据只接受当前根 run 的回执，
+    // 拒绝。反正 `validate_fast_gdd_evidence_identity` 只接受当前根 run 的回执，
     // 合法取值唯一，本来就不该让它猜。
     observation.summary = format!(
         "{} · sourceAgentId={agent_id} · sourceRunId={run_id} · sourceActionId={action_id}",
@@ -919,9 +919,9 @@ mod file_read_source_action_id_tests {
         AgentRuntimeToolObservation {
             tool: "file.read".to_string(),
             status: "ok".to_string(),
-            summary: "已读取 design.md 第 1-134 行（共 134 行）".to_string(),
+            summary: "已读取 game/fast_gdd.md 第 1-134 行（共 134 行）".to_string(),
             detail: Some(format!(
-                "design.md · sha256={} · lines 1-134 of 134
+                "game/fast_gdd.md · sha256={} · lines 1-134 of 134
 第一行内容",
                 "a".repeat(64)
             )),
@@ -954,7 +954,7 @@ mod file_read_source_action_id_tests {
             agent_runtime_action_receipt_public_safe_detail_for_test(&root, &observation)
             .expect("safe detail still parses");
         let value = serde_json::from_str::<serde_json::Value>(&safe_detail).expect("json");
-        assert_eq!(value["path"], "design.md");
+        assert_eq!(value["path"], "game/fast_gdd.md");
         assert_eq!(value["lines"], "1-134 of 134");
         assert_eq!(value["contentSha256"], "a".repeat(64));
     }

apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs

@@ -78,6 +78,12 @@ pub(super) fn game_creator_agent_final_reply_error_allows_fallback(error: &str)
     matches!(kind.as_str(), "empty-response" | "deserialize")
 }
 
+/// 这些错误只描述本次 Provider input 或候选 GDD；真正的 session CAS 冲突不在
+/// 此列——那说明 durable session 已被推进或损坏，必须 reconcile。
+fn plan_submit_error_is_business_rejection(error: &PlanningStorageError) -> bool {
+    matches!(error.code(), "PLAN_INVALID_REQUEST" | "PLAN_SIZE_LIMIT")
+}
+
 const AGENT_RUNTIME_PLAN_UPDATE_IDLE_LIMIT: u32 = 4;
 
 /// 最终回复被收束门禁拦下后 run 会原地续跑重试。多数 blocker 是模型自己能解的