Merge remote-tracking branch 'origin/master' into feat/tribo3d-integeration

# Conflicts:
#	docs/project-memory/shared-memory/pitfalls.md

.gitea/workflows/project-ci.yml

@@ -82,12 +82,23 @@ jobs:
             sleep $((attempt * 2))
           done
 
+      - name: Prepare isolated Rust compilation cache
+        shell: bash
+        run: |
+          set -euo pipefail
+          node --test scripts/ci-rust-cache.test.mjs
+          bash scripts/ci-rust-cache.sh prepare
+
       - name: Run AI game creator shell Rust shard 1/4
         run: npm run check:native-shells:agc-rust-shard-1
 
       - name: Run AI game creator shell Rust shard 2/4
         run: npm run check:native-shells:agc-rust-shard-2
 
+      - name: Report isolated Rust compilation cache
+        if: always()
+        run: bash scripts/ci-rust-cache.sh report
+
   ai-game-creator-shell-rust-lane-2:
     name: AI game creator shell Rust lane 2/2
     runs-on: genarrative-ci
@@ -118,12 +129,19 @@ jobs:
             sleep $((attempt * 2))
           done
 
+      - name: Prepare isolated Rust compilation cache
+        run: bash scripts/ci-rust-cache.sh prepare
+
       - name: Run AI game creator shell Rust shard 3/4
         run: npm run check:native-shells:agc-rust-shard-3
 
       - name: Run AI game creator shell Rust shard 4/4
         run: npm run check:native-shells:agc-rust-shard-4
 
+      - name: Report isolated Rust compilation cache
+        if: always()
+        run: bash scripts/ci-rust-cache.sh report
+
   # agent-run smoke 会 spawn `cargo run`（走壳自己的 manifest），同样不装 npm 依赖，
   # 单独一个 job，免得把已经压到 4 分钟级的片 job 拖长。
   ai-game-creator-shell-rust-smoke:
@@ -156,9 +174,16 @@ jobs:
             sleep $((attempt * 2))
           done
 
+      - name: Prepare isolated Rust compilation cache
+        run: bash scripts/ci-rust-cache.sh prepare
+
       - name: Run AI game creator shell agent-run smoke
         run: npm run check:native-shells:agc-rust-smoke
 
+      - name: Report isolated Rust compilation cache
+        if: always()
+        run: bash scripts/ci-rust-cache.sh report
+
   # AGC 壳依赖的共享 / 平台和编辑器插件 crate 各自预热独立 manifest，再运行对应测试。
   ai-game-creator-shell-rust-crates:
     name: AI game creator shell Rust crates
@@ -257,9 +282,16 @@ jobs:
             sleep $((attempt * 2))
           done
 
+      - name: Prepare isolated Rust compilation cache
+        run: bash scripts/ci-rust-cache.sh prepare
+
       - name: Run AI game creator shell shared crate gates
         run: npm run check:native-shells:agc-rust-crates
 
+      - name: Report isolated Rust compilation cache
+        if: always()
+        run: bash scripts/ci-rust-cache.sh report
+
   backend-tests:
     name: Backend tests
     runs-on: genarrative-ci
@@ -330,6 +362,9 @@ jobs:
       - name: Check server-rs boundaries
         run: npm run check:server-rs-ddd
 
+      - name: Prepare isolated Rust compilation cache
+        run: bash scripts/ci-rust-cache.sh prepare
+
       - name: Run server-rs workspace tests
         run: cargo test --locked --workspace --exclude spacetime-module --no-fail-fast --manifest-path server-rs/Cargo.toml
 
@@ -342,6 +377,10 @@ jobs:
       - name: Check SpacetimeDB module
         run: cargo check --locked -p spacetime-module --manifest-path server-rs/Cargo.toml
 
+      - name: Report isolated Rust compilation cache
+        if: always()
+        run: bash scripts/ci-rust-cache.sh report
+
   # 客户端的壳级与契约门禁：静态契约断言、H5 / 微信 / 移动 / 桌面壳运行时门禁，
   # 以及依赖发布产物的构建 smoke。
   native-shell-tests:
@@ -384,15 +423,26 @@ jobs:
       - name: Run native shell contract gates
         run: npm run check:native-shells:contract
 
+      - name: Prepare isolated Rust compilation cache
+        run: bash scripts/ci-rust-cache.sh prepare
+
       - name: Run native shell gates
         run: npm run check:native-shells:shells
 
       - name: Run native shell release build smoke
+        # 发布构建有独立 profile/features 和资源 staging，不消费测试对象快照。
+        env:
+          RUSTC_WRAPPER: ''
+          CARGO_BUILD_RUSTC_WRAPPER: ''
         run: npm run check:native-shells:release
 
       - name: Ensure native lockfiles are unchanged
         run: git diff --exit-code -- apps/desktop-shell/src-tauri/Cargo.lock apps/ai-game-creator-shell/src-tauri/Cargo.lock
 
+      - name: Report isolated Rust compilation cache
+        if: always()
+        run: bash scripts/ci-rust-cache.sh report
+
   frontend-tests:
     name: Frontend tests
     runs-on: genarrative-ci
@@ -410,7 +460,7 @@ jobs:
         run: bash scripts/ci-npm-ci-with-retry.sh
 
       - name: Run frontend and script tests
-        run: npm run test
+        run: npm run test:ci:frontend
 
       - name: Run BgFilter worker smoke harness tests
         run: npm run bgfilter-worker:smoke-test

apps/ai-game-creator-shell/scripts/run-rust-shell-test-shards.mjs

@@ -150,6 +150,7 @@ function formatDuration(milliseconds) {
 // 编译一次，直接拿到测试可执行文件：后续每片都运行同一个二进制，不再各自调用 cargo，
 // 免得 N 个 cargo 去争 package cache 与 target 目录锁。
 function resolveTestExecutable() {
+  const startedAt = Date.now();
   return new Promise((resolve, reject) => {
     const cargoArguments = buildCargoArguments({
       kind: options.targetKind,
@@ -194,6 +195,9 @@ function resolveTestExecutable() {
       reject(new Error(`unable to start cargo: ${error.message}`));
     });
     child.on('close', (code) => {
+      console.log(
+        `[rust-shards] compile duration=${formatDuration(Date.now() - startedAt)} exit=${code}`,
+      );
       if (code !== 0) {
         reject(
           new Error(

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

@@ -2,7 +2,8 @@
 //!
 //! Every caller supplies a safe public summary and a private detail.  This
 //! module is the only persistence boundary for the latter: it redacts project
-//! paths and credentials before writing a bounded diagnostic sidecar.
+//! paths and credentials before writing a bounded diagnostic sidecar, and
+//! projects the same bounded diagnosis into the AppData application log.
 
 use super::{redact_agent_runtime_error, write_agent_runtime_json_sidecar_with_max_bytes};
 use serde::{Deserialize, Serialize};
@@ -14,6 +15,20 @@ use std::time::{SystemTime, UNIX_EPOCH};
 pub(crate) const AGENT_RUNTIME_ERROR_SCHEMA_VERSION: &str = "agent-runtime-error.v1";
 pub(crate) const AGENT_RUNTIME_ERROR_MAX_DETAIL_CHARS: usize = 8 * 1024;
 
+/// 应用日志里 detail / metadata 的字符预算。
+///
+/// `application.log` 的每一行在落盘前还会被 `sanitize_diagnostic_message` 截到 2 KiB，
+/// 这里的预算留出身份字段与中文摘要的位置，保证被截掉的是诊断正文的尾部，而不是
+/// `eventId`、`code` 或 `detailRef`。
+pub(crate) const AGENT_RUNTIME_ERROR_APP_LOG_DETAIL_CHARS: usize = 1_200;
+pub(crate) const AGENT_RUNTIME_ERROR_APP_LOG_METADATA_CHARS: usize = 200;
+
+/// 详情行里 public summary 的字符预算。
+///
+/// `summary` 由调用方给，`direct_tool_bridge` 传的是工具错误原文；这里与 sidecar 侧的摘要
+/// 预算同口径（320 字符）截断，并再脱敏一次，避免摘要把整条详情行占满。
+pub(crate) const AGENT_RUNTIME_ERROR_APP_LOG_SUMMARY_CHARS: usize = 320;
+
 static ERROR_EVENT_SEQUENCE: AtomicU64 = AtomicU64::new(1);
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
@@ -71,6 +86,27 @@ pub(crate) fn persist_agent_runtime_error(
         "detail": safe_detail,
         "metadata": metadata,
     });
+    // 统一错误事件的项目内 sidecar 只在项目目录可见：用户提交错误报告时上传的是 AppData
+    // 应用日志，诊断包拿不到 detail。这里先把同一份已脱敏诊断留进应用日志，再落项目文件，
+    // 于是 sidecar 写失败也仍然留下可提交的诊断。
+    let app_log_lines = agent_runtime_error_app_log_lines(
+        root,
+        &event_id,
+        client_turn_id,
+        source,
+        stage,
+        code,
+        retryable,
+        public_text,
+        recovery_hint,
+        &detail_ref,
+        &safe_detail,
+        elapsed_ms,
+        &metadata,
+    );
+    for line in app_log_lines {
+        app_log!("{line}");
+    }
     write_agent_runtime_json_sidecar_with_max_bytes(
         root,
         &detail_ref,
@@ -96,6 +132,78 @@ pub(crate) fn persist_agent_runtime_error(
     })
 }
 
+/// 把统一错误事件投影成 AppData `diagnostics/application.log` 里的两行。
+///
+/// 传进来的 `detail` 是 sidecar 用的脱敏文本，`metadata` 则从未脱敏过。两行落到 `app_log!`
+/// 时都会先按应用日志预算（1200 / 200 字符）再脱敏、再截断：`app_log!` 还会把同一行写到
+/// stderr，那里没有 `sanitize_diagnostic_message` 兜底，所以每个调用方给的外来文本
+/// （`summary` 按 320 字符预算）都在这里过一遍脱敏。
+///
+/// 已经脱敏过的 `detail` 也照走同一遍流水线，不按「调用方已脱敏」走短路：截断会把
+/// `[redacted-secret]` 这类标记切开，而且这里是 `pub(crate)` 边界，不假设未来调用方一定先脱敏。
+///
+/// 拆成「身份行 + 详情行」是因为整行只要出现凭据标记就会被
+/// [`crate::sanitize_diagnostic_message`] 整体替换成脱敏占位。因此身份行**只放程序生成或
+/// 调用方常量字段**（eventId / source / stage / code / retryable / clientTurnId / elapsedMs /
+/// detailRef），`summary`、`hint` 这些自由文本全部放详情行：自由文本里一个裸词
+/// （例如 `credential`）就能让整行被替换，放错了就会把事件定位信息一起吃掉。
+///
+/// 单行口径在这里落地：`app_log!` 同时把这行写到 stderr，那里没有人替我们压行，
+/// 所以每个字段（含 `source` / `stage` / `code` / `detailRef` 这些调用方给的标识）都先
+/// 过一遍 [`single_line_log_field`]，不假设调用方一定给单行文本。
+pub(crate) fn agent_runtime_error_app_log_lines(
+    root: &Path,
+    event_id: &str,
+    client_turn_id: Option<&str>,
+    source: &str,
+    stage: &str,
+    code: &str,
+    retryable: bool,
+    public_text: &str,
+    recovery_hint: &str,
+    detail_ref: &str,
+    detail: &str,
+    elapsed_ms: Option<u64>,
+    metadata: &Value,
+) -> [String; 2] {
+    let event_id = single_line_log_field(event_id);
+    let client_turn_id = single_line_log_field(client_turn_id.unwrap_or("none"));
+    let source = single_line_log_field(source);
+    let stage = single_line_log_field(stage);
+    let code = single_line_log_field(code);
+    let detail_ref = single_line_log_field(detail_ref);
+    let public_text = single_line_log_field(&redact_agent_runtime_error(
+        root,
+        public_text,
+        AGENT_RUNTIME_ERROR_APP_LOG_SUMMARY_CHARS,
+    ));
+    let elapsed_ms = elapsed_ms
+        .map(|value| value.to_string())
+        .unwrap_or_else(|| "none".to_string());
+    let identity = format!(
+        "agent.runtime.error eventId={event_id} source={source} stage={stage} code={code} retryable={retryable} clientTurnId={client_turn_id} elapsedMs={elapsed_ms} detailRef={detail_ref}"
+    );
+    let detail = redact_agent_runtime_error(root, detail, AGENT_RUNTIME_ERROR_APP_LOG_DETAIL_CHARS);
+    let metadata = redact_agent_runtime_error(
+        root,
+        &metadata.to_string(),
+        AGENT_RUNTIME_ERROR_APP_LOG_METADATA_CHARS,
+    );
+    let detail_line = format!(
+        "agent.runtime.error.detail eventId={event_id} hint={} summary={} detail={} metadata={}",
+        single_line_log_field(recovery_hint),
+        single_line_log_field(&public_text),
+        single_line_log_field(&detail),
+        single_line_log_field(&metadata),
+    );
+    [identity, detail_line]
+}
+
+/// 应用日志是逐行读取的：落到日志里的自由文本必须先压平换行。
+fn single_line_log_field(value: &str) -> String {
+    value.replace(['\r', '\n'], " ")
+}
+
 pub(crate) fn classify_direct_codex_error(error: &str) -> &'static str {
     let normalized = error.to_ascii_lowercase();
     if normalized.contains("等待 turn/completed 超时") {
@@ -153,6 +261,91 @@ mod tests {
         assert!(!text.contains("token=secret"));
     }
 
+    #[test]
+    fn error_event_app_log_lines_keep_identity_and_redact_detail() {
+        let parent = tempfile::tempdir().expect("temp root");
+        let root = parent.path().join("project");
+        crate::project::init_local_game_project_at(&root, "runtime-error", "错误事件")
+            .expect("init project");
+        // 生产路径传进来的是已经脱敏的 safe_detail（8 KiB 口径），这里按同一口径造输入；
+        // metadata 在生产里从未脱敏，仍按原文传。
+        let safe_detail = redact_agent_runtime_error(
+            &root,
+            "C:\\Users\\private\\project https://provider.example/a?token=secret\n第二行诊断",
+            AGENT_RUNTIME_ERROR_MAX_DETAIL_CHARS,
+        );
+        let lines = agent_runtime_error_app_log_lines(
+            &root,
+            "error-1-1",
+            Some("turn-123"),
+            "direct-codex",
+            "code-generation",
+            "turn-idle-timeout",
+            true,
+            "本轮没有收到完成事件\n附带换行",
+            "查看诊断后重试",
+            ".agent/runtime/errors/error-1-1.json",
+            &safe_detail,
+            Some(1200),
+            &serde_json::json!({"authorization": "Bearer secret"}),
+        );
+        for line in &lines {
+            assert!(!line.contains('\n'), "{line}");
+        }
+        // 落盘边界按真实口径核验：应用日志逐行脱敏、逐行截断，两行不会先拼在一起。
+        let persisted = lines
+            .iter()
+            .map(|line| crate::sanitize_diagnostic_message(line, None))
+            .collect::<Vec<_>>();
+        for line in &persisted {
+            assert!(!line.contains("token=secret"), "{line}");
+            assert!(line.chars().count() <= 2_048, "{line}");
+        }
+        let identity = &persisted[0];
+        assert!(identity.contains("eventId=error-1-1"), "{identity}");
+        assert!(identity.contains("code=turn-idle-timeout"), "{identity}");
+        assert!(
+            identity.contains("detailRef=.agent/runtime/errors/error-1-1.json"),
+            "{identity}"
+        );
+        // 身份行只放程序生成或调用方常量字段：自由文本放错行会让「整行命中标记」把它吃掉。
+        assert!(!identity.contains("summary="), "{identity}");
+        let detail = &persisted[1];
+        assert!(
+            detail.contains("summary=本轮没有收到完成事件 附带换行"),
+            "{detail}"
+        );
+        assert!(
+            detail.contains("detail=<absolute-path> <redacted-url> 第二行诊断"),
+            "{detail}"
+        );
+        assert!(!detail.contains("Bearer secret"), "{detail}");
+
+        // 自由文本里出现裸标记词时，被整行替换的只能是详情行：身份行仍可定位事件。
+        let marked = agent_runtime_error_app_log_lines(
+            &root,
+            "error-3-1",
+            None,
+            "agc-tools",
+            "tool-execution",
+            "tool-error",
+            true,
+            "credential rotation failed",
+            "查看项目错误诊断后处理",
+            ".agent/runtime/errors/error-3-1.json",
+            &safe_detail,
+            None,
+            &serde_json::json!({"tool": "agc_tools"}),
+        );
+        let identity = crate::sanitize_diagnostic_message(&marked[0], None);
+        assert!(identity.contains("eventId=error-3-1"), "{identity}");
+        assert!(identity.contains("code=tool-error"), "{identity}");
+        assert_eq!(
+            crate::sanitize_diagnostic_message(&marked[1], None),
+            "<sensitive diagnostic details redacted>"
+        );
+    }
+
     #[test]
     fn timeout_and_tool_errors_have_distinct_codes() {
         assert_eq!(

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

@@ -2,6 +2,11 @@ use super::*;
 #[cfg(target_os = "linux")]
 use std::process::Stdio;
 
+#[cfg(target_os = "linux")]
+mod owner_fixture_cleanup;
+#[cfg(target_os = "linux")]
+use owner_fixture_cleanup::{project_processes, OwnerFixtureCleanup};
+
 static PROCESS_SESSION_TEST_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 
 fn process_session_test_guard() -> std::sync::MutexGuard<'static, ()> {
@@ -1743,20 +1748,6 @@ fn process_session_runner_owner_fixture() {
 #[cfg(target_os = "linux")]
 #[test]
 fn process_session_owner_sigkill_leaves_no_child_process() {
-    fn project_processes(root: &Path) -> Vec<i32> {
-        let canonical_root = fs::canonicalize(root).expect("canonical test project");
-        fs::read_dir("/proc")
-            .into_iter()
-            .flatten()
-            .flatten()
-            .filter_map(|entry| {
-                let process_id = entry.file_name().to_string_lossy().parse::<i32>().ok()?;
-                let cwd = fs::read_link(entry.path().join("cwd")).ok()?;
-                (cwd == canonical_root).then_some(process_id)
-            })
-            .collect()
-    }
-
     let directory = tempfile::tempdir().expect("temp project");
     let root = directory.path();
     init_local_game_project_at(root, "owner-process-project", "Owner Process Project")
@@ -1787,6 +1778,10 @@ setInterval(() => {}, 1000);
         .stderr(Stdio::null())
         .spawn()
         .expect("spawn owner fixture test process");
+    let cleanup = OwnerFixtureCleanup {
+        owner: &mut owner,
+        root,
+    };
     let deadline = std::time::Instant::now() + Duration::from_secs(10);
     while (!root.join("owner-ready").is_file() || project_processes(root).is_empty())
         && std::time::Instant::now() < deadline
@@ -1799,9 +1794,9 @@ setInterval(() => {}, 1000);
         "sandbox child should be visible from host /proc"
     );
 
-    let owner_pid = i32::try_from(owner.id()).expect("owner pid");
-    assert_eq!(unsafe { libc::kill(owner_pid, libc::SIGKILL) }, 0);
-    owner.wait().expect("reap owner fixture");
+    // Linux Child::kill 发送 SIGKILL；先检查真实子树回收，再由 guard 兜底。
+    cleanup.owner.kill().expect("SIGKILL owner fixture");
+    cleanup.owner.wait().expect("reap owner fixture");
     let deadline = std::time::Instant::now() + Duration::from_secs(5);
     loop {
         let remaining = project_processes(root);

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

@@ -0,0 +1,127 @@
+use std::fs;
+use std::path::Path;
+use std::process::Child;
+use std::thread;
+use std::time::{Duration, Instant};
+
+pub(super) fn project_processes(root: &Path) -> Vec<i32> {
+    let Ok(canonical_root) = fs::canonicalize(root) else {
+        return Vec::new();
+    };
+    fs::read_dir("/proc")
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|entry| {
+            let process_id = entry.file_name().to_string_lossy().parse::<i32>().ok()?;
+            if process_id <= 1 || process_id == std::process::id() as i32 {
+                return None;
+            }
+            let cwd = fs::read_link(entry.path().join("cwd")).ok()?;
+            (cwd == canonical_root).then_some(process_id)
+        })
+        .collect()
+}
+
+pub(super) struct OwnerFixtureCleanup<'a> {
+    pub(super) owner: &'a mut Child,
+    pub(super) root: &'a Path,
+}
+
+impl Drop for OwnerFixtureCleanup<'_> {
+    fn drop(&mut self) {
+        let _ = self.owner.kill();
+        let _ = self.owner.wait();
+
+        // 正常路径先验证子进程自行退出；这里只兜底作用域退出（包括 panic）后的残留。
+        // 项目目录由每条用例独占，不能按进程名清理其他用例或开发进程。
+        let deadline = Instant::now() + Duration::from_secs(5);
+        loop {
+            let remaining = project_processes(self.root);
+            if remaining.is_empty() {
+                return;
+            }
+            for process_id in &remaining {
+                unsafe {
+                    libc::kill(*process_id, libc::SIGKILL);
+                }
+            }
+            if Instant::now() >= deadline {
+                // Drop 可能在 panic 展开期间执行，不能再次 panic。
+                use std::io::Write;
+                let _ = writeln!(
+                    std::io::stderr(),
+                    "owner fixture cleanup timed out: pids={remaining:?}"
+                );
+                return;
+            }
+            thread::sleep(Duration::from_millis(25));
+        }
+    }
+}
+
+#[test]
+fn owner_fixture_cleanup_reaps_processes_on_panic_without_touching_other_projects() {
+    use std::panic::{catch_unwind, AssertUnwindSafe};
+    use std::process::{Command, Stdio};
+
+    // 回归夹具自己的回收不能依赖被测 guard，否则 guard 回归时测试也会泄漏。
+    struct Sleeper(Child);
+    impl Drop for Sleeper {
+        fn drop(&mut self) {
+            let _ = self.0.kill();
+            let _ = self.0.wait();
+        }
+    }
+    fn sleeper(root: &Path) -> Sleeper {
+        Sleeper(
+            Command::new("sleep")
+                .arg("60")
+                .current_dir(root)
+                .stdin(Stdio::null())
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .spawn()
+                .expect("spawn cleanup fixture"),
+        )
+    }
+
+    // 同时覆盖 owner 刚启动就失败，以及已有残留进程时失败。
+    for has_residual in [false, true] {
+        let project = tempfile::tempdir().expect("cleanup project");
+        let other_project = tempfile::tempdir().expect("unrelated project");
+        let mut owner = sleeper(project.path());
+        let cleanup = OwnerFixtureCleanup {
+            owner: &mut owner.0,
+            root: project.path(),
+        };
+        // 故意不依赖 owner 退出监测，验证兜底能清理仍留在项目目录的进程。
+        let mut residual = has_residual.then(|| sleeper(project.path()));
+        let mut other = sleeper(other_project.path());
+        let result = catch_unwind(AssertUnwindSafe(move || {
+            let _cleanup = cleanup;
+            panic!("simulate an assertion failure before owner shutdown");
+        }));
+
+        let owner_status = owner.0.try_wait();
+        let residual_status = residual.as_mut().map(|child| child.0.try_wait());
+        let other_status = other.0.try_wait();
+        // 即使 guard 回归，先收口本测试持有的进程再断言，避免回归用例自身泄漏。
+        drop(owner);
+        drop(residual);
+        drop(other);
+
+        assert!(result.is_err());
+        assert!(matches!(owner_status, Ok(Some(_))), "owner must exit");
+        if has_residual {
+            assert!(
+                matches!(residual_status, Some(Ok(Some(_)))),
+                "residual process must exit"
+            );
+        }
+        assert!(
+            matches!(other_status, Ok(None)),
+            "other project must survive"
+        );
+    }
+}

deploy/container/README.md

@@ -95,6 +95,27 @@ runner 配置保留原 `ubuntu-latest` 映射，`genarrative-ci` 继续映射到
 
 回滚时先把 workflow 的 `runs-on` 改回 `ubuntu-latest`，再恢复备份的 runner config 并用同一超时重启 runner。不要在真实 CI 验证前删除旧映射或旧镜像。
 
+### Rust 测试组编译对象快照
+
+`scripts/build-gitea-rust-cache.sh` 在已验证的 job 镜像上生成候选镜像，覆盖 AGC Rust 两条 lane、crates、agent-run smoke、Backend 和 Native shell 的桌面壳测试。Native shell 的 release build smoke 显式清空两个 wrapper，不消费测试快照。固定 sccache `0.18.0` 的 Linux x64 musl 归档并校验 SHA-256，维护者从 origin/master 的确定提交预热编译对象，PR job 没有生成/发布公共快照的权限。
+
+基础镜像必须不含 `/opt/genarrative-ci/rust-cache`；脚本在拉取源码、下载工具和预热前执行只读、断网检查，发现已有对象快照就拒绝构建。不能在旧缓存镜像上删除目录再叠加新快照，删除操作不会释放旧镜像层。切换且真实 CI 验证通过后，人工定向清理更旧的缓存镜像与导出归档，保留当前版、一个回滚版及运行中 CI 使用的版本；对象缓存上限不覆盖这些宿主文件，不使用全局 prune。
+
+```bash
+bash scripts/build-gitea-rust-cache.sh genarrative/gitea-project-ci:20260920.2 genarrative/gitea-project-ci:rust-cache-candidate
+bash scripts/gitea-ci-job-image.sh verify genarrative/gitea-project-ci:rust-cache-candidate
+bash scripts/gitea-ci-job-image.sh export /仓库外受控路径/ci-rust-cache.tar.zst genarrative/gitea-project-ci:rust-cache-candidate
+bash scripts/gitea-ci-job-image.sh load-runner genarrative/gitea-project-ci:rust-cache-candidate
+```
+
+预热容器上限为 4 核、12 GiB，移除 capabilities，不挂宿主目录/socket，也不注入 Git/OSS/Jenkins 凭据。源码通过 `git archive` 复制，当前工作区、ignored 文件和 `.git` 不进入容器。最终从原镜像重新组装，仅复制 `/opt/genarrative-ci/rust-cache` 的 sccache、对象和来源元数据，不提交含源码/target 的预热容器；镜像本身的下载缓存与工具链校验保持原样。
+
+快照由固定 Image ID 分发，每个 job 仅修改容器自己的写时复制层，缓存上限 4 GiB，构建末尾输出实际对象体积，结束后不回传。`ci-rust-cache.sh prepare` 清空继承的 `SCCACHE_*` 远程配置，使用独立配置和 Unix socket；旧镜像、工具链不匹配或限时 wrapper 探测失败时使用直接 rustc，正式编译启用 sccache 的 server IO 错误回退。真实编译/测试失败保留非零退出码。`report` 输出命中统计并停止本 job daemon，分片日志输出独立编译耗时。sccache 0.18.0 的只读模式在 miss 后仍打包再拒绝写入，不能用它宣称零 miss 开销；普通 CI 继续只向容器层写入。
+
+生成候选不会改变 runner 配置。线上有活跃 CI 时禁止停止 job、重启 runner 或切换标签；只在确认空闲后按上节流程切换固定 Image ID。全组启用须重建完整快照；旧 AGC 单目标快照不能作为其它组预热成功的证据。按组用相同源码、独立干净 target 比较编译命中与耗时；分片测试内容和前置检查不同，不能直接用两条 lane 总耗时推断缓存收益。回滚时可移除各 job 的 prepare/report，或恢复无对象缓存的原基础镜像 ID，均不需要改变 incremental 或测试分片。
+
+预热路径固定为实际 Gitea checkout 的 `/workspace/GenarrativeAI/Genarrative`：后端、独立 crate、插件、桌面壳和提示词契约从仓库根目录启动 Cargo；AGC 分片从 `src-tauri` 启动；agent-run smoke 从 AGC App 根目录启动。切换 AGC cwd 前仅清理预热容器内的 AGC target，避免 Cargo 的 fresh 判断跳过新 cwd 的对象。后端 workspace 与 spacetime-module 保持分开编译，测试仅 `--no-run`，smoke 仅 `cargo build`。`workspace.txt` 不匹配时直接编译。Rust cache key 对 cwd 敏感，不能假定 `SCCACHE_BASEDIRS` 足以跨路径复用。固定 sccache `0.18.0` 返回基础设施错误码 `2` 时 wrapper 只回退这一次 rustc 调用，其它状态原样返回，不重跑测试。
+
 ## 启动与验证
 
 ```bash

docs/project-memory/shared-memory/decision-log.md

@@ -9337,6 +9337,15 @@ CI 上 `background_agent_runtime_recovers_stale_running_before_pending_task` 在
 - 验证：定向 `projectResourceLiveIntegration`（32 条，三条断言面板留在失败态的用例按新口径改写为「重开面板再重试，身份不变」）、`resourceCanvasQuickEditDraft`（10 条）、`resourceCanvasFloatingDismiss`（18 条）全绿；`npm --prefix apps/ai-game-creator-shell run typecheck` 通过。
 - 合并前复核（2026-09-21）：合并 master 后按**仓库根**跑全量 `npx vitest run`，**373 个测试文件全过、4512 通过 / 34 跳过 / 0 失败**；PR #419 显示 `No Conflicts`。真实客户端观感与远程 CI 未复验（后者按用户要求不追，runner/镜像问题见 Issue #431）。
 
+## 2026-09-21 统一错误事件额外投影到 AppData 应用日志
+
+- 背景：`direct-codex-failure:v2 ... 详情：.agent/runtime/errors/error-<id>-9.json`（例如 `stage=code-generation code=turn-idle-timeout`）里的诊断正文只落在项目目录，而“报告问题”只上传 AppData `diagnostics/application.log`；用户提交上来的失败消息因此只有一个指向项目文件的引用，团队复现不到 stderr 摘要、退出状态这些真因。
+- 决策：统一错误写入边界 `agent/runtime_error.rs` 在落 `.agent/runtime/errors/<eventId>.json` 之前先把同一份已脱敏诊断投影成应用日志两行——`agent.runtime.error`（身份行：eventId / source / stage / code / retryable / clientTurnId / elapsedMs / detailRef）与 `agent.runtime.error.detail`（详情行：hint / summary / detail / metadata）。字段仍只从 sidecar 那份 diagnosis 来，不新增第二份来源；落盘前 summary 按 320 字符、detail / metadata 按（1200 / 200 字符）预算脱敏截断（`direct_tool_bridge` 会把它当自由文本传工具错误原文，而 `app_log!` 同时写 stderr，那里没有 `sanitize_diagnostic_message` 兜底），自由文本先压平换行。
+- 决策（两行而不是一行）：整行一旦命中 `sanitize_diagnostic_message` 的凭据标记（token / bearer / authorization / credential / api key）会被整体替换成 `<sensitive diagnostic details redacted>`；拆开后详情行即使被吃掉，身份行仍能定位 eventId 与 detailRef。后续复核发现：裸词标记（例如 `credential rotation failed`）脱敏消不掉，summary 留在身份行时仍会连 eventId 一起被替换，因此 summary / hint 等自由文本一律只放详情行，身份行只留程序生成与调用方常量字段。
+- 边界：进程内错误报告事件池（`error_report`）与项目内 `.agent/runtime/errors/<eventId>.json` sidecar 是两套东西——本次只把 sidecar 的同一份诊断作为**应用日志行**落盘，不进事件池、不改报告上传协议、不改 `read_agent_runtime_error_detail` 详情入口。
+- 影响面：只改 `apps/ai-game-creator-shell/src-tauri/src/agent/runtime_error.rs` 这一处写入边界（覆盖 direct-codex / agc-tools / agent-runtime 三类来源）；sidecar schema、对话投影、前端详情入口与错误报告协议均未改动。
+- 验证：`cargo test --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml runtime_error`（7 passed，含新增 `error_event_app_log_lines_keep_identity_and_redact_detail`）与 `-- direct_runtime direct_tool_bridge`（131 passed）全绿；`cargo fmt --check`、`npm run check:encoding`、`git diff --check` 通过。
+
 ## 2026-09-21 画布生成面板：重开草稿、重试身份与提交载荷全部收敛到一份 canonical content
 
 - 背景：DirectProject composer 收口到 `content[]` 之后，栏目画布的图片类生成浮层仍留着第二套形状——面板里 `prompt` + `references` 两份 state，重开草稿 `ResourceCanvasAssetGenerationPanelDraft` 与重试身份 `boundRequestRef` 也是 `prompt + 参考身份`，`directCodexContentToLegacyContentDto` 因此在面板渲染、关闭草稿、重试判据、宿主入队四个边界各算一遍；同时草稿用「正文 + 引用列表」两条线重建编辑器输入，`@显示名` 与引用 chip 会重复成 `@素材-a@素材-a`。

docs/project-memory/shared-memory/development-workflow.md

@@ -4,7 +4,7 @@
 
 ## 标准流程
 
-前端测试稳定性验证使用根目录 `npm test`（与 Frontend tests job 相同），保留 Vitest 的 8 worker 上限。涉及异步资源展示时，组件测试必须 mock 所有会触发的网络请求，每次调用创建独立 `Response`，并等待最终 DOM 状态而非仅等待 fetch 被调用。换签 Hook 的测试通过 `vitest.config.ts` 的 include 纳入全量运行；新增测试文件后需确认实际执行名单，命令参数指定文件不会绕过 include 白名单。排查顺序依赖可使用 `npm test -- --sequence.shuffle --sequence.seed=9467`，但不能以重试成功替代失败原因分析。
+前端测试稳定性验证使用根目录 `npm test` 执行全量集合，保留 Vitest 的 8 worker 上限。CI 的 `Frontend tests` 使用 `npm run test:ci:frontend`，继承根配置并排除 `apps/ai-game-creator-shell/tests/**`；该目录由 `AI game creator shell web tests` 执行，两个 job 的 Vitest 文件集合互斥且并集等于本地全量。原生壳定向检查与 Repository checks 的 AppSurface 检查仍保留。涉及异步资源展示时，组件测试必须 mock 所有会触发的网络请求，每次调用创建独立 `Response`，并等待最终 DOM 状态而非仅等待 fetch 被调用。换签 Hook 的测试通过 `vitest.config.ts` 的 include 纳入全量运行；新增测试文件后需确认实际执行名单，命令参数指定文件不会绕过 include 白名单。排查顺序依赖可使用 `npm test -- --sequence.shuffle --sequence.seed=9467`，但不能以重试成功替代失败原因分析。
 
 用例隔离必须包括浏览器状态与 mock 实现：修改 `window.history` 后恢复基线路由；`spyOn(window, 'getSelection')` 等 spy 在用例结束后 restore；`clearAllMocks` 仅清调用记录，不能恢复被上一个用例替换的返回值。顺序打乱暴露的失败应修复泄漏来源，保留原有业务断言。
 
@@ -61,6 +61,8 @@ AGC 预览快捷操作的界面测试按独立命令或有状态短流程注册
 
 Rust 分片失败日志保留有界的失败详情，包括 panic 位置、断言和最终通过/失败数量；分片选中数量标为 selected，避免误读为失败数量。修改分片日志时运行 `node --test apps/ai-game-creator-shell/scripts/run-rust-shell-test-shards.test.mjs`，用最小 Rust fixture 验证失败详情和成功摘要。
 
+Linux process-session 的 owner SIGKILL 测试在启动 owner 后立即建立清理 guard，正常结束和 panic 展开都必须终止并回收 owner，再按独立临时项目目录清理残留进程。先完成「杀掉 owner 后子进程自行退出」的原有断言，guard 只在退出测试作用域时兜底，不得提前清理子树使生命周期回归假绿；清理本身不得 panic 或无限等待。
+
 AGC 运行时配置默认值调整时，同步核对 Rust 默认值、分发配置模板、设置弹窗默认草稿和 `runtime-settings.suite.ts` 的恢复默认断言；显式传入旧值的配置读取用例仍验证原值保留，不批量替换测试数据。
 
 AGC 测试构造单 HTML 项目时，必须在初始化之前写入 HTML，避免自动建立 npm 工程；npm 预览和导出测试应提供 dist 产物。已有图片生成 pending/operation 属于持久化恢复合同，修改工具默认参数后仍须验证旧动作恢复不重复提交、不因默认值变化被误判为新意图。
@@ -94,4 +96,6 @@ SpacetimeDB 任务统一先读取 `.codex/skills/genarrative-spacetimedb/SKILL.m
 
 ## Gitea CI 依赖闭合
 
+AGC Rust 两条 lane、crates、smoke、Backend 和桌面壳测试使用镜像内可信 sccache 对象快照；Native shell release step 显式清空双 wrapper，前端/repository checks 不启用。维护者通过 `scripts/build-gitea-rust-cache.sh` 从远端 master 在限额、无宿主挂载的临时容器中按实际 cwd/profile/目标预热全部测试组，仅编译、不执行测试/应用；后端 workspace 与 spacetime-module 保持独立，AGC 的三个 cwd 入口之间清理预热 target，防止 fresh 判断漏产缓存键。最终镜像只追加 sccache、对象和来源元数据，不包含源码或 target。容量上限 4 GiB，不替代宿主旧镜像/归档清理。PR 只写当前容器层、不回传，不开放 Docker API/发布权限；继续禁用 incremental。`ci-rust-cache.sh` 在快照缺失、工具链不符或 wrapper 探测失败时直接编译，并隔离远程缓存配置和 daemon。分片日志记录编译耗时，收尾输出命中统计；两个 lane 的测试和前置检查不同，耗时差不是严格 A/B。线上存在活跃 CI 时不得重启 runner 或切换标签；全组启用前须刷新完整快照并逐组验证，详见开发运维文档。
+
 `.gitea/workflows/project-ci.yml` 的客户端门禁拆成 lane 与功能 job，每个 job 只预热自己会构建的那几份依赖：`AI game creator shell Rust lane 1/2`、`lane 2/2` 各自预取一次 AGC 壳 manifest，并顺序运行两片 Rust bin 单测；`AI game creator shell Rust smoke` 同样只预取 AGC 壳 manifest（`agent-run` smoke 会用 `src-tauri/Cargo.toml` spawn `cargo run`），`AI game creator shell Rust crates` 预取 `server-rs/Cargo.toml` 与独立 crate，`Native shell tests` 预取桌面壳与 AGC 壳 manifest，`AI game creator shell web tests` 不触碰 Cargo，不预热。两条 Rust lane、smoke job 与 crates job 只用 cargo 与 node 内建模块，因此不执行 `npm ci`。两个被 `server-rs/Cargo.toml` 排除、且没有提交 `Cargo.lock` 的独立 crate（`agent-runtime-core`、`agent-runtime-orchestration`）只能在 `AI game creator shell Rust crates` 里用不带锁标志的 fetch。AGC 壳的 bin target 单测（约 2466 条）由 `apps/ai-game-creator-shell/scripts/run-rust-shell-test-shards.mjs` 编译后按 `--list` 名单分 4 片：每次分片调用用 `--shard-index=<i>` 只跑自己那片，片内保持 `--test-threads=1` 并使用独立 `TMPDIR`；两条 lane 之间并发，lane 内顺序运行两片，避免重复依赖预热和同一容器内多进程争抢。不要改回「一个 job 内多进程并行这几片」——同一容器里它们会争抢共享 `HOME`、target 目录与固定临时路径，实测比整套串行还慢。每个分片调用都会自校验「片并集等于全集且互斥」，因此改分片规则不会静默漏跑。Backend host workspace tests 使用 `cargo test --locked --workspace --exclude spacetime-module --no-fail-fast`，避免 `spacetime-module` 的 `spacetime-types` feature 统一污染普通领域 crate 的 host 测试；随后单独执行 `cargo test --locked -p spacetime-module --no-fail-fast`，由 `spacetime-module/src/active.rs` 在 host 测试构建期间提供仅测试期的 SpacetimeDB ABI 链接支持，使该 crate 的纯单元测试也纳入 Backend 门禁。`spacetime-module` 的 reducer / procedure 运行时行为仍必须通过真实 SpacetimeDB runtime/integration harness 验证，host 链接支持不得被当作运行时替身。Backend 另外执行 `cargo check --locked -p spacetime-module` 验证模块源码。AGC 壳检查还会运行 `platform-llm` 与 `shared-contracts` 的 server-rs workspace 测试，这些命令以及 AGC 壳测试必须带 `--locked`，避免在测试阶段重新解析 registry index；锁文件发生变化时应先更新受信任 CI 镜像缓存，再重跑门禁。

docs/project-memory/shared-memory/pitfalls.md

@@ -5993,3 +5993,17 @@ Cocos Creator 根目录由 `package.json.creator.version` 与普通 `assets/`
 - **成因**：冲突解决只处理了同一个 `[dependencies]` 段落里的 `ts-rs`（本分支改成 git 固定 commit、master 仍是 registry `12.0.1`），把 master 在同段落新增的 `codex-patch-parser = { path = "vendor/codex-patch-parser" }` 与 `chrono = { version = "0.4", … }` 一并丢掉；vendor crate 仍是 workspace member，所以看起来"依赖还在"，但 `[dependencies]` 里已经没有它。
 - **处理（现行口径）**：合并两个 Rust workspace 的 `Cargo.toml` 后不能只看 `cargo metadata --locked`——它只验证 lock 与 manifest 自洽，不看代码用了什么。必须各做一次真实编译：`cargo check --locked --workspace --manifest-path server-rs/Cargo.toml` 与 `cargo test --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml --no-run`。CI 报 crate 找不到时，先 `git diff <merge>^2 <merge> -- <Cargo.toml>` 核对对方新增的依赖行，不要先怀疑 crate 名字或 vendor 路径。
 - **易错点**：`--locked` 通过不等于依赖齐全；任何 cargo 命令都会按当前 manifest 重新对齐 lock，缺失的依赖条目会被顺手从 lock 里剪掉，于是"缺依赖"看起来像"本来就不该有"。
+
+## 2026-09-21 应用日志整行凭据脱敏会吃掉整条结构化诊断
+
+`append_application_log_line` 在落盘前对整行做 `sanitize_diagnostic_message`：行内只要出现 `token=`、`bearer `、`authorization`、`credential`、`api key` / `apikey` / `api_key` 这类标记，**整行**就被换成 `<sensitive diagnostic details redacted>`，只留下时间戳与 `RUST module:` 前缀；同时每行还会被截到 2048 字符。于是把“身份字段 + 诊断正文”拼成一行 `app_log!` 时，正文里一个凭据词就可能让整条记录连 `eventId`、`code` 一起消失（2026-09-21 加统一错误事件的日志投影时按两行落：身份行只放程序生成与调用方常量字段，summary / hint / detail 等自由文本一律只放详情行，且自由文本先自行压平换行——裸词标记脱敏消不掉，自由文本放错行会把 eventId、code 一起带走）。
+
+## 2026-09-22 Rust 对象快照必须对齐 CI 编译目录和 Cargo 环境
+
+- 现象：sccache 快照已包含数百 MiB 对象，但全新 target 的“热缓存”仍然全部 miss，甚至比直接 rustc 更慢。
+- 原因：Rust cache key 包含编译 cwd；sccache `0.18.0` 还会 hash `CARGO_*` 环境（jobserver、jobs 等少数例外除外）。不同 checkout 根目录、随机的 `CARGO_BUILD_RUSTC_WRAPPER` 路径、预热遗漏 workflow 的 HTTP/retry/color 环境都可能让整套缓存 miss。小型真实 Rust 实验显示仅配置 `SCCACHE_BASEDIRS` 不能消除 cwd 差异。快照存在不等于缓存有效。
+- 处理：预热使用已核实的 Gitea 路径 `/workspace/GenarrativeAI/Genarrative`，并与分片运行器一样从 AGC `src-tauri` 启动 Cargo；保存 `workspace.txt`，路径不符时回退直接编译。wrapper 放在容器内固定路径，daemon 状态与 Unix socket 仍使用随机私有目录；预热环境与 workflow 的 Cargo 环境由定向契约测试核对。不要为命中率随意增加 `RUSTFLAGS`、改写源码路径或恢复共享可写 target。
+- 验证：相同源码、资源上限和独立干净 target 下分别记录无缓存、冷缓存、热缓存的编译耗时和 hit/miss；只有真实热命中有净收益才切换候选镜像。PR 的写入始终留在 job 容器层，公共快照仍由可信维护流程生成。
+- 统计：job 私有 daemon 设置 `SCCACHE_IDLE_TIMEOUT=0`，由 `report` 显式停止；最终测试 bin 的不可缓存编译或测试可能超过一分钟，短 idle timeout 会让 daemon 提前退出，结尾查询启动新 daemon 后误报零次请求。容器销毁仍会回收该 job 的全部进程。
+- 磁盘：快照构建拒绝含 `/opt/genarrative-ci/rust-cache` 的基础镜像，始终从无对象缓存的镜像重建；容器内删除旧对象不能释放 Docker 底层。对象缓存容量上限不涵盖宿主旧镜像及导出归档，切换验证后按运维文档人工保留当前版和一个回滚版，同时保护运行中 CI 使用的镜像。
+- 扩展：预热所有 Rust 测试组时保留各自 cwd、profile、features 和锁策略；同一临时 target 的 Cargo fresh 不代表不同 cwd 都已生成缓存键，AGC 提示词契约、分片和 smoke 切换入口前清理预热 target。不要把 workspace 与 spacetime-module 合并成一次编译；Native shell release step 清空双 wrapper，避免将测试缓存扩展成发布缓存。当前 sccache 0.18.0 的 READ_ONLY 在 miss 后仍打包产物并产生 cache write error，不适合用来承诺“未命中无开销”。

docs/technical/【技术方案】AGC错误报告与诊断上传-2026-08-31.md

@@ -13,6 +13,7 @@ AI Game Creator Shell 采用 IDEA 风格的当前进程错误报告：错误事
 - 指纹计算可使用调用方的 page/action 及脱敏后的首个调用点作为进程内区分输入，但这些上下文不会作为事件字段上传；消息与 stack 在入池前统一脱敏，WebCrypto 失败时降级为稳定可读指纹，采集本身不得产生新的未处理拒绝。
 - 客户端 API 自动采集只覆盖网络错误、408 和 5xx；预期的 4xx 登录/鉴权失败不进入错误报告池。
 - Rust 侧通过 `app_log!` 将普通文本日志同时输出到 stderr 和 AppData `diagnostics/application.log`，超出 256 KiB 滚动到 `application.previous.log`；WebView 的 console 输出通过 `append_application_log` 镜像到同一 raw log，并在客户端桥接处再次脱敏；`read_diagnostic_logs` 只读取应用级日志。
+- 这里有两套互不相干的东西，不要互相代入：**错误报告事件池**是进程内 `error_report` 的结构化事件（本次变更不动它，仍然只在内存里、提交时才生成 `events.jsonl`）；**统一 Agent Runtime 错误事件**是项目内 sidecar `.agent/runtime/errors/<eventId>.json`，既不进事件池也不进报告包。因为报告包里的日志附件只有 AppData 应用日志，所以 sidecar 的同一份已脱敏诊断再作为**日志行**（不是报告事件）投影成两行：`agent.runtime.error`（身份行：eventId / source / stage / code / retryable / clientTurnId / elapsedMs / detailRef，全部是程序生成或调用方常量）与 `agent.runtime.error.detail`（详情行：hint / summary / detail / metadata，自由文本只出现在这里）。两行都由 `agent/runtime_error.rs` 从同一份 diagnosis 生成，不新增字段来源；落到日志前 summary 按 320 字符、detail / metadata 按（1200 / 200 字符）预算脱敏截断（summary 由调用方给，`direct_tool_bridge` 会传工具错误原文，而 `app_log!` 同时把整行写 stderr，那里没有 `sanitize_diagnostic_message` 兜底）。`sanitize_diagnostic_message` 命中凭据标记时替换的是**整行**，自由文本因此只放详情行：详情行被吃掉也不影响身份行定位事件。
 - 报告面板只由自动诊断通知中的“查看并报告”打开，不提供聊天命令、崩溃页按钮或其他手动入口；默认选中当前快照中的全部事件，用户可取消不想提交的事件。允许填写最多 2,000 字中文描述并取消日志附件；本版本不支持截图或任意文件附件。
 - 报告面板读取当前错误快照失败时，必须明确显示“错误事件暂不可用，请关闭后重试”，不能把失败误显示为“当前没有待报告的错误”。
 - 通知中的“查看并报告”打开面板时必须保留该次通知快照；最新快照读取瞬时失败时使用这份 fallback 继续展示和提交，不能因先清空通知而丢失用户刚看到的事件。

docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md

@@ -1839,3 +1839,9 @@ Direct 回合的所有权属于进程内项目身份锁，不属于当前页面
 - 用户级配额：跨节点的用户总量配额与计费口径未定；当前用单项目 2 GiB 上限 + 清单引用回收保证常驻占用有界，用户级总量只能靠项目数间接约束。
 - 目标 bucket 的生命周期规则（例如转低频/过期删除）需要在部署环境确认后单独收口；功能本身已不再依赖它来控制增长。
 - 大项目（素材数量多、单文件大）的首轮全量上传耗时与带宽占用未实测；单次预算 512 MiB 会把超出部分留到下一次同步，但并发上限与断点续传仍未引入。
+
+## 2026-09-21 统一错误事件同时落到 AppData 应用日志
+
+`AgentRuntimeErrorEvent` 把失败投影到用户消息、运行面板和项目内 `.agent/runtime/errors/<eventId>.json` 时，同一份已脱敏诊断还要投影成 AppData `diagnostics/application.log` 的两行：`agent.runtime.error`（身份行：`eventId / source / stage / code / retryable / clientTurnId / elapsedMs / detailRef`）与 `agent.runtime.error.detail`（详情行：`hint / summary / detail / metadata`）。原因是项目内 sidecar 只在项目目录可见，而“报告问题”只上传应用级日志：没有这两行时，用户提交的失败消息里只剩一个 `详情：.agent/runtime/errors/...json` 路径，团队拿不到诊断正文。
+
+口径：两行都由 `agent/runtime_error.rs` 从同一份 diagnosis 生成，字段不退化成第二份来源；`summary` 按 320 字符、`detail` 与 `metadata` 按（1200 / 200 字符）预算先脱敏再截断，落盘前还会被 `sanitize_diagnostic_message` 二次脱敏并按行截断，因此自由文本字段在行内先压平换行。拆两行是因为整行一旦出现凭据标记会被整体替换成脱敏占位：所以**自由文本（summary / hint / detail）只放详情行**，身份行只留程序生成与调用方常量字段，详情行被整体脱敏时事件仍能按 eventId / detailRef 定位。写日志先于写 sidecar：sidecar 失败不能连日志一起丢。

docs/【开发运维】本地开发验证与生产运维-2026-05-15.md

@@ -288,12 +288,14 @@ npm run check
 
 ### Gitea Actions PR 门禁
 
+Linux process-session 的 owner SIGKILL 用例必须在启动 owner 后立即建立测试清理 guard：正常退出或断言 panic 时终止、回收 owner，并在有界时间内清理其独立临时项目目录中的残留进程。原有「owner 退出后子进程自行消失」断言在兜底清理之前执行，不能由 guard 代替生产生命周期验证。清理覆盖 panic 路径及临时项目间隔离，且不得因清理失败再次 panic。
+
 仓库级 Gitea Actions 工作流固定为 `.gitea/workflows/project-ci.yml`，在向 `master` 推送、创建或更新 PR，以及手工触发时运行。工作流拆成九个必须通过的 job。job 声明顺序就是 runner 领取顺序，因此把两条 AGC 壳 Rust lane 排在最前：并发槽位不足时它们必须最先开始，AGC 侧的关键路径才由自己而不是由排队决定。
 
 所有 CI job 和 Jenkins Web Build 在根 workspace 安装前都必须确认 `npm --version` 为 `10.9.7`。Gitea job 使用预构建镜像内的固定版本；Jenkins Web Build 在每个独立 `bash -lc` 中 source `scripts/jenkins-prepare-npm-env.sh`，首次为 Jenkins 运行用户的版本隔离目录引导同版 npm，后续复用并把该 `bin` 放到 `PATH` 首位。旧固定镜像缺少版本元数据时只能报告 `npm_version=partial` 并由当前 job 的根 `npm ci` 继续校验 lock，不能把过渡状态当作工具链已闭合。
 
 - `Repository checks`：调用唯一入口 `npm run check:repository-ci`，执行 `npm run lint`、AI 游戏创作壳 AppSurface 定向测试、主站与后台生产构建和提交差异空白检查。本地 master `pre-push` 复用同一入口，禁止在 workflow 与 hook 中维护两份近似命令。
-- `Frontend tests`：按唯一根 workspace lockfile 执行一次干净的 `npm ci`，再独立执行根 `npm run test`、`npm run bgfilter-worker:smoke-test`、`npm run check:production-health-patrol`、`npm run check:production-api-release` 和 `npm run check:production-api-deploy`，让 Vitest、Node test smoke harness 及不依赖真实服务的生产巡检 / 发布 / 部署行为 fixture 在 Gitea job 中持续执行；其中 `.test.mjs` 使用 Node test runner，不依赖 Vitest 的 `scripts/**/*.test.ts` 收集规则。
+- `Frontend tests`：按唯一根 workspace lockfile 执行一次干净的 `npm ci`，再独立执行根 `npm run test:ci:frontend`、`npm run bgfilter-worker:smoke-test`、`npm run check:production-health-patrol`、`npm run check:production-api-release` 和 `npm run check:production-api-deploy`，让 Vitest、Node test smoke harness 及不依赖真实服务的生产巡检 / 发布 / 部署行为 fixture 在 Gitea job 中持续执行。`test:ci:frontend` 使用 `vitest.frontend-ci.config.ts` 继承根配置，仅排除 `apps/ai-game-creator-shell/tests/**`，由 `AI game creator shell web tests` 执行该目录，避免两个 job 重复运行 AGC 前端测试；本地 `npm test` 仍执行原有全量集合。CI 契约测试使用 Vitest 实际文件发现验证两组互斥、并集等于全量；原生壳定向检查与 Repository checks 的 AppSurface 检查仍保留。其中 `.test.mjs` 使用 Node test runner，不依赖 Vitest 的 `scripts/**/*.test.ts` 收集规则。
 - `Backend tests`：先对 `server-rs/Cargo.lock` 执行带 5 次整命令级有界重试的 `cargo fetch --locked`，再执行 `npm run check:server-rs-ddd`、`cargo test --locked --workspace --exclude spacetime-module --no-fail-fast`、`cargo test --locked -p spacetime-module --no-fail-fast`、`api-server --all-targets` 编译和 `cargo check --locked -p spacetime-module`；普通 workspace host 测试排除 `spacetime-module` 以避免其 `spacetime-types` feature 统一污染领域 crate，模块自身的纯单元测试通过独立 package test 纳入门禁。`spacetime-module` 的 reducer / procedure 运行时行为仍必须通过真实 SpacetimeDB runtime/integration harness 验证，不能把 host 链接支持当作运行时替身。依赖准备必须位于会触发 Cargo build 的 DDD / 产物边界门禁之前，避免锁新增依赖未命中镜像缓存时绕过既有下载重试。runner 安装 `ffmpeg`，避免视频抽帧测试因工具缺失提前返回。依赖真实服务或密钥的测试必须显式 `ignored`，不能让普通 PR job访问现场环境。
 - `Native shell tests`：按唯一根 workspace lockfile 安装全部 App 依赖后，用 `npm run check:native-shells:contract`、`npm run check:native-shells:shells` 和 `npm run check:native-shells:release` 分别执行静态契约、H5 / 微信 / Expo / Tauri 桌面壳运行时门禁，以及依赖发布产物的构建 smoke，最后确认桌面壳与 AI 游戏创作壳的 `Cargo.lock` 都没有被构建过程改写。
 - `AI game creator shell web tests`：执行 `npm run check:native-shells:agc-web`（即 `npm run ai-game-creator-shell:check:web`：AGC 壳 typecheck 与壳内测试）。该分组不触碰 Cargo，因此不预热 Rust 依赖。
@@ -330,6 +332,22 @@ workflow 首次成功运行后，**不**把 Project CI 的 job 配成 Gitea `mas
 
 master 日常交付必须禁止直接 push，只允许经 PR 在最近一次 Project CI 全绿后合并；本地 `pre-commit` 的 staged ESLint/Prettier 和 master `pre-push` 的 Repository checks parity 只用于提前发现问题，可被 `--no-verify` 绕过，不能充当服务端权威门禁。紧急直推白名单如需保留，应按人员和时限最小化，并要求执行同一 `npm run check:repository-ci <base> <head>` 后回读 push CI。
 
+#### Rust 测试组的隔离编译缓存
+
+每次生成快照必须使用不含对象缓存的原始 CI 基础镜像；构建脚本在拉取源码和预热前拒绝已存在 `/opt/genarrative-ci/rust-cache` 的基础镜像，避免重复叠加不可释放的旧对象层。切换并完成真实 CI 验证后，按 `deploy/container/README.md` 的保留规则人工定向清理旧缓存镜像及归档，保护运行中 CI 使用的版本。
+
+AGC Rust 两条 lane、crates、agent-run smoke、Backend 和 Native shell 的桌面壳测试均启用 sccache。Native shell 的 release build smoke 显式清空两个 wrapper，保持发布构建原有 profile/features 与资源 staging；前端和 repository checks 不启用对象缓存。继续设置 `CARGO_INCREMENTAL=0`，不共享 target、不恢复 Actions 可写缓存。可信快照通过已有固定 Image ID 分发：镜像只增加固定版本的 sccache、编译对象和来源元数据，不包含源码、target 或凭据；容器写时复制层承接本 job 的新增对象，job 删除后丢弃，PR 没有 Docker API 或快照发布权限。该权限边界由 runner 基础设施保证，不能仅用 workflow 的分支条件替代。
+
+维护者在受信任 checkout 中运行 `bash scripts/build-gitea-rust-cache.sh <已验证基础镜像> <候选镜像tag>`。脚本从 origin 获取 master 的确定提交，在无宿主目录挂载、无凭据且有 CPU/内存上限的临时容器中预热各组实际 Cargo 目标，只编译、不执行测试或应用。后端 workspace 仍排除 spacetime-module，再单独预热该模块，禁止为缓存合并 features。AGC 独立 crate 与插件沿用各自 manifest/锁文件策略；未提交锁文件的 crate 仍可能因新版本解析产生 miss。最终镜像从原基础镜像重新组装，只导出 sccache 对象，不提交预热容器。公共快照不接受 PR 上传，也不复用 Jenkins 发布缓存。工具链或系统依赖变化时重新生成快照，缓存命中仍由 sccache 的编译输入校验决定，不能省略 Cargo 构建。
+
+各 Rust job 在编译前执行 `scripts/ci-rust-cache.sh prepare`：检查快照与 rustc 身份，隔离 sccache 配置和 daemon，限时探测真实 wrapper。旧镜像没有快照或探测失败时保留空 wrapper，输出 fallback 原因；缓存故障不得把真实编译/测试失败改成成功，也不允许重跑整个测试组掩盖失败。结束时 `report` 输出命中统计；分片日志单独记录 Cargo 编译耗时。对象缓存上限为 4 GiB，快照构建完成后输出实际体积；最终测试 bin 的链接仍须执行。全组开启时必须生成覆盖全部目标的新快照，不能把旧 AGC 单目标快照当作后端/桌面壳的预热验收。
+
+候选镜像沿用 `gitea-ci-job-image.sh verify/export/load-runner` 验证和装载。现役 CI 正在运行时只允许准备候选镜像，不停止 job、不重启 runner、不切换标签；待确认无运行中的 job 后再按上述镜像更新顺序切换。验收分别记录独立 target 的无缓存、冷缓存和热缓存构建耗时及命中率，并检查失效/故障回退、两容器写入互不影响。未完成真实 CI 验证前不能宣称提速或推广到其它 job。
+
+Rust 对象 key 包含编译工作目录。预热必须使用已核实的 Gitea checkout 路径 `/workspace/GenarrativeAI/Genarrative`：后端、独立 crate、插件、桌面壳及提示词契约从仓库根目录启动 Cargo，AGC 分片从 `apps/ai-game-creator-shell/src-tauri` 启动，agent-run smoke 从 `apps/ai-game-creator-shell` 启动。切换 AGC 编译入口前清理该临时容器的 AGC target，防止 Cargo 的 fresh 判断跳过新 cwd 所需对象；CI 各 job 的 target 本来就独立。快照保存 `workspace.txt`，job 根路径不符时直接编译。不要仅设置 `SCCACHE_BASEDIRS` 就假定 Rust 可以跨 cwd 命中，也不为缓存改写 `RUSTFLAGS` 或源码路径语义。固定 sccache `0.18.0` 的基础设施错误码 `2` 会由 wrapper 回退执行本次 rustc；其它退出码原样返回，升级 sccache/Rust 时须复核此约定。
+
+sccache `0.18.0` 还会 hash 大部分 `CARGO_*` 环境变量。因此 wrapper 固定在每个容器自己的 `/opt/genarrative-ci/rust-cache/rustc-wrapper`，prepare 重写 launcher 后才启用；daemon 状态与 socket 仍各自随机隔离。预热同步 workflow 的 `CARGO_INCREMENTAL`、`CARGO_HTTP_MULTIPLEXING`、`CARGO_NET_RETRY` 和 `CARGO_TERM_COLOR`，由现有 CI 契约测试验证一致；新增 Cargo 环境配置时须同步评估 cache key，不能只看快照文件是否存在。
+
 SpacetimeDB bindings：
 
 ```bash

package.json

@@ -128,6 +128,7 @@
     "format:staged": "lint-staged",
     "check:pre-push-master": "bash scripts/pre-push-master.sh",
     "test": "vitest run",
+    "test:ci:frontend": "vitest run --config vitest.frontend-ci.config.ts",
     "test:watch": "vitest",
     "container:init": "node scripts/container-compose.mjs init",
     "container:build": "node scripts/container-compose.mjs build",

scripts/build-gitea-rust-cache.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# 由能管理 CI 镜像的维护者运行；不得在 PR job 内提供 Docker API/发布权限。
+set -euo pipefail
+
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+base_ref="${1:?usage: build-gitea-rust-cache.sh <verified-base-image> <candidate-tag>}"
+candidate_tag="${2:?candidate image tag is required}"
+# 与实际 Gitea checkout 路径一致；Rust 对象 key 包含编译 cwd，不能随意换临时根。
+workspace=/workspace/GenarrativeAI/Genarrative
+[[ "${CI:-}" != true ]] || { echo 'Run on the trusted image builder, outside CI jobs.' >&2; exit 1; }
+base_id="$(docker image inspect --format '{{.Id}}' "${base_ref}")"
+[[ "${base_id}" =~ ^sha256:[a-f0-9]{64}$ ]]
+# 删除容器内旧对象不能释放镜像底层；每次必须从不含对象快照的基础镜像重建。
+docker run --rm --network none --read-only --cap-drop=ALL \
+  --security-opt=no-new-privileges --entrypoint /bin/bash "${base_id}" -c '
+    if [[ -e /opt/genarrative-ci/rust-cache ]]; then
+      echo "基础镜像已包含 Rust 对象缓存；请使用不含对象快照的原始 CI 镜像，禁止叠层。" >&2
+      exit 1
+    fi
+  '
+bash "${repo_root}/scripts/gitea-ci-job-image.sh" verify "${base_id}"
+
+# 只归档远端 master 的确定提交；不复制当前工作区或本地凭据。
+git -C "${repo_root}" fetch --no-tags origin refs/heads/master
+source_commit="$(git -C "${repo_root}" rev-parse FETCH_HEAD^{commit})"
+work_dir="$(mktemp -d "${TMPDIR:-/tmp}/gitea-rust-cache.XXXXXX")"
+container_id=''
+cleanup() {
+  if [[ -n "${container_id}" ]]; then docker rm -f "${container_id}" >/dev/null; fi
+  rm -rf -- "${work_dir}"
+}
+trap cleanup EXIT
+
+archive=sccache-v0.18.0-x86_64-unknown-linux-musl.tar.gz
+curl --fail --location --retry 3 --connect-timeout 15 --max-time 180 \
+  "https://github.com/mozilla/sccache/releases/download/v0.18.0/${archive}" \
+  --output "${work_dir}/${archive}"
+printf '45f1447fbe231e3037bde351ef70677dd212216c8d62ae7ca409fecc4d6acc89  %s\n' "${work_dir}/${archive}" | sha256sum --check
+tar -xzf "${work_dir}/${archive}" --directory "${work_dir}"
+mkdir "${work_dir}/snapshot"
+cp "${work_dir}/sccache-v0.18.0-x86_64-unknown-linux-musl/sccache" "${work_dir}/snapshot/sccache"
+printf '%s\n' "${source_commit}" > "${work_dir}/snapshot/source-commit.txt"
+printf '%s\n' "${base_id}" > "${work_dir}/snapshot/base-image.txt"
+printf '%s\n' "${workspace}" > "${work_dir}/snapshot/workspace.txt"
+
+# 临时容器不挂载宿主目录/socket，不携带 Git/OSS/Jenkins 凭据，限制资源占用。
+container_id="$(docker run --detach --cpus=4 --memory=12g --pids-limit=1024 \
+  --cap-drop=ALL --security-opt=no-new-privileges \
+  --entrypoint /bin/bash "${base_id}" -c 'sleep infinity')"
+docker exec "${container_id}" mkdir -p "${workspace}" /opt/genarrative-ci/rust-cache/objects
+git -C "${repo_root}" archive "${source_commit}" | docker cp - "${container_id}:${workspace}"
+docker cp "${work_dir}/snapshot/." "${container_id}:/opt/genarrative-ci/rust-cache/"
+docker cp "${repo_root}/scripts/ci-rust-cache.sh" "${container_id}:/tmp/ci-rust-cache.sh"
+docker exec --interactive --workdir "${workspace}" "${container_id}" bash -s <<'WARM'
+set -euo pipefail
+rustc -vV > /opt/genarrative-ci/rust-cache/rustc.txt
+export GITHUB_ENV=/tmp/rust-cache.env CARGO_INCREMENTAL=0 CARGO_BUILD_JOBS=4 CI=true
+# sccache 对 CARGO_*（除 jobserver/jobs 等特例）参与 hash，必须与 workflow 对齐。
+export CARGO_HTTP_MULTIPLEXING=false CARGO_NET_RETRY=10 CARGO_TERM_COLOR=always
+bash /tmp/ci-rust-cache.sh prepare
+set -a
+source "${GITHUB_ENV}"
+set +a
+test -n "${RUSTC_WRAPPER}"
+trap 'bash /tmp/ci-rust-cache.sh report' EXIT
+# 与 CI 的工作目录、features 和目标逐项对齐，只编译，不运行测试/应用。
+echo '[rust-cache] warming backend tests and checks'
+cargo test --locked --workspace --exclude spacetime-module --no-fail-fast \
+  --manifest-path server-rs/Cargo.toml --no-run
+cargo test --locked -p spacetime-module --no-fail-fast \
+  --manifest-path server-rs/Cargo.toml --no-run
+cargo check --locked -p api-server --all-targets --manifest-path server-rs/Cargo.toml
+cargo check --locked -p spacetime-module --manifest-path server-rs/Cargo.toml
+
+echo '[rust-cache] warming AGC standalone, shared and plugin crates'
+for manifest in \
+  server-rs/crates/agent-runtime-core/Cargo.toml \
+  server-rs/crates/agent-runtime-orchestration/Cargo.toml \
+  plugins/agc-cocos-editor/native/cocos-editor-bridge/Cargo.toml; do
+  # 与 CI 一样，这些 crate 没有已提交的独立 Cargo.lock。
+  cargo test --manifest-path "${manifest}" --no-run
+done
+cargo test --locked -p platform-llm --manifest-path server-rs/Cargo.toml --no-run
+cargo test --locked -p shared-contracts --manifest-path server-rs/Cargo.toml --no-run
+for editor in unity godot; do
+  cargo test --locked --manifest-path "plugins/agc-${editor}-editor/native/${editor}-editor-bridge/Cargo.toml" --no-run
+done
+
+echo '[rust-cache] warming desktop tests and AGC prompt contracts'
+cargo test --manifest-path apps/desktop-shell/src-tauri/Cargo.toml --no-run
+cargo test --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml \
+  --test runtime_prompt_bundle_build --test prompt_source_boundaries --no-run
+
+# Cargo 的 fresh 判断不保证不同 cwd 都经过 sccache；先清掉临时容器中的 target。
+cargo clean --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml
+echo '[rust-cache] warming AGC Rust lanes'
+(
+  cd apps/ai-game-creator-shell/src-tauri
+  cargo test --locked --manifest-path Cargo.toml \
+    --bin genarrative-ai-game-creator-shell --no-run
+)
+cargo clean --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml
+echo '[rust-cache] warming AGC agent-run smoke executable'
+(
+  cd apps/ai-game-creator-shell
+  cargo build --manifest-path src-tauri/Cargo.toml
+)
+du -sh /opt/genarrative-ci/rust-cache/objects
+WARM
+docker cp "${container_id}:/opt/genarrative-ci/rust-cache/." "${work_dir}/snapshot/"
+docker rm -f "${container_id}" >/dev/null
+container_id=''
+
+# 从原基础镜像重新组装，只 COPY 对象快照；不 commit 含源码/target 的预热容器。
+cat > "${work_dir}/Dockerfile" <<EOF
+FROM ${base_id}
+COPY snapshot/ /opt/genarrative-ci/rust-cache/
+LABEL world.genarrative.ci.rust-cache-source="${source_commit}"
+LABEL world.genarrative.ci.rust-cache-base="${base_id}"
+EOF
+printf '**\n!Dockerfile\n!snapshot/\n!snapshot/**\n' > "${work_dir}/.dockerignore"
+docker build --pull=false --tag "${candidate_tag}" "${work_dir}"
+bash "${repo_root}/scripts/gitea-ci-job-image.sh" verify "${candidate_tag}"
+printf 'snapshot_source=%s\ncandidate_image=%s\n' "${source_commit}" "$(docker image inspect --format '{{.Id}}' "${candidate_tag}")"
+echo 'Candidate only: the runner configuration and running jobs have not been changed.'

scripts/check-gitea-ci-job-image.sh

@@ -28,6 +28,19 @@ bash -n /usr/local/bin/genarrative-gitea-checkout
 test -d /root/.npm/_cacache
 test -d /usr/local/cargo/registry/cache
 
+# 对象快照是可选镜像层；构建/装载前验证，运行时故障由 prepare 回退直接 rustc。
+rust_cache_root=/opt/genarrative-ci/rust-cache
+if [[ -d "${rust_cache_root}" && "${GENARRATIVE_GITEA_CI_CHECK_RUNTIME:-0}" != 1 ]]; then
+  test "$("${rust_cache_root}/sccache" --version)" = 'sccache 0.18.0'
+  rustc -vV | cmp -s - "${rust_cache_root}/rustc.txt"
+  rg -q '^[a-f0-9]{40}$' "${rust_cache_root}/source-commit.txt"
+  rg -q '^sha256:[a-f0-9]{64}$' "${rust_cache_root}/base-image.txt"
+  test "$(cat "${rust_cache_root}/workspace.txt")" = '/workspace/GenarrativeAI/Genarrative'
+  test -n "$(find "${rust_cache_root}/objects" -type f -print -quit)"
+  test ! -e /workspace/GenarrativeAI/Genarrative
+  printf 'rust_object_snapshot=verified\n'
+fi
+
 verify_cache_lock() {
   local cache_name="$1"
   local expected_sha256="$2"

scripts/ci-rust-cache.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+# 仅消费镜像内的可信快照；所有写入留在当前容器的可写层。
+set -euo pipefail
+
+cache_root="${GENARRATIVE_CI_RUST_CACHE_ROOT:-/opt/genarrative-ci/rust-cache}"
+cache_binary="${cache_root}/sccache"
+state="${GENARRATIVE_CI_RUST_CACHE_STATE:-}"
+
+configure_local_cache() {
+  # 不继承开发机/其它流水线的 OSS、S3、GHA 或 daemon 配置。
+  local variable
+  for variable in ${!SCCACHE_@}; do unset "${variable}"; done
+  export SCCACHE_CONF="${state}/config"
+  export SCCACHE_DIR="${cache_root}/objects"
+  export SCCACHE_CACHE_SIZE=4G
+  export SCCACHE_SERVER_UDS="${state}/server.sock"
+  # 单个不可缓存的链接/测试阶段可能超过一分钟；保持统计直到 report 显式停止。
+  export SCCACHE_IDLE_TIMEOUT=0
+  export SCCACHE_IGNORE_SERVER_IO_ERROR=1
+}
+
+case "${1:-}" in
+  prepare)
+    : "${GITHUB_ENV:?GITHUB_ENV is required}"
+    printf 'RUSTC_WRAPPER=\nCARGO_BUILD_RUSTC_WRAPPER=\nGENARRATIVE_CI_RUST_CACHE_STATE=\n' >> "${GITHUB_ENV}"
+    fallback() { printf '[rust-cache] mode=direct reason=%s\n' "$1"; exit 0; }
+    [[ -x "${cache_binary}" && -d "${cache_root}/objects" && -f "${cache_root}/rustc.txt" && -f "${cache_root}/source-commit.txt" && -f "${cache_root}/workspace.txt" ]] \
+      || fallback snapshot-unavailable
+    if ! rustc -vV | cmp -s - "${cache_root}/rustc.txt"; then
+      fallback toolchain-mismatch
+    fi
+    if [[ "$(pwd -P)" != "$(cat "${cache_root}/workspace.txt")" ]]; then
+      fallback workspace-mismatch
+    fi
+    # 使用短 Unix socket 路径，避免共享固定端口或超出 sockaddr_un 长度。
+    state="$(mktemp -d /tmp/ci-rust-cache.XXXXXX)"
+    printf 'server_startup_timeout_ms = 5000\n' > "${state}/config"
+    configure_local_cache
+    # 探测必须暴露 daemon 故障；只有正式编译允许 sccache 的 IO 回退。
+    unset SCCACHE_IGNORE_SERVER_IO_ERROR
+    if ! timeout --kill-after=2 15 "${cache_binary}" "$(command -v rustc)" -vV > "${state}/probe.log" 2>&1; then
+      timeout --kill-after=2 5 "${cache_binary}" --stop-server >/dev/null 2>&1 || true
+      rm -rf -- "${state}"
+      fallback wrapper-probe-failed
+    fi
+    script_path="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)/$(basename "${BASH_SOURCE[0]}")"
+    # wrapper 路径也参与 Rust cache key；固定容器内路径，隔离由 job 容器保证。
+    wrapper_path="${cache_root}/rustc-wrapper"
+    printf '#!/usr/bin/env bash\nexec bash %q "$@"\n' "${script_path}" > "${wrapper_path}"
+    chmod 700 "${wrapper_path}"
+    {
+      printf 'GENARRATIVE_CI_RUST_CACHE_ROOT=%s\n' "${cache_root}"
+      printf 'GENARRATIVE_CI_RUST_CACHE_STATE=%s\n' "${state}"
+      printf 'RUSTC_WRAPPER=%s\nCARGO_BUILD_RUSTC_WRAPPER=%s\n' "${wrapper_path}" "${wrapper_path}"
+    } >> "${GITHUB_ENV}"
+    printf '[rust-cache] mode=sccache snapshot=%s\n' "$(cat "${cache_root}/source-commit.txt")"
+    ;;
+  report)
+    if [[ -n "${state}" && -d "${state}" ]]; then
+      configure_local_cache
+      timeout --kill-after=2 5 "${cache_binary}" --show-stats || true
+      timeout --kill-after=2 5 "${cache_binary}" --stop-server >/dev/null 2>&1 || true
+      rm -rf -- "${state}"
+    else
+      printf '[rust-cache] mode=direct\n'
+    fi
+    ;;
+  *)
+    # Cargo wrapper 协议：第一个参数是真实 rustc。失去缓存状态时仍执行原编译。
+    if [[ -z "${state}" || ! -f "${state}/config" || -f "${state}/disabled" || ! -x "${cache_binary}" ]]; then
+      exec "$@"
+    fi
+    configure_local_cache
+    status=0
+    "${cache_binary}" "$@" || status=$?
+    if [[ "${status}" == 2 ]]; then
+      # 固定 sccache 版本的自身错误码为 2；实际 rustc 失败通常为 1/101。
+      # 只重试这次编译，不重跑 Cargo 或测试，真实编译错误仍按 rustc 状态返回。
+      echo '[rust-cache] cache infrastructure failed; compiling directly' >&2
+      # 后续 crate 直接编译，避免坏 daemon 让每个 crate 都支付一次启动超时。
+      : > "${state}/disabled"
+      exec "$@"
+    fi
+    exit "${status}"
+    ;;
+esac

scripts/ci-rust-cache.test.mjs

@@ -0,0 +1,217 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { test } from 'node:test';
+
+const script = resolve('scripts/ci-rust-cache.sh');
+const linuxTest = process.platform === 'linux' ? test : test.skip;
+
+function fixture(t) {
+  const directory = mkdtempSync(join(tmpdir(), 'ci-rust-cache-test-'));
+  const root = join(directory, 'snapshot');
+  const bin = join(directory, 'bin');
+  mkdirSync(join(root, 'objects'), { recursive: true });
+  mkdirSync(bin);
+  const envFile = join(directory, 'github-env');
+  writeFileSync(envFile, '');
+  writeFileSync(join(root, 'rustc.txt'), 'fixture rustc identity\n');
+  writeFileSync(join(root, 'source-commit.txt'), 'trusted-master-commit\n');
+  writeFileSync(join(root, 'workspace.txt'), `${process.cwd()}\n`);
+  writeFileSync(
+    join(bin, 'rustc'),
+    '#!/bin/bash\necho "fixture rustc identity"\n',
+    { mode: 0o755 },
+  );
+  writeFileSync(
+    join(root, 'sccache'),
+    `#!/bin/bash
+set -eu
+case "$1" in
+  --stop-server|--show-stats) exit 0 ;;
+esac
+if [[ "$*" == *-vV ]]; then
+  [[ "\${PROBE_FAILURE:-}" != 1 ]] || exit 1
+  exec "$@"
+fi
+printf '%s\\n' "\${SCCACHE_OSS_BUCKET-unset}" "\${SCCACHE_CONF}" "\${SCCACHE_DIR}" "\${SCCACHE_SERVER_UDS}" "\${SCCACHE_IGNORE_SERVER_IO_ERROR}" "\${SCCACHE_IDLE_TIMEOUT}" >> "\${TRACE}"
+[[ "\${CACHE_FAILURE:-}" != 2 ]] || exit 2
+exec "$@"
+`,
+    { mode: 0o755 },
+  );
+  const env = {
+    ...process.env,
+    PATH: `${bin}:${process.env.PATH}`,
+    GITHUB_ENV: envFile,
+    GENARRATIVE_CI_RUST_CACHE_ROOT: root,
+    GENARRATIVE_CI_RUST_CACHE_STATE: '',
+    RUSTC_WRAPPER: 'bad-inherited-wrapper',
+    CARGO_BUILD_RUSTC_WRAPPER: 'bad-inherited-wrapper',
+    SCCACHE_OSS_BUCKET: 'must-not-use-publishing-cache',
+    TRACE: join(directory, 'trace'),
+  };
+  function run(args, extraEnv = {}) {
+    return spawnSync('bash', [script, ...args], {
+      env: { ...env, ...extraEnv },
+      encoding: 'utf8',
+    });
+  }
+  function preparedEnv() {
+    return Object.fromEntries(
+      readFileSync(envFile, 'utf8')
+        .trim()
+        .split('\n')
+        .map((line) => {
+          const separator = line.indexOf('=');
+          return [line.slice(0, separator), line.slice(separator + 1)];
+        }),
+    );
+  }
+  t.after(() => {
+    run(['report'], preparedEnv());
+    rmSync(directory, { recursive: true, force: true });
+  });
+  return { directory, root, env, run, preparedEnv };
+}
+
+linuxTest(
+  'missing snapshot and toolchain mismatch retain direct rustc',
+  (t) => {
+    const f = fixture(t);
+    const missing = f.run(['prepare'], {
+      GENARRATIVE_CI_RUST_CACHE_ROOT: join(f.directory, 'absent'),
+    });
+    assert.equal(missing.status, 0, missing.stderr);
+    assert.match(missing.stdout, /reason=snapshot-unavailable/);
+    assert.equal(f.preparedEnv().RUSTC_WRAPPER, '');
+    writeFileSync(join(f.root, 'rustc.txt'), 'different compiler\n');
+    const mismatch = f.run(['prepare']);
+    assert.equal(mismatch.status, 0, mismatch.stderr);
+    assert.match(mismatch.stdout, /reason=toolchain-mismatch/);
+    assert.equal(f.preparedEnv().CARGO_BUILD_RUSTC_WRAPPER, '');
+    writeFileSync(join(f.root, 'rustc.txt'), 'fixture rustc identity\n');
+    writeFileSync(join(f.root, 'workspace.txt'), '/different-checkout\n');
+    const moved = f.run(['prepare']);
+    assert.equal(moved.status, 0, moved.stderr);
+    assert.match(moved.stdout, /reason=workspace-mismatch/);
+    assert.equal(f.preparedEnv().RUSTC_WRAPPER, '');
+  },
+);
+
+linuxTest(
+  'preparations keep the compiler wrapper path stable with separate daemons',
+  (t) => {
+    const f = fixture(t);
+    assert.equal(f.run(['prepare']).status, 0);
+    const first = f.preparedEnv();
+    f.run(['report'], first);
+    assert.equal(f.run(['prepare']).status, 0);
+    const second = f.preparedEnv();
+    assert.equal(
+      first.CARGO_BUILD_RUSTC_WRAPPER,
+      second.CARGO_BUILD_RUSTC_WRAPPER,
+    );
+    assert.equal(first.RUSTC_WRAPPER, second.RUSTC_WRAPPER);
+    assert.notEqual(
+      first.GENARRATIVE_CI_RUST_CACHE_STATE,
+      second.GENARRATIVE_CI_RUST_CACHE_STATE,
+    );
+  },
+);
+
+linuxTest('failed wrapper probe falls back without enabling the cache', (t) => {
+  const f = fixture(t);
+  const result = f.run(['prepare'], { PROBE_FAILURE: '1' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /reason=wrapper-probe-failed/);
+  assert.equal(f.preparedEnv().RUSTC_WRAPPER, '');
+  assert.equal(f.preparedEnv().GENARRATIVE_CI_RUST_CACHE_STATE, '');
+});
+
+linuxTest(
+  'wrapper isolates remote settings and preserves compiler failures without retry',
+  (t) => {
+    const f = fixture(t);
+    const prepared = f.run(['prepare']);
+    assert.equal(prepared.status, 0, prepared.stderr);
+    const cachedEnv = f.preparedEnv();
+    const result = spawnSync(
+      cachedEnv.RUSTC_WRAPPER,
+      ['/bin/bash', '-c', 'exit 42'],
+      {
+        env: { ...f.env, ...cachedEnv },
+        encoding: 'utf8',
+      },
+    );
+    assert.equal(result.status, 42, result.stderr);
+    const trace = readFileSync(f.env.TRACE, 'utf8').trim().split('\n');
+    assert.deepEqual(trace, [
+      'unset',
+      `${cachedEnv.GENARRATIVE_CI_RUST_CACHE_STATE}/config`,
+      `${f.root}/objects`,
+      `${cachedEnv.GENARRATIVE_CI_RUST_CACHE_STATE}/server.sock`,
+      '1',
+      '0',
+    ]);
+  },
+);
+
+linuxTest(
+  'job copies use different cache directories and daemon sockets',
+  (t) => {
+    const first = fixture(t);
+    const second = fixture(t);
+    for (const f of [first, second]) {
+      const prepared = f.run(['prepare']);
+      assert.equal(prepared.status, 0, prepared.stderr);
+      const result = spawnSync(f.preparedEnv().RUSTC_WRAPPER, ['/bin/true'], {
+        env: { ...f.env, ...f.preparedEnv() },
+        encoding: 'utf8',
+      });
+      assert.equal(result.status, 0, result.stderr);
+    }
+    const a = readFileSync(first.env.TRACE, 'utf8').split('\n');
+    const b = readFileSync(second.env.TRACE, 'utf8').split('\n');
+    assert.notEqual(a[2], b[2]);
+    assert.notEqual(a[3], b[3]);
+  },
+);
+
+linuxTest(
+  'sccache infrastructure failure invokes rustc and preserves its result',
+  (t) => {
+    const f = fixture(t);
+    const prepared = f.run(['prepare']);
+    assert.equal(prepared.status, 0, prepared.stderr);
+    for (const [compiler, status] of [
+      ['/bin/false', 1],
+      ['/bin/true', 0],
+    ]) {
+      const result = spawnSync(f.preparedEnv().RUSTC_WRAPPER, [compiler], {
+        env: { ...f.env, ...f.preparedEnv(), CACHE_FAILURE: '2' },
+        encoding: 'utf8',
+      });
+      assert.equal(result.status, status, result.stderr);
+      if (status === 1)
+        assert.match(result.stderr, /cache infrastructure failed/);
+      else assert.equal(result.stderr, '');
+    }
+    assert.equal(
+      readFileSync(f.env.TRACE, 'utf8').trim().split('\n').length,
+      6,
+    );
+  },
+);
+
+linuxTest('lost local cache state still invokes the real compiler', (t) => {
+  const f = fixture(t);
+  assert.equal(f.run(['/bin/bash', '-c', 'exit 43']).status, 43);
+});

scripts/project-ci-workflow.test.ts

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 import { describe, expect, it } from 'vitest';
+import { createVitest } from 'vitest/node';
 
 const workflow = readFileSync(
   resolve(process.cwd(), '.gitea/workflows/project-ci.yml'),
@@ -15,6 +16,10 @@ const imageCheckScript = readFileSync(
   resolve(process.cwd(), 'scripts/check-gitea-ci-job-image.sh'),
   'utf8',
 );
+const rustCacheBuildScript = readFileSync(
+  resolve(process.cwd(), 'scripts/build-gitea-rust-cache.sh'),
+  'utf8',
+);
 const npmCiRetryScript = readFileSync(
   resolve(process.cwd(), 'scripts/ci-npm-ci-with-retry.sh'),
   'utf8',
@@ -137,6 +142,80 @@ function backendStepIndex(stepName: string) {
 }
 
 describe('project CI workflow', () => {
+  it('uses isolated compilation caching for every Rust test job', () => {
+    const firstRustSteps = {
+      'ai-game-creator-shell-rust-lane-1':
+        'Run AI game creator shell Rust shard 1/4',
+      'ai-game-creator-shell-rust-lane-2':
+        'Run AI game creator shell Rust shard 3/4',
+      'ai-game-creator-shell-rust-smoke':
+        'Run AI game creator shell agent-run smoke',
+      'ai-game-creator-shell-rust-crates':
+        'Run AI game creator shell shared crate gates',
+      'backend-tests': 'Run server-rs workspace tests',
+      'native-shell-tests': 'Run native shell gates',
+    };
+    for (const job of jobNames) {
+      const section = jobSection(job);
+      if (!(job in firstRustSteps)) {
+        expect(section).not.toContain('ci-rust-cache.sh');
+        continue;
+      }
+      const firstRustStep = firstRustSteps[job as keyof typeof firstRustSteps];
+      const prepare = section.indexOf('bash scripts/ci-rust-cache.sh prepare');
+      expect(prepare).toBeGreaterThan(
+        section.indexOf('Checkout full history from Gitea'),
+      );
+      expect(prepare).toBeLessThan(section.indexOf(`- name: ${firstRustStep}`));
+      expect(
+        stepSection(job, 'Report isolated Rust compilation cache'),
+      ).toContain('if: always()');
+    }
+    // 缓存自身的行为测试只执行一次，避免随 job 数量重复运行。
+    expect(
+      workflow.match(/node --test scripts\/ci-rust-cache.test.mjs/g),
+    ).toHaveLength(1);
+    const releaseStep = stepSection(
+      'native-shell-tests',
+      'Run native shell release build smoke',
+    );
+    expect(releaseStep).toContain("RUSTC_WRAPPER: ''");
+    expect(releaseStep).toContain("CARGO_BUILD_RUSTC_WRAPPER: ''");
+    expect(workflow).toContain("CARGO_INCREMENTAL: '0'");
+    expect(workflow).toContain("RUSTC_WRAPPER: ''");
+    for (const [, name, value] of workflow
+      .slice(0, workflow.indexOf('\njobs:'))
+      .matchAll(/^ {2}(CARGO_[A-Z0-9_]+): '?([^'\n]*)'?$/gm)) {
+      // wrapper 在 prepare 中选择，其余 Cargo 环境必须和预热一致。
+      if (name === 'CARGO_BUILD_RUSTC_WRAPPER') continue;
+      expect(rustCacheBuildScript).toContain(`${name}=${value}`);
+    }
+  });
+
+  it('warms backend targets without merging the SpacetimeDB feature boundary', () => {
+    const warmCommands = rustCacheBuildScript
+      .replace(/\\\r?\n/g, '')
+      .replace(/\s+/g, ' ');
+    for (const [, command] of jobSection('backend-tests').matchAll(
+      /run: (cargo [^\n]+)/g,
+    )) {
+      expect(warmCommands).toContain(command.trim());
+    }
+    expect(warmCommands).toContain(
+      'cargo test --locked --workspace --exclude spacetime-module --no-fail-fast --manifest-path server-rs/Cargo.toml --no-run',
+    );
+    expect(warmCommands).toContain(
+      'cargo test --locked -p spacetime-module --no-fail-fast --manifest-path server-rs/Cargo.toml --no-run',
+    );
+    expect(warmCommands).toContain('cd apps/ai-game-creator-shell/src-tauri');
+    expect(warmCommands).toContain(
+      'cd apps/ai-game-creator-shell cargo build --manifest-path src-tauri/Cargo.toml',
+    );
+    expect(warmCommands).toContain(
+      'cargo test --manifest-path apps/desktop-shell/src-tauri/Cargo.toml --no-run',
+    );
+  });
+
   it('runs for master pushes, pull requests, and manual dispatch only', () => {
     expect(workflow).toMatch(
       /on:\n {2}push:\n {4}branches:\n {6}- master\n {2}pull_request:\n {2}workflow_dispatch:/u,
@@ -397,7 +476,10 @@ describe('project CI workflow', () => {
 
   it('keeps frontend, operations fixture, and native shell gates in dedicated jobs', () => {
     const frontendJob = jobSection('frontend-tests');
-    expect(frontendJob).toContain('run: npm run test');
+    expect(frontendJob).toMatch(/^ {8}run: npm run test:ci:frontend$/mu);
+    expect(rootPackageJson.scripts?.['test:ci:frontend']).toBe(
+      'vitest run --config vitest.frontend-ci.config.ts',
+    );
     expect(frontendJob).toContain('run: npm run bgfilter-worker:smoke-test');
     expect(frontendJob).toContain(
       'run: npm run check:production-health-patrol',
@@ -419,6 +501,39 @@ describe('project CI workflow', () => {
     expect(nativeJob).toContain('cargo fetch --locked');
   });
 
+  it('partitions frontend and AGC test files without gaps or duplicates', async () => {
+    expect(rootPackageJson.scripts?.test).toBe('vitest run');
+    const full = await createVitest('test', {
+      config: resolve('vitest.config.ts'),
+      watch: false,
+    });
+    try {
+      const allFiles = (await full.globTestFiles()).map(([, file]) => file);
+      const agcFiles = (
+        await full.globTestFiles(['apps/ai-game-creator-shell/tests'])
+      ).map(([, file]) => file);
+      const frontend = await createVitest('test', {
+        config: resolve('vitest.frontend-ci.config.ts'),
+        watch: false,
+      });
+      try {
+        const frontendFiles = (await frontend.globTestFiles()).map(
+          ([, file]) => file,
+        );
+        expect(agcFiles.length).toBeGreaterThan(0);
+        expect(frontendFiles.length).toBeGreaterThan(0);
+        expect(frontendFiles.filter((file) => agcFiles.includes(file))).toEqual(
+          [],
+        );
+        expect([...frontendFiles, ...agcFiles].sort()).toEqual(allFiles.sort());
+      } finally {
+        await frontend.close();
+      }
+    } finally {
+      await full.close();
+    }
+  }, 30_000);
+
   it('runs every native shell gate group exactly once across the split jobs', () => {
     for (const [group, script] of Object.entries(nativeShellGateGroupScripts)) {
       expect(rootPackageJson.scripts?.[`check:native-shells:${group}`]).toBe(

vitest.frontend-ci.config.ts

@@ -0,0 +1,10 @@
+import { mergeConfig } from 'vitest/config';
+
+import config from './vitest.config';
+
+// AGC 前端测试由专属 CI job 执行；本地全量入口继续使用根配置。
+export default mergeConfig(config, {
+  test: {
+    exclude: ['apps/ai-game-creator-shell/tests/**'],
+  },
+});