From 1c2f82e246b58a894919387585e96010e68026fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=91=A3=E7=BE=BD=E7=A7=A6?= <suzmii@qq.com>
Date: Mon, 31 Aug 2026 14:36:58 +0800
Subject: [PATCH 1/8] =?UTF-8?q?=E4=BC=98=E5=8C=96=20Game=20Agent=20?=
 =?UTF-8?q?=E8=B5=84=E6=BA=90=E7=94=BB=E5=B8=83=E5=B1=95=E7=A4=BA=E4=B8=8E?=
 =?UTF-8?q?=E9=BB=98=E8=AE=A4=E7=BC=A9=E6=94=BE=20(#208)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## 变更内容

### 1. 普通资源画布隐藏游戏代码

- 资源画布的大纲、分页和卡片展示不再显示“游戏代码”栏目。
- 保留内部完整的五栏目布局契约，避免已有代码资源坐标被重写。
- 补充回归测试，确认游戏代码不会出现在普通资源画布中，且代码端点不可见时不会渲染对应依赖边。

### 2. 增加资源类型角标

- 资源卡右上角增加类型角标，用于快速识别资源类型。
- 类型从既有资源投影字段推导，覆盖图片、SVG、视频、音频、文档、任务产物、Agent 回执、项目版本等类型，并为未知类型兜底。
- 该能力仅用于前端展示，不新增后端字段或修改资源投影契约。

### 3. 限制默认自动适配缩放

- 画布首次自动适配和显式复位时的默认最大缩放统一限制为 `1.5`，避免内容较少或只有一个资源时卡片被放得过大。
- 该限制对设计文档、美术、音频、游戏代码、项目版本全部资源栏目生效。
- 用户主动缩放仍沿用现有上限，不受默认适配上限影响。
- 用户调整后的画布缩放会按排序模式和栏目保留；切换到其他栏目再返回后，仍恢复用户调整后的 viewport，而不是重新自动放大。

## 兼容性

- 不修改后端 API、SpacetimeDB schema 或 `/api/external/v1`。
- 资源类型角标是展示层推导逻辑，不改变资源数据结构。
- 内部布局仍保留游戏代码栏目契约，已有布局数据不需要迁移。

## 验证

- `resourceCanvasLayoutModel.test.ts`
- `project-development.suite.ts` 相关 App Surface 用例
- `npm run typecheck`
- `npm run check:encoding`
- Prettier 相关文件检查
- `git diff --check`

历史分支检查不替代最新 head CI；PR 更新后将以最新 CI 结果为准。

---------

Co-authored-by: 段舒康 <kdletters@qq.com>
Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/208
Co-authored-by: 董羽秦 <suzmii@qq.com>
Co-committed-by: 董羽秦 <suzmii@qq.com>
---
 apps/ai-game-creator-shell/src/styles.css     |  25 +++
 .../src/view/project-development/index.tsx    |  74 ++++----
 .../resourceCanvasLayoutModel.ts              |  10 +-
 .../resourceProjectionModel.ts                |  61 +++++++
 .../appSurface/project-development.suite.ts   | 166 +++++++++++++++---
 .../projectResourceProjectionModel.test.ts    | 120 ++++++++++++-
 .../tests/resourceCanvasLayoutModel.test.ts   |  25 ++-
 ...AI游戏创作】项目开发工作台PRD-2026-07-20.md |  10 +-
 ...�案】AI游戏创作智能体App实施计划-2026-06-24.md |   2 +-
 9 files changed, 423 insertions(+), 70 deletions(-)

diff --git a/apps/ai-game-creator-shell/src/styles.css b/apps/ai-game-creator-shell/src/styles.css
index b150722b5..c733e6704 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -5458,6 +5458,31 @@ iframe.preview-frame {
   visibility: visible;
 }
 
+.game-resource-card-type-badge {
+  position: absolute;
+  top: 8px;
+  right: 8px;
+  z-index: 2;
+  display: inline-flex;
+  max-width: calc(100% - 16px);
+  align-items: center;
+  min-width: 0;
+  padding: 4px 8px;
+  overflow: hidden;
+  border: 1px solid rgb(255 255 255 / 72%);
+  border-radius: 999px;
+  background: rgb(75 48 38 / 84%);
+  color: #fff;
+  font-size: 10px;
+  font-weight: 900;
+  line-height: 1;
+  letter-spacing: 0.02em;
+  pointer-events: none;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  box-shadow: 0 8px 18px rgb(96 62 47 / 20%);
+}
+
 .game-resource-card-open {
   position: absolute;
   z-index: 1;
diff --git a/apps/ai-game-creator-shell/src/view/project-development/index.tsx b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
index 272916fa5..f539fc02f 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/index.tsx
+++ b/apps/ai-game-creator-shell/src/view/project-development/index.tsx
@@ -82,10 +82,10 @@ import {
   normalizeInfiniteResourceCanvasViewport,
   RESOURCE_CANVAS_DRAG_THRESHOLD,
   RESOURCE_CANVAS_FIT_PADDING,
-  RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE,
   RESOURCE_CANVAS_SECTION_MIN_HEIGHT,
   RESOURCE_CANVAS_SECTION_MIN_WIDTH,
   RESOURCE_CANVAS_SECTION_ORDER,
+  RESOURCE_CANVAS_VISIBLE_SECTION_ORDER,
   type ResourceCanvasCardSize,
   resourceCanvasCardSize,
   resourceCanvasContentBounds,
@@ -123,6 +123,7 @@ import {
   type ProjectResource,
   type ProjectResourceCategory,
   projectResourcesFromReadModels,
+  projectResourceTypeLabel,
 } from './resourceProjectionModel';
 import {
   clampProjectResourceSectionZoom,
@@ -393,6 +394,7 @@ export type ProjectDevelopmentViewProps = {
 };
 
 const categoryOrder = RESOURCE_CANVAS_SECTION_ORDER;
+const visibleCategoryOrder = RESOURCE_CANVAS_VISIBLE_SECTION_ORDER;
 
 const categoryLabels: Record<ResourceCategory, string> = {
   code: '游戏代码',
@@ -592,6 +594,7 @@ const ResourceCard = memo(function ResourceCard({
   const [decodedIdentity, setDecodedIdentity] = useState<string | null>(null);
   const Icon = categoryIcons[resource.category];
   const kind = projectResourceCardPreviewKind(resource);
+  const resourceTypeLabel = projectResourceTypeLabel(resource);
   const isMedia = kind === 'video' || kind === 'audio';
   const mediaActive = activeMediaIdentity === previewIdentity;
   const sourceUrl =
@@ -797,6 +800,13 @@ const ResourceCard = memo(function ResourceCard({
       <span className="game-resource-card-visual" aria-hidden="true">
         {visual}
       </span>
+      <span
+        className="game-resource-card-type-badge"
+        data-resource-type={resourceTypeLabel}
+        title={resourceTypeLabel}
+      >
+        {resourceTypeLabel}
+      </span>
       <button
         type="button"
         className="game-resource-card-open"
@@ -1243,6 +1253,10 @@ export default function ProjectDevelopmentView({
       }),
     [manifestTaskById, projectedResources, resourceGraph],
   );
+  const canvasResources = useMemo(
+    () => resources.filter((resource) => resource.category !== 'code'),
+    [resources],
+  );
   // 做方案在拿到第一个产物之前，左边的资源画布是空的（文档 0 项、项目版本 0 项），而澄清
   // 问答、决定卡和 GDD 审批全挤在右边那一列里。这段时间先把画布收掉让对话铺满，一旦有第
   // 一个已登记资源就自动恢复双栏。用 CSS 收而不是不渲染：画布里的页签、缩放和选中状态都
@@ -1288,7 +1302,7 @@ export default function ProjectDevelopmentView({
     projectPath,
     projectId: manifest.projectId,
     mode: sortMode,
-    resources,
+    resources: canvasResources,
     canvasRef: resourceCanvasRef,
     eagerPreviewLimit: 12,
     previewVersionByResourceId: resourcePreviewVersionByResourceId,
@@ -1382,7 +1396,7 @@ export default function ProjectDevelopmentView({
   const normalizedSearch = searchText.trim().toLowerCase();
   const visibleResources = useMemo(
     () =>
-      resources.filter((resource) =>
+      canvasResources.filter((resource) =>
         normalizedSearch
           ? [
               resource.label,
@@ -1392,7 +1406,7 @@ export default function ProjectDevelopmentView({
             ].some((value) => value.toLowerCase().includes(normalizedSearch))
           : true,
       ),
-    [normalizedSearch, resources],
+    [canvasResources, normalizedSearch],
   );
   const visibleResourceIds = useMemo(
     () => new Set(visibleResources.map((resource) => resource.id)),
@@ -1401,7 +1415,7 @@ export default function ProjectDevelopmentView({
   const visibleResourcesByCategory = useMemo(
     () =>
       new Map(
-        categoryOrder.map((category) => [
+        visibleCategoryOrder.map((category) => [
           category,
           visibleResources.filter((resource) => resource.category === category),
         ]),
@@ -1411,17 +1425,17 @@ export default function ProjectDevelopmentView({
   const projectResourcesByCategory = useMemo(
     () =>
       new Map(
-        categoryOrder.map((category) => [
+        visibleCategoryOrder.map((category) => [
           category,
-          resources.filter((resource) => resource.category === category),
+          canvasResources.filter((resource) => resource.category === category),
         ]),
       ),
-    [resources],
+    [canvasResources],
   );
   const resourceIdsByCategory = useMemo(
     () =>
       new Map(
-        categoryOrder.map((category) => [
+        visibleCategoryOrder.map((category) => [
           category,
           new Set(
             (projectResourcesByCategory.get(category) ?? []).map(
@@ -1437,8 +1451,8 @@ export default function ProjectDevelopmentView({
     [manifest.projectId, projectPath],
   );
   const resourcePageCategories = useMemo(
-    () => (resources.length > 0 ? categoryOrder : []),
-    [resources.length],
+    () => (canvasResources.length > 0 ? visibleCategoryOrder : []),
+    [canvasResources.length],
   );
   const activePageCategory =
     resourcePageCategories.find(
@@ -1468,16 +1482,18 @@ export default function ProjectDevelopmentView({
       return;
     }
 
-    const categoriesWithNewResources = categoryOrder.filter((category) => {
-      if (category === viewedResourceCategory) {
-        return false;
-      }
-      const previousIds =
-        previousSnapshot.resourceIdsByCategory.get(category) ?? new Set();
-      return Array.from(resourceIdsByCategory.get(category) ?? []).some(
-        (resourceId) => !previousIds.has(resourceId),
-      );
-    });
+    const categoriesWithNewResources = visibleCategoryOrder.filter(
+      (category) => {
+        if (category === viewedResourceCategory) {
+          return false;
+        }
+        const previousIds =
+          previousSnapshot.resourceIdsByCategory.get(category) ?? new Set();
+        return Array.from(resourceIdsByCategory.get(category) ?? []).some(
+          (resourceId) => !previousIds.has(resourceId),
+        );
+      },
+    );
     resourceCategorySnapshotRef.current = {
       scopeKey: resourceCategoryScopeKey,
       resourceIdsByCategory,
@@ -1683,9 +1699,11 @@ export default function ProjectDevelopmentView({
     }
   }, [activePageCategory, activeResourceCanvasViewport]);
   const selectedResource =
-    resources.find((resource) => resource.id === selectedResourceId) ?? null;
+    canvasResources.find((resource) => resource.id === selectedResourceId) ??
+    null;
   const focusedResource =
-    resources.find((resource) => resource.id === focusedResourceId) ?? null;
+    canvasResources.find((resource) => resource.id === focusedResourceId) ??
+    null;
   const focusedResourceDependencyDetails = useMemo(() => {
     if (!focusedResource) {
       return {
@@ -2245,10 +2263,6 @@ export default function ProjectDevelopmentView({
               bounds: resourceCanvasFitBounds,
               canvasSize: { width: measuredWidth, height: measuredHeight },
               padding: RESOURCE_CANVAS_FIT_PADDING,
-              maxScale:
-                activePageCategory === 'art'
-                  ? RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE
-                  : undefined,
             }),
           );
           return;
@@ -2853,10 +2867,6 @@ export default function ProjectDevelopmentView({
         bounds: resourceCanvasFitBounds,
         canvasSize,
         padding: RESOURCE_CANVAS_FIT_PADDING,
-        maxScale:
-          activePageCategory === 'art'
-            ? RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE
-            : undefined,
       }),
     );
   }, [activePageCategory, resourceCanvasFitBounds, setResourceCanvasViewport]);
@@ -5035,7 +5045,7 @@ export default function ProjectDevelopmentView({
                       </div>
                     ) : (
                       <div className="game-resource-section-stack">
-                        {categoryOrder.map((category) => {
+                        {visibleCategoryOrder.map((category) => {
                           const Icon = categoryIcons[category];
                           const sectionHeight =
                             resourceSectionHeights.sectionStates.get(category);
diff --git a/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts b/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
index ac8ac9143..d4133ab05 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/resourceCanvasLayoutModel.ts
@@ -44,6 +44,14 @@ export const RESOURCE_CANVAS_FIT_PADDING = 16;
 export const RESOURCE_CANVAS_SECTION_ORDER: readonly ProjectResourceCanvasSection[] =
   ['document', 'art', 'audio', 'code', 'version'];
 
+/**
+ * Ordinary resource-canvas navigation intentionally omits game code. The
+ * complete five-section order above remains the internal layout/sidecar
+ * contract so existing code-resource coordinates are not rewritten.
+ */
+export const RESOURCE_CANVAS_VISIBLE_SECTION_ORDER: readonly ProjectResourceCanvasSection[] =
+  ['document', 'art', 'audio', 'version'];
+
 export type ResourceCanvasCardSize = {
   width: number;
   height: number;
@@ -1345,7 +1353,7 @@ export function fitResourceCanvasViewportToContent({
   bounds,
   canvasSize,
   padding = RESOURCE_CANVAS_FIT_PADDING,
-  maxScale = MAX_SCALE,
+  maxScale = RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE,
 }: {
   bounds: { x: number; y: number; width: number; height: number };
   canvasSize: { width: number; height: number };
diff --git a/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts b/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts
index 6151887d7..b43bf1352 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/resourceProjectionModel.ts
@@ -55,6 +55,18 @@ export type ProjectResource = {
   imageSequenceDurationMs?: number | null;
 };
 
+export type ProjectResourceTypeLabel =
+  | '图片'
+  | 'SVG'
+  | '视频'
+  | '音频'
+  | '文档'
+  | '任务产物'
+  | 'Agent 回执'
+  | '项目版本'
+  | '游戏代码'
+  | '未知';
+
 const documentExtension =
   /\.(md|markdown|mdx|txt|json|ya?ml|toml|csv|ini|conf|xml)$/iu;
 const gameCodeExtension =
@@ -116,6 +128,55 @@ export function classifyProjectedResource(input: {
   return null;
 }
 
+/**
+ * Converts an already projected resource into short user-facing type text.
+ * This is deliberately display-only: it derives from existing projection
+ * fields and does not add a backend/read-model attribute.
+ */
+export function projectResourceTypeLabel(
+  resource: Pick<
+    ProjectResource,
+    'category' | 'subtype' | 'path' | 'mediaType'
+  >,
+): ProjectResourceTypeLabel {
+  const subtype = resource.subtype.trim().toLowerCase();
+  const path = resource.path.trim().toLowerCase();
+  const mediaType = resource.mediaType.trim().toLowerCase();
+
+  if (resource.category === 'version' || subtype === 'project-version') {
+    return '项目版本';
+  }
+  if (subtype === 'agent-result') {
+    return 'Agent 回执';
+  }
+  if (resource.category === 'code') {
+    return '游戏代码';
+  }
+  if (mediaType === 'image/svg+xml' || /\.svg$/iu.test(path)) {
+    return 'SVG';
+  }
+  if (
+    resource.category === 'audio' ||
+    mediaType.startsWith('audio/') ||
+    audioExtension.test(path)
+  ) {
+    return '音频';
+  }
+  if (mediaType.startsWith('video/') || /\.(mp4|webm|mov)$/iu.test(path)) {
+    return '视频';
+  }
+  if (resource.category === 'document' || mediaType.startsWith('text/')) {
+    return '文档';
+  }
+  if (resource.category === 'art' || mediaType.startsWith('image/')) {
+    return '图片';
+  }
+  if (subtype === 'task-artifact') {
+    return '任务产物';
+  }
+  return '未知';
+}
+
 function resourcePriority(resource: ProjectResource) {
   if (resource.manifestAssetId) {
     return 4;
diff --git a/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
index e6fb313ba..39654209b 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/project-development.suite.ts
@@ -6,6 +6,7 @@ import {
   RESOURCE_CANVAS_CARD_WIDTH,
   RESOURCE_CANVAS_COLUMN_GAP,
   RESOURCE_CANVAS_DEPENDENCY_COLUMN_GAP,
+  RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE,
 } from '../../src/view/project-development/resourceCanvasLayoutModel';
 import { normalizeProjectResourceGraph } from '../../src/view/project-development/resourceDependencyGraphModel';
 import { ResourceDependencyOverlay } from '../../src/view/project-development/ResourceDependencyOverlay';
@@ -429,6 +430,13 @@ export function registerProjectWorkbenchFoundationTests() {
           localPath: 'assets/section.mp3',
           source: { kind: 'generated', taskId: 'audio-asset-plan' },
         },
+        {
+          id: 'section-code',
+          kind: 'game-code',
+          mediaType: 'text/javascript',
+          localPath: 'game/section.js',
+          source: { kind: 'generated', taskId: 'code-prototype' },
+        },
       ];
       manifest.versions = [
         {
@@ -448,9 +456,13 @@ export function registerProjectWorkbenchFoundationTests() {
     );
     addSectionResources(manifest);
     let layoutRevision = 0;
+    let graphResourceIds: string[] = [];
     const invoke = vi.fn(
       async (command: string, args?: Record<string, unknown>) => {
         if (command === 'read_local_project_resource_graph') {
+          graphResourceIds = (
+            (args?.resources as Array<{ resourceId: string }> | undefined) ?? []
+          ).map(({ resourceId }) => resourceId);
           return resourceGraphForInputs(args);
         }
         if (command === 'read_local_project_resource_canvas_layout') {
@@ -529,7 +541,12 @@ export function registerProjectWorkbenchFoundationTests() {
       Array.from(outline.querySelectorAll('strong')).map(
         (item) => item.textContent,
       ),
-    ).toEqual(['设计文档', '美术资源', '音乐音效', '游戏代码', '项目版本']);
+    ).toEqual(['设计文档', '美术资源', '音乐音效', '项目版本']);
+    expect(graphResourceIds).toContain('asset:section-code');
+    expect(screen.queryByRole('button', { name: /section\.js/ })).toBeNull();
+    expect(
+      screen.queryByRole('region', { name: '游戏代码资源画布' }),
+    ).toBeNull();
     expect(outline.querySelectorAll('small')).toHaveLength(0);
     expect(
       screen.getByRole('region', { name: '设计文档资源画布' }),
@@ -541,11 +558,12 @@ export function registerProjectWorkbenchFoundationTests() {
       screen.getByRole('button', { name: /下一页\s*美术资源/ }),
     ).not.toBeNull();
 
-    fireEvent.click(within(outline).getByRole('button', { name: /游戏代码/ }));
     expect(
-      screen.getByRole('region', { name: '游戏代码资源画布' }),
-    ).not.toBeNull();
-    expect(screen.getByText('没有匹配资源')).not.toBeNull();
+      within(outline).queryByRole('button', { name: /游戏代码/ }),
+    ).toBeNull();
+    expect(
+      screen.queryByRole('region', { name: '游戏代码资源画布' }),
+    ).toBeNull();
     fireEvent.click(within(outline).getByRole('button', { name: /文档/ }));
 
     const dispatchPageWheel = (target: Element, deltaY = 160) => {
@@ -606,10 +624,12 @@ export function registerProjectWorkbenchFoundationTests() {
         .map(Number);
     const fittedViewport = readViewport();
     const fittedBounds = readFitBounds();
-    expect(
-      Math.abs(fittedBounds[2]! * fittedViewport[2]! - 468) < 1 ||
-        Math.abs(fittedBounds[3]! * fittedViewport[2]! - 268) < 1,
-    ).toBe(true);
+    const expectedDocumentFitScale = Math.min(
+      RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE,
+      468 / fittedBounds[2]!,
+      268 / fittedBounds[3]!,
+    );
+    expect(fittedViewport[2]).toBeCloseTo(expectedDocumentFitScale, 8);
 
     const viewportBeforeZoom = fittedViewport;
     const zoomWheel = new WheelEvent('wheel', {
@@ -626,6 +646,15 @@ export function registerProjectWorkbenchFoundationTests() {
     });
     expect(zoomWheelResult).toBe(false);
     expect(readViewport()[2]).toBeGreaterThan(viewportBeforeZoom[2]!);
+    const documentViewportAfterZoom = readViewport();
+    fireEvent.click(within(outline).getByRole('button', { name: /美术资源/ }));
+    expect(
+      screen.getByRole('region', { name: '美术资源资源画布' }),
+    ).not.toBeNull();
+    fireEvent.click(within(outline).getByRole('button', { name: /设计文档/ }));
+    await waitFor(() =>
+      expect(readViewport()).toEqual(documentViewportAfterZoom),
+    );
     expect(
       screen.getByRole('region', { name: '设计文档资源画布' }),
     ).not.toBeNull();
@@ -1051,10 +1080,16 @@ export function registerProjectWorkbenchFoundationTests() {
       }),
     );
     await waitFor(() => {
+      expect(screen.queryByLabelText('资源栏目大纲')).toBeNull();
+      expect(screen.getAllByText('暂无已登记资源')).toHaveLength(4);
       expect(
-        within(screen.getByLabelText('资源栏目大纲')).queryByRole('button', {
-          name: /有新资源/,
-        }),
+        screen
+          .getByLabelText(/资源(?:依赖|类型)视图/)
+          .classList.contains('game-resource-canvas--paged'),
+      ).toBe(false);
+      expect(screen.queryByRole('button', { name: /game\.js/ })).toBeNull();
+      expect(
+        screen.queryByRole('region', { name: '游戏代码资源画布' }),
       ).toBeNull();
     });
   });
@@ -1224,14 +1259,8 @@ export function registerProjectWorkbenchFoundationTests() {
           .getByLabelText(/资源(?:依赖|类型)视图/)
           .classList.contains('game-resource-canvas--dependency'),
       ).toBe(false);
-      expect(screen.getAllByText('暂无已登记资源')).toHaveLength(5);
-      for (const label of [
-        '设计文档',
-        '美术资源',
-        '音乐音效',
-        '游戏代码',
-        '项目版本',
-      ]) {
+      expect(screen.getAllByText('暂无已登记资源')).toHaveLength(4);
+      for (const label of ['设计文档', '美术资源', '音乐音效', '项目版本']) {
         expect(screen.getByRole('region', { name: label })).not.toBeNull();
       }
     };
@@ -1394,6 +1423,9 @@ export function registerProjectWorkbenchFoundationTests() {
     expect(heroCard?.textContent).not.toContain('hero.png');
     expect(heroCard?.textContent).not.toContain('assets/hero.png');
     expect(heroCard?.textContent).not.toContain('Agent 生成');
+    expect(
+      heroCard?.querySelector('[data-resource-type="图片"]')?.textContent,
+    ).toBe('图片');
     expect(
       heroCard?.querySelector('.game-resource-card-open button'),
     ).toBeNull();
@@ -1411,7 +1443,12 @@ export function registerProjectWorkbenchFoundationTests() {
     });
     showResourcePage('设计文档');
     act(() => observer.triggerVisible());
-    await screen.findByText(/这是安全的卡片正文摘要。/);
+    const documentSummary = await screen.findByText(/这是安全的卡片正文摘要。/);
+    expect(
+      documentSummary
+        .closest('.game-resource-card')
+        ?.querySelector('[data-resource-type="文档"]'),
+    ).not.toBeNull();
     showResourcePage('美术资源');
     expect(
       invoke.mock.calls.some(
@@ -1425,6 +1462,9 @@ export function registerProjectWorkbenchFoundationTests() {
       name: '播放 intro.mp4',
     });
     const videoCard = videoControl.closest('.game-resource-card');
+    expect(
+      videoCard?.querySelector('[data-resource-type="视频"]'),
+    ).not.toBeNull();
     const video = videoCard?.querySelector('video');
     expect(video).not.toBeNull();
     expect(video?.preload).toBe('auto');
@@ -1475,7 +1515,13 @@ export function registerProjectWorkbenchFoundationTests() {
     expect(document.activeElement).toBe(stableVideoControl);
 
     showResourcePage('音乐音效');
-    fireEvent.click(screen.getByRole('button', { name: '播放 theme.mp3' }));
+    const audioControl = screen.getByRole('button', { name: '播放 theme.mp3' });
+    expect(
+      audioControl
+        .closest('.game-resource-card')
+        ?.querySelector('[data-resource-type="音频"]'),
+    ).not.toBeNull();
+    fireEvent.click(audioControl);
     await waitFor(() => {
       expect(
         invoke.mock.calls.some(
@@ -2800,6 +2846,82 @@ export function registerProjectWorkbenchFoundationTests() {
     });
   });
 
+  it('hides dependency edges whose code endpoint is not visible while preserving visible edges', async () => {
+    const visibleEdgeId = 'asset-reference:["art-a","art-b"]';
+    const hiddenEdgeId = 'asset-reference:["code","art-a"]';
+    const graph = normalizeProjectResourceGraph({
+      resourceIds: ['code', 'art-a', 'art-b'],
+      referenceEdges: [
+        {
+          id: visibleEdgeId,
+          kind: 'asset-reference',
+          sourceResourceId: 'art-a',
+          targetResourceId: 'art-b',
+          cyclic: false,
+        },
+        {
+          id: hiddenEdgeId,
+          kind: 'asset-reference',
+          sourceResourceId: 'code',
+          targetResourceId: 'art-a',
+          cyclic: false,
+        },
+      ],
+      taskFlows: [],
+      connectionIndex: [],
+      producerAssignments: [],
+      dependencyDepths: [],
+      unresolvedReferenceResourceIds: [],
+      cyclicResourceIds: [],
+      cyclicTaskIds: [],
+      producerMappingTruncated: false,
+    });
+    const positions: ProjectResourceCanvasPosition[] = [
+      {
+        resourceId: 'code',
+        section: 'code',
+        x: 0,
+        y: 0,
+        manuallyPlaced: false,
+      },
+      {
+        resourceId: 'art-a',
+        section: 'art',
+        x: 0,
+        y: 0,
+        manuallyPlaced: false,
+      },
+      {
+        resourceId: 'art-b',
+        section: 'art',
+        x: 0,
+        y: 144,
+        manuallyPlaced: false,
+      },
+    ];
+
+    render(
+      React.createElement(ResourceDependencyOverlay, {
+        graph,
+        positions,
+        section: 'art',
+        visibleResourceIds: new Set(['art-a', 'art-b']),
+      }),
+    );
+
+    const overlay = await screen.findByTestId(
+      'resource-dependency-overlay-art',
+    );
+    await waitFor(() => {
+      const edgeById = (edgeId: string) =>
+        Array.from(
+          overlay.querySelectorAll<SVGPathElement>('[data-edge-id]'),
+        ).find((edge) => edge.getAttribute('data-edge-id') === edgeId);
+      expect(edgeById(visibleEdgeId)).not.toBeNull();
+      expect(edgeById(hiddenEdgeId)).toBeUndefined();
+    });
+  });
+
   it('coalesces section scroll geometry, keeps partial endpoints stable, and cleans one dependency observer', async () => {
     const referenceId = 'asset-reference:["resource-a","resource-b"]';
     const graph = normalizeProjectResourceGraph({
diff --git a/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts b/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts
index 92ef7f361..7ff71b3da 100644
--- a/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/projectResourceProjectionModel.test.ts
@@ -1,7 +1,10 @@
 import { describe, expect, it } from 'vitest';
 
 import { createGameCreationAppManifest } from '../../../packages/shared/src/contracts/gameCreationApp';
-import { projectResourcesFromReadModels } from '../src/view/project-development/resourceProjectionModel';
+import {
+  projectResourcesFromReadModels,
+  projectResourceTypeLabel,
+} from '../src/view/project-development/resourceProjectionModel';
 
 describe('项目资源投影', () => {
   it('只把明确资源投影到固定分类，未知任务产物不会伪装成项目版本', () => {
@@ -225,4 +228,119 @@ describe('项目资源投影', () => {
     expect(versions[0]?.version?.childVersionIds).toEqual(['version-child']);
     expect(versions[1]?.version?.parentVersionId).toBe('version-root');
   });
+
+  it('按稳定优先级推导资源卡类型标识并为未知类型兜底', () => {
+    expect(
+      projectResourceTypeLabel({
+        category: 'version',
+        subtype: 'project-version',
+        path: 'versions/v1',
+        mediaType: '正式项目版本',
+      }),
+    ).toBe('项目版本');
+    expect(
+      projectResourceTypeLabel({
+        category: 'document',
+        subtype: 'agent-result',
+        path: '专业 Agent 文本回执',
+        mediaType: 'Agent 历史文本回执',
+      }),
+    ).toBe('Agent 回执');
+    expect(
+      projectResourceTypeLabel({
+        category: 'document',
+        subtype: 'task-artifact',
+        path: 'memory/plan.md',
+        mediaType: '项目文档',
+      }),
+    ).toBe('文档');
+    expect(
+      projectResourceTypeLabel({
+        category: 'audio',
+        subtype: 'task-artifact',
+        path: 'audio/theme.wav',
+        mediaType: '音乐音效产物',
+      }),
+    ).toBe('音频');
+    expect(
+      projectResourceTypeLabel({
+        category: 'art',
+        subtype: 'task-artifact',
+        path: 'assets/hero.svg',
+        mediaType: '美术产物',
+      }),
+    ).toBe('SVG');
+    expect(
+      projectResourceTypeLabel({
+        category: 'art',
+        subtype: 'task-artifact',
+        path: 'assets/unknown',
+        mediaType: '美术产物',
+      }),
+    ).toBe('图片');
+    expect(
+      projectResourceTypeLabel({
+        category: 'art',
+        subtype: 'character',
+        path: 'assets/hero.svg',
+        mediaType: 'image/svg+xml',
+      }),
+    ).toBe('SVG');
+    expect(
+      projectResourceTypeLabel({
+        category: 'art',
+        subtype: 'video',
+        path: 'assets/intro.mp4',
+        mediaType: 'video/mp4',
+      }),
+    ).toBe('视频');
+    expect(
+      projectResourceTypeLabel({
+        category: 'art',
+        subtype: 'character',
+        path: 'assets/hero.png',
+        mediaType: 'image/png',
+      }),
+    ).toBe('图片');
+    expect(
+      projectResourceTypeLabel({
+        category: 'document',
+        subtype: 'attachment',
+        path: 'docs/rules.yaml',
+        mediaType: 'application/yaml',
+      }),
+    ).toBe('文档');
+    expect(
+      projectResourceTypeLabel({
+        category: 'document',
+        subtype: 'unknown',
+        path: 'data/blob',
+        mediaType: 'application/octet-stream',
+      }),
+    ).toBe('文档');
+    expect(
+      projectResourceTypeLabel({
+        category: 'code',
+        subtype: 'source',
+        path: 'game/main.ts',
+        mediaType: 'text/typescript',
+      }),
+    ).toBe('游戏代码');
+    expect(
+      projectResourceTypeLabel({
+        category: 'art',
+        subtype: 'unknown',
+        path: 'assets/blob',
+        mediaType: 'application/octet-stream',
+      }),
+    ).toBe('图片');
+    expect(
+      projectResourceTypeLabel({
+        category: 'unsupported' as never,
+        subtype: 'unknown',
+        path: 'data/blob',
+        mediaType: 'application/octet-stream',
+      }),
+    ).toBe('未知');
+  });
 });
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts
index 959f7c5af..db6b2df22 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasLayoutModel.test.ts
@@ -18,6 +18,7 @@ import {
   RESOURCE_CANVAS_COLUMN_GAP,
   RESOURCE_CANVAS_DEPENDENCY_COLUMN_GAP,
   RESOURCE_CANVAS_DEPENDENCY_ROW_GAP,
+  RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE,
   type ResourceCanvasCardSize,
   resourceCanvasContentBounds,
   resourceCanvasImageCardSize,
@@ -831,15 +832,23 @@ describe('resource canvas variable card geometry', () => {
     expect(viewport.x + bounds.x * viewport.scale).toBeCloseTo(16, 8);
   });
 
-  it('caps the initial fit without limiting explicit canvas zoom', () => {
-    const viewport = fitResourceCanvasViewportToContent({
-      bounds: { x: 0, y: 0, width: 180, height: 128 },
-      canvasSize: { width: 800, height: 600 },
-      maxScale: 1.5,
-    });
+  it.each(['document', 'art', 'audio', 'code', 'version'])(
+    'caps the initial fit for every resource category (%s) while keeping explicit zoom overrides available',
+    () => {
+      const viewport = fitResourceCanvasViewportToContent({
+        bounds: { x: 0, y: 0, width: 180, height: 128 },
+        canvasSize: { width: 800, height: 600 },
+      });
+      const explicitViewport = fitResourceCanvasViewportToContent({
+        bounds: { x: 0, y: 0, width: 180, height: 128 },
+        canvasSize: { width: 800, height: 600 },
+        maxScale: 2.5,
+      });
 
-    expect(viewport.scale).toBe(1.5);
-  });
+      expect(viewport.scale).toBe(RESOURCE_CANVAS_INITIAL_FIT_MAX_SCALE);
+      expect(explicitViewport.scale).toBe(2.5);
+    },
+  );
 
   it('accepts card sizes directly on resource items for hook integration', () => {
     const wide = {
diff --git a/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md b/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
index 5ff2dee1f..4ae5a4fc8 100644
--- a/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
+++ b/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
@@ -322,7 +322,7 @@ type UpdateProjectResourceCanvasLayoutResult =
 - type 模式资源集合变化时保留全部仍存在的坐标，只为新 ID 计算默认位置，并删除已确认失效的旧 ID。dependency 模式只永久保留 `manuallyPlaced=true` 的历史坐标；`manuallyPlaced=false` 属于可派生自动位置，在 Rust 关系图首次就绪、`dependencyDepth` 或资源拓扑身份签名（精确引用端点和聚合 task-flow 成员）变化后按最终拓扑确定性重算。签名以稳定资源 ID 的规范端点 / 成员序列生成固定大小摘要，不使用显示名称或浏览器测量值；自动重算不得移动手动坐标，协调结果与持久布局逐项一致时不得产生 CAS 写入。
 - 搜索或筛选只隐藏卡片，不删除、压缩或重排其坐标；清空搜索后恢复原位置。
 - 窗口尺寸变化只改变当前栏目的可视范围，不回写或裁切持久坐标，也不因资源 extent 或 resize 把已平移的 viewport 拉回内容边界。当前客户端继续以 `1280×800` 横屏合同验收。
-- 任一栏目出现资源后，资源管理固定使用 `设计文档 -> 美术资源 -> 音乐音效 -> 游戏代码 -> 项目版本` 五栏目分页画布；每个栏目按 `projectId + mode + category` 保留独立 viewport。普通 wheel 切换栏目，`Ctrl/Cmd + wheel` 以指针位置为锚点缩放当前无限画布，空白拖动只平移当前栏目；非空状态不提供分区高度、分区内部滚动或分区内容倍率。搜索和详情开关不得重置 viewport，项目、mode 或栏目切换只恢复各自会话状态，显式复位才重新适配当前栏目内容。
+- 任一可见资源出现后，普通用户资源管理固定使用 `设计文档 -> 美术资源 -> 音乐音效 -> 项目版本` 四栏目分页画布；游戏代码仍保留在内部资源、布局和依赖事实中，但不进入普通资源画布的导航、分页、卡片、搜索或详情入口。每个可见栏目按 `projectId + mode + category` 保留独立 viewport，普通 wheel 切换栏目，`Ctrl/Cmd + wheel` 以指针位置为锚点缩放当前无限画布，空白拖动只平移当前栏目；非空状态不提供分区高度、分区内部滚动或分区内容倍率。搜索和详情开关不得重置 viewport，项目、mode 或栏目切换只恢复各自会话状态，显式复位才重新适配当前栏目内容。
 - 首次载入项目中的既有资源不显示未读标识。当前会话内，非当前栏目出现稳定 ID 的新资源时，在对应栏目名称右上角显示红点；当前栏目新增资源不显示红点，用户通过点击、滚轮或程序跳转进入该栏目后立即清除。未读状态只属于当前前端会话，并按 `projectPath + projectId` 隔离，切换项目时清空，不写入 manifest、布局 sidecar 或后端。
 - 打开项目、切换 mode 或当前 mode 首次出现新资源时执行“读取 -> 协调 -> 必要时 CAS 写入”；dependency 模式必须先等待与当前 `projectPath + projectId + resource inputs` 匹配的 Rust 图进入 `ready` 或 `failed` 终态，等待期间不得创建 fallback、读取 sidecar、协调资源或入队保存。`failed` 只允许以空图降级初始化一次。项目或 mode 已切换后返回的旧异步结果必须丢弃。
 - 同一 `projectPath + projectId + mode` 的首次读取与资源集合协调必须分开：资源集合变化不得取消已经发出的读取或保存。当前 scope 内资源自动协调写入使用单写者 FIFO，任一时刻最多一个 CAS 在途，后一笔必须使用前一笔成功返回的 revision。切换项目或 mode 后，旧 scope 的在途请求不能阻塞新 scope 队列；前端放弃旧请求槽位并丢弃其迟到响应，后端继续依靠 `expectedProjectId + expectedRevision + 系统锁` 仲裁已发出的请求。
@@ -355,7 +355,7 @@ type UpdateProjectResourceCanvasLayoutResult =
 
 ### 5.3 资源类型与替换兼容性（P1）
 
-实现状态（2026-08-23）：当前资源投影与栏目页顺序收口为“设计文档 -> 美术资源 -> 音乐音效 -> 游戏代码 -> 项目版本”。设计文档接收受支持的 UTF-8 文档、代码资产中的文档类型和合法 Agent 文本回执；项目版本只接收显式 `ProjectVersionResourceSummary` read model，未知任务产物不得兜底为版本；美术资源接收图片、SVG、动画和视频类产物；音乐音效接收 manifest 资产、上传登记资产和已完成任务 `artifacts` 明确声明的音频产物；游戏代码接收 Direct Codex / 任务产物登记的 HTML、CSS 和 JavaScript。无法识别的二进制任务产物和附件不进入资源画布。受控读取、中央聚焦、失败空态与媒体播放不改变 manifest 真相；编辑成功后只追加新的 asset 或版本子记录。
+实现状态（2026-08-29）：内部资源投影仍识别“设计文档、美术资源、音乐音效、游戏代码、项目版本”五类事实，但普通用户资源画布只展示“设计文档 -> 美术资源 -> 音乐音效 -> 项目版本”四个栏目；游戏代码不进入画布导航、分页、卡片、搜索或详情入口。设计文档接收受支持的 UTF-8 文档、代码资产中的文档类型和合法 Agent 文本回执；项目版本只接收显式 `ProjectVersionResourceSummary` read model，未知任务产物不得兜底为版本；美术资源接收图片、SVG、动画和视频类产物；音乐音效接收 manifest 资产、上传登记资产和已完成任务 `artifacts` 明确声明的音频产物；游戏代码继续接收 Direct Codex / 任务产物登记的 HTML、CSS 和 JavaScript，底层文件、manifest 事实、生成/编辑/运行能力、项目版本引用与依赖关系不变。无法识别的二进制任务产物和附件不进入资源画布。受控读取、中央聚焦、失败空态与媒体播放不改变 manifest 真相；编辑成功后只追加新的 asset 或版本子记录。
 
 资源身份固定使用 manifest asset ID、正式 version ID、Agent ID + run ID 或已导入资源稳定路径；显示标题、来源文案变化不得改变 `resourceId`，从而避免布局、依赖边、选择和聚焦状态因改名失效。
 
@@ -533,12 +533,12 @@ type ProjectAgentMudPointAttribution = {
 
 ### 7.5 资源栏目分页无限画布验收
 
-1. 完全空项目继续显示全部栏目的分区展览；任一栏目出现资源后，dependency / type 都切换为固定五栏目分页画布，悬浮 Dock、底部下一页标题和普通 wheel 可访问全部栏目，空栏目也可打开空画布。
-2. 每个 `projectId + dependency|type + document|art|audio|code|version` 组合保留独立 viewport；切换栏目、模式、项目和打开 / 关闭详情后恢复对应平移与缩放，窗口 resize、媒体测量和资源 extent 变化不得重置用户 viewport。
+1. 完全空项目继续显示四个可见栏目的分区展览；任一可见栏目出现资源后，dependency / type 都切换为固定四栏目分页画布，悬浮 Dock、底部下一页标题和普通 wheel 可访问全部可见栏目，空栏目也可打开空画布；游戏代码栏目和代码卡片不出现。
+2. 每个 `projectId + dependency|type + document|art|audio|version` 组合保留独立 viewport；隐藏代码资源的历史内部坐标和 sidecar 会话状态不被删除或重写，切换栏目、模式、项目和打开 / 关闭详情后恢复对应可见栏目平移与缩放，窗口 resize、媒体测量和资源 extent 变化不得重置用户 viewport。
 3. 当前栏目允许空白拖动无限平移；`Ctrl/Cmd + wheel` 以指针为锚点缩放，显式复位按包含负坐标资源在内的完整 bounds 适配内容。非空状态不显示分区高度、分区内部滚动或分区内容倍率操作。
 4. 资源卡超过 `5px` 阈值后进入拖动，预览和 dependency 线同步移动；成功释放只提交一次 `manuallyPlaced=true` CAS，取消、移出释放、媒体控制点击和未超过阈值均不写布局。
 5. dependency 引导线消费当前栏目的同类型精确引用，并与卡片共享同一 viewport transform；平移、缩放、拖动预览、搜索和 resize 后端点保持对齐，type 模式不渲染引导线。
-6. 栏目分页、viewport 和资源卡拖动只修改工作台会话状态或资源布局 sidecar，不改 manifest、项目 mutation revision、Runtime verification、Agent 权限和预览状态；图片、视频、音频、文档、代码、版本卡片及非模态详情回归全部通过。
+6. 栏目分页、viewport 和资源卡拖动只修改工作台会话状态或资源布局 sidecar，不改 manifest、项目 mutation revision、Runtime verification、Agent 权限和预览状态；图片、SVG、视频、音频、文档、任务产物、Agent 回执、项目版本卡片及非模态详情回归全部通过，游戏代码仅保留内部事实而不进入普通资源画布。
 
 ### 7.6 阶段七完整验收
 
diff --git a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
index 0b558f157..c8b24793d 100644
--- a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
+++ b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
@@ -555,7 +555,7 @@ game-project/
 - 阶段三的聚类已落在 `reconcileResourceCanvasLayout` 的 dependency 自动坐标派生步骤。它先按资源分类过滤 reference edge，并把 task-flow 按固定分类切成仅在同类 source / target 同时存在时有效的聚合超边；每个 section 再用精确边与 flow 临时节点建无向邻接表，以迭代遍历生成弱连通组。task-flow 只以“流节点 -> 成员”的线性成员关联参与布局，绝不展开 source × target 资源组合，不绘制 SVG，也不把搜索后的 visible set 用作输入。`dependencyDepth` 仍唯一决定横向业务层级；相关簇按 `minDependencyDepth + minStableResourceId` 排序，孤立集合置于所有相关簇之后，簇间使用单一布局常量留白。每个相关簇内先按稳定资源 ID 建同层初始序，再做固定两轮左至右 / 右至左的中位数扫描：精确引用读取相邻层的上下游 rank，task-flow 读取另一端成员 rank 的中位数，平局按稳定资源 ID 收口。dependency 自动位置使用 `48px` 列间走线区和 `40px` 行间走线区；每个相关簇以最大层行数确定高度，资源较少的层增加确定性半差偏移而在簇内居中，菱形 / 分叉两侧因此保持均衡。type 模式仍使用原 `16px` 行列间距。跨分类 read model 关系不进入前端聚类、边界偏置或拓扑签名，但 Rust 深度与原始图真相不改。显示坐标必须遵守前后端共享的 `0..=1_000_000` 上限；超深依赖在最后合法列确定性饱和，保留原始 `dependencyDepth`，同列资源继续按稳定顺序纵向避让。若任一自动 `x / y` 无法在合法域内落槽，协调必须在 IPC 前失败关闭，不持续提交必然被 Rust 拒绝的坐标。算法保持 `O(V + E)` 图遍历，加固定轮数的层内稳定排序和现有有界占用索引；4096 资源不允许全量配对。旧的 `manuallyPlaced=true` 坐标先占位并原样保留，聚类只派生自动坐标；同类型拓扑身份签名只记录有界的资源 ID 端点 / 成员，以便深度未变但邻接变化时触发重派生。图边、cluster ID 和签名都不写 sidecar。
 - 中间主视窗提供 `resource-overview / asset-canvas / resource-editor / run` 四种状态。2026-08-10 起普通用户“新增资源”显示为禁用态且处理函数拒绝 create；所有现役资源从聚焦态“编辑资源”进入非破坏性派生。静态图片继续进入 refine 素材创作无限画布，SVG、视频、音频、文档/代码、Agent 回执和项目版本进入统一资源编辑壳并按能力分流；底层 create 合同仅保留兼容。编辑面板只替换中央区域，不覆盖右侧 Supervisor 或底部 Agent。`code-prototype` 任务完成前运行入口保持视觉不可用，但仍可点击查看“当前无可运行版本”，不能使用会阻断说明交互的原生 `disabled` 或 `aria-disabled`；完成后才允许进入运行表现层。切回资源总览只修改前端展示态，不伪造后端预览暂停结果。
 - 资源管理从当前 `GameCreationAppManifest`（包含可选 `versions`）、合法 Agent 文本回执、已导入附件和已完成任务明确登记的产物派生资源，固定按文档、项目版本、美术资源、音乐音效资源分区；未知任务产物不再兜底为版本，未完成任务或未在 `artifacts` 中登记的任意本地音频也不冒充正式资源。`按依赖 / 按类型` 使用各自前端排列，dependency 模式额外绘制当前 manifest 与资源投影可证明的依赖关系。排列与图层都不写回 manifest，不能推断或伪造缺失依赖。
-- 资源卡支持点击聚焦、搜索和类型筛选。2026-07-28 起完成两套二维坐标与本地 CAS sidecar；2026-07-31 起 dependency 模式增加不持久化的原生 SVG 关系图层。2026-08-03 mentor 决定暂缓资源总览卡片拖动，当前卡片不挂载 Pointer Down / Move / Up / Cancel 拖动入口，只允许自动布局和点击聚焦。聚焦态替换中央主视窗内容，保留左侧导航、右侧对话和底部 Agent 状态栏，退出后恢复搜索、布局模式、滚动位置与选中资源；不提供通用工具栏、工具侧边栏或可拖动标题栏。阶段四已补齐安全本地文档、扩展美术媒体与音频聚焦，正文独立滚动，视频 / 音频使用内置媒体控件，失败显示空态。2026-08-26 视觉验收修正：资源总览初次适配与复位最多以 `1.5` 倍缩放卡片，避免把低尺寸卡片位图插值放大成糊图；用户主动缩放仍沿用通用画布倍率。美术资源聚焦态改为视口级大预览，保留原始资源读取与元数据，不生成第二份缩略图，图片 / 视频预览按弹窗可用高度展示并允许正文滚动。该资源总览边界不限制后续素材创作无限画布内的图片图层移动/缩放、生成和正式回写。
+- 资源卡支持点击聚焦、搜索和类型筛选。2026-07-28 起完成两套二维坐标与本地 CAS sidecar；2026-07-31 起 dependency 模式增加不持久化的原生 SVG 关系图层。2026-08-03 mentor 决定暂缓资源总览卡片拖动，当前卡片不挂载 Pointer Down / Move / Up / Cancel 拖动入口，只允许自动布局和点击聚焦。聚焦态替换中央主视窗内容，保留左侧导航、右侧对话和底部 Agent 状态栏，退出后恢复搜索、布局模式、滚动位置与选中资源；不提供通用工具栏、工具侧边栏或可拖动标题栏。阶段四已补齐安全本地文档、扩展美术媒体与音频聚焦，正文独立滚动，视频 / 音频使用内置媒体控件，失败显示空态。2026-08-30 视觉验收修正：资源总览所有栏目初次适配与复位最多以 `1.5` 倍缩放卡片，避免单个低尺寸卡片被插值放大成糊图；用户主动缩放仍沿用通用画布倍率，并按“排序模式 + 栏目”保留当前会话内的平移和缩放。美术资源聚焦态改为视口级大预览，保留原始资源读取与元数据，不生成第二份缩略图，图片 / 视频预览按弹窗可用高度展示并允许正文滚动。该资源总览边界不限制后续素材创作无限画布内的图片图层移动/缩放、生成和正式回写。
 - 运行表现层首版直接嵌入当前项目的 loopback 游戏画面，并保留素材信息和数值微调面板；两个面板保持原有 `156px` 最小高度，没有真实数据时只让正文为空，不渲染预设字段、默认数值、未载入控件或自然语言功能占位，也不随空内容收缩。`preview.start` 启动本地 server 后把真实 URL 回写工作台，`preview.open` 只激活客户端内运行视图，不再调用系统浏览器；参数调整首版仍只保留本地 UI 草稿，不修改代码或 manifest。preview server 对 UTF-8 HTML 响应注入固定同源尺寸桥脚本；注入点通过真实 HTML tokenizer 边界定位，保守处理注释异常结束、DOCTYPE 引号、script escaped / double-escaped、raw-text、template、plaintext、foreign content 与重复 `src`，并支持省略 `</body>` / `</html>`。桥以 `ResizeObserver` 观察 `documentElement / body` 根布局，结合页面 load、窗口 resize 与字体就绪重新测量；页面可见时另以 `500ms` 低频兜底探测至多 `512` 个元素的实际边界，探测截断时保留 body / scroll 上界，并按连续测量排除随 viewport 同步变化的 `100vh / 100% / bottom / right` 自反馈。相同尺寸元组去重后才以固定版本 `postMessage` 上报，不订阅整页 `MutationObserver`。宿主同时校验消息 origin 和 `event.source`，以实际内容宽高与当前容器宽高计算不超过 `1` 的等比缩放；首次适配后仍接受内容宽高的真实变化，但仅 viewport 回灌或重复内容尺寸不更新 React 状态。容器 resize 后回到原生视口重新测量；放得下时保持 `1:1`，超出时完整缩小并居中，iframe 禁止横纵滚动条，不能以 `overflow: hidden` 直接裁掉超出内容。非 UTF-8 HTML 原样返回，不因适配桥破坏已有预览。
 - 右侧继续复用现有 Project Supervisor 会话、Runtime 澄清和确认链路；输入区展示 `严格审批 / 风险审批 / 无需审批` 独立面板。P0 只有严格审批可选；风险审批和无需审批保持视觉不可用但允许点击查看原因，不替代 Runtime 的逐动作权限、确认、sandbox 或 reconciliation 门禁。风险 Rank 算法记录在 `docs/project-memory/todos/【待解决】AI游戏创作高风险审批Rank-2026-07-20.md`，前端不得自行计算。
 - 底部状态栏默认展示策划、美术、程序 3 组，并允许在同一栏展开数值、音频、发布组；状态来自 manifest 与当前 Supervisor run 的 Runtime，悬停显示当前任务与进度。累计泥点必须等待后端计费归因投影；Agent.md 编辑和自定义 Skill 在来源审核、版本、权限、sandbox 与回滚合同完备前不向普通用户开放。

From aa0e0ce5fa0ef538a4fff8c0d21f8a576e5b90cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AD=94=E4=BB=A4=E5=BC=98?= <ink29535@proton.me>
Date: Mon, 31 Aug 2026 14:37:16 +0800
Subject: [PATCH 2/8] =?UTF-8?q?=E6=89=B9=E5=87=86=20GDD=20=E5=9B=9E?=
 =?UTF-8?q?=E5=A1=AB=E5=81=9A=E6=B8=B8=E6=88=8F=E5=85=A5=E5=8F=A3=20(#210)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

新增批准态 GDD 的做成游戏按钮与 Launcher 回调链

读取 game/fast_gdd.md 并回首页预填做游戏参考附件

补充不触发创建项目和 Runtime 的 appSurface 回归

同步 Fast GDD 技术方案与共享决策记录

Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/210
Co-authored-by: 孔令弘 <ink29535@proton.me>
Co-committed-by: 孔令弘 <ink29535@proton.me>
---
 apps/ai-game-creator-shell/src/App.tsx        |  18 ++
 .../features/app-shell/WorkspaceLauncher.tsx  |   2 +
 .../src/features/app-shell/model.ts           |   1 +
 .../app-shell/useHomeProjectCreation.ts       |  68 ++++++
 .../project-workspace/GddApprovalCard.tsx     |  34 +++
 .../ProjectSupervisorView.tsx                 |   3 +
 .../ProjectWorkspaceChatPane.tsx              |   3 +
 .../tests/appSurface/home.suite.ts            | 101 ++++++++
 .../tests/appSurface/plan-gdd.suite.ts        |  22 ++
 .../shared-memory/decision-log.md             |   8 +
 ...方案】立项策划Agent（Fast GDD）-2026-08-10.md |  15 +-
 ...irectProject未消费用户上传权威文档-2026-08-30.md | 216 ++++++++++++++++++
 12 files changed, 484 insertions(+), 7 deletions(-)
 create mode 100644 docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md

diff --git a/apps/ai-game-creator-shell/src/App.tsx b/apps/ai-game-creator-shell/src/App.tsx
index e265d1e82..903debb7d 100644
--- a/apps/ai-game-creator-shell/src/App.tsx
+++ b/apps/ai-game-creator-shell/src/App.tsx
@@ -419,6 +419,7 @@ type AppProps = {
     summaries: ProjectAgentRuntimeSummary[],
   ) => void;
   onAgentResultsChange?: (results: ProjectAgentResultSummary[]) => void;
+  onMakeGameFromApprovedGdd?: (projectPath: string) => Promise<void>;
 };
 
 export function App({
@@ -437,6 +438,7 @@ export function App({
   onPreviewChange,
   onAgentRuntimeSummariesChange,
   onAgentResultsChange,
+  onMakeGameFromApprovedGdd,
 }: AppProps = {}) {
   const { setTitle: setWindowTitle } = useWindowChrome();
   // 做方案入口独立成链：立项策划需要委派、澄清 pending 与 GDD 审批，这些只存在于
@@ -10915,6 +10917,14 @@ export function App({
         planGddError={planGddError}
         onPlanGddRefresh={() => void hydratePlanGddState()}
         onPlanGddDecision={decidePlanGdd}
+        onMakeGameFromApprovedGdd={
+          onMakeGameFromApprovedGdd
+            ? () =>
+                onMakeGameFromApprovedGdd(
+                  localProject?.projectPath ?? projectPath,
+                )
+            : undefined
+        }
         runtime={projectSupervisorRuntime}
         error={projectSupervisorRuntimeError}
         runtimeByAgentId={agentRuntimeById}
@@ -11013,6 +11023,14 @@ export function App({
         planGddError={planGddError}
         onPlanGddRefresh={() => void hydratePlanGddState()}
         onPlanGddDecision={decidePlanGdd}
+        onMakeGameFromApprovedGdd={
+          onMakeGameFromApprovedGdd
+            ? () =>
+                onMakeGameFromApprovedGdd(
+                  localProject?.projectPath ?? projectPath,
+                )
+            : undefined
+        }
         queueAgentRunControlFromPanel={queueAgentRunControlFromPanel}
         queueOrExecuteProjectIndex={queueOrExecuteProjectIndex}
         queuePendingCommand={queuePendingCommand}
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx b/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
index 6d63481a4..501eca0b1 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
+++ b/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
@@ -77,6 +77,7 @@ export function WorkspaceLauncherShell({
     activeProjectAgentResults,
     setAgentResults: setActiveProjectAgentResults,
     resetLauncherHomeDraft,
+    startGameFromApprovedGdd,
     createHomeDraftAutomatically,
     openProject,
   } = homeProject;
@@ -351,6 +352,7 @@ export function WorkspaceLauncherShell({
                   setActiveProjectAgentRuntimeSummaries
                 }
                 onAgentResultsChange={setActiveProjectAgentResults}
+                onMakeGameFromApprovedGdd={startGameFromApprovedGdd}
               />
             }
           />
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/model.ts b/apps/ai-game-creator-shell/src/features/app-shell/model.ts
index f87101410..eb8aa9f07 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/model.ts
+++ b/apps/ai-game-creator-shell/src/features/app-shell/model.ts
@@ -50,6 +50,7 @@ export type ProjectSupervisorComponentProps = {
     summaries: ProjectAgentRuntimeSummary[],
   ) => void;
   onAgentResultsChange?: (results: ProjectAgentResultSummary[]) => void;
+  onMakeGameFromApprovedGdd?: (projectPath: string) => Promise<void>;
 };
 
 export type WorkspaceLauncherShellProps = WorkspaceLauncherProps & {
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts b/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts
index b5f9e13cd..366ddbf6f 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts
+++ b/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts
@@ -19,6 +19,7 @@ import type {
   LauncherProjectContext,
   LocalGameProjectRevisionStatus,
   LocalProjectDirectoryStatus,
+  LocalProjectFileResult,
   PendingNonEmptyProject,
   ProjectStartMode,
   TauriInvoke,
@@ -48,6 +49,27 @@ type UseHomeProjectCreationOptions = {
   rememberRecentWorkspace: (projectPath: string) => void;
 };
 
+const APPROVED_GDD_BUILD_PROMPT = [
+  '请按照附件中的已批准 GDD 开始建造这款游戏。',
+  '',
+  '这份 GDD 已覆盖游戏定位与一句话概念、类型与美术方向、游戏支柱、核心循环、目标用户、平台与输入事实、MVP 系统、暂不纳入范围、创作者提示和原型验证项。',
+  '',
+  '请先阅读并理解附件中的 fast_gdd.md，以它作为本次建造的主要依据，优先实现其中 MVP 范围内的可运行游戏原型。',
+].join('\n');
+
+function createTextAttachmentFile(content: string) {
+  const file = new File([content], 'fast_gdd.md', {
+    type: 'text/markdown',
+    lastModified: Date.now(),
+  });
+  if (typeof file.arrayBuffer !== 'function') {
+    Object.defineProperty(file, 'arrayBuffer', {
+      value: async () => new TextEncoder().encode(content).buffer,
+    });
+  }
+  return file;
+}
+
 export function useHomeProjectCreation({
   setStatus,
   setLauncherView,
@@ -77,6 +99,7 @@ export function useHomeProjectCreation({
   const resetLauncherHomeDraft = useLauncherHomeDraftStore(
     (state) => state.reset,
   );
+  const approvedGddStartInFlightRef = useRef(false);
 
   function validateProjectPath(nextProjectPath: string) {
     const trimmedProjectPath = nextProjectPath.trim();
@@ -91,6 +114,50 @@ export function useHomeProjectCreation({
     return trimmedProjectPath;
   }
 
+  async function startGameFromApprovedGdd(nextProjectPath: string) {
+    if (approvedGddStartInFlightRef.current) {
+      return;
+    }
+    approvedGddStartInFlightRef.current = true;
+    const invoke = resolveTauriInvoke();
+    try {
+      if (!invoke) {
+        throw new Error('需要在陶泥儿客户端内运行');
+      }
+      const projectPath = nextProjectPath.trim();
+      if (!projectPath) {
+        throw new Error('当前项目路径无效');
+      }
+
+      setStatus('正在读取已批准 GDD');
+      const result = await invoke<LocalProjectFileResult>(
+        'read_local_project_file',
+        {
+          projectPath,
+          relativePath: 'game/fast_gdd.md',
+          commandId: 'file.read',
+        },
+      );
+      const file = createTextAttachmentFile(result.content);
+
+      await createHomeDraftAutomatically(
+        {
+          creationType: 'game',
+          prompt: APPROVED_GDD_BUILD_PROMPT,
+          attachments: [
+            {
+              id: `approved-gdd-${Date.now().toString(36)}`,
+              file,
+            },
+          ],
+        },
+        'direct-build',
+      );
+    } finally {
+      approvedGddStartInFlightRef.current = false;
+    }
+  }
+
   function enterProjectDevelopment(context: LauncherProjectContext) {
     setCurrentProjectContext(context);
     setActiveProjectPreview(context.manifest.preview ?? null);
@@ -600,6 +667,7 @@ export function useHomeProjectCreation({
     projectBusy: projectAction !== null,
     pendingNonEmptyProject,
     resetLauncherHomeDraft,
+    startGameFromApprovedGdd,
     createHomeDraft,
     createHomeDraftAutomatically,
     openProject,
diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/GddApprovalCard.tsx b/apps/ai-game-creator-shell/src/features/project-workspace/GddApprovalCard.tsx
index 628f6f517..5a470dd39 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/GddApprovalCard.tsx
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/GddApprovalCard.tsx
@@ -42,6 +42,7 @@ type GddApprovalCardProps = {
     action: PlanGddDecisionAction,
     comment: string | null,
   ) => Promise<void>;
+  onMakeGame?: () => Promise<void>;
 };
 
 const stateLabels: Record<PlanGddStateViewV1['state'], string> = {
@@ -82,6 +83,7 @@ export function PlanGddSurface({
   error,
   onRefresh,
   onDecision,
+  onMakeGame,
 }: GddApprovalCardProps & { active?: boolean; projectPath: string }) {
   const showProgress = stageProgressVisible(state, active);
   const showCard = approvalCardVisible(state);
@@ -98,6 +100,7 @@ export function PlanGddSurface({
           state={state}
           active={active}
           projectPath={projectPath}
+          onMakeGame={onMakeGame}
         />
       ) : null}
       {showCard ? (
@@ -118,14 +121,18 @@ export function PlanGddStageProgress({
   state,
   active = false,
   projectPath = '',
+  onMakeGame,
 }: {
   state: PlanGddStateViewV1 | null;
   active?: boolean;
   projectPath?: string;
+  onMakeGame?: () => Promise<void>;
 }) {
   const [detailsOpen, setDetailsOpen] = useState(false);
   const [openError, setOpenError] = useState('');
   const [opening, setOpening] = useState(false);
+  const [makingGame, setMakingGame] = useState(false);
+  const [makeGameError, setMakeGameError] = useState('');
   if (!state || !stageProgressVisible(state, active)) {
     return null;
   }
@@ -198,6 +205,25 @@ export function PlanGddStageProgress({
             >
               {opening ? '正在打开' : '打开文件'}
             </button>
+            {onMakeGame ? (
+              <button
+                type="button"
+                disabled={opening || makingGame || !projectPath.trim()}
+                onClick={() => {
+                  setMakeGameError('');
+                  setMakingGame(true);
+                  void onMakeGame()
+                    .catch((error: unknown) =>
+                      setMakeGameError(
+                        error instanceof Error ? error.message : String(error),
+                      ),
+                    )
+                    .finally(() => setMakingGame(false));
+                }}
+              >
+                {makingGame ? '正在启动' : '做成游戏'}
+              </button>
+            ) : null}
           </div>
           {openError ? (
             <small
@@ -207,6 +233,14 @@ export function PlanGddStageProgress({
               {openError}
             </small>
           ) : null}
+          {makeGameError ? (
+            <small
+              className="plan-gdd-stage-progress__delivery-error"
+              role="alert"
+            >
+              {makeGameError}
+            </small>
+          ) : null}
         </div>
       ) : null}
       {detailsOpen && deliveredGdd ? (
diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/ProjectSupervisorView.tsx b/apps/ai-game-creator-shell/src/features/project-workspace/ProjectSupervisorView.tsx
index 1e22942f0..dba7534dc 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/ProjectSupervisorView.tsx
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/ProjectSupervisorView.tsx
@@ -68,6 +68,7 @@ type ProjectSupervisorViewProps = RuntimePanelProps & {
     action: PlanGddDecisionAction,
     comment: string | null,
   ) => Promise<void>;
+  onMakeGameFromApprovedGdd?: () => Promise<void>;
 };
 
 export function ProjectSupervisorView({
@@ -99,6 +100,7 @@ export function ProjectSupervisorView({
   planGddError,
   onPlanGddRefresh,
   onPlanGddDecision,
+  onMakeGameFromApprovedGdd,
   ...runtimePanelProps
 }: ProjectSupervisorViewProps) {
   const submitLabel = needsUserInput
@@ -121,6 +123,7 @@ export function ProjectSupervisorView({
           error={planGddError}
           onRefresh={onPlanGddRefresh}
           onDecision={onPlanGddDecision}
+          onMakeGame={onMakeGameFromApprovedGdd}
         />
         <div
           ref={messagesRef}
diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx b/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx
index f06471eb9..126e08dc3 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx
@@ -189,6 +189,7 @@ type ProjectWorkspaceChatPaneProps = {
     action: PlanGddDecisionAction,
     comment: string | null,
   ) => Promise<void>;
+  onMakeGameFromApprovedGdd?: () => Promise<void>;
   queueAgentRunControlFromPanel: (action: 'kill' | 'retry' | 'resume') => void;
   queueOrExecuteProjectIndex: () => Promise<void>;
   queuePendingCommand: (command: PendingCommand) => void;
@@ -278,6 +279,7 @@ export function ProjectWorkspaceChatPane({
   planGddError,
   onPlanGddRefresh,
   onPlanGddDecision,
+  onMakeGameFromApprovedGdd,
   queueAgentRunControlFromPanel,
   queueOrExecuteProjectIndex,
   queuePendingCommand,
@@ -376,6 +378,7 @@ export function ProjectWorkspaceChatPane({
           error={planGddError}
           onRefresh={onPlanGddRefresh}
           onDecision={onPlanGddDecision}
+          onMakeGame={onMakeGameFromApprovedGdd}
         />
         <div className="chat-quick-actions" aria-label="预览快捷操作">
           <button
diff --git a/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
index 6ab9c7a13..520ff4666 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
@@ -1,6 +1,8 @@
 import { PROJECT_SUPERVISOR_PLAN_SOURCE } from '../../src/app/constants';
 import type { ProjectSupervisorComponentProps } from '../../src/features/app-shell/model';
+import { useHomeProjectCreation } from '../../src/features/app-shell/useHomeProjectCreation';
 import { WorkspaceLauncherShell } from '../../src/features/app-shell/WorkspaceLauncher';
+import type { LauncherView } from '../../src/view/layout';
 import {
   act,
   agentRuntimeUserInputRequest,
@@ -27,6 +29,38 @@ import {
   within,
 } from './harness';
 
+function ApprovedGddStartHarness() {
+  const [, setLauncherView] = React.useState<LauncherView>(
+    'project-development',
+  );
+  const [, setStatus] = React.useState('');
+  const [, setAgentChatProjectPath] = React.useState('');
+  const controller = useHomeProjectCreation({
+    setStatus,
+    setLauncherView,
+    setAgentChatProjectPath,
+    rememberRecentWorkspace: () => undefined,
+  });
+
+  if (controller.currentProjectContext) {
+    return React.createElement(
+      'p',
+      { 'aria-label': '已进入自动游戏项目' },
+      controller.currentProjectContext.initialPrompt,
+    );
+  }
+
+  return React.createElement(
+    'button',
+    {
+      type: 'button',
+      onClick: () =>
+        void controller.startGameFromApprovedGdd('/tmp/planning-project'),
+    },
+    '直接用已批准 GDD 开始建造',
+  );
+}
+
 export function registerClientHomeTests() {
   it('anchors the empty home input placeholder to the editor while the page scrolls', () => {
     renderLauncherAt('/?launcher');
@@ -1502,6 +1536,73 @@ export function registerHomeProjectCreationTests() {
     );
   });
 
+  it('starts an automatic game project from the approved GDD', async () => {
+    const automaticProjectPath = '/tmp/approved-gdd-game';
+    const manifest = createGameCreationAppManifest(
+      'approved-gdd-game',
+      '已批准 GDD 游戏',
+    );
+    const gddContent = '# Fast GDD\n\n批准后的方案内容';
+    const invoke = vi.fn(async (command: string) => {
+      if (command === 'read_local_project_file') {
+        return {
+          path: 'game/fast_gdd.md',
+          absolutePath: '/tmp/planning-project/game/fast_gdd.md',
+          content: gddContent,
+        };
+      }
+      if (command === 'create_automatic_local_game_project') {
+        return {
+          projectPath: automaticProjectPath,
+          manifestPath: `${automaticProjectPath}/.agent/manifest.json`,
+          manifest,
+        };
+      }
+      if (command === 'upload_local_asset') {
+        return {
+          id: 'approved-gdd-asset',
+          localPath: 'assets/uploads/fast_gdd.md',
+          absolutePath: `${automaticProjectPath}/assets/uploads/fast_gdd.md`,
+          manifestPath: `${automaticProjectPath}/.agent/manifest.json`,
+        };
+      }
+      throw new Error(`unexpected invoke ${command}`);
+    });
+    window.__TAURI__ = { core: { invoke } };
+    render(React.createElement(ApprovedGddStartHarness));
+
+    fireEvent.click(
+      screen.getByRole('button', { name: '直接用已批准 GDD 开始建造' }),
+    );
+    fireEvent.click(
+      screen.getByRole('button', { name: '直接用已批准 GDD 开始建造' }),
+    );
+
+    await waitFor(() => {
+      expect(
+        invoke.mock.calls.filter(
+          ([command]) => command === 'create_automatic_local_game_project',
+        ),
+      ).toHaveLength(1);
+    });
+    expect(screen.getByLabelText('已进入自动游戏项目').textContent).toContain(
+      '请按照附件中的已批准 GDD 开始建造这款游戏。',
+    );
+    expect(invoke).toHaveBeenCalledWith('read_local_project_file', {
+      projectPath: '/tmp/planning-project',
+      relativePath: 'game/fast_gdd.md',
+      commandId: 'file.read',
+    });
+    await waitFor(() => {
+      expect(invoke).toHaveBeenCalledWith('upload_local_asset', {
+        projectPath: automaticProjectPath,
+        fileName: 'fast_gdd.md',
+        mediaType: 'text/markdown',
+        bytes: Array.from(new TextEncoder().encode(gddContent)),
+      });
+    });
+  });
+
   it('keeps the home composer out of chat mode while automatic project creation is pending', async () => {
     let rejectAutomaticProject: ((error: Error) => void) | null = null;
     const automaticProject = new Promise<never>((_resolve, reject) => {
diff --git a/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts
index 6a4ca9104..1960bd5cd 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts
@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
+import { PlanGddStageProgress } from '../../src/features/project-workspace/GddApprovalCard';
 import {
   agentRuntimeUserInputRequest,
   createPlanGddStateView,
@@ -9,8 +10,11 @@ import {
   fireEvent,
   it,
   openMainProject,
+  React,
+  render,
   renderAppAt,
   screen,
+  vi,
   waitFor,
   within,
 } from './harness';
@@ -382,6 +386,24 @@ export function registerPlanGddApprovalTests() {
     expect(args).toEqual({ projectPath: harness.projectPath });
   });
 
+  it('offers to make an approved GDD into a game reference on the home entry', async () => {
+    const onMakeGame = vi.fn(async () => undefined);
+    render(
+      React.createElement(PlanGddStageProgress, {
+        state: approvedPlanGddState(),
+        active: true,
+        projectPath: '/tmp/approved-gdd-project',
+        onMakeGame,
+      }),
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: '做成游戏' }));
+
+    await waitFor(() => {
+      expect(onMakeGame).toHaveBeenCalledTimes(1);
+    });
+  });
+
   it('keeps the delivery row hidden while the approval projection is still recovering', async () => {
     // 恢复态下权威投影还没收敛，磁盘上那份 Markdown 未必是用户批的那版。此时给出口
     // 等于让用户读一份可能已经失效的交付物。
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index d2918098b..5e0ee27db 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -15,6 +15,14 @@
 - 关联文档：相关 PRD、技术文档、提交或 Issue
 ```
 
+## 2026-08-30 批准 GDD 直接进入做游戏链路
+
+- 背景：立项策划 GDD 批准后需要给用户一个进入做游戏的自然出口，产品决策改为点击按钮后直接开始建造。
+- 决策：批准态 GDD 交付行提供“做成游戏”按钮。点击后读取当前项目的权威 `game/fast_gdd.md`，直接创建自动游戏工作区、导入 `text/markdown` 参考附件，并以固定建造指令自动启动 Direct Codex；不再回首页等待用户二次提交。该动作不复制原项目的 `approvedGddRef`、planning sidecar 或 approval receipt。
+- 影响范围：AGC 前端 GDD 交付行与现有自动建项/附件导入/Direct Codex 链路；移除首页 RichInputArea 的 GDD 一次性预填链路；不新增 HTTP API、SpacetimeDB schema、迁移、OpenAPI 或正式构建绑定。
+- 验证方式：批准态按钮直接创建工作区、导入附件、携带固定首条指令进入项目工作台且重复点击不重复创建的 appSurface 回归；类型检查、编码检查和 `git diff --check` 通过。
+- 关联文档：`docs/technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md`。
+
 ---
 
 ## 2026-08-26 运行中自主扩图提案留在编排层
diff --git a/docs/technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md b/docs/technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md
index b48a05c30..02b245051 100644
--- a/docs/technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md	
+++ b/docs/technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md	
@@ -3,7 +3,7 @@
 - 日期：2026-08-10
 - 适用范围：AI 游戏创作独立 App、Project Supervisor、Agent Runtime、本地项目策划 sidecar 与后续完整构建准入
 
-> 当前口径（2026-08-25）：以本文件中标注的 D11 / 最新修订和当前 `apps/ai-game-creator-shell` 实现为准。D6～D9 等被明确标注为作废或被取代的段落仅保留推导背景，不得作为现行拓扑、入口或 Runtime 真相；产品入口与 DirectProject 总体口径见 `docs/README.md` 和 App 实施计划。
+> 当前口径（2026-08-30）：以本文件中标注的 D11 / 最新修订和当前 `apps/ai-game-creator-shell` 实现为准。D6～D9 等被明确标注为作废或被取代的段落仅保留推导背景，不得作为现行拓扑、入口或 Runtime 真相；产品入口与 DirectProject 总体口径见 `docs/README.md` 和 App 实施计划。
 
 ## 1. 背景与目标
 
@@ -180,7 +180,7 @@ D9/D10 描述的「manifest ready-task 调度器在 Supervisor 下游启动策
 | 构建引用 | `approvedGddRef {gddId, version, fingerprint}` |
 | 现有 design 组 UI 名 | `设计实现组`，替代原“策划 Agent”卡片名称 |
 | 新组件名 | `GDD 审批卡` |
-| 固定入口动作 | `直接开建`、`开始完整制作`、`批准并开建` |
+| 固定入口动作 | 当前客户端为 `做成游戏`：读取 `game/fast_gdd.md`，直接创建自动游戏工作区、导入参考附件并以固定建造指令启动 Direct Codex；不再回首页等待用户二次提交 |
 
 `approvalRequestId` 与 `responseId` 是两个不同的持久 ID：前者由 Runtime 在 GDD 提交前生成、进入不可变 GDD，一张审批卡终身不变；后者由 UI 在用户执行一次决定时生成，并在传输重试中复用。不得继续用含义不明的单个 `requestId` 同时承担两种职责。
 
@@ -278,7 +278,7 @@ flowchart TD
     SPLAN -->|"在自己的 runtime/session 上建 pending，向用户提问"| U
     SPLAN -->|"answersSha256 绑回 delivery，再发 continuation 委派<br/>（最多 3 轮，受 clarification_round 上限约束，见第 23.5 节）"| PLANAGENT
     PLANAGENT --> GDD["不可变 GDD + approve receipt"]
-    GDD -->|"用户动作：开始完整制作"| BUILD
+    GDD -->|"用户动作：做成游戏；读取并导入 game/fast_gdd.md"| BUILD["自动创建游戏工作区<br/>参考附件：fast_gdd.md<br/>固定建造指令"]
     U -.->|"直接开建"| BUILD
     BUILD --> DAG["现行 16 任务 DAG"]
     U --> CHAT
@@ -1517,7 +1517,8 @@ type PlanningBaselineInput =
 - 仅首页“做方案”新建项目提交 `standard + project-supervisor-plan`（2026-08-13 按 D11 更正，旧值 `project-supervisor-plan-chat` 作废）；“做游戏”和“做素材”保持 `autonomous-game-build` 直接开建。前端只提交 Supervisor 根 run 的身份，**不提交也不感知策划子 Agent**——后者由 Supervisor 在服务端通过 `agent.delegate` 派生，页面侧不得直接创建或引用它。
 - 项目页新建、打开既有项目和 Godot 导入不新增“进入立项策划”入口，保持现行构建/打开语义；只有已存在 planning sidecar 或 active plan lineage 的项目恢复原有策划链路。
 - 策划阶段聊天输入属于当前 run：有活跃决策卡/审批卡时，输入回到该卡片对应 action；无 active run 时才可创建新的 plan continuation。
-- approved 后显示“开始完整制作”；“批准并开建”只是先审批、后开建的快捷交互，不合并后端命令或 durable 记录。
+- approved 后显示“做成游戏”。点击后读取当前有效的 `game/fast_gdd.md`，直接沿现有自动做游戏链路创建新的工作区、导入 `text/markdown` 参考附件，并以固定建造指令作为 `initialSupervisorMessage` 自动启动 Direct Codex；固定指令只说明 GDD 覆盖的栏目，不根据具体 GDD 内容生成总结。该动作不回首页等待二次提交，不把原项目的 `approvedGddRef` 复制到新项目。
+- 用户仍可在项目工作台继续补充需求；普通首页“做游戏”入口的手动提交行为保持不变。
 
 ### 18.2 GDD 审批卡
 
@@ -1529,7 +1530,7 @@ type PlanningBaselineInput =
 - command 进行中禁用重复点击；另一个窗口先决定后，当前卡刷新为 `already-decided`，不能覆盖。
 - `recoveryPending=true` 时显示可恢复状态，只允许重试同一 ID，不允许提交新版本或启动构建。
 - 待审版本的 receipt 已存在时隐藏对应 stale pending 卡；hydrate 只恢复精确 project/session/run/action identity。
-- approved 后只在所有必需投影恢复完成时启用完整构建按钮。
+- approved 后只有在所有必需投影恢复完成时启用“做成游戏”；恢复态不提供该出口。
 
 决策卡继续复用现有用户输入卡，不新建平行提问系统。现有完整构建 design 组用户名称改为“设计实现组”，与新阶段“立项策划”区分；内部 Agent ID 不改。
 
@@ -1703,7 +1704,7 @@ receipt 永远压过 stale pending：一旦该版本存在有效 receipt，pendi
 | agent.db | 专用幂等 helper；same key conflict；日志达到普通容量、尾部截断与压缩后仍能补齐并保留决定记录 |
 | source/security | durable exact identity；三个 action tool（`file.read` / `file.list` / `plan.submit_gdd`）广告与执行；MCP 空且 webSearchEnabled=false；control functions 单列；tool-plan/batch/ledger/context/repair/completion 全部跳过 collaboration；plan retry 保留 source/profile；除 Runtime-owned submit 外的副作用工具拒绝 |
 | Prompt | **2026-08-13 按 D11 改写**：不新增 composition，Supervisor 根 run 沿用现役 supervisor composition、策划子 Agent 复用 `runtime` composition（见第 4.2 节）；`decision-checkpoint` 请求 kind 随 D10 作废（见第 5.1 节）。仍冻结：3 轮/单题/固定选项；回答后设计解释与 prototype item；平台事实；恢复摘要；direct-out 条件 |
-| frontend | 首页“做方案”目录提交与 Enter 自动创建均为 `standard + project-supervisor-plan`；“做游戏/做素材”均保持 `autonomous-game-build`；项目页新建/打开不首次注入 planning；stable approvalRequestId/responseId；busy；stale card；hydrate strict input/view；无目录空态；receipt 隐藏 stale pending；corrupt authority typed error；project open/reload/resume/submit/decision 刷新；recovery pending；批准并开建两命令顺序 |
+| frontend | 首页“做方案”目录提交与 Enter 自动创建均为 `standard + project-supervisor-plan`；“做游戏/做素材”均保持 `autonomous-game-build`；项目页新建/打开不首次注入 planning；stable approvalRequestId/responseId；busy；stale card；hydrate strict input/view；无目录空态；receipt 隐藏 stale pending；corrupt authority typed error；project open/reload/resume/submit/decision 刷新；recovery pending；批准 GDD 后“做成游戏”直接创建自动工作区、导入 `fast_gdd.md` 并自动启动 Direct Codex；重复点击不重复创建；普通首页链路不回归 |
 | M2 integration | explicit approved/direct mode；锁内重验 receipt；ref 贯穿 task/run/completion/context；无 ref 非回归；恢复不换稿 |
 
 关键强杀点逐项覆盖：
@@ -1994,7 +1995,7 @@ M0 完成不表示完整策划闭环已经上线。`M1A-1`～`M1A-4`、`M1B-1`
 | `M1C-2b` | 澄清中转接线、轮次派生、预算注入 | `M1C-2a` | **实现与本包门禁已完成并已快进合回 `feat/five_min_design`**：首 child 的 revision 1 session、`NeedsUserInput → awaiting_user_input`、回答绑定后 continuation 的确定性 session 投影、审批后 `revise/reject` 用户修订谱系及 Provider 活跃时间 usage fact/fold 已接线；末次 `plan.submit_gdd` usage 在 receipt/session successor 落盘且 standalone/v4 anchors 精确消费后于同一项目锁内折叠，真实 receipt 回归证明累计值恰好推进一次，重复审批与 recovery reconcile 不二次推进。`planning_clarification_*` **13 passed / 0 failed**（M1C-2c 语义回归另见本包），另有 static deliveries 44、planning storage 13、planning submit 53、Provider usage 4、末次 usage receipt 1、barrier detail 3 条定向回归通过；格式、offline all-targets、编码与 diff 门禁通过。锁序承诺只适用于 **M1C-2b 新增的 planning 澄清写投影路径**；`main_loop` 既有通用 completion blocker 的 execution→project 路径不在本包。第 4 轮信封在正常路径不可达：`agent.delegate` 已在工具边界按血缘上限硬拒并返回 failed observation；coordinator 的超三轮 reconciliation 仅用于损坏血缘纵深防御。审批 UI、hydrate、构建准入和下游完整构建不在本包范围 |
 | `M1C-2c` | 决策卡 A/B 语义（第 23.9 节，2026-08-18 实现完成并合回）：选项 → 台账映射改为 A/B 均 `confirmed/user_option`、信封 label 形状校验、planning role brief 与 Supervisor playbook/final-reply 文案（B 必须是真实岔路、第 3 项恒定且 description 须给出可执行验证方式、改口转述规则、提问纪律） | `M1C-2b` | **实现与门禁完成，已由 `6e4bd9703` 合回 `feat/five_min_design`**：Runtime 已实现 A/B/固定第三项校验、B 不再生成 `default_pending`、`answerSummary` 逐字保真；非法 C/缺项 fail-closed，A/B/自由填写回归已通过。`planning_clarification_*` 13、`project_planning` prompt 5、`planning_submit` 定向回归、prompt bundle、格式、编码、diff、offline all-targets 均通过；不含 M1D-1 前端、hydrate、构建准入或下游完整构建 |
 | `M1D-1` | 前端 hydrate 与 GDD 审批卡；决策卡按第 23.9 节实现（label 动态渲染、默认焦点 A、Other 槽不变） | `M1C-2b` | **已完成并合入 `feat/five_min_design`（落地 `0052a80da`，其后 ESLint 修正 `5b11a0530`）**：新增严格 `{projectPath}` hydrate command、`plan-gdd-state-view.v1` Rust read model、审批卡与独立 GDD 正文详情弹层；页面只消费 hydrate，决定 responseId 按审批请求/动作复用，`recoveryPending` 仅提供恢复重试；审批前置 pending 与错绑 session 继续 fail-closed。 |
-| `M1D-2` | 入口分流与阶段进度 | `M1D-1` | **2026-08-19 更正 `bf2185fba` 的错误入口映射**：仅首页“做方案”新项目以 `standard + project-supervisor-plan` 启动；“做游戏/做素材”保持 `autonomous-game-build`，不再展示额外“直接开建”按钮；项目页新建、打开和 Godot 导入不新增策划入口，仅恢复已有 planning lineage。阶段进度显示轮次 x/3、当前版本和状态徽章；实际项目总控页面挂载 hydrate/审批卡，并将 `project-planning` / 设计组展示名收口。未接 M2 approved-GDD 构建绑定或完整构建按钮。 |
+| `M1D-2` | 入口分流与阶段进度 | `M1D-1` | **2026-08-19 更正 `bf2185fba` 的错误入口映射**：仅首页“做方案”新项目以 `standard + project-supervisor-plan` 启动；“做游戏/做素材”保持 `autonomous-game-build`，不再展示额外“直接开建”按钮；项目页新建、打开和 Godot 导入不新增策划入口，仅恢复已有 planning lineage。阶段进度显示轮次 x/3、当前版本和状态徽章；实际项目总控页面挂载 hydrate/审批卡，并将 `project-planning` / 设计组展示名收口。**2026-08-30 变更：批准 GDD 后的“做成游戏”直接创建自动工作区、导入 `game/fast_gdd.md` 并自动启动 Direct Codex；仍未接入正式 `approvedGddRef` 构建绑定。** |
 | `M1E` | 端到端与故障注入收口 | `M1D-2` | **已完成**：planning 覆盖审计与 submit 拒绝上限收口完成。`PLAN_INVALID_REQUEST` / Provider input 或候选 GDD 的 `PLAN_SIZE_LIMIT` 每 child run 最多 5 次 rejected observation，第 5 次在 observation durable 后终态失败；counter durable，重启不清零。若在第五条 rejected observation 落盘与终态失败之间崩溃，恢复入口会按 durable counter 直接终态失败，不请求第六次 Provider tool-plan。既有不可变 GDD/receipt 的超限读取及 lineage 版本已耗尽均改走 reconciliation，不误耗 Provider 重试额度。第 21 节已存在的三轮、续跑、receipt/replay、投影恢复及 hydrate 回归复核通过；不为“拼接已有单测”新增脆弱大 E2E。 |
 
 **2026-08-18 M1D 审查修复快照**：对 `14c00017c..bf2185fba` 做规格对照审查后，修复三条决定链路缺陷并补齐回归。① `decidePlanGdd` 的失败分支原来不 hydrate，命中后端任一 `PLAN_STALE_APPROVAL` 分支后卡片会停在已失效的 pending 身份上、`recoveryPending` 永不翻真导致「重试恢复」入口不渲染，现已按第 18.3 节在失败分支同样重灌（顺序钉死：`hydratePlanGddState` 入口会清空错误，必须先 hydrate 再写决定错误）。② responseId 复用键原为 `approvalRequestId:action`，不含 comment，违反第 13.2 节「改变 action/comment 必须换新 responseId」，现改为比对 `{action, comment}` 完整意图，判据方向为宁可多换不可少换。③ 第 18.2 节「`recoveryPending` 时不允许提交决定」原来只作用于三个触发按钮，已打开的评论弹层仍可提交，现已同门控并保留用户已输入内容。回归位于 `tests/appSurface/plan-gdd.suite.ts`，三条均经变异验证（逆转对应修复即变红）；`appSurface.test.ts` 381 passed，`agc:typecheck`、ESLint、编码检查通过。其中锁错误回传绝对路径、阶段进度轮次差一格与 design 组展示名收口三条已于同日补修（见 decision-log 同日两条）；仅 hydrate 身份校验与落盘投影修复的顺序一条单列后续，未并入。
diff --git a/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md b/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md
new file mode 100644
index 000000000..4de2f960b
--- /dev/null
+++ b/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md
@@ -0,0 +1,216 @@
+# 【技术说明】DirectProject 未消费用户上传权威文档
+
+- 首次记录：2026-08-30
+- 问题类型：DirectProject 上下文消费缺陷 / 可审计性缺陷
+- 影响范围：用户上传文档并在正文中明确指定其为本次建造依据的“做游戏”链路
+- 当前状态：待排期，本文只用于提 Issue，暂不修复
+
+## 0. Issue 摘要
+
+当用户在正文中明确说明“我上传了一份 GDD，里面包含某些具体内容，请按照这份 GDD 做游戏”时，做游戏 Agent 没有可靠地把该附件当作本轮权威规格来检索、读取和消费。
+
+这不是“上传附件功能失败”：附件已经成功复制到新项目并登记。问题在于，DirectProject 只收到用户正文和项目路径，没有收到“用户上传了哪些附件、附件的真实项目路径、哪个附件被正文指认为权威参考”这类一等上下文；Agent 只能自行猜测并搜索项目文件。
+
+当前实现虽然存在条件性的 native 文件检索路径，但该路径既不是稳定的应用层契约，也没有对应的 Direct 读取审计记录。因此一次 run 结束后无法可靠回答：Agent 是否发现了附件、是否读取了附件、读取结果是否进入了后续设计和代码决策。
+
+## 1. 预期行为
+
+本 Issue 讨论的预期行为有一个重要前提：**不是所有上传文档都自动视为 GDD，也不是所有附件都必须被读取。**
+
+只有当用户在正文或交互中明确表达类似以下意图时，相关文档才应被视为本轮权威参考：
+
+> 我上传了一份 GDD，里面有探测艇、脉冲射击、敌方弹幕、模块选择和棱镜母体，请按照这份 GDD 做游戏。
+
+在这一前提下，Agent 应能够：
+
+1. 知道本轮存在用户上传的参考文档；
+2. 找到该文档在当前项目中的真实路径；
+3. 读取文档内容；
+4. 将文档内容用于后续游戏设计、代码和资源决策；
+5. 在可共享、可复核的审计信息中留下足以判断上述行为是否发生的记录。
+
+用户手写 GDD、通过外部功能生成后导入的 GDD、普通上传的 GDD，以及“做成游戏”入口带入的 GDD，在这里都属于同一个用户意图场景。是否来自“做方案”审批链路不是必要前提。
+
+## 2. 实际现象
+
+在 `gameagent-77b5aa31` 这次 2026-08-30 的 Direct run 中：
+
+- 用户正文明确要求先阅读附件中的 `fast_gdd.md`，并以其作为主要依据；
+- 文件成功复制到新项目：
+
+  ```text
+  assets/uploads/upload-1788083777445-fast_gdd.md
+  ```
+
+- 原策划项目文件与上传副本大小均为 `7944` 字节，SHA-256 一致，说明复制没有损坏；
+- 最终游戏却生成了《星光收集者》：星星收集、荆棘碰撞、左右移动、生命值；
+- 原 GDD 的核心实体和循环（探测艇、脉冲射击、敌人、弹幕、模块、风险岔路、棱镜母体）没有体现在最终游戏中；
+- 最终美术生成 prompt 只有“轻量、明快、暖色纸张质感背景、可爱的主角、可收集物、障碍物和简洁 HUD”等泛化描述；
+- 浏览器验收的 `expectedText` 为空，没有对 GDD 语义做断言。
+
+因此最终产物表现为一个内部自洽、但与用户指定 GDD 不同类型的通用收集类小游戏。
+
+## 3. 代码层证据
+
+### 3.1 附件不进入 Direct turn 的结构化输入
+
+首页正文和附件在前端被分开处理；附件节点不会进入正文 prompt，而是作为单独的附件集合保存。
+
+[richTextToPrompt.tsx](../../apps/ai-game-creator-shell/src/view/home/components/RichInputArea/richTextToPrompt.tsx:21)
+
+进入项目工作台后，`ProjectSupervisor` 只收到项目路径、manifest、初始消息和创作类型，没有附件字段。
+
+[WorkspaceLauncher.tsx](../../apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx:335)
+
+[model.ts](../../apps/ai-game-creator-shell/src/features/app-shell/model.ts:29)
+
+Direct Codex 调用的输入也只有：
+
+```ts
+{
+  projectPath,
+  prompt,
+  clientTurnId,
+  creationType
+}
+```
+
+[App.tsx](../../apps/ai-game-creator-shell/src/App.tsx:5484)
+
+其中没有附件列表、附件路径、附件 hash 或附件正文。
+
+### 3.2 上传后路径被重写，Agent 不会自动得到真实路径
+
+上传实现会把文件写入 `assets/uploads/upload-<timestamp>-<原文件名>`，例如 `fast_gdd.md` 会变成 `upload-...-fast_gdd.md`。
+
+[assets.rs](../../apps/ai-game-creator-shell/src-tauri/src/assets.rs:460)
+
+上传结果会写入项目的 `.agent/manifest.json` 和 `.agent/agent.db`，但这些是项目持久化产物，不是自动注入到 Direct LLM 请求的上下文；`.agent` 还是 Direct 的控制面边界，不能作为普通项目文档让 Agent 读取。
+
+### 3.3 代码中存在条件性的主动检索路径，但不是稳定契约
+
+DirectProject 的 app-server 使用项目根作为 `cwd`，并在可用配置下保留 native shell / 命令能力，因此 Agent 理论上可以：
+
+```text
+搜索 fast_gdd
+→ 找到 assets/uploads/upload-...-fast_gdd.md
+→ 用 native 命令读取正文
+```
+
+[codex_app_server.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs:1482)
+
+[codex_app_server.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs:1160)
+
+但这条路径有三个问题：
+
+- 需要 Agent 自己判断“这份附件值得检索”，应用没有把附件关系告诉它；
+- `agc_list_project_files` 只能返回路径、大小和类型，不返回 Markdown 正文；
+- DirectProject 没有接入旧 Agent Runtime 的 `file.read` / `project.search` 工具目录，读取能力取决于 Direct app-server 的 native 工具配置。
+
+[direct_tools_mcp.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs:214)
+
+[agent_native_tools.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/agent_native_tools.rs:1349)
+
+因此当前代码不能称为“附件已可靠进入 Agent 上下文”，只能称为“Agent 在部分配置下可能自行发现项目文件”。
+
+## 4. 持久化与取证现状
+
+### 4.1 这次 Direct run 没有持久化读取记录
+
+`gameagent-77b5aa31/.agent/agent.db` 共 12 条记录，类型只有：
+
+```text
+project.init                  1
+asset.register                5
+canvas.asset_generate         3
+conversation.message         3
+```
+
+其中没有：
+
+```text
+file.read
+file.list
+project.search
+command.exec
+agent.runtime.tool_observation
+agent.runtime.action_receipt
+```
+
+这能证明上传、资源生成、游戏入口写入和对话消息被记录，但不能证明 Direct app-server 没有执行过 native 文件读取。
+
+### 4.2 Direct app-server 的 native read 不在当前 Agent DB 审计范围内
+
+Direct app-server 使用 ephemeral thread。stdout 中的 `item/started`、`item/completed`、`commandExecution` 等事件只在运行期间被解析成有限的活动状态，再通过 Tauri event 发给前端；当前实现没有把 native 命令、读取路径、读取结果或读取 hash 追加到项目 `agent.db`。
+
+[codex_app_server.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs:883)
+
+[codex_app_server.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs:2496)
+
+相对地，旧 Agent Runtime 的 `file.read` 会写入 `agent.runtime.action_receipt` 和 `agent.runtime.tool_observation`，因此旧路径可以审计到读取了哪个文件。
+
+[main_loop.rs](../../apps/ai-game-creator-shell/src-tauri/src/agent/runtime_driver/main_loop.rs:3347)
+
+这说明问题不是项目完全没有持久化能力，而是 DirectProject 的文件读取路径绕过了现有可审计工具链。
+
+## 5. 问题定性
+
+本 Issue 应定性为：
+
+> 当用户明确把某个上传文档指定为本轮游戏制作的权威参考时，DirectProject 没有可靠地把“用户—附件—当前任务”的关系传给 Agent，也没有让文档发现、读取和后续消费形成可观察的工作流证据。结果是 Agent 可以从泛化的游戏目标出发完成一个可运行产物，却不一定消费用户指定的文档规格。
+
+这属于用户意图和 Agent 上下文消费之间的契约缺失，不属于 GDD 审批状态传递错误，也不属于附件复制损坏。
+
+## 6. 明确排除的归因与修复方向
+
+以下内容不应作为本问题的主要根因，也不应直接作为本 Issue 的修复目标：
+
+### 6.1 不把 `approvedGddRef` / approval receipt 缺失视为根因
+
+用户手写 GDD、外部生成后导入的 GDD、普通文件上传的 GDD，都不一定存在 `approvedGddRef` 或审批 receipt，但只要用户在 prompt 中明确指定“按照这份 GDD 做游戏”，Agent 就应该能够正确消费它。
+
+因此，缺失审批状态绑定不能解释这类通用失败。
+
+### 6.2 不把所有上传文档强制当成 GDD
+
+用户上传的文件可能是图片、素材说明、参考资料、README、代码片段或与游戏无关的文档。不能因为文件被上传，就默认它是策划案或本轮的权威规格。
+
+只有用户明确建立“这份文档用于本轮任务”的关系时，才进入本文讨论的语义范围。
+
+### 6.3 不采用“把所有上传文档正文直接拼进 prompt”作为通用修复
+
+附件可能很大、可能是二进制、可能包含不可信内容，也可能只是可选参考。把所有上传文件正文无条件塞入 prompt 会混淆普通附件、参考资料和权威任务规格，也改变当前附件模型的边界。
+
+本文不要求把上传文件正文统一注入 prompt。
+
+### 6.4 不采用“所有附件必须先读取，否则一律阻断”作为通用硬门禁
+
+对于用户没有要求使用的附件，系统不应强制 Agent 读取；对于非文本附件，也不能套用 Markdown 文本读取规则。
+
+本文关注的是用户明确指定文档为权威参考时的消费缺失，不要求把所有附件都改造成强制读取工作流。
+
+## 7. Issue 验收口径
+
+本问题修复完成后，至少应能验证以下事实，但具体实现方式不在本文展开：
+
+- 用户明确指定某个上传文档为本轮任务依据时，Agent 能够发现并读取对应文档；
+- 用户未指定的普通附件不会被自动当成 GDD 或强制纳入任务；
+- Agent 是否发现、读取以及使用该文档，应能从可共享的 run 审计产物或等价的可审计证据中判断；
+- 同一语义在“做成游戏”、普通上传、外部生成后导入和用户手写文档等入口下不依赖审批 receipt 才成立；
+- 文档被读取后，至少有一种可验证方式能判断其关键内容是否进入了后续任务上下文，而不是只记录了文件存在。
+
+具体修复方案、上下文协议设计和持久化字段设计另行讨论，本 Issue 不预设实现方案。
+
+## 8. 关联产物
+
+- 策划 run ID：`gameagent-cd7f6c81`
+- 做游戏 run ID：`gameagent-77b5aa31`
+- 上传 GDD（项目相对路径）：`assets/uploads/upload-1788083777445-fast_gdd.md`
+- 建议随 Issue 附上或引用对应 run 的以下复核材料：
+  - Direct 对话：`.agent/conversations/project.jsonl`
+  - Direct Agent DB：`.agent/agent.db`
+  - Direct manifest：`.agent/manifest.json`
+  - 最终游戏：`game/index.html`
+  - 浏览器验证：`.agent/runtime/direct-codex-browser-validation/6/attempt-3/validation.json`
+
+上述材料应以 Issue 附件、仓库归档或团队共享存储的形式提供；本文不依赖某位开发者电脑上的绝对路径。

From 80b8238d0a9fc77ba80808ae46abc8a3474743ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=91=A3=E7=BE=BD=E7=A7=A6?= <suzmii@qq.com>
Date: Mon, 31 Aug 2026 14:37:34 +0800
Subject: [PATCH 3/8] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=20AGC=20Windows=20ACL=20?=
 =?UTF-8?q?=E6=8F=90=E6=9D=83=E4=B8=8E=E6=96=87=E4=BB=B6=E8=AE=BF=E9=97=AE?=
 =?UTF-8?q?=E8=BE=B9=E7=95=8C=20(#211)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### 背景

Windows 下 AGC 读取配置目录、项目文件和本地资源时，可能先于 ACL 校验阶段就因继承权限、错误 owner 或拒绝访问而失败，表现为 `拒绝访问。 (os error 5)`。

此前自定义 `--config-dir` 场景还存在 scope 无法传递到提权子进程的问题；native picker 路径也缺少进程内来源证明，递归索引可能跟随 junction/reparse point，新建文件在权限加固失败时可能留下残留文件。

### 本次变更

1. 修复自定义 `--config-dir` 的 `managed / user-selected` scope 传递与提权票据校验。
2. 增加 native picker 文件/目录路径的短期 provenance 授权；未经过 picker 授权的任意 IPC 绝对路径不能触发 `user-selected` 自动提权。
3. 项目文件列表和索引递归改用 `symlink_metadata()`，拒绝 symlink、junction 和 Windows reparse point。
4. 统一在 metadata/read/open 前完成 ACL 准备，对 ACL 导致的 metadata 失败执行一次受控修复和重试。
5. 新建 conversation、导出包、Agent DB、资源、字体等文件在 harden 失败时关闭句柄并清理刚创建的文件。
6. 修复 UAC 提权授权票据以 `share_mode(0)` 独占打开后与 `GetNamedSecurityInfoW/SetNamedSecurityInfoW` 产生共享冲突的问题。
7. 同步 AGC Windows ACL 技术方案与安全回归测试。

### 安全行为

- UAC 取消返回 `1223`，不会被当作成功。
- 提权子进程重新校验目标路径、scope、当前用户 SID、nonce、有效期和票据一次性消费。
- symlink、junction、reparse point 和非普通文件对象保持失败关闭。
- 自定义配置目录可以位于用户 profile 外部，但仍受 owner、DACL 和路径类型校验。

### 验证结果

已执行并通过：

```
cargo check --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml
cargo test --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml private_path_elevation_policy_tests -- --nocapture
# 10 passed

cargo test --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml local_project -- --nocapture
# 20 passed

cargo test --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml checkpoint::security_tests -- --nocapture
# 10 passed

cargo test --locked --manifest-path apps/ai-game-creator-shell/src-tauri/Cargo.toml private_file_write_tests -- --nocapture
# 2 passed

npm run check:encoding
# 5554 files passed

git diff --check
# passed
```

另外确认：

- `origin/master` 是当前分支祖先。
- 交接文档已删除，且原本不在 Git 跟踪列表中。
- 全量 `cargo test` 未作为通过依据；此前存在与 ACL 无关的失败项。
- `cargo fmt --check` 仍受仓库已有格式漂移影响，本次未执行全仓库格式化。
- 真实 Windows UAC 点击“Yes”的手工回归仍需在目标机器上确认。

### 手工验收

使用：

```powershell
& "C:\Users\dongy\workspace\Genarrative\.worktrees\agc-windows-acl-fix\apps\ai-game-creator-shell\src-tauri\target\debug\genarrative-ai-game-creator-shell.exe" `
  --config-dir "C:\Users\dongy\AppData\Local\Temp\agc-acl-live-20260830\deny-config-2"
```

验收标准：

1. 选择“否”：进程返回 `exit code 1223`。
2. 重新启动并选择“Yes”：不再返回 `exit code 1`，ACL 修复完成后继续启动。
3. 再次启动同一配置目录：不应重复弹出修复。
4. 检查目录 owner 和 DACL，确认归当前用户所有且为私有权限。

---------

Co-authored-by: 段舒康 <kdletters@qq.com>
Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/211
Co-authored-by: 董羽秦 <suzmii@qq.com>
Co-committed-by: 董羽秦 <suzmii@qq.com>
---
 .../src-tauri/src/assets.rs                   |  206 +-
 .../src-tauri/src/commands.rs                 |  215 +-
 .../src-tauri/src/config.rs                   | 2416 ++++++++++++++++-
 .../src-tauri/src/main.rs                     |   59 +
 .../src-tauri/src/project/agent_db.rs         |  206 +-
 .../src-tauri/src/project/checkpoint.rs       |  136 +-
 .../src-tauri/src/project/conversation.rs     |  154 +-
 .../src-tauri/src/project/export.rs           |   34 +-
 .../src-tauri/src/project/filesystem.rs       |  126 +-
 .../src-tauri/src/project/manifest.rs         |  110 +-
 .../src-tauri/src/project/memory.rs           |   32 +-
 .../src-tauri/src/project/resource_editor.rs  |   71 +-
 .../src-tauri/src/project/verification.rs     |   36 +-
 .../src-tauri/src/tests/project.rs            |    2 +-
 ...�案】AI游戏创作智能体App实施计划-2026-06-24.md |    1 +
 15 files changed, 3334 insertions(+), 470 deletions(-)

diff --git a/apps/ai-game-creator-shell/src-tauri/src/assets.rs b/apps/ai-game-creator-shell/src-tauri/src/assets.rs
index 6398725f7..2abccf8f7 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/assets.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/assets.rs
@@ -136,23 +136,20 @@ fn normalize_external_editor_api_key(value: &str) -> Result<String, String> {
 fn private_external_editor_api_credentials_from_file_at(
     path: &Path,
 ) -> Result<Option<ExternalEditorApiCredentials>, String> {
-    let metadata = match fs::symlink_metadata(path) {
-        Ok(metadata) => metadata,
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
-        Err(error) => {
-            return Err(format!("读取本机陶泥儿开发者 Key 配置失败：{error}"));
-        }
-    };
-    if metadata.file_type().is_symlink() || !metadata.is_file() {
-        return Err("本机陶泥儿开发者 Key 配置必须是普通文件".to_string());
+    if !crate::prepare_game_creator_private_path_for_read(path, false, "本机陶泥儿开发者 Key 文件")?
+    {
+        return Ok(None);
     }
+    let metadata = fs::symlink_metadata(path)
+        .map_err(|error| format!("读取本机陶泥儿开发者 Key 配置失败：{error}"))?;
     if metadata.len() > PRIVATE_EXTERNAL_EDITOR_API_KEY_MAX_BYTES {
         return Err("本机陶泥儿开发者 Key 配置过大，已拒绝读取".to_string());
     }
-    #[cfg(windows)]
-    secure_windows_game_creator_path_for_current_user(path, false, false)?;
-    let content = fs::read_to_string(path)
-        .map_err(|error| format!("读取本机陶泥儿开发者 Key 配置失败：{error}"))?;
+    let content = crate::read_game_creator_private_file_to_string(
+        path,
+        "本机陶泥儿开发者 Key 配置",
+        PRIVATE_EXTERNAL_EDITOR_API_KEY_MAX_BYTES,
+    )?;
     let parsed = serde_json::from_str::<PrivateExternalEditorApiKeyFile>(&content)
         .map_err(|_| "本机陶泥儿开发者 Key 配置格式无效，请重新登录客户端后重试".to_string())?;
     let api_key = normalize_external_editor_api_key(&parsed.api_key)?;
@@ -162,6 +159,22 @@ fn private_external_editor_api_credentials_from_file_at(
             .as_deref()
             .unwrap_or(DEFAULT_CANVAS_SYNC_API_BASE_URL),
     )?;
+    let expected_fingerprint = format!("{:x}", Sha256::digest(api_base_url.as_bytes()));
+    let actual_fingerprint = path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .and_then(|value| {
+            value
+                .strip_prefix(PRIVATE_EXTERNAL_EDITOR_API_KEY_FILE_PREFIX)
+                .and_then(|value| value.strip_suffix(".json"))
+        })
+        .filter(|value| value.len() == 16 && value.bytes().all(|byte| byte.is_ascii_hexdigit()))
+        .ok_or_else(|| "本机陶泥儿开发者 Key 文件名身份无效，请重新登录客户端后重试".to_string())?;
+    if !actual_fingerprint.eq_ignore_ascii_case(&expected_fingerprint[..16]) {
+        return Err(
+            "本机陶泥儿开发者 Key 文件身份与服务器地址不一致，请重新登录客户端后重试".to_string(),
+        );
+    }
     Ok(Some(ExternalEditorApiCredentials {
         api_base_url,
         api_key,
@@ -171,18 +184,13 @@ fn private_external_editor_api_credentials_from_file_at(
 fn unique_private_external_editor_api_credentials_at(
     directory: &Path,
 ) -> Result<Option<ExternalEditorApiCredentials>, String> {
-    let metadata = match fs::symlink_metadata(directory) {
-        Ok(metadata) => metadata,
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
-        Err(error) => {
-            return Err(format!("读取本机陶泥儿开发者 Key 目录失败：{error}"));
-        }
-    };
-    if metadata.file_type().is_symlink() || !metadata.is_dir() {
-        return Err("本机陶泥儿开发者 Key 目录必须是普通目录".to_string());
+    if !crate::prepare_game_creator_private_path_for_read(
+        directory,
+        true,
+        "本机陶泥儿开发者 Key 目录",
+    )? {
+        return Ok(None);
     }
-    #[cfg(windows)]
-    secure_windows_game_creator_path_for_current_user(directory, true, false)?;
     let mut candidates = fs::read_dir(directory)
         .map_err(|error| format!("读取本机陶泥儿开发者 Key 目录失败：{error}"))?
         .filter_map(Result::ok)
@@ -219,35 +227,15 @@ fn ensure_plain_private_external_editor_directory(
     path: &Path,
     label: &str,
 ) -> Result<bool, String> {
-    match fs::symlink_metadata(path) {
-        Ok(metadata) => {
-            if metadata.file_type().is_symlink() || !metadata.is_dir() {
-                return Err(format!("本机陶泥儿开发者凭据{label}必须是普通目录"));
-            }
-            Ok(false)
-        }
-        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
-            let created = match fs::create_dir(path) {
-                Ok(()) => true,
-                Err(create_error) if create_error.kind() == std::io::ErrorKind::AlreadyExists => {
-                    false
-                }
-                Err(create_error) => {
-                    return Err(format!(
-                        "创建本机陶泥儿开发者凭据{label}失败：{create_error}"
-                    ));
-                }
-            };
-            let metadata = fs::symlink_metadata(path).map_err(|metadata_error| {
-                format!("读取本机陶泥儿开发者凭据{label}失败：{metadata_error}")
-            })?;
-            if metadata.file_type().is_symlink() || !metadata.is_dir() {
-                return Err(format!("本机陶泥儿开发者凭据{label}必须是普通目录"));
-            }
-            Ok(created)
-        }
-        Err(error) => Err(format!("读取本机陶泥儿开发者凭据{label}失败：{error}")),
+    let label = format!("本机陶泥儿开发者凭据{label}");
+    let created = crate::ensure_game_creator_private_directory_tree(path, &label)?;
+    #[cfg(windows)]
+    if !created {
+        crate::secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+            path, true, true,
+        )?;
     }
+    Ok(created)
 }
 
 /// Prepares the exact private directory before a one-time remote developer key
@@ -264,15 +252,11 @@ fn prepare_private_external_editor_api_credentials_parent_dir_at(
         .parent()
         .ok_or_else(|| "本机陶泥儿开发者凭据配置缺少上级目录".to_string())?;
     ensure_plain_private_external_editor_directory(container, "上级目录")?;
-    let parent_created = ensure_plain_private_external_editor_directory(parent, "目录")?;
+    ensure_plain_private_external_editor_directory(parent, "目录")?;
     #[cfg(windows)]
-    if parent_created {
-        initialize_windows_game_creator_directory_owner_for_current_user(parent)?;
-    } else {
-        secure_windows_game_creator_path_for_current_user(parent, true, true)?;
-    }
+    secure_windows_game_creator_path_for_current_user_with_auto_elevation(parent, true, true)?;
     #[cfg(unix)]
-    if parent_created {
+    {
         use std::os::unix::fs::PermissionsExt;
         fs::set_permissions(parent, fs::Permissions::from_mode(0o700))
             .map_err(|error| format!("收紧本机陶泥儿开发者凭据目录权限失败：{error}"))?;
@@ -301,8 +285,19 @@ fn write_private_external_editor_api_credentials_at(
     if parent_metadata.file_type().is_symlink() || !parent_metadata.is_dir() {
         return Err("本机陶泥儿开发者 Key 目录必须是普通目录".to_string());
     }
-    if path.exists() {
-        return Err("本机陶泥儿开发者 Key 已存在，拒绝覆盖".to_string());
+    match fs::symlink_metadata(path) {
+        Ok(metadata) => {
+            if metadata.file_type().is_symlink() || !metadata.is_file() {
+                return Err(
+                    "本机陶泥儿开发者 Key 目标必须是普通文件，不能是链接或其他对象".to_string(),
+                );
+            }
+            return Err("本机陶泥儿开发者 Key 已存在，拒绝覆盖".to_string());
+        }
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+        Err(error) => {
+            return Err(format!("读取本机陶泥儿开发者 Key 目标失败：{error}"));
+        }
     }
     let body = serde_json::to_string_pretty(&PrivateExternalEditorApiKeyFile {
         api_key: credentials.api_key.clone(),
@@ -325,9 +320,19 @@ fn write_private_external_editor_api_credentials_at(
         use std::os::unix::fs::OpenOptionsExt;
         options.mode(0o600);
     }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(crate::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
     let mut file = options
         .open(&temporary)
         .map_err(|error| format!("创建本机陶泥儿开发者 Key 临时文件失败：{error}"))?;
+    crate::harden_new_game_creator_private_path(&temporary, false, "本机陶泥儿开发者 Key 临时文件")
+        .map_err(|error| {
+            let _ = fs::remove_file(&temporary);
+            format!("初始化本机陶泥儿开发者 Key 临时文件安全权限失败：{error}")
+        })?;
     let write_result = file
         .write_all(format!("{body}\n").as_bytes())
         .and_then(|_| file.sync_all());
@@ -336,8 +341,6 @@ fn write_private_external_editor_api_credentials_at(
         let _ = fs::remove_file(&temporary);
         return Err(format!("写入本机陶泥儿开发者 Key 临时文件失败：{error}"));
     }
-    #[cfg(windows)]
-    initialize_windows_game_creator_file_owner_for_current_user(&temporary)?;
     match fs::hard_link(&temporary, path) {
         Ok(()) => {
             let _ = fs::remove_file(&temporary);
@@ -353,7 +356,14 @@ fn write_private_external_editor_api_credentials_at(
         }
     }
     #[cfg(windows)]
-    secure_windows_game_creator_path_for_current_user(path, false, true)?;
+    if let Err(error) =
+        secure_windows_game_creator_path_for_current_user_with_auto_elevation(path, false, true)
+    {
+        let _ = fs::remove_file(path);
+        return Err(format!(
+            "复核本机陶泥儿开发者 Key 文件安全权限失败：{error}"
+        ));
+    }
     Ok(())
 }
 
@@ -474,11 +484,10 @@ pub(crate) fn upload_local_asset_at(
     let relative_path = format!("assets/uploads/{asset_id}-{safe_name}");
     let absolute_path = root.join(&relative_path);
     if let Some(parent) = absolute_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建上传目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "上传目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "上传目录")?;
     }
-    fs::write(&absolute_path, bytes)
-        .map_err(|error| format!("写入上传文件失败：{}: {error}", absolute_path.display()))?;
+    crate::write_game_creator_private_file(&absolute_path, bytes, "上传文件")?;
 
     register_local_asset_entry(
         root,
@@ -578,13 +587,11 @@ pub(crate) fn import_canvas_export_at(
     if !export_path.is_absolute() {
         return Err("画板导出 ZIP 路径必须是绝对路径".to_string());
     }
+    crate::prepare_game_creator_user_selected_path_for_read(export_path, false, "画板导出 ZIP")?;
     let metadata = fs::symlink_metadata(export_path)
         .map_err(|error| format!("读取画板导出 ZIP 失败：{}: {error}", export_path.display()))?;
-    if metadata.file_type().is_symlink() {
-        return Err("画板导出 ZIP 不能是符号链接".to_string());
-    }
-    if !metadata.is_file() {
-        return Err("画板导出路径必须是 ZIP 文件".to_string());
+    if metadata.file_type().is_symlink() || !metadata.is_file() {
+        return Err("画板导出路径必须是普通 ZIP 文件".to_string());
     }
 
     init_local_game_project_at(root, "local-project-draft", "未命名游戏原型")?;
@@ -765,12 +772,10 @@ pub(crate) async fn sync_canvas_project_assets_at(
         );
         let absolute_path = root.join(&local_path);
         if let Some(parent) = absolute_path.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|error| format!("创建画板同步目录失败：{}: {error}", parent.display()))?;
+            ensure_game_creator_private_directory_tree(parent, "画板同步目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "画板同步目录")?;
         }
-        fs::write(&absolute_path, &download.bytes).map_err(|error| {
-            format!("写入画板同步资产失败：{}: {error}", absolute_path.display())
-        })?;
+        crate::write_game_creator_private_file(&absolute_path, &download.bytes, "画板同步资产")?;
         assets.push(register_local_asset_entry(
             root,
             &local_path,
@@ -1523,13 +1528,18 @@ pub(crate) fn extract_canvas_export_zip_files(
         let local_relative_path = format!("{import_relative_root}/{normalized_relative}");
         let target_path = resolve_local_project_path(root, &local_relative_path)?;
         if let Some(parent) = target_path.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|error| format!("创建画板导入目录失败：{}: {error}", parent.display()))?;
+            ensure_game_creator_private_directory_tree(parent, "画板导入目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "画板导入目录")?;
         }
-        let mut output = File::create(&target_path)
-            .map_err(|error| format!("写入画板导入文件失败：{}: {error}", target_path.display()))?;
-        std::io::copy(&mut entry, &mut output)
+        let entry_size = entry.size();
+        let mut bytes = Vec::with_capacity(entry_size.min(MAX_CANVAS_EXPORT_BYTES as u64) as usize);
+        std::io::Read::take(&mut entry, entry_size + 1)
+            .read_to_end(&mut bytes)
             .map_err(|error| format!("解压画板导出文件失败：{}: {error}", target_path.display()))?;
+        if bytes.len() as u64 != entry_size {
+            return Err("画板导出 ZIP 条目读取长度不一致".to_string());
+        }
+        crate::write_game_creator_private_file(&target_path, &bytes, "画板导入文件")?;
         copied_files.push(normalized_relative);
     }
     if copied_files.is_empty() {
@@ -1807,11 +1817,16 @@ mod tests {
     {
         let root = tempfile::tempdir().expect("temp dir");
         let directory = root.path().join("config").join("genarrative");
-        let first_path = directory.join("external-editor-api-0000000000000001.json");
         let first = ExternalEditorApiCredentials {
             api_base_url: "https://dev.genarrative.world".to_string(),
             api_key: "tnr_sk_headless_fixture_1".to_string(),
         };
+        let first_path = directory.join(
+            private_external_editor_api_key_path_for_base_url(&first.api_base_url)
+                .expect("first credential path")
+                .file_name()
+                .expect("first credential filename"),
+        );
         write_private_external_editor_api_credentials_at(&first_path, &first)
             .expect("write first private credential");
         let recovered = unique_private_external_editor_api_credentials_at(&directory)
@@ -1820,11 +1835,16 @@ mod tests {
         assert_eq!(recovered.api_base_url, first.api_base_url);
         assert_eq!(recovered.api_key, first.api_key);
 
-        let second_path = directory.join("external-editor-api-0000000000000002.json");
         let second = ExternalEditorApiCredentials {
             api_base_url: "https://www.genarrative.world".to_string(),
             api_key: "tnr_sk_headless_fixture_2".to_string(),
         };
+        let second_path = directory.join(
+            private_external_editor_api_key_path_for_base_url(&second.api_base_url)
+                .expect("second credential path")
+                .file_name()
+                .expect("second credential filename"),
+        );
         write_private_external_editor_api_credentials_at(&second_path, &second)
             .expect("write second private credential");
         let error = match unique_private_external_editor_api_credentials_at(&directory) {
@@ -1856,11 +1876,17 @@ mod tests {
     #[test]
     fn newly_created_private_external_editor_credentials_directory_is_owned_by_token_user() {
         let root = tempfile::tempdir().expect("temp dir");
+        let credential_file_name =
+            private_external_editor_api_key_path_for_base_url("https://dev.genarrative.world")
+                .expect("credential path")
+                .file_name()
+                .expect("credential filename")
+                .to_owned();
         let path = root
             .path()
             .join("config")
             .join("genarrative")
-            .join("external-editor-api-test.json");
+            .join(credential_file_name);
 
         prepare_private_external_editor_api_credentials_parent_dir_at(&path)
             .expect("prepare private credential directory");
@@ -1889,7 +1915,13 @@ mod tests {
             "fixture must reproduce the inherited ACL rejection"
         );
 
-        let path = parent.join("external-editor-api-test.json");
+        let credential_file_name =
+            private_external_editor_api_key_path_for_base_url("https://dev.genarrative.world")
+                .expect("credential path")
+                .file_name()
+                .expect("credential filename")
+                .to_owned();
+        let path = parent.join(credential_file_name);
         prepare_private_external_editor_api_credentials_parent_dir_at(&path)
             .expect("current-user directory should be tightened locally before remote creation");
         secure_windows_game_creator_path_for_current_user(&parent, true, false)
diff --git a/apps/ai-game-creator-shell/src-tauri/src/commands.rs b/apps/ai-game-creator-shell/src-tauri/src/commands.rs
index 73221b283..465d07443 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/commands.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/commands.rs
@@ -165,8 +165,14 @@ fn validate_local_asset_import_requirements(
     }
     let mut total_size = 0u64;
     for source in source_paths {
-        let metadata =
-            fs::symlink_metadata(source.trim()).map_err(|_| "读取本地文件失败".to_string())?;
+        let path = Path::new(source.trim());
+        // Run the explicit user-selection ACL preparation before any size/type
+        // preflight.  On Windows, metadata traversal can itself fail with
+        // ERROR_ACCESS_DENIED; doing this only in the later import worker would
+        // leave the early validation path unable to reach the one-shot UAC
+        // repair entry.
+        crate::prepare_game_creator_user_selected_path_for_read(path, false, "本地导入文件")?;
+        let metadata = fs::symlink_metadata(path).map_err(|_| "读取本地文件失败".to_string())?;
         if metadata.file_type().is_symlink() || !metadata.is_file() {
             return Err("只能导入普通文件".to_string());
         }
@@ -282,12 +288,8 @@ pub(crate) fn create_automatic_local_game_project_at(
     if projects_root.as_os_str().is_empty() || !projects_root.is_absolute() {
         return Err("自动工作区根目录必须是绝对路径".to_string());
     }
-    fs::create_dir_all(projects_root).map_err(|error| {
-        format!(
-            "创建自动工作区根目录失败：{}: {error}",
-            projects_root.display()
-        )
-    })?;
+    ensure_game_creator_private_directory_tree(projects_root, "自动工作区根目录")?;
+    prepare_game_creator_private_path_for_read(projects_root, true, "自动工作区根目录")?;
     let metadata = fs::symlink_metadata(projects_root).map_err(|error| {
         format!(
             "读取自动工作区根目录失败：{}: {error}",
@@ -306,6 +308,11 @@ pub(crate) fn create_automatic_local_game_project_at(
         match fs::create_dir(&project_root) {
             Ok(()) => {
                 let result = (|| {
+                    prepare_game_creator_private_path_for_read(
+                        &project_root,
+                        true,
+                        "自动项目目录",
+                    )?;
                     enforce_project_permission_policy(&project_root, "project.create")?;
                     let _lock = acquire_project_write_lock(&project_root, "project.create")?;
                     init_local_game_project_at(
@@ -377,6 +384,7 @@ pub(crate) fn is_local_project_directory_non_empty(project_path: String) -> Resu
     if project_path_has_control_chars(root) {
         return Err("项目目录不能包含控制字符".to_string());
     }
+    crate::prepare_game_creator_project_root_for_read(root, true, "项目目录")?;
     if !root.exists() {
         return Ok(false);
     }
@@ -405,6 +413,15 @@ pub(crate) fn inspect_local_project_directory(
     if project_path_has_control_chars(root) {
         return Err("项目目录不能包含控制字符".to_string());
     }
+    match fs::symlink_metadata(root) {
+        Ok(metadata) if metadata.is_dir() => {
+            crate::prepare_game_creator_project_root_for_read(root, true, "项目目录")?;
+        }
+        Err(error) if error.kind() == std::io::ErrorKind::PermissionDenied => {
+            crate::prepare_game_creator_project_root_for_read(root, true, "项目目录")?;
+        }
+        _ => {}
+    }
     let recent_run_trace = recent_game_creator_run_trace(root);
     let godot_project_root = discover_local_godot_project_root(root)?;
     Ok(LocalProjectDirectoryStatus {
@@ -464,7 +481,12 @@ pub(crate) fn game_creator_project_manifest_error(root: &Path) -> Option<String>
 
 pub(crate) fn recent_game_creator_run_trace(root: &Path) -> Option<GameCreationAgentRunTrace> {
     let trace_path = root.join(".agent/run.latest.json");
-    let content = fs::read_to_string(trace_path).ok()?;
+    let content = crate::read_game_creator_private_file_to_string(
+        &trace_path,
+        "最近运行状态",
+        256 * 1024,
+    )
+    .ok()?;
     serde_json::from_str::<GameCreationAgentRunTrace>(&content).ok()
 }
 
@@ -500,9 +522,24 @@ pub(crate) async fn pick_local_project_directory(
     else {
         return Ok(None);
     };
-    path.into_path()
-        .map(|path| Some(path.to_string_lossy().into_owned()))
-        .map_err(|error| format!("读取项目目录失败：{error}"))
+    let path = path
+        .into_path()
+        .map_err(|error| format!("读取项目目录失败：{error}"))?;
+    #[cfg(windows)]
+    crate::register_game_creator_user_selected_path(&path, true);
+    // The native picker is the explicit user-selection boundary. Prepare the
+    // selected root before returning it so inspect/create/open never races the
+    // first ACL read.
+    if let Err(error) = crate::prepare_game_creator_project_root_for_read(
+        &path,
+        true,
+        "用户选择项目目录",
+    ) {
+        #[cfg(windows)]
+        crate::revoke_game_creator_user_selected_path(&path);
+        return Err(error);
+    }
+    Ok(Some(path.to_string_lossy().into_owned()))
 }
 
 #[tauri::command]
@@ -521,9 +558,21 @@ pub(crate) async fn pick_local_file(app: tauri::AppHandle) -> Result<Option<Stri
     else {
         return Ok(None);
     };
-    path.into_path()
-        .map(|path| Some(path.to_string_lossy().into_owned()))
-        .map_err(|error| format!("读取本地文件失败：{error}"))
+    let path = path
+        .into_path()
+        .map_err(|error| format!("读取本地文件失败：{error}"))?;
+    #[cfg(windows)]
+    crate::register_game_creator_user_selected_path(&path, false);
+    if let Err(error) = crate::prepare_game_creator_user_selected_path_for_read(
+        &path,
+        false,
+        "用户选择文件",
+    ) {
+        #[cfg(windows)]
+        crate::revoke_game_creator_user_selected_path(&path);
+        return Err(error);
+    }
+    Ok(Some(path.to_string_lossy().into_owned()))
 }
 
 #[tauri::command]
@@ -553,6 +602,7 @@ pub(crate) fn validated_local_project_directory_path(
     if !path.is_dir() {
         return Err("项目路径不是文件夹".to_string());
     }
+    crate::prepare_game_creator_project_root_for_read(path, true, "项目目录")?;
     Ok(path.to_path_buf())
 }
 
@@ -1805,6 +1855,7 @@ pub(crate) fn install_platform_account_session(
 
 #[tauri::command]
 pub(crate) fn clear_platform_account_session(generation: u64) -> Result<(), String> {
+    shutdown_game_creator_codex_app_servers()?;
     clear_external_agent_runner_platform_session(generation)?;
     clear_platform_session(generation);
     Ok(())
@@ -1901,14 +1952,30 @@ pub(crate) fn create_ui_design_resource(
     let relative_path = format!("ui/{resource_name}.json");
     let absolute_path = resolve_local_project_path(root, &relative_path)?;
     if let Some(parent) = absolute_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建 UI 资源目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "UI 资源目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "UI 资源目录")?;
     }
-    if absolute_path.exists() {
+    if prepare_game_creator_private_path_for_read(&absolute_path, false, "UI 资源")? {
         return Err("UI 设计资源路径已存在，拒绝覆盖".to_string());
     }
-    fs::write(&absolute_path, "")
+    let mut options = fs::OpenOptions::new();
+    options.write(true).create_new(true);
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(crate::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
+    let mut file = options
+        .open(&absolute_path)
         .map_err(|error| format!("创建 UI 资源失败：{}: {error}", absolute_path.display()))?;
+    if let Err(error) = harden_new_game_creator_private_path(&absolute_path, false, "UI 资源") {
+        drop(file);
+        let _ = fs::remove_file(&absolute_path);
+        return Err(error);
+    }
+    file.sync_all()
+        .map_err(|error| format!("同步 UI 资源失败：{}: {error}", absolute_path.display()))?;
+    drop(file);
     let asset = match register_local_asset_at(
         root,
         &relative_path,
@@ -2123,6 +2190,7 @@ pub(crate) fn import_ui_editor_local_files(
     let mut total_size = 0u64;
     for source in source_paths {
         let path = Path::new(source.trim());
+        crate::prepare_game_creator_user_selected_path_for_read(path, false, "本地图片")?;
         let metadata = fs::symlink_metadata(path).map_err(|e| format!("读取本地图片失败：{e}"))?;
         if metadata.file_type().is_symlink() || !metadata.is_file() {
             return Err("只能导入普通图片文件".to_string());
@@ -2203,6 +2271,7 @@ fn read_registered_ui_editor_font(
         return Err("项目资产不是受支持的字体候选".to_string());
     }
     let target = resolve_local_project_path(root, &asset.local_path)?;
+    prepare_game_creator_private_path_for_read(&target, false, "项目字体")?;
     let metadata = fs::symlink_metadata(&target).map_err(|_| "读取项目字体失败".to_string())?;
     if metadata.file_type().is_symlink() || !metadata.is_file() {
         return Err("项目字体必须是普通文件".to_string());
@@ -2279,6 +2348,7 @@ pub(crate) fn import_ui_editor_local_fonts(
     let mut input_hashes = std::collections::BTreeSet::new();
     for source in source_paths {
         let path = Path::new(source.trim());
+        crate::prepare_game_creator_user_selected_path_for_read(path, false, "本地字体")?;
         let metadata = fs::symlink_metadata(path).map_err(|_| "读取本地字体失败".to_string())?;
         if metadata.file_type().is_symlink() || !metadata.is_file() {
             return Err("只能导入普通字体文件".to_string());
@@ -2337,7 +2407,8 @@ pub(crate) fn import_ui_editor_local_fonts(
 
     if !new_inputs.is_empty() {
         let font_root = root.join("assets/fonts");
-        fs::create_dir_all(&font_root).map_err(|_| "创建项目字体目录失败".to_string())?;
+        ensure_game_creator_private_directory_tree(&font_root, "项目字体目录")?;
+        prepare_game_creator_private_path_for_read(&font_root, true, "项目字体目录")?;
     }
     // 字体批次同样是增量提交合同：已经复制并登记的字体在后续失败时保留。
     let mut result = Vec::with_capacity(inputs.len());
@@ -2358,7 +2429,28 @@ pub(crate) fn import_ui_editor_local_fonts(
             validated.metadata.format.extension()
         );
         let target = resolve_local_project_path(root, &relative_path)?;
-        fs::write(&target, &bytes).map_err(|_| "写入项目字体失败".to_string())?;
+        if prepare_game_creator_private_path_for_read(&target, false, "项目字体")? {
+            return Err(format!("项目字体目标已存在但未登记：{}", target.display()));
+        }
+        let mut options = fs::OpenOptions::new();
+        options.write(true).create_new(true);
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::OpenOptionsExt;
+            options.custom_flags(crate::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+        }
+        let mut file = options
+            .open(&target)
+            .map_err(|error| format!("写入项目字体失败：{}: {error}", target.display()))?;
+        if let Err(error) = harden_new_game_creator_private_path(&target, false, "项目字体") {
+            drop(file);
+            let _ = fs::remove_file(&target);
+            return Err(error);
+        }
+        file.write_all(&bytes)
+            .and_then(|_| file.sync_all())
+            .map_err(|error| format!("写入项目字体失败：{}: {error}", target.display()))?;
+        drop(file);
         let registered = register_local_asset_entry(
             root,
             &relative_path,
@@ -2598,7 +2690,7 @@ mod ui_editor_font_tests {
 
         assert_eq!(
             read_registered_ui_editor_font(root, &entry).expect_err("reject symlink"),
-            "项目文件路径不能包含符号链接"
+            "项目文件路径不能包含符号链接或 Windows reparse point"
         );
     }
 }
@@ -3380,6 +3472,7 @@ pub(crate) fn import_local_project_image_assets_for_agent(
         reject_sensitive_project_file_read(&normalized)?;
         reject_agent_local_image_source_path(&normalized)?;
         let source = resolve_local_project_path(root, &normalized)?;
+        prepare_game_creator_private_path_for_read(&source, false, "本地图片")?;
         let metadata =
             fs::symlink_metadata(&source).map_err(|_| format!("本地图片不存在：{normalized}"))?;
         if metadata.file_type().is_symlink() || !metadata.is_file() {
@@ -3430,16 +3523,37 @@ pub(crate) fn import_local_project_image_assets_for_agent(
             });
             continue;
         }
-        if target.exists() && source_path != local_path {
+        if target.exists() {
+            prepare_game_creator_private_path_for_read(&target, false, "目标图片")?;
             let existing_bytes = fs::read(&target).map_err(|_| "读取目标图片失败".to_string())?;
             if existing_bytes != bytes {
                 return Err(format!("本地图片目标已存在且内容不同：{local_path}"));
             }
         } else {
             if let Some(parent) = target.parent() {
-                fs::create_dir_all(parent).map_err(|_| "创建本地图片导入目录失败".to_string())?;
+                ensure_game_creator_private_directory_tree(parent, "本地图片导入目录")?;
+                prepare_game_creator_private_path_for_read(parent, true, "本地图片导入目录")?;
             }
-            fs::write(&target, &bytes).map_err(|_| "写入本地图片失败".to_string())?;
+            let mut options = fs::OpenOptions::new();
+            options.write(true).create_new(true);
+            #[cfg(windows)]
+            {
+                use std::os::windows::fs::OpenOptionsExt;
+                options.custom_flags(crate::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+            }
+            let mut file = options
+                .open(&target)
+                .map_err(|error| format!("写入本地图片失败：{}: {error}", target.display()))?;
+            if let Err(error) = harden_new_game_creator_private_path(&target, false, "目标图片")
+            {
+                drop(file);
+                let _ = fs::remove_file(&target);
+                return Err(error);
+            }
+            file.write_all(&bytes)
+                .and_then(|_| file.sync_all())
+                .map_err(|error| format!("写入本地图片失败：{}: {error}", target.display()))?;
+            drop(file);
         }
         let registered = register_local_asset_entry(
             root,
@@ -3588,12 +3702,33 @@ pub(crate) async fn import_account_editor_assets_for_agent(
             continue;
         }
         if target.exists() {
+            prepare_game_creator_private_path_for_read(&target, false, "账户图片目标")?;
             return Err(format!("账户图片目标已存在但尚未登记：{local_path}"));
         }
         if let Some(parent) = target.parent() {
-            fs::create_dir_all(parent).map_err(|_| "创建账户图片导入目录失败".to_string())?;
+            ensure_game_creator_private_directory_tree(parent, "账户图片导入目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "账户图片导入目录")?;
         }
-        fs::write(&target, &bytes).map_err(|_| "写入账户图片失败".to_string())?;
+        let mut options = fs::OpenOptions::new();
+        options.write(true).create_new(true);
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::OpenOptionsExt;
+            options.custom_flags(crate::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+        }
+        let mut file = options
+            .open(&target)
+            .map_err(|error| format!("写入账户图片失败：{}: {error}", target.display()))?;
+        if let Err(error) = harden_new_game_creator_private_path(&target, false, "账户图片目标")
+        {
+            drop(file);
+            let _ = fs::remove_file(&target);
+            return Err(error);
+        }
+        file.write_all(&bytes)
+            .and_then(|_| file.sync_all())
+            .map_err(|error| format!("写入账户图片失败：{}: {error}", target.display()))?;
+        drop(file);
         let (source_kind, canvas_project_id, generation_route) = match record.origin {
             AgentEditorAssetOrigin::AccountLibrary => (
                 GameCreationAppAssetSourceKind::Canvas,
@@ -3695,9 +3830,31 @@ pub(crate) async fn import_ui_editor_remote_assets(
     for (asset, asset_id, media_type, local_path, bytes) in downloads {
         let target = resolve_local_project_path(root, &local_path)?;
         if let Some(parent) = target.parent() {
-            fs::create_dir_all(parent).map_err(|e| format!("创建导入目录失败：{e}"))?;
+            ensure_game_creator_private_directory_tree(parent, "平台素材导入目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "平台素材导入目录")?;
         }
-        fs::write(&target, &bytes).map_err(|e| format!("写入平台素材失败：{e}"))?;
+        if prepare_game_creator_private_path_for_read(&target, false, "平台素材")? {
+            return Err(format!("平台素材目标已存在但尚未登记：{local_path}"));
+        }
+        let mut options = fs::OpenOptions::new();
+        options.write(true).create_new(true);
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::OpenOptionsExt;
+            options.custom_flags(crate::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+        }
+        let mut file = options
+            .open(&target)
+            .map_err(|error| format!("写入平台素材失败：{e}", e = error))?;
+        if let Err(error) = harden_new_game_creator_private_path(&target, false, "平台素材") {
+            drop(file);
+            let _ = fs::remove_file(&target);
+            return Err(error);
+        }
+        file.write_all(&bytes)
+            .and_then(|_| file.sync_all())
+            .map_err(|error| format!("写入平台素材失败：{error}"))?;
+        drop(file);
         let registered = register_local_asset_entry(
             root,
             &local_path,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/config.rs b/apps/ai-game-creator-shell/src-tauri/src/config.rs
index 89d87e38b..514345097 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/config.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/config.rs
@@ -1,5 +1,96 @@
 use super::*;
 
+#[cfg(windows)]
+use std::collections::HashMap;
+#[cfg(windows)]
+use std::time::Instant;
+
+#[cfg(windows)]
+const GAME_CREATOR_USER_SELECTED_PATH_GRANT_TTL: Duration = Duration::from_secs(300);
+
+#[cfg(windows)]
+#[derive(Clone, Copy)]
+struct UserSelectedPathGrant {
+    is_directory: bool,
+    expires_at: Instant,
+}
+
+#[cfg(windows)]
+static GAME_CREATOR_USER_SELECTED_PATH_GRANTS:
+    OnceLock<Mutex<HashMap<String, UserSelectedPathGrant>>> = OnceLock::new();
+
+#[cfg(windows)]
+fn user_selected_path_grants() -> &'static Mutex<HashMap<String, UserSelectedPathGrant>> {
+    GAME_CREATOR_USER_SELECTED_PATH_GRANTS.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+#[cfg(windows)]
+fn normalize_user_selected_path_key(path: &Path) -> Option<String> {
+    if !path.is_absolute()
+        || path
+            .components()
+            .any(|component| matches!(component, std::path::Component::ParentDir))
+    {
+        return None;
+    }
+    Some(
+        path.to_string_lossy()
+            .replace('/', "\\")
+            .trim_end_matches('\\')
+            .to_ascii_lowercase(),
+    )
+}
+
+#[cfg(windows)]
+pub(crate) fn register_game_creator_user_selected_path(path: &Path, is_directory: bool) {
+    let Some(key) = normalize_user_selected_path_key(path) else {
+        return;
+    };
+    let mut grants = user_selected_path_grants()
+        .lock()
+        .expect("user-selected path grants lock");
+    grants.retain(|_, grant| grant.expires_at > Instant::now());
+    grants.insert(
+        key,
+        UserSelectedPathGrant {
+            is_directory,
+            expires_at: Instant::now() + GAME_CREATOR_USER_SELECTED_PATH_GRANT_TTL,
+        },
+    );
+}
+
+#[cfg(windows)]
+pub(crate) fn revoke_game_creator_user_selected_path(path: &Path) {
+    let Some(key) = normalize_user_selected_path_key(path) else {
+        return;
+    };
+    user_selected_path_grants()
+        .lock()
+        .expect("user-selected path grants lock")
+        .remove(&key);
+}
+
+#[cfg(windows)]
+fn user_selected_path_is_authorized(path: &Path, is_directory: bool) -> bool {
+    let Some(key) = normalize_user_selected_path_key(path) else {
+        return false;
+    };
+    let mut grants = user_selected_path_grants()
+        .lock()
+        .expect("user-selected path grants lock");
+    let now = Instant::now();
+    grants.retain(|_, grant| grant.expires_at > now);
+    grants.iter().any(|(granted_key, grant)| {
+        if granted_key == &key {
+            return grant.is_directory == is_directory;
+        }
+        grant.is_directory
+            && key
+                .strip_prefix(granted_key)
+                .is_some_and(|suffix| suffix.starts_with('\\'))
+    })
+}
+
 pub(crate) const GAME_CREATOR_LLM_AGENT_REASONING_EFFORT_DEFAULTS: [(&str, &str); 21] = [
     (GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID, "high"),
     ("planner", "high"),
@@ -638,6 +729,1068 @@ fn validate_game_creator_runtime_config_dir_metadata(
     Ok(())
 }
 
+/// Checks every already-existing path component without following links.
+/// `canonicalize` alone is insufficient here because it resolves a junction
+/// before the caller gets a chance to apply the owner/DACL policy.
+pub(crate) fn validate_game_creator_private_path_ancestors(
+    path: &Path,
+    label: &str,
+) -> Result<(), String> {
+    if !path.is_absolute() {
+        return Err(format!("{label}必须是绝对路径"));
+    }
+    for ancestor in path.ancestors().collect::<Vec<_>>().into_iter().rev() {
+        match fs::symlink_metadata(ancestor) {
+            Ok(metadata) => {
+                if metadata.file_type().is_symlink() {
+                    return Err(format!(
+                        "{label} 路径不能包含符号链接：{}",
+                        ancestor.display()
+                    ));
+                }
+                #[cfg(windows)]
+                {
+                    use std::os::windows::fs::MetadataExt;
+                    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+                    if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+                        return Err(format!(
+                            "{label} 路径不能包含 Windows reparse point：{}",
+                            ancestor.display()
+                        ));
+                    }
+                }
+                if ancestor != path && !metadata.is_dir() {
+                    return Err(format!(
+                        "{label} 父路径必须是普通目录：{}",
+                        ancestor.display()
+                    ));
+                }
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+            Err(error) => {
+                return Err(format!(
+                    "读取 {label} 路径元数据失败：{}: {error}",
+                    ancestor.display()
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Automatic ACL repair for managed paths is limited to objects AGC owns. A
+/// separate, explicit user-selected scope below covers native picker/project
+/// root results, including projects stored outside the current profile.
+fn game_creator_private_path_allows_auto_elevation(path: &Path) -> bool {
+    if !path.is_absolute()
+        || path
+            .components()
+            .any(|component| matches!(component, std::path::Component::ParentDir))
+    {
+        return false;
+    }
+
+    let starts_with_path = |root: &Path| path == root || path.starts_with(root);
+    if game_creator_runtime_config_dir()
+        .as_deref()
+        .is_some_and(starts_with_path)
+    {
+        return true;
+    }
+
+    if let Some(home) = std::env::var_os("USERPROFILE")
+        .or_else(|| std::env::var_os("HOME"))
+        .map(PathBuf::from)
+        .filter(|candidate| candidate.is_absolute())
+    {
+        let credentials_root = home.join(".config").join("genarrative");
+        if starts_with_path(&credentials_root) {
+            return true;
+        }
+
+        // The Tauri release uses this stable per-user AppData directory. The
+        // elevated helper runs in a fresh process, so the in-memory runtime
+        // config-dir override is unavailable there; recognize the packaged
+        // path from the user's profile as well.
+        let packaged_app_data = home
+            .join("AppData")
+            .join("Local")
+            .join("world.genarrative.ai-game-creator");
+        if starts_with_path(&packaged_app_data) {
+            return true;
+        }
+    }
+
+    for environment_name in ["LOCALAPPDATA", "APPDATA"] {
+        if let Some(root) = std::env::var_os(environment_name)
+            .map(PathBuf::from)
+            .filter(|candidate| candidate.is_absolute())
+        {
+            if starts_with_path(&root.join("world.genarrative.ai-game-creator")) {
+                return true;
+            }
+        }
+    }
+
+    // A bare `.agent` component is not enough to authorize ownership repair:
+    // an arbitrary user-selected path can contain a directory with that name.
+    // An existing AGC marker establishes the managed project root, after
+    // which every regular descendant (for example `game/index.html`) is
+    // covered by the same repair boundary.  New projects use the explicit
+    // project-root preparation entry below until their marker is written.
+    // Nested or unrelated `.agent` directories remain outside the boundary.
+    let agent_components = path
+        .components()
+        .filter_map(|component| match component {
+            std::path::Component::Normal(name)
+                if name.to_string_lossy().eq_ignore_ascii_case(".agent") =>
+            {
+                Some(name.to_os_string())
+            }
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+    if agent_components.len() > 1 {
+        return false;
+    }
+
+    for project_root in path.ancestors() {
+        let root_metadata = match fs::symlink_metadata(project_root) {
+            Ok(metadata) => metadata,
+            Err(_) => continue,
+        };
+        if root_metadata.file_type().is_symlink() || !root_metadata.is_dir() {
+            continue;
+        }
+        let agent_directory = project_root.join(".agent");
+        let agent_metadata = match fs::symlink_metadata(&agent_directory) {
+            Ok(metadata) => metadata,
+            Err(_) => continue,
+        };
+        let manifest_path = agent_directory.join("manifest.json");
+        let manifest_metadata = match fs::symlink_metadata(&manifest_path) {
+            Ok(metadata) => metadata,
+            Err(_) => continue,
+        };
+        if agent_metadata.file_type().is_symlink()
+            || !agent_metadata.is_dir()
+            || manifest_metadata.file_type().is_symlink()
+            || !manifest_metadata.is_file()
+        {
+            continue;
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::MetadataExt;
+            const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+            if root_metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+                || agent_metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+                || manifest_metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+            {
+                continue;
+            }
+        }
+
+        if let Some(agent_name) = agent_components.first() {
+            let Some(actual_agent_directory) = path.ancestors().find(|candidate| {
+                candidate
+                    .file_name()
+                    .is_some_and(|name| name.to_string_lossy().eq_ignore_ascii_case(".agent"))
+            }) else {
+                continue;
+            };
+            if actual_agent_directory != &agent_directory
+                || actual_agent_directory
+                    .file_name()
+                    .map(|name| name != agent_name)
+                    .unwrap_or(true)
+            {
+                continue;
+            }
+        }
+        return true;
+    }
+    false
+}
+
+/// A file-picker/project-root result is an explicit native user action.  Once
+/// the caller has crossed that boundary, a regular object may be repaired by
+/// the one-shot UAC helper even when it lives outside the current profile
+/// (projects are commonly stored on another drive).  The normal
+/// reparse/regular-object/ancestor-type checks still run before this predicate
+/// is consulted, so links, junctions and non-regular objects never become
+/// elevation targets.
+#[cfg(windows)]
+fn game_creator_user_selected_path_allows_auto_elevation(path: &Path) -> bool {
+    if !path.is_absolute()
+        || path
+            .components()
+            .any(|component| matches!(component, std::path::Component::ParentDir))
+    {
+        return false;
+    }
+    // Never treat a drive/UNC root as a user file.  This also prevents an
+    // unreadable ancestor walk from turning a picker selection into ownership
+    // repair of the entire volume root.  A native picker can technically
+    // return Windows/Program Files paths, but taking ownership there would
+    // damage the operating system rather than repair an AGC user file.
+    if path.as_os_str().is_empty() || path.file_name().is_none() {
+        return false;
+    }
+    let normalized = path
+        .to_string_lossy()
+        .replace('/', "\\")
+        .trim_end_matches('\\')
+        .to_ascii_lowercase();
+    for variable in [
+        "WINDIR",
+        "PROGRAMFILES",
+        "PROGRAMFILES(X86)",
+        "PROGRAMDATA",
+        "COMMONPROGRAMFILES",
+        "COMMONPROGRAMFILES(X86)",
+    ] {
+        let Some(root) = std::env::var_os(variable).map(PathBuf::from) else {
+            continue;
+        };
+        let root = root
+            .to_string_lossy()
+            .replace('/', "\\")
+            .trim_end_matches('\\')
+            .to_ascii_lowercase();
+        if normalized == root || normalized.starts_with(&(root + "\\")) {
+            return false;
+        }
+    }
+    true
+}
+
+#[cfg(windows)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum WindowsAclRepairScope {
+    Managed,
+    UserSelected,
+}
+
+#[cfg(windows)]
+impl WindowsAclRepairScope {
+    fn wire_name(self) -> &'static str {
+        match self {
+            Self::Managed => "managed",
+            Self::UserSelected => "user-selected",
+        }
+    }
+
+    fn allows_path(self, path: &Path) -> bool {
+        match self {
+            Self::Managed => game_creator_private_path_allows_auto_elevation(path),
+            Self::UserSelected => game_creator_user_selected_path_allows_auto_elevation(path),
+        }
+    }
+}
+
+#[cfg(windows)]
+pub(crate) fn parse_windows_acl_repair_scope(value: &str) -> Result<WindowsAclRepairScope, String> {
+    match value.trim() {
+        "managed" => Ok(WindowsAclRepairScope::Managed),
+        "user-selected" => Ok(WindowsAclRepairScope::UserSelected),
+        _ => Err("AGC ACL 修复 scope 无效".to_string()),
+    }
+}
+
+#[cfg(windows)]
+fn game_creator_runtime_config_repair_scope(path: &Path) -> WindowsAclRepairScope {
+    let is_builtin_root = |root: PathBuf| path == root || path.starts_with(root);
+    if let Some(home) = std::env::var_os("USERPROFILE")
+        .or_else(|| std::env::var_os("HOME"))
+        .map(PathBuf::from)
+        .filter(|candidate| candidate.is_absolute())
+    {
+        if is_builtin_root(home.join(".config").join("genarrative"))
+            || is_builtin_root(
+                home.join("AppData")
+                    .join("Local")
+                    .join("world.genarrative.ai-game-creator"),
+            )
+        {
+            return WindowsAclRepairScope::Managed;
+        }
+    }
+    for environment_name in ["LOCALAPPDATA", "APPDATA"] {
+        if let Some(root) = std::env::var_os(environment_name)
+            .map(PathBuf::from)
+            .filter(|candidate| candidate.is_absolute())
+        {
+            if is_builtin_root(root.join("world.genarrative.ai-game-creator")) {
+                return WindowsAclRepairScope::Managed;
+            }
+        }
+    }
+    WindowsAclRepairScope::UserSelected
+}
+
+/// Prepares a caller-selected AGC project root. The root itself has no
+/// `.agent/manifest.json` yet during first initialization, so it cannot use
+/// the marker-based auto-elevation predicate above. This explicit entry is
+/// only called by project initialization and the Runner, where the path has
+/// already been accepted as the workspace root; descendants remain subject
+/// to the marker-based managed-root check.
+pub(crate) fn prepare_game_creator_project_root_for_read(
+    path: &Path,
+    is_directory: bool,
+    label: &str,
+) -> Result<bool, String> {
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false),
+        Err(error) => {
+            let detail = format!("读取 {label} 元数据失败：{}: {error}", path.display());
+            #[cfg(windows)]
+            {
+                // A selected project root may be unreadable before the leaf
+                // metadata can be inspected.  Keep the same explicit
+                // user-selected scope and one-shot UAC path used after the
+                // metadata check, while rejecting all paths outside the
+                // current profile.
+                let scope = if game_creator_private_path_allows_auto_elevation(path) {
+                    WindowsAclRepairScope::Managed
+                } else if user_selected_path_is_authorized(path, is_directory)
+                    && game_creator_user_selected_path_allows_auto_elevation(path)
+                {
+                    WindowsAclRepairScope::UserSelected
+                } else {
+                    return Err(detail);
+                };
+                if windows_acl_error_may_need_elevation(&detail) {
+                    return secure_windows_game_creator_path_for_current_user_with_auto_elevation_scoped(
+                        path,
+                        is_directory,
+                        true,
+                        scope,
+                    )
+                    .map(|_| true)
+                    .map_err(|repair_error| {
+                        format!("{detail}；自动提权修复未完成：{repair_error}")
+                    });
+                }
+            }
+            return Err(detail);
+        }
+    };
+    if metadata.file_type().is_symlink()
+        || (is_directory && !metadata.is_dir())
+        || (!is_directory && !metadata.is_file())
+    {
+        return Err(format!(
+            "{label} 必须是普通{}，不能是链接或其他对象：{}",
+            if is_directory { "目录" } else { "文件" },
+            path.display()
+        ));
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::MetadataExt;
+        const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+        if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+            return Err(format!(
+                "{label} 不能是 Windows reparse point：{}",
+                path.display()
+            ));
+        }
+        // A project root is explicitly selected by the user before the AGC
+        // marker exists, so the managed-path predicate cannot identify it yet.
+        // Use the explicit user-selected scope for the root; this allows a
+        // project stored on another drive to be repaired while retaining the
+        // strict reparse/type checks above.
+        let scope = if game_creator_private_path_allows_auto_elevation(path) {
+            WindowsAclRepairScope::Managed
+        } else if user_selected_path_is_authorized(path, is_directory)
+            && game_creator_user_selected_path_allows_auto_elevation(path)
+        {
+            WindowsAclRepairScope::UserSelected
+        } else {
+            return secure_windows_game_creator_path_for_current_user(path, is_directory, true)
+                .map(|_| true);
+        };
+        secure_windows_game_creator_path_for_current_user_with_auto_elevation_scoped(
+            path,
+            is_directory,
+            true,
+            scope,
+        )?;
+    }
+    #[cfg(not(windows))]
+    {
+        validate_game_creator_private_path_ancestors(path, label)?;
+    }
+    Ok(true)
+}
+
+#[cfg(windows)]
+fn validate_game_creator_private_path_ancestors_with_auto_elevation(
+    path: &Path,
+    label: &str,
+) -> Result<(), String> {
+    validate_game_creator_private_path_ancestors_with_auto_elevation_scoped(
+        path,
+        label,
+        WindowsAclRepairScope::Managed,
+    )
+}
+
+#[cfg(windows)]
+fn validate_game_creator_private_path_ancestors_with_auto_elevation_scoped(
+    path: &Path,
+    label: &str,
+    scope: WindowsAclRepairScope,
+) -> Result<(), String> {
+    #[cfg(test)]
+    {
+        return validate_game_creator_private_path_ancestors(path, label);
+    }
+    #[cfg(not(test))]
+    {
+        let target_user_sid = current_windows_token_user_sid_string()?;
+        let mut attempted_targets = Vec::<PathBuf>::new();
+        loop {
+            match validate_game_creator_private_path_ancestors(path, label) {
+                Ok(()) => return Ok(()),
+                Err(error)
+                    if scope.allows_path(path) && windows_acl_error_may_need_elevation(&error) =>
+                {
+                    let repair_target = windows_acl_repair_target(path, scope);
+                    if attempted_targets
+                        .iter()
+                        .any(|target| target == &repair_target)
+                    {
+                        return Err(format!(
+                            "{error}；自动提权修复重复命中同一目标，拒绝继续重试：{}",
+                            repair_target.display()
+                        ));
+                    }
+                    attempted_targets.push(repair_target);
+                    attempt_elevated_windows_acl_repair(path, &target_user_sid, scope).map_err(
+                        |repair_error| format!("{error}；自动提权修复未完成：{repair_error}"),
+                    )?;
+                }
+                Err(error) => return Err(error),
+            }
+        }
+    }
+}
+
+/// Creates a private directory tree one component at a time.  `create_dir_all`
+/// can follow a junction that appears between components, so every existing
+/// and newly-created component is checked before the next one is touched.
+pub(crate) fn ensure_game_creator_private_directory_tree(
+    path: &Path,
+    label: &str,
+) -> Result<bool, String> {
+    #[cfg(windows)]
+    validate_game_creator_private_path_ancestors_with_auto_elevation(path, label)?;
+    #[cfg(not(windows))]
+    validate_game_creator_private_path_ancestors(path, label)?;
+    let mut missing = Vec::new();
+    let mut current = path.to_path_buf();
+    loop {
+        match fs::symlink_metadata(&current) {
+            Ok(metadata) => {
+                if metadata.file_type().is_symlink() {
+                    return Err(format!("{label} 不能包含符号链接：{}", current.display()));
+                }
+                #[cfg(windows)]
+                {
+                    use std::os::windows::fs::MetadataExt;
+                    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+                    if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+                        return Err(format!(
+                            "{label} 不能包含 Windows reparse point：{}",
+                            current.display()
+                        ));
+                    }
+                }
+                if !metadata.is_dir() {
+                    return Err(format!(
+                        "{label} 父路径必须是普通目录：{}",
+                        current.display()
+                    ));
+                }
+                break;
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+                missing.push(current.clone());
+                current = current
+                    .parent()
+                    .ok_or_else(|| {
+                        format!("{label} 没有可用于创建的现存父目录：{}", path.display())
+                    })?
+                    .to_path_buf();
+            }
+            Err(error) => {
+                return Err(format!(
+                    "读取 {label} 元数据失败：{}: {error}",
+                    current.display()
+                ));
+            }
+        }
+    }
+
+    let created_target = missing.first().is_some_and(|created| created == path);
+    for directory in missing.into_iter().rev() {
+        let create_result = fs::create_dir(&directory);
+        match create_result {
+            Ok(()) => {
+                #[cfg(windows)]
+                if game_creator_private_path_allows_auto_elevation(&directory) {
+                    secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                        &directory, true, true,
+                    )?;
+                } else {
+                    secure_windows_game_creator_path_for_current_user_with_owner_policy(
+                        &directory, true, true, true,
+                    )?;
+                }
+                #[cfg(unix)]
+                {
+                    use std::os::unix::fs::PermissionsExt;
+                    fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).map_err(
+                        |error| format!("收紧 {label} 权限失败：{}: {error}", directory.display()),
+                    )?;
+                }
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {
+                // Another process won the create race. This object was not
+                // created by the current invocation, so it must go through
+                // the full existing-object owner/DACL gate before we touch
+                // any descendant. A type-only metadata check here would allow
+                // an attacker-created directory to become trusted.
+                prepare_game_creator_private_path_for_read(&directory, true, label)?;
+            }
+            #[cfg(windows)]
+            Err(error)
+                if matches!(
+                    error.kind(),
+                    std::io::ErrorKind::PermissionDenied | std::io::ErrorKind::WouldBlock
+                ) || matches!(error.raw_os_error(), Some(5)) =>
+            {
+                let parent = directory.parent().ok_or_else(|| {
+                    format!("创建 {label} 失败：{}: {error}", directory.display())
+                })?;
+                if game_creator_private_path_allows_auto_elevation(parent) {
+                    secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                        parent, true, true,
+                    )?;
+                } else {
+                    secure_windows_game_creator_path_for_current_user_with_owner_policy(
+                        parent, true, true, true,
+                    )?;
+                }
+                fs::create_dir(&directory).map_err(|retry_error| {
+                    format!("创建 {label} 失败：{}: {retry_error}", directory.display())
+                })?;
+                if game_creator_private_path_allows_auto_elevation(&directory) {
+                    secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                        &directory, true, true,
+                    )?;
+                } else {
+                    secure_windows_game_creator_path_for_current_user_with_owner_policy(
+                        &directory, true, true, true,
+                    )?;
+                }
+            }
+            Err(error) => {
+                return Err(format!(
+                    "创建 {label} 失败：{}: {error}",
+                    directory.display()
+                ));
+            }
+        }
+        let metadata = fs::symlink_metadata(&directory)
+            .map_err(|error| format!("复核 {label} 失败：{}: {error}", directory.display()))?;
+        if metadata.file_type().is_symlink() || !metadata.is_dir() {
+            return Err(format!("{label} 必须是普通目录：{}", directory.display()));
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::MetadataExt;
+            const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+            if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+                return Err(format!(
+                    "{label} 不能是 Windows reparse point：{}",
+                    directory.display()
+                ));
+            }
+        }
+    }
+    Ok(created_target)
+}
+
+/// Hardens a directory or file that this invocation has just created.  This
+/// intentionally does not adopt an existing object: callers that discover an
+/// existing path must go through `prepare_game_creator_private_path_for_read`,
+/// which performs the strict owner/reparse/DACL checks and the controlled UAC
+/// repair flow.  Keeping the two paths separate prevents a race from turning
+/// an attacker-owned object into an AGC-managed credential or sidecar file.
+pub(crate) fn harden_new_game_creator_private_path(
+    path: &Path,
+    is_directory: bool,
+    label: &str,
+) -> Result<(), String> {
+    if !path.is_absolute() {
+        return Err(format!("{label}必须是绝对路径"));
+    }
+    let metadata = fs::symlink_metadata(path)
+        .map_err(|error| format!("读取新建 {label} 元数据失败：{}: {error}", path.display()))?;
+    if metadata.file_type().is_symlink()
+        || (is_directory && !metadata.is_dir())
+        || (!is_directory && !metadata.is_file())
+    {
+        return Err(format!(
+            "新建 {label} 必须是普通{}，不能是链接或其他对象：{}",
+            if is_directory { "目录" } else { "文件" },
+            path.display()
+        ));
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::MetadataExt;
+        const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+        if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+            return Err(format!(
+                "新建 {label} 不能是 Windows reparse point：{}",
+                path.display()
+            ));
+        }
+        // A newly-created object normally inherits the creator's security
+        // descriptor.  AGC-owned roots may request the one-shot UAC repair;
+        // a user-selected path is still hardened strictly after creation so
+        // a race cannot turn an attacker-owned object into a credential file.
+        if game_creator_private_path_allows_auto_elevation(path) {
+            secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                path,
+                is_directory,
+                true,
+            )?;
+        } else {
+            secure_windows_game_creator_path_for_current_user_with_owner_policy(
+                path,
+                is_directory,
+                true,
+                true,
+            )?;
+        }
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        fs::set_permissions(
+            path,
+            fs::Permissions::from_mode(if is_directory { 0o700 } else { 0o600 }),
+        )
+        .map_err(|error| format!("收紧新建 {label} 权限失败：{}: {error}", path.display()))?;
+    }
+    Ok(())
+}
+
+/// Writes a regular AGC-managed file only after its parent and any existing
+/// target have passed the private-path policy.  The post-write check also
+/// hardens a newly-created file, so inherited Windows ACLs cannot remain on a
+/// file that was created by this process.
+pub(crate) fn write_game_creator_private_file(
+    path: &Path,
+    bytes: &[u8],
+    label: &str,
+) -> Result<(), String> {
+    if !path.is_absolute() {
+        return Err(format!("{label}必须是绝对路径"));
+    }
+    let parent = path.parent().ok_or_else(|| format!("{label}缺少父目录"))?;
+    ensure_game_creator_private_directory_tree(parent, label)?;
+    prepare_game_creator_private_path_for_read(parent, true, label)?;
+    let existed = prepare_game_creator_private_path_for_read(path, false, label)?;
+
+    // Never write directly through the checked pathname.  A pathname can be
+    // replaced after the preflight by another process (or by a junction/link
+    // attack).  Create and harden a sibling temporary inode first, then link
+    // it into place without replacement.  Existing targets are moved to a
+    // unique backup only after a second strict check; if installation fails,
+    // the original target is restored.
+    let file_name = path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .ok_or_else(|| format!("{label}文件名无效"))?;
+    let temporary = (0..8)
+        .map(|attempt| {
+            path.with_file_name(format!(
+                ".{file_name}.tmp-{}-{}-{attempt}",
+                std::process::id(),
+                uuid::Uuid::new_v4().simple()
+            ))
+        })
+        .find(|candidate| {
+            matches!(
+                fs::symlink_metadata(candidate),
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound
+            )
+        })
+        .ok_or_else(|| format!("创建 {label} 临时文件路径失败：目录中存在冲突残留"))?;
+
+    let mut options = fs::OpenOptions::new();
+    options.write(true).create_new(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.custom_flags(libc::O_NOFOLLOW).mode(0o600);
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+        options.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT);
+    }
+    let mut file = options.open(&temporary).map_err(|error| {
+        format!(
+            "创建 {label} 临时文件失败：{}: {error}",
+            temporary.display()
+        )
+    })?;
+    if let Err(error) = harden_new_game_creator_private_path(&temporary, false, label) {
+        drop(file);
+        let _ = fs::remove_file(&temporary);
+        return Err(error);
+    }
+    let write_result = std::io::Write::write_all(&mut file, bytes).and_then(|_| file.sync_all());
+    drop(file);
+    if let Err(error) = write_result {
+        let _ = fs::remove_file(&temporary);
+        return Err(format!(
+            "写入 {label} 临时文件失败：{}: {error}",
+            temporary.display()
+        ));
+    }
+    let backup = path.with_file_name(format!(
+        ".{file_name}.previous-{}-{}",
+        std::process::id(),
+        uuid::Uuid::new_v4().simple()
+    ));
+    if existed {
+        // Re-check immediately before moving the old target.  Links and
+        // reparse points remain fail-closed; only a regular managed file may
+        // enter the recoverable replacement path.
+        if let Err(error) = prepare_game_creator_private_path_for_read(path, false, label) {
+            let _ = fs::remove_file(&temporary);
+            return Err(error);
+        }
+        if fs::symlink_metadata(&backup).is_ok() {
+            let _ = fs::remove_file(&temporary);
+            return Err(format!("{label}替换备份路径已存在，已拒绝覆盖"));
+        }
+        if let Err(error) = fs::rename(path, &backup) {
+            let _ = fs::remove_file(&temporary);
+            return Err(format!("准备替换 {label} 失败：{error}"));
+        }
+    }
+
+    let install_result = fs::hard_link(&temporary, path).and_then(|_| fs::remove_file(&temporary));
+    if let Err(error) = install_result {
+        let _ = fs::remove_file(&temporary);
+        if existed {
+            let _ = fs::rename(&backup, path);
+        }
+        return Err(format!("原子安装 {label} 失败：{error}"));
+    }
+    if let Err(error) = prepare_game_creator_private_path_for_read(path, false, label) {
+        if existed {
+            let _ = fs::remove_file(path);
+            let _ = fs::rename(&backup, path);
+        } else {
+            let _ = fs::remove_file(path);
+        }
+        return Err(format!("复核 {label} 失败：{error}"));
+    }
+    if existed {
+        fs::remove_file(&backup)
+            .map_err(|error| format!("回收 {label} 旧文件备份失败：{error}"))?;
+    }
+    Ok(())
+}
+
+/// Appends to a regular AGC-managed file while applying the same ACL policy
+/// as replacement writes.  This is used for human-readable logs and memory
+/// journals whose append semantics are part of their existing contract.
+pub(crate) fn append_game_creator_private_file(
+    path: &Path,
+    bytes: &[u8],
+    label: &str,
+) -> Result<(), String> {
+    if !path.is_absolute() {
+        return Err(format!("{label}必须是绝对路径"));
+    }
+    let parent = path.parent().ok_or_else(|| format!("{label}缺少父目录"))?;
+    ensure_game_creator_private_directory_tree(parent, label)?;
+    prepare_game_creator_private_path_for_read(parent, true, label)?;
+    let existed = prepare_game_creator_private_path_for_read(path, false, label)?;
+    if existed {
+        let metadata = fs::symlink_metadata(path)
+            .map_err(|error| format!("读取 {label} 元数据失败：{}: {error}", path.display()))?;
+        if !metadata.is_file() {
+            return Err(format!("{label} 必须是普通文件"));
+        }
+    }
+    let mut options = fs::OpenOptions::new();
+    options.write(true).append(true).read(true);
+    if !existed {
+        options.create_new(true);
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.custom_flags(libc::O_NOFOLLOW).mode(0o600);
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+        const FILE_SHARE_READ: u32 = 0x0000_0001;
+        const FILE_SHARE_WRITE: u32 = 0x0000_0002;
+        const FILE_SHARE_DELETE: u32 = 0x0000_0004;
+        options
+            .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
+            .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE);
+    }
+    let mut file = options
+        .open(path)
+        .map_err(|error| format!("写入 {label} 失败：{}: {error}", path.display()))?;
+    let opened_metadata = file.metadata().map_err(|error| {
+        format!(
+            "读取 {label} 文件句柄元数据失败：{}: {error}",
+            path.display()
+        )
+    })?;
+    if !opened_metadata.is_file() {
+        drop(file);
+        return Err(format!("{label} 必须是普通文件"));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        if opened_metadata.nlink() != 1 {
+            drop(file);
+            return Err(format!("{label} 不能是硬链接"));
+        }
+        let path_metadata = fs::symlink_metadata(path)
+            .map_err(|error| format!("复核 {label} 路径失败：{}: {error}", path.display()))?;
+        if path_metadata.file_type().is_symlink()
+            || path_metadata.dev() != opened_metadata.dev()
+            || path_metadata.ino() != opened_metadata.ino()
+        {
+            drop(file);
+            return Err(format!("{label} 路径在安全打开期间发生替换"));
+        }
+    }
+    #[cfg(windows)]
+    crate::runner::validate_windows_regular_file_handle(&file, label)?;
+    if !existed {
+        if let Err(error) = harden_new_game_creator_private_path(path, false, label) {
+            drop(file);
+            let _ = fs::remove_file(path);
+            return Err(error);
+        }
+    }
+    use std::io::Write as _;
+    file.write_all(bytes)
+        .and_then(|_| file.sync_data())
+        .map_err(|error| format!("写入 {label} 失败：{}: {error}", path.display()))?;
+    if existed {
+        prepare_game_creator_private_path_for_read(path, false, label)?;
+    }
+    Ok(())
+}
+
+/// Checks a private file/directory before the caller opens it.  Windows ACL
+/// failures must be handled before `OpenOptions::open`: an inherited DACL can
+/// otherwise make the open fail before the strict verifier gets a chance to
+/// request UAC repair.  Missing leaves are returned as `false`; existing
+/// objects are fully validated and, on Windows, repaired/re-validated through
+/// the normal auto-elevation path.
+pub(crate) fn prepare_game_creator_private_path_for_read(
+    path: &Path,
+    is_directory: bool,
+    label: &str,
+) -> Result<bool, String> {
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false),
+        Err(error) => {
+            let detail = format!("读取 {label} 元数据失败：{}: {error}", path.display());
+            #[cfg(windows)]
+            {
+                let result = if game_creator_private_path_allows_auto_elevation(path) {
+                    secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                        path,
+                        is_directory,
+                        true,
+                    )
+                } else {
+                    secure_windows_game_creator_path_for_current_user(path, is_directory, true)
+                };
+                return result.map(|_| true).map_err(|repair_error| {
+                    if game_creator_private_path_allows_auto_elevation(path) {
+                        format!("{detail}；自动提权修复未完成：{repair_error}")
+                    } else {
+                        format!("{detail}；严格私有权限校验未通过：{repair_error}")
+                    }
+                });
+            }
+            #[cfg(not(windows))]
+            return Err(detail);
+        }
+    };
+    if metadata.file_type().is_symlink()
+        || (is_directory && !metadata.is_dir())
+        || (!is_directory && !metadata.is_file())
+    {
+        return Err(format!(
+            "{label} 必须是普通{}，不能是链接或其他对象：{}",
+            if is_directory { "目录" } else { "文件" },
+            path.display()
+        ));
+    }
+    // Metadata on the leaf can be readable while traversal of an ancestor is
+    // blocked by a foreign owner or inherited ACL.  Give the managed object a
+    // single explicit repair opportunity before surfacing a permission error;
+    // links/reparse points have already been rejected above and therefore stay
+    // fail-closed.
+    #[cfg(windows)]
+    validate_game_creator_private_path_ancestors_with_auto_elevation(path, label)?;
+    #[cfg(not(windows))]
+    validate_game_creator_private_path_ancestors(path, label)?;
+    #[cfg(windows)]
+    if game_creator_private_path_allows_auto_elevation(path) {
+        secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+            path,
+            is_directory,
+            true,
+        )?;
+    } else {
+        // User-selected external files are never silently adopted.  Keep the
+        // strict owner/DACL check, but do not escalate an arbitrary path.
+        secure_windows_game_creator_path_for_current_user(path, is_directory, true)?;
+    }
+    Ok(true)
+}
+
+/// Prepares a path returned by an explicit native file picker.  On Windows,
+/// owner/DACL failures on a regular selected object receive the same one-shot
+/// UAC repair as AGC-managed files, including projects stored outside the
+/// current profile.  Reparse points, links, non-regular objects and ancestor
+/// type conflicts are rejected before any repair attempt.
+pub(crate) fn prepare_game_creator_user_selected_path_for_read(
+    path: &Path,
+    is_directory: bool,
+    label: &str,
+) -> Result<bool, String> {
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false),
+        Err(error) => {
+            let detail = format!("读取 {label} 元数据失败：{}: {error}", path.display());
+            #[cfg(windows)]
+            {
+                // Explicit native file-picker/project-root selections are
+                // bounded UAC targets even when the normal token cannot
+                // traverse far enough to read leaf metadata. The helper still
+                // re-validates owner, type and reparse state before changing
+                // anything.
+                if user_selected_path_is_authorized(path, is_directory)
+                    && game_creator_user_selected_path_allows_auto_elevation(path)
+                    && windows_acl_error_may_need_elevation(&detail)
+                {
+                    return secure_windows_game_creator_path_for_current_user_with_auto_elevation_scoped(
+                        path,
+                        is_directory,
+                        true,
+                        WindowsAclRepairScope::UserSelected,
+                    )
+                    .map(|_| true)
+                    .map_err(|repair_error| {
+                        format!("{detail}；自动提权修复未完成：{repair_error}")
+                    });
+                }
+            }
+            return Err(detail);
+        }
+    };
+    if metadata.file_type().is_symlink()
+        || (is_directory && !metadata.is_dir())
+        || (!is_directory && !metadata.is_file())
+    {
+        return Err(format!(
+            "{label} 必须是普通{}，不能是链接或其他对象：{}",
+            if is_directory { "目录" } else { "文件" },
+            path.display()
+        ));
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::MetadataExt;
+        const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+        if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+            return Err(format!(
+                "{label} 不能是 Windows reparse point：{}",
+                path.display()
+            ));
+        }
+        if user_selected_path_is_authorized(path, is_directory)
+            && game_creator_user_selected_path_allows_auto_elevation(path)
+        {
+            validate_game_creator_private_path_ancestors_with_auto_elevation_scoped(
+                path,
+                label,
+                WindowsAclRepairScope::UserSelected,
+            )?;
+            secure_windows_game_creator_path_for_current_user_with_auto_elevation_scoped(
+                path,
+                is_directory,
+                true,
+                WindowsAclRepairScope::UserSelected,
+            )?;
+        } else {
+            validate_game_creator_private_path_ancestors(path, label)?;
+            secure_windows_game_creator_path_for_current_user(path, is_directory, true)?;
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        validate_game_creator_private_path_ancestors(path, label)?;
+    }
+    Ok(true)
+}
+
+/// Reads an AGC-managed private text file through a validated regular-file
+/// handle. The pathname is used only for preflight/open identity checks; bytes
+/// are read from the handle so a later rename cannot redirect the read.
+pub(crate) fn read_game_creator_private_file_to_string(
+    path: &Path,
+    label: &str,
+    max_bytes: u64,
+) -> Result<String, String> {
+    let (mut file, metadata) = open_project_private_regular_file(path, label)?;
+    if metadata.len() > max_bytes {
+        return Err(format!("{label}过大，已拒绝读取：{}", path.display()));
+    }
+    let mut content = String::with_capacity(metadata.len() as usize);
+    file.read_to_string(&mut content)
+        .map_err(|error| format!("读取{label}失败：{}: {error}", path.display()))?;
+    let final_metadata = file
+        .metadata()
+        .map_err(|error| format!("复核{label}失败：{}: {error}", path.display()))?;
+    if final_metadata.len() != metadata.len() {
+        return Err(format!("{label}读取期间文件发生漂移：{}", path.display()));
+    }
+    Ok(content)
+}
+
 fn resolve_game_creator_runtime_config_dir(
     path: &Path,
     create_and_tighten: bool,
@@ -645,18 +1798,24 @@ fn resolve_game_creator_runtime_config_dir(
     if !path.is_absolute() {
         return Err("客户端 AppData 配置目录必须是绝对路径".to_string());
     }
+    #[cfg(windows)]
+    validate_game_creator_private_path_ancestors_with_auto_elevation_scoped(
+        path,
+        "客户端 AppData 配置目录",
+        game_creator_runtime_config_repair_scope(path),
+    )?;
+    #[cfg(not(windows))]
+    validate_game_creator_private_path_ancestors(path, "客户端 AppData 配置目录")?;
     let mut created = false;
     if create_and_tighten {
         match fs::symlink_metadata(path) {
             Ok(_) => {}
             Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                 if let Some(parent) = path.parent() {
-                    fs::create_dir_all(parent).map_err(|create_error| {
-                        format!(
-                            "创建客户端 AppData 配置父目录失败：{}: {create_error}",
-                            parent.display()
-                        )
-                    })?;
+                    ensure_game_creator_private_directory_tree(
+                        parent,
+                        "客户端 AppData 配置父目录",
+                    )?;
                 }
                 match fs::create_dir(path) {
                     Ok(()) => created = true,
@@ -681,18 +1840,71 @@ fn resolve_game_creator_runtime_config_dir(
     }
     // canonicalize 会跟随目录链接，因此必须先检查用户给出的目录项本身。
     validate_game_creator_runtime_config_dir_entry_type(path)?;
-    let canonical = fs::canonicalize(path).map_err(|error| {
-        format!(
-            "解析客户端 AppData 配置目录失败：{}: {error}",
-            path.display()
-        )
-    })?;
+    let canonical = match fs::canonicalize(path) {
+        Ok(canonical) => canonical,
+        Err(error) => {
+            let detail = format!(
+                "解析客户端 AppData 配置目录失败：{}: {error}",
+                path.display()
+            );
+            #[cfg(windows)]
+            if !cfg!(test)
+                && windows_acl_error_may_need_elevation(&detail)
+                && game_creator_private_path_allows_auto_elevation(path)
+            {
+                // canonicalize follows the directory and therefore can fail
+                // with access denied before the normal owner/DACL verifier is
+                // reached.  Repair the managed target first, then canonicalize
+                // again so a denied config directory gets the same one-shot
+                // UAC treatment as an already-readable object.
+                let target_user_sid = current_windows_token_user_sid_string()
+                    .map_err(|sid_error| format!("{detail}；读取当前用户 SID 失败：{sid_error}"))?;
+                attempt_elevated_windows_acl_repair(
+                    path,
+                    &target_user_sid,
+                    game_creator_runtime_config_repair_scope(path),
+                )
+                .map_err(|repair_error| format!("{detail}；自动提权修复未完成：{repair_error}"))?;
+                validate_game_creator_runtime_config_dir_metadata(path, true, false)?;
+                return fs::canonicalize(path).map_err(|canonicalize_error| {
+                    format!(
+                        "ACL 修复后解析客户端 AppData 配置目录失败：{}: {canonicalize_error}",
+                        path.display()
+                    )
+                });
+            }
+            return Err(detail);
+        }
+    };
     match validate_game_creator_runtime_config_dir_metadata(&canonical, create_and_tighten, created)
     {
         Ok(()) => {}
         #[cfg(windows)]
+        Err(error) if !cfg!(test) && windows_acl_error_may_need_elevation(&error) => {
+            // Any existing private AppData directory that cannot be safely
+            // read is repaired through the one-shot elevated helper.  This
+            // covers inherited ACLs and foreign owners while the earlier
+            // entry/reparse checks remain fail-closed.
+            let target_user_sid = current_windows_token_user_sid_string()
+                .map_err(|sid_error| format!("{error}；读取当前用户 SID 失败：{sid_error}"))?;
+            attempt_elevated_windows_acl_repair(
+                path,
+                &target_user_sid,
+                game_creator_runtime_config_repair_scope(path),
+            )
+            .map_err(|repair_error| format!("{error}；自动提权修复未完成：{repair_error}"))?;
+            validate_game_creator_runtime_config_dir_metadata(path, true, false)?;
+            return fs::canonicalize(path).map_err(|canonicalize_error| {
+                format!(
+                    "ACL 修复后解析客户端 AppData 配置目录失败：{}: {canonicalize_error}",
+                    path.display()
+                )
+            });
+        }
+        #[cfg(windows)]
         Err(error)
-            if create_and_tighten
+            if cfg!(test)
+                && create_and_tighten
                 && !created
                 && error.starts_with("Windows 安全对象不属于当前用户：") =>
         {
@@ -820,14 +2032,102 @@ pub(crate) fn secure_windows_game_creator_path_for_current_user(
     is_directory: bool,
     tighten: bool,
 ) -> Result<(), String> {
-    secure_windows_game_creator_path_for_current_user_with_owner_policy(
+    secure_windows_game_creator_path_for_user_sid_with_owner_policy(
         path,
         is_directory,
         tighten,
         false,
+        None,
     )
 }
 
+/// Strictly validates a Windows private object and, when its owner/DACL cannot
+/// be used by the current account, performs one explicit UAC repair before
+/// validating again. Reparse points and non-regular objects remain
+/// fail-closed; a repaired regular object is reassigned to the current token
+/// user and receives a private non-inherited DACL.
+#[cfg(windows)]
+pub(crate) fn secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+    path: &Path,
+    is_directory: bool,
+    tighten: bool,
+) -> Result<(), String> {
+    secure_windows_game_creator_path_for_current_user_with_auto_elevation_scoped(
+        path,
+        is_directory,
+        tighten,
+        WindowsAclRepairScope::Managed,
+    )
+}
+
+/// Same strict verifier as the managed-path entry, but with an explicit scope
+/// selected by the caller.  This is used by file-picker imports only; the
+/// scope is included in the one-shot UAC ticket and checked again by the
+/// elevated child process.
+#[cfg(windows)]
+fn secure_windows_game_creator_path_for_current_user_with_auto_elevation_scoped(
+    path: &Path,
+    is_directory: bool,
+    tighten: bool,
+    scope: WindowsAclRepairScope,
+) -> Result<(), String> {
+    #[cfg(test)]
+    {
+        // Unit tests must not trigger an interactive UAC prompt.  The strict
+        // verifier remains directly testable.  For an owner-correct object
+        // whose only defect is an inherited DACL, emulate the formal prepare
+        // entry's local tightening in-process; foreign-owner fixtures still
+        // fail closed because they cannot be reassigned without elevation.
+        return match secure_windows_game_creator_path_for_current_user(path, is_directory, tighten)
+        {
+            Ok(()) => Ok(()),
+            Err(error)
+                if scope.allows_path(path)
+                    && windows_acl_error_may_need_elevation(&error)
+                    && !error.contains("安全对象不属于当前用户") =>
+            {
+                secure_windows_game_creator_path_for_current_user_with_owner_policy(
+                    path,
+                    is_directory,
+                    true,
+                    false,
+                )
+            }
+            Err(error) => Err(error),
+        };
+    }
+    #[cfg(not(test))]
+    {
+        let target_user_sid = current_windows_token_user_sid_string()?;
+        let mut attempted_targets = Vec::<PathBuf>::new();
+        loop {
+            match secure_windows_game_creator_path_for_current_user(path, is_directory, tighten) {
+                Ok(()) => return Ok(()),
+                Err(error) if windows_acl_error_may_need_elevation(&error) => {
+                    if !scope.allows_path(path) {
+                        return Err(error);
+                    }
+                    let repair_target = windows_acl_repair_target(path, scope);
+                    if attempted_targets
+                        .iter()
+                        .any(|target| target == &repair_target)
+                    {
+                        return Err(format!(
+                            "{error}；自动提权修复重复命中同一目标，拒绝继续重试：{}",
+                            repair_target.display()
+                        ));
+                    }
+                    attempted_targets.push(repair_target);
+                    attempt_elevated_windows_acl_repair(path, &target_user_sid, scope).map_err(
+                        |repair_error| format!("{error}；自动提权修复未完成：{repair_error}"),
+                    )?;
+                }
+                Err(error) => return Err(error),
+            }
+        }
+    }
+}
+
 #[cfg(windows)]
 pub(crate) fn initialize_windows_game_creator_file_owner_for_current_user(
     path: &Path,
@@ -845,6 +2145,451 @@ pub(crate) fn initialize_windows_game_creator_directory_owner_for_current_user(
     secure_windows_game_creator_path_for_current_user_with_owner_policy(path, true, true, true)
 }
 
+/// Repairs an AGC-managed private object after an explicit UAC elevation.
+/// Foreign-owned regular files/directories are deliberately reassigned to the
+/// current token user here. The caller has already rejected links/reparse
+/// points, and the final strict verification below is mandatory.
+#[cfg(windows)]
+pub(crate) fn repair_game_creator_private_acl_for_current_user(path: &Path) -> Result<(), String> {
+    let target_user_sid = current_windows_token_user_sid_string()?;
+    repair_game_creator_private_acl_for_user_sid(path, &target_user_sid)
+}
+
+#[cfg(windows)]
+fn current_windows_token_user_sid_string() -> Result<String, String> {
+    use std::ffi::c_void;
+
+    type Handle = *mut c_void;
+    type Sid = *mut c_void;
+
+    #[repr(C)]
+    struct SidAndAttributes {
+        sid: Sid,
+        attributes: u32,
+    }
+
+    #[repr(C)]
+    struct TokenUser {
+        user: SidAndAttributes,
+    }
+
+    #[link(name = "advapi32")]
+    unsafe extern "system" {
+        fn OpenProcessToken(process: Handle, access: u32, token: *mut Handle) -> i32;
+        fn GetTokenInformation(
+            token: Handle,
+            information_class: u32,
+            information: *mut c_void,
+            information_length: u32,
+            return_length: *mut u32,
+        ) -> i32;
+        fn ConvertSidToStringSidW(sid: Sid, string_sid: *mut *mut u16) -> i32;
+    }
+
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        fn GetCurrentProcess() -> Handle;
+        fn CloseHandle(handle: Handle) -> i32;
+        fn LocalFree(memory: *mut c_void) -> *mut c_void;
+    }
+
+    const TOKEN_QUERY: u32 = 0x0000_0008;
+    const TOKEN_USER_CLASS: u32 = 1;
+
+    let mut token = std::ptr::null_mut();
+    if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) } == 0
+        || token.is_null()
+    {
+        return Err(format!(
+            "读取 Windows 当前用户 token 失败：{}",
+            std::io::Error::last_os_error()
+        ));
+    }
+    let result = (|| {
+        let mut required = 0_u32;
+        unsafe {
+            GetTokenInformation(
+                token,
+                TOKEN_USER_CLASS,
+                std::ptr::null_mut(),
+                0,
+                &mut required,
+            );
+        }
+        if required == 0 {
+            return Err("读取 Windows 当前用户 SID 长度失败".to_string());
+        }
+        let word_size = std::mem::size_of::<usize>();
+        let mut token_buffer = vec![0_usize; (required as usize).div_ceil(word_size)];
+        if unsafe {
+            GetTokenInformation(
+                token,
+                TOKEN_USER_CLASS,
+                token_buffer.as_mut_ptr().cast(),
+                required,
+                &mut required,
+            )
+        } == 0
+        {
+            return Err(format!(
+                "读取 Windows 当前用户 SID 失败：{}",
+                std::io::Error::last_os_error()
+            ));
+        }
+        let sid = unsafe { (*(token_buffer.as_ptr().cast::<TokenUser>())).user.sid };
+        if sid.is_null() {
+            return Err("Windows 当前用户 SID 无效".to_string());
+        }
+        let mut string_sid = std::ptr::null_mut();
+        if unsafe { ConvertSidToStringSidW(sid, &mut string_sid) } == 0 || string_sid.is_null() {
+            return Err(format!(
+                "转换 Windows 当前用户 SID 失败：{}",
+                std::io::Error::last_os_error()
+            ));
+        }
+        let mut length = 0_usize;
+        while unsafe { *string_sid.add(length) } != 0 {
+            length = length.saturating_add(1);
+            if length > 256 {
+                unsafe { LocalFree(string_sid.cast()) };
+                return Err("Windows 当前用户 SID 长度无效".to_string());
+            }
+        }
+        let value = String::from_utf16(unsafe { std::slice::from_raw_parts(string_sid, length) })
+            .map_err(|_| "Windows 当前用户 SID 编码无效".to_string());
+        unsafe { LocalFree(string_sid.cast()) };
+        value
+    })();
+    unsafe { CloseHandle(token) };
+    result
+}
+
+/// The elevated helper may run under administrator credentials that differ
+/// from the original desktop user's token. Keep ownership and the private
+/// DACL bound to the original TokenUser SID passed by the caller.
+#[cfg(windows)]
+pub(crate) fn repair_game_creator_private_acl_for_user_sid(
+    path: &Path,
+    target_user_sid: &str,
+) -> Result<(), String> {
+    let metadata = fs::symlink_metadata(path)
+        .map_err(|error| format!("读取待修复私有对象失败：{}: {error}", path.display()))?;
+    use std::os::windows::fs::MetadataExt;
+    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+    if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+        || metadata.file_type().is_symlink()
+    {
+        return Err("待修复私有对象不能是 Windows reparse point 或链接".to_string());
+    }
+    if !metadata.is_dir() && !metadata.is_file() {
+        return Err("待修复私有对象必须是普通文件或目录".to_string());
+    }
+    secure_windows_game_creator_path_for_user_sid_with_owner_policy(
+        path,
+        metadata.is_dir(),
+        true,
+        true,
+        Some(target_user_sid),
+    )
+}
+
+#[cfg(windows)]
+pub(crate) fn windows_acl_error_may_need_elevation(error: &str) -> bool {
+    (error.contains("DACL")
+        || error.contains("权限")
+        || error.contains("error 5")
+        || error.contains("安全对象不属于当前用户")
+        || error.contains("启用 Windows")
+        || error.contains("特权")
+        || error.contains("1300"))
+        && !error.contains("链接")
+        && !error.contains("reparse")
+}
+
+#[cfg(windows)]
+fn windows_acl_repair_target(path: &Path, scope: WindowsAclRepairScope) -> PathBuf {
+    // A user-selected object is the only trusted identity in that scope.  Do
+    // not widen it to an unreadable parent (which could be another user's
+    // profile or a protected system directory); the helper will validate the
+    // selected regular object itself and fail closed if traversal remains
+    // impossible.  Managed paths have an established AGC root and may repair
+    // the first blocked ancestor so inherited ACLs can be fixed in one pass.
+    if matches!(scope, WindowsAclRepairScope::UserSelected) {
+        return path.to_path_buf();
+    }
+    // Walk from the filesystem root towards the leaf.  If traversal is denied
+    // on an ancestor, repairing the leaf cannot help because the elevated
+    // helper will hit the same ancestor before it can inspect the leaf.
+    for ancestor in path.ancestors().collect::<Vec<_>>().into_iter().rev() {
+        match fs::symlink_metadata(ancestor) {
+            Ok(_) => {}
+            Err(error)
+                if error.kind() == std::io::ErrorKind::PermissionDenied
+                    || error.raw_os_error() == Some(5) =>
+            {
+                return ancestor.to_path_buf();
+            }
+            Err(_) => {}
+        }
+    }
+    path.to_path_buf()
+}
+
+#[cfg(windows)]
+const WINDOWS_ACL_REPAIR_AUTHORIZATION_MAX_BYTES: u64 = 4 * 1024;
+
+#[cfg(windows)]
+struct WindowsAclRepairAuthorizationCleanup {
+    path: PathBuf,
+    armed: bool,
+}
+
+#[cfg(windows)]
+impl WindowsAclRepairAuthorizationCleanup {
+    fn new(path: PathBuf) -> Self {
+        Self { path, armed: true }
+    }
+
+    fn disarm(&mut self) {
+        self.armed = false;
+    }
+}
+
+#[cfg(windows)]
+impl Drop for WindowsAclRepairAuthorizationCleanup {
+    fn drop(&mut self) {
+        if self.armed {
+            let _ = fs::remove_file(&self.path);
+        }
+    }
+}
+
+#[cfg(windows)]
+#[derive(Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct WindowsAclRepairAuthorization {
+    path: String,
+    target_user_sid: String,
+    scope: String,
+    issued_at: u64,
+}
+
+#[cfg(windows)]
+fn windows_acl_repair_authorization_path(nonce: &str) -> Result<PathBuf, String> {
+    let nonce = nonce.trim();
+    if nonce.len() != 32 || !nonce.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+        return Err("AGC ACL 修复授权票据无效".to_string());
+    }
+    let temporary_directory = std::env::temp_dir();
+    if !temporary_directory.is_absolute() {
+        return Err("AGC ACL 修复临时目录必须是绝对路径".to_string());
+    }
+    Ok(temporary_directory.join(format!(".genarrative-acl-repair-{nonce}.json")))
+}
+
+#[cfg(windows)]
+fn create_windows_acl_repair_authorization(
+    path: &Path,
+    target_user_sid: &str,
+    scope: WindowsAclRepairScope,
+) -> Result<String, String> {
+    let nonce = uuid::Uuid::new_v4().simple().to_string();
+    let authorization_path = windows_acl_repair_authorization_path(&nonce)?;
+    let payload = serde_json::to_vec(&WindowsAclRepairAuthorization {
+        path: path.to_string_lossy().into_owned(),
+        target_user_sid: target_user_sid.to_string(),
+        scope: scope.wire_name().to_string(),
+        issued_at: unix_timestamp(),
+    })
+    .map_err(|error| format!("创建 AGC ACL 修复授权票据失败：{error}"))?;
+    let mut options = fs::OpenOptions::new();
+    options.write(true).create_new(true);
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
+    let mut file = options.open(&authorization_path).map_err(|error| {
+        format!(
+            "创建 AGC ACL 修复授权票据文件失败：{}: {error}",
+            authorization_path.display()
+        )
+    })?;
+    // The ticket is created in the per-user TEMP directory while the normal
+    // process is not elevated.  Do not call the auto-elevation wrapper here:
+    // that wrapper itself creates a ticket and would recurse indefinitely when
+    // TEMP inherits a broad DACL.  The strict owner-policy path can still
+    // tighten an owner-correct inherited ACL and rejects a foreign TEMP owner.
+    if let Err(error) = secure_windows_game_creator_path_for_current_user_with_owner_policy(
+        &authorization_path,
+        false,
+        true,
+        true,
+    ) {
+        drop(file);
+        let _ = fs::remove_file(&authorization_path);
+        return Err(format!("初始化 AGC ACL 修复授权票据安全权限失败：{error}"));
+    }
+    if let Err(error) = file.write_all(&payload).and_then(|_| file.sync_all()) {
+        drop(file);
+        let _ = fs::remove_file(&authorization_path);
+        return Err(format!("写入 AGC ACL 修复授权票据失败：{error}"));
+    }
+    drop(file);
+    Ok(nonce)
+}
+
+#[cfg(windows)]
+pub(crate) fn consume_windows_acl_repair_authorization(
+    path: &Path,
+    target_user_sid: &str,
+    nonce: &str,
+    scope: WindowsAclRepairScope,
+) -> Result<(), String> {
+    if !scope.allows_path(path) {
+        return Err(format!(
+            "AGC ACL 修复目标不在当前用户允许的 {} 范围内：{}",
+            scope.wire_name(),
+            path.display()
+        ));
+    }
+    let authorization_path = windows_acl_repair_authorization_path(nonce)?;
+    let mut cleanup = WindowsAclRepairAuthorizationCleanup::new(authorization_path.clone());
+
+    // Open the ticket before validating its contents. The security helper
+    // below uses GetNamedSecurityInfoW/SetNamedSecurityInfoW by pathname; an
+    // exclusive handle would make those calls fail with a sharing violation
+    // on Windows. Keep the ticket in the per-user TEMP directory with a
+    // hardened owner-only DACL, then validate the opened handle's metadata and
+    // exact payload before consuming the one-shot file.
+    use std::os::windows::fs::MetadataExt;
+    use std::os::windows::fs::OpenOptionsExt;
+    const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+    const FILE_SHARE_READ: u32 = 0x0000_0001;
+    const FILE_SHARE_WRITE: u32 = 0x0000_0002;
+    const FILE_SHARE_DELETE: u32 = 0x0000_0004;
+    use std::io::Read as _;
+    const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+    let mut file = fs::OpenOptions::new()
+        .read(true)
+        .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)
+        .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
+        .open(&authorization_path)
+        .map_err(|error| format!("读取 AGC ACL 修复授权票据内容失败：{error}"))?;
+    crate::runner::validate_windows_regular_file_handle(&file, "AGC ACL 修复授权票据")?;
+    let opened_metadata = file
+        .metadata()
+        .map_err(|error| format!("读取 AGC ACL 修复授权票据句柄元数据失败：{error}"))?;
+    if opened_metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0
+        || !opened_metadata.is_file()
+    {
+        return Err("AGC ACL 修复授权票据必须是普通文件".to_string());
+    }
+    if opened_metadata.len() > WINDOWS_ACL_REPAIR_AUTHORIZATION_MAX_BYTES {
+        return Err("AGC ACL 修复授权票据过大".to_string());
+    }
+    // The elevated helper runs under an administrator token, so validate the
+    // ticket against the original desktop user's SID rather than the helper's
+    // current SID. This also rejects a ticket placed in TEMP by another user.
+    // This check deliberately happens after opening the ticket handle so the
+    // payload is tied to a real regular file before it is authorized.
+    secure_windows_game_creator_path_for_user_sid_with_owner_policy(
+        &authorization_path,
+        false,
+        true,
+        false,
+        Some(target_user_sid),
+    )?;
+
+    let mut content = String::new();
+    file.read_to_string(&mut content)
+        .map_err(|error| format!("读取 AGC ACL 修复授权票据内容失败：{error}"))?;
+    let final_metadata = file
+        .metadata()
+        .map_err(|error| format!("复核 AGC ACL 修复授权票据句柄元数据失败：{error}"))?;
+    if final_metadata.len() != opened_metadata.len() {
+        return Err("AGC ACL 修复授权票据读取期间发生漂移".to_string());
+    }
+    let authorization = serde_json::from_str::<WindowsAclRepairAuthorization>(&content)
+        .map_err(|error| format!("AGC ACL 修复授权票据格式无效：{error}"))?;
+    if unix_timestamp().saturating_sub(authorization.issued_at) > 300 {
+        return Err("AGC ACL 修复授权票据已过期".to_string());
+    }
+    if authorization.path != path.to_string_lossy()
+        || authorization.target_user_sid != target_user_sid
+        || authorization.scope != scope.wire_name()
+    {
+        return Err("AGC ACL 修复授权票据与目标不匹配".to_string());
+    }
+
+    // Release the read handle before consuming the one-shot file. The cleanup
+    // guard retries removal on every failure path, while a successful removal
+    // disarms it to avoid a second delete attempt during unwinding.
+    drop(file);
+    fs::remove_file(&authorization_path)
+        .map_err(|error| format!("删除 AGC ACL 修复授权票据失败：{error}"))?;
+    cleanup.disarm();
+    Ok(())
+}
+
+/// Starts a one-shot elevated copy of the current executable.  The elevated
+/// process performs only the allow-listed ACL repair command and exits with a
+/// truthful status; UAC cancellation is never treated as success.
+#[cfg(windows)]
+fn attempt_elevated_windows_acl_repair(
+    path: &Path,
+    target_user_sid: &str,
+    scope: WindowsAclRepairScope,
+) -> Result<(), String> {
+    if !scope.allows_path(path) {
+        return Err(format!(
+            "AGC ACL 提权目标不在当前用户允许的 {} 范围内：{}",
+            scope.wire_name(),
+            path.display()
+        ));
+    }
+    let executable =
+        std::env::current_exe().map_err(|error| format!("定位 AGC ACL 修复程序失败：{error}"))?;
+    if !executable.is_file() {
+        return Err("AGC ACL 修复程序不存在".to_string());
+    }
+    let repair_path = windows_acl_repair_target(path, scope);
+    let nonce = create_windows_acl_repair_authorization(&repair_path, target_user_sid, scope)?;
+    let escaped_executable = executable.to_string_lossy().replace('\'', "''");
+    let escaped_path = repair_path.to_string_lossy().replace('\'', "''");
+    let escaped_target_user_sid = target_user_sid.replace('\'', "''");
+    let escaped_nonce = nonce.replace('\'', "''");
+    let script = format!(
+        "$ErrorActionPreference = 'Stop'; try {{ $p = Start-Process -Verb RunAs -Wait -PassThru -FilePath '{escaped_executable}' -ArgumentList @('--repair-private-acl','{escaped_path}','--target-user-sid','{escaped_target_user_sid}','--authorization','{escaped_nonce}','--scope','{}'); if ($null -eq $p) {{ exit 1223 }}; exit $p.ExitCode }} catch {{ exit 1223 }}",
+        scope.wire_name()
+    );
+    use std::os::windows::process::CommandExt;
+    let status = std::process::Command::new("powershell.exe")
+        .args([
+            "-NoProfile",
+            "-NonInteractive",
+            "-WindowStyle",
+            "Hidden",
+            "-Command",
+            script.as_str(),
+        ])
+        .creation_flags(0x0800_0000)
+        .status()
+        .map_err(|error| format!("启动 AGC ACL 提权修复失败：{error}"));
+    let _ = windows_acl_repair_authorization_path(&nonce).and_then(|authorization_path| {
+        fs::remove_file(authorization_path).map_err(|error| error.to_string())
+    });
+    let status = status?;
+    if status.success() {
+        Ok(())
+    } else {
+        Err(format!(
+            "AGC ACL 提权修复未成功（exit code {:?}）",
+            status.code()
+        ))
+    }
+}
+
 #[cfg(windows)]
 pub(crate) fn windows_private_dacl_security_information(
     initialize_owner: bool,
@@ -861,11 +2606,26 @@ pub(crate) fn windows_private_dacl_security_information(
         } else {
             0
         }
-        | if initialize_owner && !owner_matches {
-            OWNER_SECURITY_INFORMATION
-        } else {
-            0
-        }
+}
+
+#[cfg(windows)]
+fn windows_security_object_path(path: &Path) -> std::ffi::OsString {
+    use std::ffi::OsString;
+
+    let raw = path.as_os_str().to_string_lossy();
+    // GetNamedSecurityInfoW/SetNamedSecurityInfoW report ERROR_INVALID_NAME
+    // for ordinary absolute paths at the MAX_PATH boundary.  Extended-length
+    // paths are accepted by these APIs and preserve the exact object identity.
+    // Do not add the prefix twice, and translate UNC paths to the documented
+    // \\?\UNC\server\share form.
+    if raw.starts_with("\\\\?\\") || raw.encode_utf16().count() < 260 {
+        return path.as_os_str().to_os_string();
+    }
+    if let Some(unc) = raw.strip_prefix("\\\\") {
+        OsString::from(format!("\\\\?\\UNC\\{unc}"))
+    } else {
+        OsString::from(format!("\\\\?\\{raw}"))
+    }
 }
 
 #[cfg(windows)]
@@ -874,10 +2634,57 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
     is_directory: bool,
     tighten: bool,
     initialize_owner: bool,
+) -> Result<(), String> {
+    secure_windows_game_creator_path_for_user_sid_with_owner_policy(
+        path,
+        is_directory,
+        tighten,
+        initialize_owner,
+        None,
+    )
+}
+
+#[cfg(windows)]
+fn secure_windows_game_creator_path_for_user_sid_with_owner_policy(
+    path: &Path,
+    is_directory: bool,
+    tighten: bool,
+    initialize_owner: bool,
+    target_user_sid: Option<&str>,
 ) -> Result<(), String> {
     use std::ffi::c_void;
     use std::os::windows::ffi::OsStrExt;
 
+    let metadata = fs::symlink_metadata(path).map_err(|error| {
+        format!(
+            "读取 Windows 私有对象元数据失败：{}: {error}",
+            path.display()
+        )
+    })?;
+    if metadata.file_type().is_symlink() {
+        return Err(format!(
+            "Windows 私有对象不能是符号链接：{}",
+            path.display()
+        ));
+    }
+    {
+        use std::os::windows::fs::MetadataExt;
+        const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+        if metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+            return Err(format!(
+                "Windows 私有对象不能是 reparse point：{}",
+                path.display()
+            ));
+        }
+    }
+    if (is_directory && !metadata.is_dir()) || (!is_directory && !metadata.is_file()) {
+        return Err(format!(
+            "Windows 私有对象类型不符合预期：{}",
+            path.display()
+        ));
+    }
+    validate_game_creator_private_path_ancestors(path, "Windows 私有对象")?;
+
     type Handle = *mut c_void;
     type Sid = *mut c_void;
 
@@ -932,6 +2739,24 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
         sid_start: u32,
     }
 
+    #[repr(C)]
+    struct Luid {
+        low_part: u32,
+        high_part: i32,
+    }
+
+    #[repr(C)]
+    struct LuidAndAttributes {
+        luid: Luid,
+        attributes: u32,
+    }
+
+    #[repr(C)]
+    struct TokenPrivileges {
+        privilege_count: u32,
+        privileges: [LuidAndAttributes; 1],
+    }
+
     #[link(name = "advapi32")]
     unsafe extern "system" {
         fn GetNamedSecurityInfoW(
@@ -960,6 +2785,16 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
             new_acl: *mut *mut c_void,
         ) -> u32;
         fn OpenProcessToken(process: Handle, access: u32, token: *mut Handle) -> i32;
+        fn LookupPrivilegeValueW(system_name: *const u16, name: *const u16, luid: *mut Luid)
+            -> i32;
+        fn AdjustTokenPrivileges(
+            token: Handle,
+            disable_all_privileges: i32,
+            new_state: *mut TokenPrivileges,
+            buffer_length: u32,
+            previous_state: *mut TokenPrivileges,
+            return_length: *mut u32,
+        ) -> i32;
         fn GetTokenInformation(
             token: Handle,
             information_class: u32,
@@ -967,8 +2802,10 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
             information_length: u32,
             return_length: *mut u32,
         ) -> i32;
+        fn ConvertStringSidToSidW(string_sid: *const u16, sid: *mut Sid) -> i32;
         fn EqualSid(first: Sid, second: Sid) -> i32;
         fn IsValidSid(sid: Sid) -> i32;
+        fn GetLengthSid(sid: Sid) -> u32;
         fn IsValidAcl(acl: *mut c_void) -> i32;
         fn GetAce(acl: *mut c_void, index: u32, ace: *mut *mut c_void) -> i32;
         fn GetSecurityDescriptorControl(
@@ -983,6 +2820,7 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
         fn GetCurrentProcess() -> Handle;
         fn CloseHandle(handle: Handle) -> i32;
         fn LocalFree(memory: *mut c_void) -> *mut c_void;
+        fn GetLastError() -> u32;
     }
 
     const SE_FILE_OBJECT: u32 = 1;
@@ -990,7 +2828,10 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
     const DACL_SECURITY_INFORMATION: u32 = 0x0000_0004;
     const SE_DACL_PROTECTED: u16 = 0x1000;
     const TOKEN_QUERY: u32 = 0x0000_0008;
+    const TOKEN_ADJUST_PRIVILEGES: u32 = 0x0000_0020;
     const TOKEN_USER_CLASS: u32 = 1;
+    const SE_PRIVILEGE_ENABLED: u32 = 0x0000_0002;
+    const ERROR_NOT_ALL_ASSIGNED: u32 = 1300;
     const SET_ACCESS: i32 = 2;
     const TRUSTEE_IS_SID: i32 = 0;
     const TRUSTEE_IS_USER: i32 = 1;
@@ -1001,7 +2842,13 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
 
     let mut token = std::ptr::null_mut();
     // SAFETY: GetCurrentProcess returns a valid pseudo handle and token is a valid output pointer.
-    if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) } == 0
+    if unsafe {
+        OpenProcessToken(
+            GetCurrentProcess(),
+            TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
+            &mut token,
+        )
+    } == 0
         || token.is_null()
     {
         return Err(format!(
@@ -1010,6 +2857,7 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
         ));
     }
 
+    let mut requested_user_sid = std::ptr::null_mut();
     let result = (|| {
         let mut required = 0_u32;
         // SAFETY: the null query buffer is the documented size-probe call.
@@ -1048,8 +2896,34 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
         if current_user_sid.is_null() || unsafe { IsValidSid(current_user_sid) } == 0 {
             return Err("Windows 当前用户 SID 无效".to_string());
         }
+        let target_user_sid = if let Some(target_user_sid) = target_user_sid {
+            let target_user_sid = target_user_sid.trim();
+            if target_user_sid.is_empty() {
+                return Err("Windows ACL 修复目标 TokenUser SID 不能为空".to_string());
+            }
+            let mut wide_target_user_sid = target_user_sid
+                .encode_utf16()
+                .chain(std::iter::once(0))
+                .collect::<Vec<_>>();
+            if unsafe {
+                ConvertStringSidToSidW(wide_target_user_sid.as_mut_ptr(), &mut requested_user_sid)
+            } == 0
+                || requested_user_sid.is_null()
+                || unsafe { IsValidSid(requested_user_sid) } == 0
+            {
+                return Err("Windows ACL 修复目标 TokenUser SID 无效".to_string());
+            }
+            requested_user_sid
+        } else {
+            current_user_sid
+        };
 
-        let mut wide_path = path
+        // Security APIs otherwise reject a perfectly valid private sidecar at
+        // the MAX_PATH boundary with ERROR_INVALID_NAME.  Use the extended
+        // length spelling only when needed; short paths retain the ordinary
+        // Win32 form for compatibility with older Windows builds.
+        let security_path = windows_security_object_path(path);
+        let mut wide_path = security_path
             .as_os_str()
             .encode_wide()
             .chain(std::iter::once(0))
@@ -1079,7 +2953,7 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
             ));
         }
         let owner_matches = unsafe { IsValidSid(initial_owner) } != 0
-            && unsafe { EqualSid(initial_owner, current_user_sid) } != 0;
+            && unsafe { EqualSid(initial_owner, target_user_sid) } != 0;
         unsafe { LocalFree(initial_descriptor) };
         if !owner_matches {
             if !(initialize_owner && tighten) {
@@ -1088,6 +2962,58 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
                     path.display()
                 ));
             }
+
+            // Assigning ownership to the current token user requires the
+            // take-ownership/restore privileges on an elevated process.
+            // Enabling them is attempted only for this allow-listed repair;
+            // a normal process will fail and the caller will request UAC
+            // elevation instead of weakening the verifier.
+            for privilege_name in ["SeTakeOwnershipPrivilege", "SeRestorePrivilege"] {
+                let mut privilege_name_wide = privilege_name
+                    .encode_utf16()
+                    .chain(std::iter::once(0))
+                    .collect::<Vec<_>>();
+                let mut luid = Luid {
+                    low_part: 0,
+                    high_part: 0,
+                };
+                if unsafe {
+                    LookupPrivilegeValueW(
+                        std::ptr::null(),
+                        privilege_name_wide.as_mut_ptr(),
+                        &mut luid,
+                    )
+                } == 0
+                {
+                    return Err(format!(
+                        "启用 Windows {privilege_name} 失败：{}",
+                        std::io::Error::last_os_error()
+                    ));
+                }
+                let mut privileges = TokenPrivileges {
+                    privilege_count: 1,
+                    privileges: [LuidAndAttributes {
+                        luid,
+                        attributes: SE_PRIVILEGE_ENABLED,
+                    }],
+                };
+                let adjust_status = unsafe {
+                    AdjustTokenPrivileges(
+                        token,
+                        0,
+                        &mut privileges,
+                        std::mem::size_of::<TokenPrivileges>() as u32,
+                        std::ptr::null_mut(),
+                        std::ptr::null_mut(),
+                    )
+                };
+                let adjust_error = unsafe { GetLastError() };
+                if adjust_status == 0 || adjust_error == ERROR_NOT_ALL_ASSIGNED {
+                    return Err(format!(
+                        "启用 Windows {privilege_name} 失败：error {adjust_error}"
+                    ));
+                }
+            }
         }
         if tighten {
             let mut entry = ExplicitAccessW {
@@ -1103,7 +3029,7 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
                     multiple_trustee_operation: 0,
                     trustee_form: TRUSTEE_IS_SID,
                     trustee_type: TRUSTEE_IS_USER,
-                    name: current_user_sid.cast(),
+                    name: target_user_sid.cast(),
                 },
             };
             let mut private_dacl = std::ptr::null_mut();
@@ -1124,7 +3050,7 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
                     SE_FILE_OBJECT,
                     windows_private_dacl_security_information(initialize_owner, owner_matches),
                     if should_initialize_owner {
-                        current_user_sid
+                        target_user_sid
                     } else {
                         std::ptr::null_mut()
                     },
@@ -1171,8 +3097,7 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
         }
 
         let validation = (|| {
-            if unsafe { IsValidSid(owner) } == 0
-                || unsafe { EqualSid(owner, current_user_sid) } == 0
+            if unsafe { IsValidSid(owner) } == 0 || unsafe { EqualSid(owner, target_user_sid) } == 0
             {
                 return Err(format!(
                     "Windows 安全对象不属于当前用户：{}",
@@ -1229,18 +3154,23 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
             } else {
                 0
             };
-            if allowed.header.ace_flags & (OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE)
-                != required_inheritance
-            {
+            if allowed.header.ace_flags != required_inheritance {
                 return Err(format!("Windows DACL 继承边界无效：{}", path.display()));
             }
             let ace_sid = std::ptr::addr_of!(allowed.sid_start)
                 .cast_mut()
                 .cast::<c_void>();
-            if unsafe { IsValidSid(ace_sid) } == 0
-                || unsafe { EqualSid(ace_sid, current_user_sid) } == 0
+            let sid_length = unsafe { GetLengthSid(ace_sid) } as usize;
+            let sid_offset = std::mem::size_of::<AceHeader>() + std::mem::size_of::<u32>();
+            if sid_length == 0
+                || sid_offset.saturating_add(sid_length) > usize::from(header.ace_size)
+                || unsafe { IsValidSid(ace_sid) } == 0
+                || unsafe { EqualSid(ace_sid, target_user_sid) } == 0
             {
-                return Err(format!("Windows DACL 含非当前用户 ACE：{}", path.display()));
+                return Err(format!(
+                    "Windows DACL 当前用户 ACE 身份无效：{}",
+                    path.display()
+                ));
             }
             Ok(())
         })();
@@ -1250,6 +3180,10 @@ fn secure_windows_game_creator_path_for_current_user_with_owner_policy(
     })();
 
     // SAFETY: token was opened successfully above.
+    if !requested_user_sid.is_null() {
+        // SAFETY: ConvertStringSidToSidW allocates this SID with LocalAlloc.
+        unsafe { LocalFree(requested_user_sid.cast()) };
+    }
     unsafe { CloseHandle(token) };
     result
 }
@@ -1263,16 +3197,51 @@ pub(crate) fn configure_game_creator_runtime_config_dir(
     let config_dir = prepare_game_creator_runtime_config_dir(&requested_config_dir)
         .map_err(std::io::Error::other)?;
     let config_path = config_dir.join(GAME_CREATOR_CONFIG_FILE_NAME);
-    if !config_path.exists() {
+    let config_exists =
+        validate_game_creator_config_file_entry(&config_path).map_err(std::io::Error::other)?;
+    if !config_exists {
         write_game_creator_config_atomically(&config_path, DEFAULT_GAME_CREATOR_APP_CONFIG_JSON)
             .map_err(std::io::Error::other)?;
-    } else {
-        migrate_legacy_game_creator_agent_mode(&config_path).map_err(std::io::Error::other)?;
+    }
+    // Both the normal config and the optional local override are persisted
+    // inputs.  A release build must scrub legacy provider credentials from
+    // either file before the next read can observe them again.
+    for path in [
+        config_path,
+        config_dir.join(GAME_CREATOR_LOCAL_CONFIG_FILE_NAME),
+    ] {
+        migrate_legacy_game_creator_agent_mode(&path).map_err(std::io::Error::other)?;
     }
     set_game_creator_runtime_config_dir(config_dir);
     Ok(())
 }
 
+/// Validates a persisted AGC config file without following links. Existing
+/// regular files are tightened through the same Windows owner/DACL gate used
+/// by credential files before any read is allowed.
+fn validate_game_creator_config_file_entry(path: &Path) -> Result<bool, String> {
+    #[cfg(windows)]
+    validate_game_creator_private_path_ancestors_with_auto_elevation(path, "客户端配置文件")?;
+    #[cfg(not(windows))]
+    validate_game_creator_private_path_ancestors(path, "客户端配置文件")?;
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false),
+        Err(error) => {
+            return Err(format!(
+                "读取客户端配置文件元数据失败：{}: {error}",
+                path.display()
+            ));
+        }
+    };
+    if metadata.file_type().is_symlink() || !metadata.is_file() {
+        return Err("客户端配置文件必须是普通文件，不能是链接或其他对象".to_string());
+    }
+    #[cfg(windows)]
+    secure_windows_game_creator_path_for_current_user_with_auto_elevation(path, false, true)?;
+    Ok(true)
+}
+
 pub(crate) fn legacy_game_creator_agent_mode(
     config: &GameCreatorAppConfigFile,
 ) -> Option<&'static str> {
@@ -1300,8 +3269,10 @@ pub(crate) fn legacy_game_creator_agent_mode(
 }
 
 fn migrate_legacy_game_creator_agent_mode(path: &Path) -> Result<(), String> {
-    let content = fs::read_to_string(path)
-        .map_err(|error| format!("读取客户端配置失败：{}: {error}", path.display()))?;
+    if !validate_game_creator_config_file_entry(path)? {
+        return Ok(());
+    }
+    let content = read_game_creator_private_file_to_string(path, "客户端配置", 256 * 1024)?;
     let mut config = serde_json::from_str::<GameCreatorAppConfigFile>(&content)
         .map_err(|error| format!("解析客户端配置失败：{}: {error}", path.display()))?;
     let Some(agent_mode) = legacy_game_creator_agent_mode(&config) else {
@@ -1435,15 +3406,15 @@ pub(crate) fn merge_game_creator_config_file(
     path: &Path,
 ) -> Result<(), String> {
     let backup_path = game_creator_config_backup_path(path);
-    let read_path = if path.is_file() {
+    let path_exists = validate_game_creator_config_file_entry(path)?;
+    let read_path = if path_exists {
         path
-    } else if backup_path.is_file() {
+    } else if validate_game_creator_config_file_entry(&backup_path)? {
         backup_path.as_path()
     } else {
         return Ok(());
     };
-    let content = fs::read_to_string(read_path)
-        .map_err(|error| format!("读取客户端配置失败：{}: {error}", read_path.display()))?;
+    let content = read_game_creator_private_file_to_string(read_path, "客户端配置", 256 * 1024)?;
     let file_config = serde_json::from_str::<GameCreatorAppConfigFile>(&content)
         .map_err(|error| format!("解析客户端配置失败：{}: {error}", read_path.display()))?;
     if let Some(agent_mode) = file_config.agent_mode {
@@ -1486,11 +3457,19 @@ pub(crate) fn write_game_creator_config_atomically(
     path: &Path,
     content: &str,
 ) -> Result<(), String> {
+    #[cfg(windows)]
+    validate_game_creator_private_path_ancestors_with_auto_elevation(path, "客户端配置文件")?;
+    #[cfg(not(windows))]
+    validate_game_creator_private_path_ancestors(path, "客户端配置文件")?;
     let parent = path
         .parent()
         .ok_or_else(|| "客户端配置缺少父目录".to_string())?;
-    fs::create_dir_all(parent)
+    ensure_game_creator_private_directory_tree(parent, "客户端配置目录")
         .map_err(|error| format!("创建客户端配置目录失败：{}: {error}", parent.display()))?;
+    // Never replace a symlink or another non-regular object. A regular
+    // existing config is repaired/tightened before it can be moved to the
+    // recoverable backup below.
+    let _initial_path_exists = validate_game_creator_config_file_entry(path)?;
     let temp_path = path.with_file_name(format!(
         ".{}.tmp.{}.{}",
         path.file_name()
@@ -1509,12 +3488,24 @@ pub(crate) fn write_game_creator_config_atomically(
         use std::os::unix::fs::OpenOptionsExt;
         options.mode(0o600);
     }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
     let mut file = options.open(&temp_path).map_err(|error| {
         format!(
             "创建客户端配置临时文件失败：{}: {error}",
             temp_path.display()
         )
     })?;
+    if let Err(error) =
+        harden_new_game_creator_private_path(&temp_path, false, "客户端配置临时文件")
+    {
+        drop(file);
+        let _ = fs::remove_file(&temp_path);
+        return Err(error);
+    }
     let write_result = file
         .write_all(content.as_bytes())
         .and_then(|_| file.sync_all());
@@ -1527,44 +3518,55 @@ pub(crate) fn write_game_creator_config_atomically(
         ));
     }
 
+    let backup_path = game_creator_config_backup_path(path);
+    // Re-check the destination immediately before changing either directory
+    // entry.  A newly appeared regular target is moved aside; a link,
+    // reparse point, foreign object, or unsafe ACL is rejected by the same
+    // private-path policy used for reads.
+    let had_previous = validate_game_creator_config_file_entry(path)?;
+    if validate_game_creator_config_file_entry(&backup_path)? {
+        fs::remove_file(&backup_path).map_err(|error| {
+            let _ = fs::remove_file(&temp_path);
+            format!(
+                "清理旧客户端配置备份失败：{}: {error}",
+                backup_path.display()
+            )
+        })?;
+    }
+    if had_previous {
+        if let Err(error) = fs::rename(path, &backup_path) {
+            let _ = fs::remove_file(&temp_path);
+            return Err(format!(
+                "准备替换客户端配置失败：{} -> {}: {error}",
+                path.display(),
+                backup_path.display()
+            ));
+        }
+    }
     match fs::rename(&temp_path, path) {
         Ok(()) => {
-            let _ = fs::remove_file(game_creator_config_backup_path(path));
+            let _ = fs::remove_file(&backup_path);
+            #[cfg(windows)]
+            secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                path, false, true,
+            )?;
             Ok(())
         }
-        Err(replace_error) => {
-            let backup_path = game_creator_config_backup_path(path);
-            if path.exists() {
-                let _ = fs::remove_file(&backup_path);
-                fs::rename(path, &backup_path).map_err(|error| {
-                    let _ = fs::remove_file(&temp_path);
-                    format!(
-                        "准备替换客户端配置失败：{} -> {}: {error}",
-                        path.display(),
-                        backup_path.display()
-                    )
-                })?;
-            }
-            match fs::rename(&temp_path, path) {
-                Ok(()) => {
-                    let _ = fs::remove_file(&backup_path);
-                    Ok(())
-                }
-                Err(error) => {
-                    let restore_error = if backup_path.exists() {
-                        fs::rename(&backup_path, path).err()
-                    } else {
-                        None
-                    };
-                    let _ = fs::remove_file(&temp_path);
-                    let restore_detail = restore_error
-                        .map(|error| format!("；恢复旧配置失败：{error}"))
-                        .unwrap_or_default();
-                    Err(format!(
-                        "替换客户端配置失败：{replace_error}；重试失败：{error}{restore_detail}"
-                    ))
-                }
-            }
+        Err(error) => {
+            let restore_error = if had_previous {
+                fs::rename(&backup_path, path).err()
+            } else {
+                None
+            };
+            let _ = fs::remove_file(&temp_path);
+            let restore_detail = restore_error
+                .map(|error| format!("；恢复旧配置失败：{error}"))
+                .unwrap_or_default();
+            Err(format!(
+                "替换客户端配置失败：{} -> {}: {error}{restore_detail}",
+                temp_path.display(),
+                path.display()
+            ))
         }
     }
 }
@@ -1894,3 +3896,265 @@ mod anthropic_strict_capability_tests {
         }
     }
 }
+
+#[cfg(test)]
+mod private_file_write_tests {
+    use super::*;
+
+    #[test]
+    fn private_file_write_installs_via_hardened_sibling_and_replaces_regular_target() {
+        let root = tempfile::tempdir().expect("create private file fixture");
+        let parent = root.path().join("private");
+        let path = parent.join("state.json");
+
+        write_game_creator_private_file(&path, b"first\n", "测试私有文件")
+            .expect("install first private file");
+        assert_eq!(
+            fs::read(&path).expect("read first private file"),
+            b"first\n"
+        );
+
+        write_game_creator_private_file(&path, b"second\n", "测试私有文件")
+            .expect("replace private file");
+        assert_eq!(
+            fs::read(&path).expect("read replaced private file"),
+            b"second\n"
+        );
+
+        let leftovers = fs::read_dir(&parent)
+            .expect("read private file directory")
+            .filter_map(Result::ok)
+            .map(|entry| entry.file_name().to_string_lossy().into_owned())
+            .filter(|name| name.contains(".tmp-") || name.contains(".previous-"))
+            .collect::<Vec<_>>();
+        assert!(
+            leftovers.is_empty(),
+            "temporary/backup residue: {leftovers:?}"
+        );
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::{MetadataExt, PermissionsExt};
+            let metadata = fs::symlink_metadata(&path).expect("metadata");
+            assert_eq!(metadata.mode() & 0o777, 0o600);
+        }
+    }
+
+    #[test]
+    fn private_file_append_creates_and_reuses_hardened_target() {
+        let root = tempfile::tempdir().expect("create append fixture");
+        let path = root.path().join("private").join("journal.log");
+
+        append_game_creator_private_file(&path, b"first\n", "测试追加文件")
+            .expect("append first record");
+        append_game_creator_private_file(&path, b"second\n", "测试追加文件")
+            .expect("append second record");
+        assert_eq!(
+            fs::read(&path).expect("read append file"),
+            b"first\nsecond\n"
+        );
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::{MetadataExt, PermissionsExt};
+            let metadata = fs::symlink_metadata(&path).expect("append metadata");
+            assert_eq!(metadata.nlink(), 1);
+            assert_eq!(metadata.mode() & 0o777, 0o600);
+        }
+    }
+}
+
+#[cfg(test)]
+mod private_path_elevation_policy_tests {
+    use super::*;
+
+    #[test]
+    fn automatic_elevation_covers_all_regular_project_descendants() {
+        let root = tempfile::tempdir().expect("create path policy fixture");
+        let external_file = root.path().join("game").join("index.html");
+        let nested_project_file = root.path().join("assets").join("sprites").join("hero.png");
+        let managed_agent_file = root
+            .path()
+            .join(".agent")
+            .join("runtime")
+            .join("state.json");
+        fs::create_dir_all(managed_agent_file.parent().expect("agent parent"))
+            .expect("create managed agent fixture");
+        fs::write(root.path().join(".agent/manifest.json"), b"{}").expect("create marker");
+        let traversal_path = root
+            .path()
+            .join(".agent")
+            .join("..")
+            .join("Windows")
+            .join("System32");
+
+        assert!(game_creator_private_path_allows_auto_elevation(
+            &external_file
+        ));
+        assert!(game_creator_private_path_allows_auto_elevation(
+            &nested_project_file
+        ));
+        assert!(game_creator_private_path_allows_auto_elevation(
+            &managed_agent_file
+        ));
+        assert!(!game_creator_private_path_allows_auto_elevation(
+            &traversal_path
+        ));
+    }
+
+    #[test]
+    fn project_marker_does_not_authorize_unrelated_or_nested_agent_paths() {
+        let root = tempfile::tempdir().expect("create path policy fixture");
+        fs::create_dir_all(root.path().join(".agent")).expect("create agent directory");
+        fs::write(root.path().join(".agent/manifest.json"), b"{}").expect("create marker");
+
+        let unrelated = tempfile::tempdir().expect("create unrelated fixture");
+        let unrelated_file = unrelated.path().join("game/index.html");
+        let nested_agent = root.path().join("game").join(".agent").join("state.json");
+
+        assert!(!game_creator_private_path_allows_auto_elevation(
+            &unrelated_file
+        ));
+        assert!(!game_creator_private_path_allows_auto_elevation(
+            &nested_agent
+        ));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn explicit_user_selection_allows_repair_on_user_selected_non_system_path() {
+        let profile = std::env::var_os("USERPROFILE")
+            .or_else(|| std::env::var_os("HOME"))
+            .map(PathBuf::from)
+            .expect("current user profile");
+        let windir = std::env::var_os("WINDIR")
+            .map(PathBuf::from)
+            .expect("WINDIR");
+        let program_files = std::env::var_os("ProgramFiles")
+            .map(PathBuf::from)
+            .expect("ProgramFiles");
+        let system_drive = std::env::var_os("SystemDrive")
+            .map(PathBuf::from)
+            .expect("SystemDrive");
+        let selected = profile.join("Documents").join("fixture.png");
+        let external_drive = PathBuf::from(r"D:\Genarrative\fixture.png");
+        let system_path = windir.join("System32").join("fixture.png");
+        let program_files_path = program_files.join("Genarrative").join("fixture.png");
+        let drive_root = PathBuf::from(format!(
+            "{}\\",
+            system_drive.to_string_lossy().trim_end_matches(['\\', '/'])
+        ));
+        let unc_root = PathBuf::from(r"\\server\share\");
+        let traversal_path = PathBuf::from(r"C:\Users\test\..\Windows\fixture.png");
+
+        assert!(game_creator_user_selected_path_allows_auto_elevation(
+            &selected
+        ));
+        assert!(game_creator_user_selected_path_allows_auto_elevation(
+            &external_drive
+        ));
+        assert!(!game_creator_user_selected_path_allows_auto_elevation(
+            &system_path
+        ));
+        assert!(!game_creator_user_selected_path_allows_auto_elevation(
+            &program_files_path
+        ));
+        assert!(!game_creator_user_selected_path_allows_auto_elevation(
+            &drive_root
+        ));
+        assert!(!game_creator_user_selected_path_allows_auto_elevation(
+            &unc_root
+        ));
+        assert!(!game_creator_user_selected_path_allows_auto_elevation(
+            &traversal_path
+        ));
+    }
+
+    #[test]
+    fn arbitrary_agent_directory_without_project_marker_cannot_trigger_elevation() {
+        let root = tempfile::tempdir().expect("create unverified agent fixture");
+        let path = root
+            .path()
+            .join(".agent")
+            .join("runtime")
+            .join("state.json");
+        fs::create_dir_all(path.parent().expect("agent parent")).expect("create agent fixture");
+        assert!(!game_creator_private_path_allows_auto_elevation(&path));
+    }
+
+    #[test]
+    fn nested_agent_components_cannot_trigger_elevation() {
+        let root = tempfile::tempdir().expect("create nested agent fixture");
+        let path = root
+            .path()
+            .join(".agent")
+            .join("nested")
+            .join(".agent")
+            .join("state.json");
+        fs::create_dir_all(path.parent().expect("nested agent parent"))
+            .expect("create nested agent");
+        fs::write(root.path().join(".agent/manifest.json"), b"{}").expect("create marker");
+        assert!(!game_creator_private_path_allows_auto_elevation(&path));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn explicit_project_root_entry_can_tighten_owner_correct_inherited_acl() {
+        let root = tempfile::tempdir().expect("create project root fixture");
+        assert!(prepare_game_creator_project_root_for_read(root.path(), true, "项目根").is_ok());
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn owner_flag_is_requested_only_when_owner_initialization_is_needed() {
+        const OWNER_SECURITY_INFORMATION: u32 = 0x0000_0001;
+        assert_eq!(
+            windows_private_dacl_security_information(true, false) & OWNER_SECURITY_INFORMATION,
+            OWNER_SECURITY_INFORMATION
+        );
+        assert_eq!(
+            windows_private_dacl_security_information(true, true) & OWNER_SECURITY_INFORMATION,
+            0
+        );
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn canonicalize_access_denied_is_classified_as_acl_repair_candidate() {
+        let detail =
+            "解析客户端 AppData 配置目录失败：C:\\Temp\\agc-config: 拒绝访问。 (os error 5)";
+        assert!(windows_acl_error_may_need_elevation(detail));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn custom_runtime_config_path_uses_explicit_user_selected_scope() {
+        let root = tempfile::tempdir().expect("create custom config fixture");
+        assert_eq!(
+            game_creator_runtime_config_repair_scope(&root.path().join("config")),
+            WindowsAclRepairScope::UserSelected
+        );
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn picker_grant_is_required_and_directory_grant_covers_descendants() {
+        let root = tempfile::tempdir().expect("create picker grant fixture");
+        let directory = root.path().join("selected");
+        let child = directory.join("nested").join("file.png");
+        let unapproved = root.path().join("other").join("file.png");
+
+        assert!(!user_selected_path_is_authorized(&directory, true));
+        assert!(!user_selected_path_is_authorized(&unapproved, false));
+
+        register_game_creator_user_selected_path(&directory, true);
+        assert!(user_selected_path_is_authorized(&directory, true));
+        assert!(user_selected_path_is_authorized(&child, false));
+        assert!(!user_selected_path_is_authorized(&directory, false));
+        assert!(!user_selected_path_is_authorized(&unapproved, false));
+
+        revoke_game_creator_user_selected_path(&directory);
+        assert!(!user_selected_path_is_authorized(&directory, true));
+        assert!(!user_selected_path_is_authorized(&child, false));
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/main.rs b/apps/ai-game-creator-shell/src-tauri/src/main.rs
index ad1499c0b..d7657c796 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/main.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/main.rs
@@ -1891,6 +1891,61 @@ fn install_agent_runtime_async_runtime_with_deep_stack() {
     Box::leak(Box::new(runtime));
 }
 
+#[cfg(windows)]
+fn run_windows_acl_repair_if_requested(args: &[String]) -> Option<i32> {
+    let [
+        command,
+        path,
+        target_user_sid_flag,
+        target_user_sid,
+        authorization_flag,
+        nonce,
+        scope_flag,
+        scope_value,
+    ] = args
+    else {
+        if args.first().map(String::as_str) == Some("--repair-private-acl") {
+            eprintln!(
+                "用法：--repair-private-acl <路径> --target-user-sid <SID> --authorization <票据> --scope <managed|user-selected>"
+            );
+            return Some(1);
+        }
+        return None;
+    };
+    if command != "--repair-private-acl"
+        || target_user_sid_flag != "--target-user-sid"
+        || authorization_flag != "--authorization"
+        || scope_flag != "--scope"
+    {
+        eprintln!(
+            "用法：--repair-private-acl <路径> --target-user-sid <SID> --authorization <票据> --scope <managed|user-selected>"
+        );
+        return Some(1);
+    }
+    let path = std::path::PathBuf::from(path);
+    let scope = match config::parse_windows_acl_repair_scope(scope_value) {
+        Ok(scope) => scope,
+        Err(error) => {
+            eprintln!("{error}");
+            return Some(1);
+        }
+    };
+    let result = config::consume_windows_acl_repair_authorization(
+        &path,
+        target_user_sid,
+        nonce,
+        scope,
+    )
+    .and_then(|()| config::repair_game_creator_private_acl_for_user_sid(&path, target_user_sid));
+    match result {
+        Ok(()) => Some(0),
+        Err(error) => {
+            eprintln!("AGC ACL 提权修复失败：{error}");
+            Some(1)
+        }
+    }
+}
+
 #[cfg(test)]
 mod async_runtime_stack_tests {
     /// 每帧固定占 16 KiB，用 black_box 挡住优化，让递归深度直接换算成栈用量。
@@ -1928,6 +1983,10 @@ fn main() {
     if let Some(exit_code) = run_direct_tools_mcp_if_requested(&args) {
         std::process::exit(exit_code);
     }
+    #[cfg(windows)]
+    if let Some(exit_code) = run_windows_acl_repair_if_requested(&args) {
+        std::process::exit(exit_code);
+    }
     #[cfg(target_os = "linux")]
     if command_sandbox_trampoline::is_trampoline_mode(&args) {
         match command_sandbox_trampoline::run_trampoline() {
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/agent_db.rs b/apps/ai-game-creator-shell/src-tauri/src/project/agent_db.rs
index b9e2f985e..bd2f3e18b 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/agent_db.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/agent_db.rs
@@ -349,8 +349,8 @@ fn open_agent_db_directory(root: &Path, create: bool) -> Result<Option<AgentDbDi
     use std::os::unix::ffi::OsStrExt;
 
     if create {
-        fs::create_dir_all(root)
-            .map_err(|error| format!("创建 Agent DB 项目目录失败：{}: {error}", root.display()))?;
+        ensure_game_creator_private_directory_tree(root, "Agent DB 项目目录")?;
+        prepare_game_creator_private_path_for_read(root, true, "Agent DB 项目目录")?;
     }
     let root_name = std::ffi::CString::new(root.as_os_str().as_bytes())
         .map_err(|_| "Agent DB 项目目录包含 NUL".to_string())?;
@@ -813,8 +813,17 @@ fn nt_open_windows_agent_db_relative(
 #[cfg(windows)]
 fn open_agent_db_directory(root: &Path, create: bool) -> Result<Option<AgentDbDirectory>, String> {
     if create {
-        fs::create_dir_all(root)
-            .map_err(|error| format!("创建 Agent DB 项目目录失败：{}: {error}", root.display()))?;
+        ensure_game_creator_private_directory_tree(root, "Agent DB 项目目录")?;
+    }
+    if !prepare_game_creator_private_path_for_read(root, true, "Agent DB 项目目录")? {
+        return Ok(None);
+    }
+    let agent_path = root.join(".agent");
+    if create {
+        ensure_game_creator_private_directory_tree(&agent_path, "项目 .agent 目录")?;
+    }
+    if !prepare_game_creator_private_path_for_read(&agent_path, true, "项目 .agent 目录")? {
+        return Ok(None);
     }
     let root_directory = match open_windows_agent_db_root(root, create) {
         Ok(file) => file,
@@ -875,6 +884,21 @@ fn open_agent_db_storage(
     create: bool,
 ) -> Result<Option<AgentDbStorage>, String> {
     verify_agent_db_directory_current(&directory)?;
+    let path = directory.path.join("agent.db");
+    let existed = match fs::symlink_metadata(&path) {
+        Ok(_) => true,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => false,
+        Err(_) => {
+            // Do not let an ACL-denied existing Agent DB fall through to
+            // NtCreateFile, which would otherwise be reported as a generic
+            // open failure without trying the approved repair path.
+            prepare_game_creator_private_path_for_read(&path, false, "Agent 本地索引")?;
+            true
+        }
+    };
+    if existed {
+        prepare_game_creator_private_path_for_read(&path, false, "Agent 本地索引")?;
+    }
     let file = {
         let mut opened = None;
         for attempt in 0..100 {
@@ -924,10 +948,16 @@ fn open_agent_db_storage(
         return Err("Agent 本地索引必须是普通文件".to_string());
     }
     validate_windows_regular_file_handle(&file, "Agent 本地索引")?;
+    if existed {
+        secure_windows_game_creator_path_for_current_user_with_auto_elevation(&path, false, true)?;
+    } else {
+        initialize_windows_game_creator_file_owner_for_current_user(&path)?;
+        secure_windows_game_creator_path_for_current_user_with_auto_elevation(&path, false, false)?;
+    }
     verify_agent_db_directory_current(&directory)?;
     Ok(Some(AgentDbStorage {
         file,
-        path: directory.path.join("agent.db"),
+        path,
         root_path: directory.root_path,
         root_directory: directory.root_directory,
         agent_directory: directory.agent_directory,
@@ -4369,13 +4399,10 @@ fn project_append_os_lock_path(path: &Path) -> Result<PathBuf, String> {
 
 fn acquire_project_append_os_lock(path: &Path, error_label: &str) -> Result<File, String> {
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent).map_err(|error| {
-            format!(
-                "创建{error_label}跨进程锁目录失败：{}: {error}",
-                parent.display()
-            )
-        })?;
+        ensure_game_creator_private_directory_tree(parent, error_label)?;
+        prepare_game_creator_private_path_for_read(parent, true, error_label)?;
     }
+    prepare_game_creator_private_path_for_read(path, false, error_label)?;
     for attempt in 0..100 {
         if let Some(file) = try_open_project_append_os_lock(path, error_label)? {
             return Ok(file);
@@ -4391,12 +4418,58 @@ fn acquire_project_append_os_lock(path: &Path, error_label: &str) -> Result<File
 fn try_open_project_append_os_lock(path: &Path, error_label: &str) -> Result<Option<File>, String> {
     use std::os::fd::AsRawFd;
 
-    let file = fs::OpenOptions::new()
-        .create(true)
-        .read(true)
-        .write(true)
+    let existed = prepare_game_creator_private_path_for_read(path, false, error_label)?;
+    let mut options = fs::OpenOptions::new();
+    options.create(true).read(true).write(true);
+    use std::os::unix::fs::OpenOptionsExt;
+    options.custom_flags(libc::O_NOFOLLOW).mode(0o600);
+    let file = options
         .open(path)
         .map_err(|error| format!("打开{error_label}跨进程锁失败：{}: {error}", path.display()))?;
+    let metadata = file.metadata().map_err(|error| {
+        format!(
+            "读取{error_label}跨进程锁元数据失败：{}: {error}",
+            path.display()
+        )
+    })?;
+    if !metadata.is_file() {
+        return Err(format!(
+            "{error_label}跨进程锁必须是普通文件：{}",
+            path.display()
+        ));
+    }
+    if !existed {
+        if let Err(error) = harden_new_game_creator_private_path(path, false, error_label) {
+            drop(file);
+            let _ = fs::remove_file(path);
+            return Err(error);
+        }
+    }
+    let path_metadata = fs::symlink_metadata(path).map_err(|error| {
+        format!(
+            "复核{error_label}跨进程锁路径失败：{}: {error}",
+            path.display()
+        )
+    })?;
+    if path_metadata.file_type().is_symlink() {
+        return Err(format!(
+            "{error_label}跨进程锁不能是符号链接：{}",
+            path.display()
+        ));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        if path_metadata.nlink() != 1
+            || path_metadata.dev() != metadata.dev()
+            || path_metadata.ino() != metadata.ino()
+        {
+            return Err(format!(
+                "{error_label}跨进程锁路径在打开期间发生替换：{}",
+                path.display()
+            ));
+        }
+    }
     let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
     if result == 0 {
         return Ok(Some(file));
@@ -4416,14 +4489,33 @@ fn try_open_project_append_os_lock(path: &Path, error_label: &str) -> Result<Opt
 fn try_open_project_append_os_lock(path: &Path, error_label: &str) -> Result<Option<File>, String> {
     use std::os::windows::fs::OpenOptionsExt;
 
-    match fs::OpenOptions::new()
-        .create(true)
-        .read(true)
-        .write(true)
-        .share_mode(0)
-        .open(path)
-    {
-        Ok(file) => Ok(Some(file)),
+    let existed = prepare_game_creator_private_path_for_read(path, false, error_label)?;
+    const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+    match {
+        let mut options = fs::OpenOptions::new();
+        options
+            .create(true)
+            .read(true)
+            .write(true)
+            .share_mode(0)
+            .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT);
+        options.open(path)
+    } {
+        Ok(file) => {
+            crate::runner::validate_windows_regular_file_handle(&file, error_label)?;
+            if !existed {
+                if let Err(error) = harden_new_game_creator_private_path(path, false, error_label) {
+                    drop(file);
+                    let _ = fs::remove_file(path);
+                    return Err(error);
+                }
+            }
+            crate::secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                path, false, true,
+            )?;
+            crate::runner::validate_windows_regular_file_handle(&file, error_label)?;
+            Ok(Some(file))
+        }
         Err(error)
             if matches!(
                 error.kind(),
@@ -4453,22 +4545,76 @@ pub(super) fn append_jsonl_line_unlocked(
     error_label: &str,
 ) -> Result<(), String> {
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建{error_label}目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, error_label)?;
+        prepare_game_creator_private_path_for_read(parent, true, error_label)?;
     }
-    let mut file = fs::OpenOptions::new()
-        .create(true)
-        .read(true)
-        .write(true)
+    let existed = prepare_game_creator_private_path_for_read(path, false, error_label)?;
+    let mut options = fs::OpenOptions::new();
+    options.create(true).read(true).write(true);
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::OpenOptionsExt;
+        options.custom_flags(libc::O_NOFOLLOW).mode(0o600);
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+        const FILE_SHARE_READ: u32 = 0x0000_0001;
+        const FILE_SHARE_WRITE: u32 = 0x0000_0002;
+        const FILE_SHARE_DELETE: u32 = 0x0000_0004;
+        options
+            .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
+            .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE);
+    }
+    let mut file = options
         .open(path)
         .map_err(|error| format!("打开{error_label}失败：{}: {error}", path.display()))?;
+    let opened_metadata = file.metadata().map_err(|error| {
+        format!(
+            "读取{error_label}文件句柄元数据失败：{}: {error}",
+            path.display()
+        )
+    })?;
+    if !opened_metadata.is_file() {
+        return Err(format!("{error_label}必须是普通文件：{}", path.display()));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        if opened_metadata.nlink() != 1 {
+            return Err(format!("{error_label}不能是硬链接：{}", path.display()));
+        }
+        let path_metadata = fs::symlink_metadata(path)
+            .map_err(|error| format!("复核{error_label}路径失败：{}: {error}", path.display()))?;
+        if path_metadata.file_type().is_symlink()
+            || path_metadata.dev() != opened_metadata.dev()
+            || path_metadata.ino() != opened_metadata.ino()
+        {
+            return Err(format!(
+                "{error_label}路径在安全打开期间发生替换：{}",
+                path.display()
+            ));
+        }
+    }
+    #[cfg(windows)]
+    crate::runner::validate_windows_regular_file_handle(&file, error_label)?;
+    if !existed {
+        if let Err(error) = harden_new_game_creator_private_path(path, false, error_label) {
+            drop(file);
+            let _ = fs::remove_file(path);
+            return Err(error);
+        }
+    }
     repair_truncated_jsonl_tail_unlocked(&mut file, path, error_label)?;
     let framed = format!("{line}\n");
     file.seek(SeekFrom::End(0))
         .and_then(|_| file.write_all(framed.as_bytes()))
         .and_then(|_| file.flush())
         .and_then(|_| file.sync_data())
-        .map_err(|error| format!("写入{error_label}失败：{}: {error}", path.display()))
+        .map_err(|error| format!("写入{error_label}失败：{}: {error}", path.display()))?;
+    prepare_game_creator_private_path_for_read(path, false, error_label)?;
+    Ok(())
 }
 
 const AGENT_DB_FINALIZATION_SLOT_PREPARED: u8 = 0;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/checkpoint.rs b/apps/ai-game-creator-shell/src-tauri/src/project/checkpoint.rs
index 66b6b142b..9c99aaede 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/checkpoint.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/checkpoint.rs
@@ -5,6 +5,54 @@ use super::filesystem::validate_portable_project_path_component;
 #[cfg(windows)]
 use super::filesystem::PROJECT_FILE_FLAG_OPEN_REPARSE_POINT;
 
+#[cfg(windows)]
+fn windows_regular_file_handle_identity(file: &File, label: &str) -> Result<(u32, u64), String> {
+    use std::ffi::c_void;
+    use std::os::windows::io::AsRawHandle;
+
+    #[repr(C)]
+    struct FileTime {
+        low_date_time: u32,
+        high_date_time: u32,
+    }
+
+    #[repr(C)]
+    struct ByHandleFileInformation {
+        file_attributes: u32,
+        creation_time: FileTime,
+        last_access_time: FileTime,
+        last_write_time: FileTime,
+        volume_serial_number: u32,
+        file_size_high: u32,
+        file_size_low: u32,
+        number_of_links: u32,
+        file_index_high: u32,
+        file_index_low: u32,
+    }
+
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        fn GetFileInformationByHandle(
+            file: *mut c_void,
+            information: *mut ByHandleFileInformation,
+        ) -> i32;
+    }
+
+    // SAFETY: the structure is plain data initialized by GetFileInformationByHandle.
+    let mut information = unsafe { std::mem::zeroed::<ByHandleFileInformation>() };
+    // SAFETY: file owns a live kernel handle and information is a valid output pointer.
+    if unsafe { GetFileInformationByHandle(file.as_raw_handle().cast(), &mut information) } == 0 {
+        return Err(format!(
+            "读取 {label} Windows 文件句柄身份失败：{}",
+            std::io::Error::last_os_error()
+        ));
+    }
+    Ok((
+        information.volume_serial_number,
+        (u64::from(information.file_index_high) << 32) | u64::from(information.file_index_low),
+    ))
+}
+
 pub(crate) fn create_local_project_checkpoint_at(
     root: &Path,
 ) -> Result<LocalProjectCheckpointResult, String> {
@@ -22,10 +70,10 @@ pub(crate) fn create_local_project_checkpoint_at(
             &checkpoint_file_relative_path(&checkpoint_id, &normalized_path),
         )?;
         if let Some(parent) = target.parent() {
-            fs::create_dir_all(parent).map_err(|error| {
-                format!("创建 checkpoint 目录失败：{}: {error}", parent.display())
-            })?;
+            ensure_game_creator_private_directory_tree(parent, "checkpoint 目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "checkpoint 目录")?;
         }
+        prepare_game_creator_private_path_for_read(&target, false, "checkpoint 文件")?;
         fs::copy(&source, &target).map_err(|error| {
             format!(
                 "写入 checkpoint 文件失败：{} -> {}: {error}",
@@ -33,6 +81,7 @@ pub(crate) fn create_local_project_checkpoint_at(
                 target.display()
             )
         })?;
+        prepare_game_creator_private_path_for_read(&target, false, "checkpoint 文件")?;
     }
     let total_bytes = files.iter().map(|file| file.size).sum::<u64>();
     let manifest = serde_json::json!({
@@ -42,20 +91,21 @@ pub(crate) fn create_local_project_checkpoint_at(
     });
     let manifest_path =
         resolve_local_project_path(root, &checkpoint_manifest_relative_path(&checkpoint_id))?;
-    fs::write(
+    if let Some(parent) = manifest_path.parent() {
+        ensure_game_creator_private_directory_tree(parent, "checkpoint manifest 目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "checkpoint manifest 目录")?;
+    }
+    prepare_game_creator_private_path_for_read(&manifest_path, false, "checkpoint manifest")?;
+    crate::write_game_creator_private_file(
         &manifest_path,
         format!(
             "{}\n",
             serde_json::to_string_pretty(&manifest)
                 .map_err(|error| format!("序列化 checkpoint 失败：{error}"))?
-        ),
-    )
-    .map_err(|error| {
-        format!(
-            "写入 checkpoint manifest 失败：{}: {error}",
-            manifest_path.display()
         )
-    })?;
+        .as_bytes(),
+        "checkpoint manifest",
+    )?;
     append_agent_db_record(
         root,
         serde_json::json!({
@@ -147,13 +197,68 @@ pub(crate) fn open_project_snapshot_regular_file(
     }
     #[cfg(windows)]
     validate_windows_regular_file_handle(&file, label)?;
+    // The pathname was checked before opening, but another process can replace
+    // it between those two operations.  Compare the opened handle identity to
+    // the current directory entry before any caller reads bytes; subsequent
+    // reads use the already-open handle and therefore are not pathname-based.
+    let path_metadata = fs::symlink_metadata(path)
+        .map_err(|error| format!("复核{label}路径失败：{}: {error}", path.display()))?;
+    if path_metadata.file_type().is_symlink() || !path_metadata.is_file() {
+        return Err(format!(
+            "{label}路径在安全打开期间发生替换：{}",
+            path.display()
+        ));
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt;
+        if path_metadata.dev() != metadata.dev() || path_metadata.ino() != metadata.ino() {
+            return Err(format!(
+                "{label}路径在安全打开期间发生替换：{}",
+                path.display()
+            ));
+        }
+    }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        let mut identity_options = fs::OpenOptions::new();
+        identity_options
+            .read(true)
+            .custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+        let identity_file = identity_options
+            .open(path)
+            .map_err(|error| format!("复核{label}路径失败：{}: {error}", path.display()))?;
+        validate_windows_regular_file_handle(&identity_file, label)?;
+        if windows_regular_file_handle_identity(&identity_file, label)?
+            != windows_regular_file_handle_identity(&file, label)?
+        {
+            return Err(format!(
+                "{label}路径在安全打开期间发生替换：{}",
+                path.display()
+            ));
+        }
+    }
     Ok((file, metadata))
 }
 
+/// Opens an AGC-managed project file after the private-path owner/DACL gate
+/// has had a chance to repair an inherited or foreign ACL.  Callers that read
+/// arbitrary user-selected files must keep using
+/// `open_project_snapshot_regular_file` so importing an external file never
+/// silently changes its owner.
+pub(crate) fn open_project_private_regular_file(
+    path: &Path,
+    label: &str,
+) -> Result<(File, fs::Metadata), String> {
+    prepare_game_creator_private_path_for_read(path, false, label)?;
+    open_project_snapshot_regular_file(path, label)
+}
+
 fn read_local_project_content_diff_source(
     path: &Path,
 ) -> Result<LocalProjectContentDiffSource, String> {
-    let (mut file, metadata) = open_project_snapshot_regular_file(path, "内容 diff 文件")?;
+    let (mut file, metadata) = open_project_private_regular_file(path, "内容 diff 文件")?;
     let mut hasher = Sha256::new();
     let mut bytes = (metadata.len() <= PROJECT_CONTENT_DIFF_MAX_FILE_BYTES)
         .then(|| Vec::with_capacity(metadata.len() as usize));
@@ -518,10 +623,12 @@ pub(crate) fn restore_local_project_checkpoint_at(
 
     let restored_count = restore_plan.len();
     for (source, target) in restore_plan {
+        prepare_game_creator_private_path_for_read(&source, false, "checkpoint 源文件")?;
         if let Some(parent) = target.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|error| format!("创建恢复目录失败：{}: {error}", parent.display()))?;
+            ensure_game_creator_private_directory_tree(parent, "恢复目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "恢复目录")?;
         }
+        prepare_game_creator_private_path_for_read(&target, false, "恢复目标文件")?;
         fs::copy(&source, &target).map_err(|error| {
             format!(
                 "恢复 checkpoint 文件失败：{} -> {}: {error}",
@@ -529,6 +636,7 @@ pub(crate) fn restore_local_project_checkpoint_at(
                 target.display()
             )
         })?;
+        prepare_game_creator_private_path_for_read(&target, false, "恢复目标文件")?;
     }
     let deleted_count = delete_plan.len();
     for target in delete_plan {
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/conversation.rs b/apps/ai-game-creator-shell/src-tauri/src/project/conversation.rs
index 12eb9f5d0..3ad3d43f7 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/conversation.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/conversation.rs
@@ -68,6 +68,9 @@ fn file_modified_timestamp(path: &Path) -> u64 {
 }
 
 fn count_conversation_messages(path: &Path) -> Result<u64, String> {
+    if !prepare_game_creator_private_path_for_read(path, false, "对话记录")? {
+        return Ok(0);
+    }
     match File::open(path) {
         Ok(file) => {
             let mut count = 0_u64;
@@ -118,6 +121,7 @@ fn read_agent_conversation_session_catalog_unlocked(
     validate_project_root(root)?;
     let agent_id = normalize_conversation_agent_id(agent_id)?;
     let catalog_path = agent_conversation_session_catalog_path(root, &agent_id);
+    prepare_game_creator_private_path_for_read(&catalog_path, false, "Agent Session 目录")?;
     let mut catalog = match fs::read_to_string(&catalog_path) {
         Ok(content) => serde_json::from_str::<AgentConversationSessionCatalogFile>(&content)
             .map_err(|error| {
@@ -305,37 +309,16 @@ fn write_agent_conversation_session_catalog_unlocked(
 ) -> Result<(), String> {
     let path = agent_conversation_session_catalog_path(root, &catalog.agent_id);
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent).map_err(|error| {
-            format!("创建 Agent Session 目录失败：{}: {error}", parent.display())
-        })?;
+        ensure_game_creator_private_directory_tree(parent, "Agent Session 目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "Agent Session 目录")?;
     }
     let content = serde_json::to_string_pretty(catalog)
         .map_err(|error| format!("序列化 Agent Session 目录失败：{error}"))?;
-    let temp_path = path.with_file_name(format!(
-        ".{}.tmp.{}.{}",
-        path.file_name()
-            .and_then(|value| value.to_str())
-            .unwrap_or("sessions.json"),
-        std::process::id(),
-        SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_nanos()
-    ));
-    fs::write(&temp_path, format!("{content}\n")).map_err(|error| {
-        format!(
-            "写入 Agent Session 临时目录失败：{}: {error}",
-            temp_path.display()
-        )
-    })?;
-    fs::rename(&temp_path, &path).map_err(|error| {
-        let _ = fs::remove_file(&temp_path);
-        format!(
-            "替换 Agent Session 目录失败：{} -> {}: {error}",
-            temp_path.display(),
-            path.display()
-        )
-    })
+    write_game_creator_private_file(
+        &path,
+        format!("{content}\n").as_bytes(),
+        "Agent Session 目录",
+    )
 }
 
 pub(crate) fn ensure_agent_conversation_session_at(
@@ -419,6 +402,7 @@ pub(crate) fn ensure_agent_session_has_no_live_tasks(
     let task_path = root
         .join(".agent/runtime/tasks")
         .join(format!("{agent_id}.jsonl"));
+    prepare_game_creator_private_path_for_read(&task_path, false, "Agent Runtime 任务")?;
     match File::open(&task_path) {
         Ok(file) => {
             for line in BufReader::new(file).lines() {
@@ -497,6 +481,7 @@ pub(crate) fn ensure_agent_session_has_no_live_tasks(
         if path.extension().and_then(|value| value.to_str()) != Some("jsonl") {
             continue;
         }
+        prepare_game_creator_private_path_for_read(&path, false, "Agent Runtime 任务")?;
         let mut delegated_latest_by_run = BTreeMap::<String, AgentRuntimeTaskRecord>::new();
         let file = File::open(&path)
             .map_err(|error| format!("读取 Agent Runtime 任务失败：{}: {error}", path.display()))?;
@@ -558,19 +543,33 @@ pub(crate) fn create_game_creator_agent_session_at(
         let conversation_path =
             conversation_file_path_for_resolved_session(root, &agent_id, &session_id);
         if let Some(parent) = conversation_path.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|error| format!("创建对话目录失败：{}: {error}", parent.display()))?;
+            ensure_game_creator_private_directory_tree(parent, "对话目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "对话目录")?;
         }
-        fs::OpenOptions::new()
-            .create_new(true)
-            .write(true)
-            .open(&conversation_path)
-            .map_err(|error| {
-                format!(
-                    "创建 Agent Session 对话失败：{}: {error}",
-                    conversation_path.display()
-                )
-            })?;
+        prepare_game_creator_private_path_for_read(&conversation_path, false, "对话记录")?;
+        let mut options = fs::OpenOptions::new();
+        options.create_new(true).write(true);
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::OpenOptionsExt;
+            options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+        }
+        let file = options.open(&conversation_path).map_err(|error| {
+            format!(
+                "创建 Agent Session 对话失败：{}: {error}",
+                conversation_path.display()
+            )
+        })?;
+        if let Err(error) = harden_new_game_creator_private_path(
+            &conversation_path,
+            false,
+            "对话记录",
+        ) {
+            drop(file);
+            let _ = fs::remove_file(&conversation_path);
+            return Err(error);
+        }
+        drop(file);
         catalog.sessions.push(AgentConversationSessionRecord {
             session_id: session_id.clone(),
             title,
@@ -665,20 +664,28 @@ where
         let conversation_path =
             conversation_file_path_for_resolved_session(root, &agent_id, &session_id);
         if let Some(parent) = conversation_path.parent() {
-            fs::create_dir_all(parent)
-                .map_err(|error| format!("创建对话目录失败：{}: {error}", parent.display()))?;
+            ensure_game_creator_private_directory_tree(parent, "对话目录")?;
+            prepare_game_creator_private_path_for_read(parent, true, "对话目录")?;
         }
+        prepare_game_creator_private_path_for_read(
+            &conversation_path,
+            false,
+            "Agent Session 分叉对话",
+        )?;
         let write_result = (|| -> Result<(), String> {
-            let mut file = fs::OpenOptions::new()
-                .create_new(true)
-                .write(true)
-                .open(&conversation_path)
-                .map_err(|error| {
-                    format!(
-                        "创建 Agent Session 分叉对话失败：{}: {error}",
-                        conversation_path.display()
-                    )
-                })?;
+            let mut options = fs::OpenOptions::new();
+            options.create_new(true).write(true);
+            #[cfg(windows)]
+            {
+                use std::os::windows::fs::OpenOptionsExt;
+                options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+            }
+            let mut file = options.open(&conversation_path).map_err(|error| {
+                format!(
+                    "创建 Agent Session 分叉对话失败：{}: {error}",
+                    conversation_path.display()
+                )
+            })?;
             for record in &records {
                 serde_json::to_writer(&mut file, record)
                     .map_err(|error| format!("序列化 Agent Session 分叉消息失败：{error}"))?;
@@ -700,6 +707,11 @@ where
             let _ = fs::remove_file(&conversation_path);
             return Err(error);
         }
+        prepare_game_creator_private_path_for_read(
+            &conversation_path,
+            false,
+            "Agent Session 分叉对话",
+        )?;
 
         let now = unix_timestamp();
         let requested_title = title.trim();
@@ -938,6 +950,7 @@ fn read_persisted_local_conversation_records_unlocked(
     path: &Path,
 ) -> Result<Vec<PersistedLocalConversationMessageRecord>, String> {
     let mut records = Vec::new();
+    prepare_game_creator_private_path_for_read(path, false, "对话记录")?;
     match File::open(path) {
         Ok(file) => {
             for line in BufReader::new(file).lines() {
@@ -1431,23 +1444,22 @@ pub(crate) fn append_markdown_entry(
     error_label: &str,
 ) -> Result<(), String> {
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("{error_label}：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, error_label)?;
+        prepare_game_creator_private_path_for_read(parent, true, error_label)?;
     }
+    prepare_game_creator_private_path_for_read(path, false, error_label)?;
     let needs_header = fs::metadata(path)
         .map(|metadata| metadata.len() == 0)
         .unwrap_or(true);
-    let mut file = fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(path)
-        .map_err(|error| format!("{error_label}：{}: {error}", path.display()))?;
-    if needs_header {
-        file.write_all(header.as_bytes())
-            .map_err(|error| format!("{error_label}：{}: {error}", path.display()))?;
-    }
-    file.write_all(entry.as_bytes())
-        .map_err(|error| format!("{error_label}：{}: {error}", path.display()))
+    let bytes = if needs_header {
+        let mut bytes = Vec::with_capacity(header.len() + entry.len());
+        bytes.extend_from_slice(header.as_bytes());
+        bytes.extend_from_slice(entry.as_bytes());
+        bytes
+    } else {
+        entry.as_bytes().to_vec()
+    };
+    append_game_creator_private_file(path, &bytes, error_label)
 }
 
 pub(crate) fn append_local_permission_log_at(
@@ -1474,16 +1486,12 @@ pub(crate) fn append_local_permission_log_at(
 
     let log_path = root.join(".agent/logs/command.log");
     if let Some(parent) = log_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建命令日志目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "命令日志目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "命令日志目录")?;
     }
+    prepare_game_creator_private_path_for_read(&log_path, false, "命令日志")?;
     let line = format!("{} {event} {command_id}\n", unix_timestamp());
-    fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(&log_path)
-        .and_then(|mut file| file.write_all(line.as_bytes()))
-        .map_err(|error| format!("写入命令日志失败：{}: {error}", log_path.display()))
+    append_game_creator_private_file(&log_path, line.as_bytes(), "命令日志")
 }
 
 #[cfg(test)]
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/export.rs b/apps/ai-game-creator-shell/src-tauri/src/project/export.rs
index 0b1238987..d52959460 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/export.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/export.rs
@@ -13,6 +13,7 @@ pub(crate) fn export_local_project_package_at(
     if !game_index_metadata.is_file() {
         return Err("导出试玩包前需要先生成 game/index.html".to_string());
     }
+    prepare_game_creator_private_path_for_read(&game_index_path, false, "游戏入口")?;
     let game_index = fs::read_to_string(&game_index_path)
         .map_err(|error| format!("读取游戏入口失败：{}: {error}", game_index_path.display()))?;
     if game_index.trim().is_empty() {
@@ -51,12 +52,26 @@ pub(crate) fn export_local_project_package_at(
     let package_relative_path = next_project_export_package_relative_path(root)?;
     let package_path = resolve_local_project_path(root, &package_relative_path)?;
     if let Some(parent) = package_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建导出目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "导出目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "导出目录")?;
     }
+    prepare_game_creator_private_path_for_read(&package_path, false, "试玩包")?;
 
-    let file = File::create(&package_path)
+    let mut options = fs::OpenOptions::new();
+    options.write(true).create_new(true);
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
+    let file = options
+        .open(&package_path)
         .map_err(|error| format!("创建试玩包失败：{}: {error}", package_path.display()))?;
+    if let Err(error) = harden_new_game_creator_private_path(&package_path, false, "试玩包") {
+        drop(file);
+        let _ = fs::remove_file(&package_path);
+        return Err(error);
+    }
     let mut writer = zip::ZipWriter::new(file);
     let options = zip::write::SimpleFileOptions::default()
         .compression_method(zip::CompressionMethod::Deflated);
@@ -64,6 +79,7 @@ pub(crate) fn export_local_project_package_at(
         writer
             .start_file(relative_path, options)
             .map_err(|error| format!("写入试玩包条目失败：{relative_path}: {error}"))?;
+        prepare_game_creator_private_path_for_read(absolute_path, false, "导出文件")?;
         let bytes = fs::read(absolute_path)
             .map_err(|error| format!("读取导出文件失败：{}: {error}", absolute_path.display()))?;
         writer
@@ -73,13 +89,10 @@ pub(crate) fn export_local_project_package_at(
     writer
         .finish()
         .map_err(|error| format!("完成试玩包失败：{}: {error}", package_path.display()))?;
+    prepare_game_creator_private_path_for_read(&package_path, false, "试玩包")?;
 
     let updated_at = unix_timestamp();
     let log_path = root.join(".agent/logs/command.log");
-    if let Some(parent) = log_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建命令日志目录失败：{}: {error}", parent.display()))?;
-    }
     let output = format!(
         "导出试玩包：{}，{} 个文件，{}B",
         package_relative_path,
@@ -87,12 +100,7 @@ pub(crate) fn export_local_project_package_at(
         total_bytes
     );
     let line = format!("{updated_at} project.export_package: {output}\n");
-    fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(&log_path)
-        .and_then(|mut file| file.write_all(line.as_bytes()))
-        .map_err(|error| format!("写入命令日志失败：{}: {error}", log_path.display()))?;
+    append_game_creator_private_file(&log_path, line.as_bytes(), "命令日志")?;
     record_command_run(
         root,
         GameCreationAppCommandRunState {
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs b/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs
index c7f8f38e1..062a74e3c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/filesystem.rs
@@ -1,7 +1,7 @@
 use super::*;
 
 #[cfg(windows)]
-pub(super) const PROJECT_FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+pub(crate) const PROJECT_FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
 
 static PROJECT_WRITE_LOCK_NONCE: std::sync::atomic::AtomicU64 =
     std::sync::atomic::AtomicU64::new(1);
@@ -135,6 +135,7 @@ fn project_write_lock_can_be_reclaimed(path: &Path) -> bool {
         return false;
     };
     if metadata.file_type().is_symlink()
+        || windows_metadata_is_reparse_point(&metadata)
         || !metadata.is_file()
         || metadata.len() > PROJECT_WRITE_LOCK_MAX_BYTES
     {
@@ -196,8 +197,8 @@ pub(crate) fn acquire_project_write_lock(
     validate_project_root(root)?;
     let mut path = resolve_project_write_lock_path(root)?;
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建项目锁目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "项目锁目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "项目锁目录")?;
     }
     // Re-check the parent after creation so skipping metadata only for the final
     // create_new target cannot weaken the normal ancestor link/reparse checks.
@@ -212,16 +213,26 @@ pub(crate) fn acquire_project_write_lock(
         .map_err(|error| format!("生成项目写锁失败：{error}"))?;
     let mut retried_after_reclaim = false;
     loop {
-        match fs::OpenOptions::new()
-            .create_new(true)
-            .write(true)
-            .open(&path)
+        let mut options = fs::OpenOptions::new();
+        options.create_new(true).write(true);
+        #[cfg(windows)]
         {
+            use std::os::windows::fs::OpenOptionsExt;
+            options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+        }
+        match options.open(&path) {
             Ok(mut file) => {
+                if let Err(error) = harden_new_game_creator_private_path(&path, false, "项目写锁")
+                {
+                    drop(file);
+                    let _ = fs::remove_file(&path);
+                    return Err(error);
+                }
                 if let Err(error) = file.write_all(content.as_bytes()) {
                     let _ = fs::remove_file(&path);
                     return Err(format!("写入项目写锁失败：{}: {error}", path.display()));
                 }
+                prepare_game_creator_private_path_for_read(&path, false, "项目写锁")?;
                 return Ok(ProjectWriteLock {
                     path,
                     content: content.clone(),
@@ -283,14 +294,13 @@ pub(crate) fn list_local_project_files_at(
         {
             let entry =
                 entry.map_err(|error| format!("读取项目文件失败：{}: {error}", dir.display()))?;
-            let file_type = entry.file_type().map_err(|error| {
-                format!("读取文件类型失败：{}: {error}", entry.path().display())
-            })?;
-            if file_type.is_symlink() {
+            let path = entry.path();
+            let metadata = fs::symlink_metadata(&path)
+                .map_err(|error| format!("读取文件元数据失败：{}: {error}", path.display()))?;
+            if metadata.file_type().is_symlink() || windows_metadata_is_reparse_point(&metadata) {
                 continue;
             }
-
-            let path = entry.path();
+            let file_type = metadata.file_type();
             let relative_path = relative_project_path(root, &path)?;
             if is_agent_runtime_private_control_path(&relative_path)
                 || is_agent_checkpoint_control_path(&relative_path)
@@ -298,9 +308,6 @@ pub(crate) fn list_local_project_files_at(
             {
                 continue;
             }
-            let metadata = entry.metadata().map_err(|error| {
-                format!("读取文件元数据失败：{}: {error}", entry.path().display())
-            })?;
             let modified_at = metadata
                 .modified()
                 .ok()
@@ -342,6 +349,7 @@ pub(crate) fn read_local_project_file_at(
     reject_agent_runtime_private_control_path(&normalized_path)?;
     reject_sensitive_project_file_read(&normalized_path)?;
     let path = resolve_local_project_path(root, &normalized_path)?;
+    prepare_game_creator_private_path_for_read(&path, false, "项目文件")?;
     let metadata = fs::metadata(&path)
         .map_err(|error| format!("读取文件元数据失败：{}: {error}", path.display()))?;
     if !metadata.is_file() {
@@ -483,12 +491,7 @@ pub(crate) fn write_local_project_file_at(
     if path.exists() && !path.is_file() {
         return Err("只能写入文件".to_string());
     }
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建项目目录失败：{}: {error}", parent.display()))?;
-    }
-    fs::write(&path, content)
-        .map_err(|error| format!("写入项目文件失败：{}: {error}", path.display()))?;
+    crate::write_game_creator_private_file(&path, content.as_bytes(), "项目文件")?;
 
     Ok(LocalProjectFileMutationResult {
         path: normalized_path,
@@ -516,6 +519,7 @@ pub(crate) fn delete_local_project_file_at(
     if !path.is_file() {
         return Err("只能删除文件".to_string());
     }
+    prepare_game_creator_private_path_for_read(&path, false, "项目文件")?;
     fs::remove_file(&path)
         .map_err(|error| format!("删除项目文件失败：{}: {error}", path.display()))?;
 
@@ -537,24 +541,17 @@ pub(crate) fn build_local_project_index_at(root: &Path) -> Result<LocalProjectIn
         total_bytes,
         files,
     };
-    if let Some(parent) = root.join(PROJECT_INDEX_PATH).parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建项目索引目录失败：{}: {error}", parent.display()))?;
-    }
-    fs::write(
-        root.join(PROJECT_INDEX_PATH),
+    let index_path = root.join(PROJECT_INDEX_PATH);
+    crate::write_game_creator_private_file(
+        &index_path,
         format!(
             "{}\n",
             serde_json::to_string_pretty(&result)
                 .map_err(|error| format!("序列化项目索引失败：{error}"))?
-        ),
-    )
-    .map_err(|error| {
-        format!(
-            "写入项目索引失败：{}: {error}",
-            root.join(PROJECT_INDEX_PATH).display()
         )
-    })?;
+        .as_bytes(),
+        "项目索引",
+    )?;
     append_agent_db_record(
         root,
         serde_json::json!({
@@ -582,13 +579,13 @@ pub(crate) fn collect_project_index_files(
         {
             let entry =
                 entry.map_err(|error| format!("读取项目文件失败：{}: {error}", dir.display()))?;
-            let file_type = entry.file_type().map_err(|error| {
-                format!("读取文件类型失败：{}: {error}", entry.path().display())
-            })?;
-            if file_type.is_symlink() {
+            let path = entry.path();
+            let metadata = fs::symlink_metadata(&path)
+                .map_err(|error| format!("读取文件元数据失败：{}: {error}", path.display()))?;
+            if metadata.file_type().is_symlink() || windows_metadata_is_reparse_point(&metadata) {
                 continue;
             }
-            let path = entry.path();
+            let file_type = metadata.file_type();
             let relative_path = relative_project_path(root, &path)?;
             if should_skip_project_index_path(&relative_path) {
                 continue;
@@ -597,7 +594,7 @@ pub(crate) fn collect_project_index_files(
                 dirs.push(path);
             } else if file_type.is_file() {
                 let (mut file, metadata) =
-                    open_project_snapshot_regular_file(&path, "项目索引文件")?;
+                    open_project_private_regular_file(&path, "项目索引文件")?;
                 let mut bytes =
                     Vec::with_capacity(usize::try_from(metadata.len()).unwrap_or_default());
                 file.read_to_end(&mut bytes)
@@ -777,19 +774,36 @@ pub(crate) fn resolve_local_project_path(
     let normalized = normalize_relative_path(relative_path)?;
     let mut path = root.to_path_buf();
     let mut should_check_metadata = true;
+    let mut acl_repair_attempted = false;
     for part in normalized.split('/') {
         path.push(part);
         if !should_check_metadata {
             continue;
         }
         match fs::symlink_metadata(&path) {
-            Ok(metadata) if metadata.file_type().is_symlink() => {
-                return Err("项目文件路径不能包含符号链接".to_string());
+            Ok(metadata)
+                if metadata.file_type().is_symlink()
+                    || windows_metadata_is_reparse_point(&metadata) =>
+            {
+                return Err("项目文件路径不能包含符号链接或 Windows reparse point".to_string());
             }
             Ok(_) => {}
             Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                 should_check_metadata = false;
             }
+            Err(error)
+                if !acl_repair_attempted
+                    && error.kind() == std::io::ErrorKind::PermissionDenied =>
+            {
+                acl_repair_attempted = true;
+                #[cfg(windows)]
+                if crate::prepare_game_creator_private_path_for_read(&path, true, "项目路径")
+                    .is_ok()
+                {
+                    continue;
+                }
+                return Err(format!("读取路径失败：{}: {error}", path.display()));
+            }
             Err(error) => {
                 return Err(format!("读取路径失败：{}: {error}", path.display()));
             }
@@ -808,10 +822,18 @@ pub(crate) fn validate_project_root(root: &Path) -> Result<(), String> {
     if project_path_has_control_chars(root) {
         return Err("项目目录不能包含控制字符".to_string());
     }
+    // Every project operation enters through this validator. On Windows the
+    // root may be a historical directory whose owner is still the elevated
+    // installer account or whose DACL is inherited. Reuse the formal prepare
+    // entry here so all downstream reads/writes get the same one-shot UAC
+    // repair and post-repair verification, instead of failing later at the
+    // first individual sidecar read.
+    #[cfg(windows)]
+    crate::prepare_game_creator_project_root_for_read(root, true, "项目目录")?;
     match fs::symlink_metadata(root) {
         Ok(metadata) => {
-            if metadata.file_type().is_symlink() {
-                return Err("项目目录不能是符号链接".to_string());
+            if metadata.file_type().is_symlink() || windows_metadata_is_reparse_point(&metadata) {
+                return Err("项目目录不能是符号链接或 Windows reparse point".to_string());
             }
         }
         Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
@@ -822,6 +844,20 @@ pub(crate) fn validate_project_root(root: &Path) -> Result<(), String> {
     Ok(())
 }
 
+fn windows_metadata_is_reparse_point(metadata: &fs::Metadata) -> bool {
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::MetadataExt;
+        const FILE_ATTRIBUTE_REPARSE_POINT: u32 = 0x0000_0400;
+        return metadata.file_attributes() & FILE_ATTRIBUTE_REPARSE_POINT != 0;
+    }
+    #[cfg(not(windows))]
+    {
+        let _ = metadata;
+        false
+    }
+}
+
 pub(crate) fn project_path_has_control_chars(root: &Path) -> bool {
     root.to_string_lossy().chars().any(char::is_control)
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
index 5168849e5..8b2efaf66 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs
@@ -253,6 +253,8 @@ fn try_open_manifest_write_lock_file(path: &Path) -> Result<Option<File>, String
         .lock()
         .map_err(|_| "manifest 锁安全打开门禁已损坏".to_string())?;
     let lock_path = manifest_lock_path(path);
+    let existed =
+        crate::prepare_game_creator_private_path_for_read(&lock_path, false, "manifest 锁")?;
     let mut options = fs::OpenOptions::new();
     options
         .create(true)
@@ -277,6 +279,9 @@ fn try_open_manifest_write_lock_file(path: &Path) -> Result<Option<File>, String
             lock_path.display()
         ));
     }
+    if !existed {
+        crate::harden_new_game_creator_private_path(&lock_path, false, "manifest 锁")?;
+    }
     file.set_permissions(fs::Permissions::from_mode(0o600))
         .map_err(|error| format!("收紧 manifest 锁权限失败：{}: {error}", lock_path.display()))?;
     let path_metadata = fs::symlink_metadata(&lock_path)
@@ -340,6 +345,18 @@ fn try_open_manifest_write_lock_file(path: &Path) -> Result<Option<File>, String
             ));
         }
     }
+    let existed = match fs::symlink_metadata(&lock_path) {
+        Ok(_) => true,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => false,
+        Err(_) => {
+            // An inherited/foreign ACL can hide an existing lock from the
+            // normal token.  Prepare it through the formal elevation gate so
+            // the subsequent exclusive open does not misclassify access
+            // denial as a stale lock or a generic failure.
+            crate::prepare_game_creator_private_path_for_read(&lock_path, false, "manifest 锁")?;
+            true
+        }
+    };
     match fs::OpenOptions::new()
         .create(true)
         .read(true)
@@ -350,12 +367,21 @@ fn try_open_manifest_write_lock_file(path: &Path) -> Result<Option<File>, String
     {
         Ok(file) => {
             validate_windows_regular_file_handle(&file, "manifest 锁")?;
-            // 提升权限运行时，Windows 可能用 TokenOwner=Administrators 创建新文件。
-            // 独占句柄与普通文件检查通过后，将这个固定锁文件收归当前 TokenUser，
-            // 再复核句柄并按既有规则验证 owner/DACL；不放宽旧文件的安全门禁。
-            crate::initialize_windows_game_creator_file_owner_for_current_user(&lock_path)?;
-            validate_windows_regular_file_handle(&file, "manifest 锁")?;
-            crate::secure_windows_game_creator_path_for_current_user(&lock_path, false, false)?;
+            if existed {
+                // Existing files may have a foreign owner or inherited DACL;
+                // let the strict verifier request one-shot UAC repair.
+                crate::secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                    &lock_path, false, true,
+                )?;
+            } else {
+                // Only this invocation's newly created lock may initialize its
+                // owner. It is still revalidated after initialization.
+                crate::initialize_windows_game_creator_file_owner_for_current_user(&lock_path)?;
+                validate_windows_regular_file_handle(&file, "manifest 锁")?;
+                crate::secure_windows_game_creator_path_for_current_user_with_auto_elevation(
+                    &lock_path, false, false,
+                )?;
+            }
             Ok(Some(file))
         }
         Err(error)
@@ -402,19 +428,20 @@ pub(crate) fn init_local_game_project_at(
         return Err("项目名称不能为空".to_string());
     }
 
+    prepare_game_creator_project_root_for_read(root, true, "本地项目目录")?;
     for relative in ["game", "assets", "memory", "memory/agents", "exports"] {
-        fs::create_dir_all(root.join(relative)).map_err(|error| {
-            format!(
-                "创建本地项目目录失败：{}: {error}",
-                root.join(relative).display()
-            )
-        })?;
+        let path = root.join(relative);
+        ensure_game_creator_private_directory_tree(&path, "本地项目目录")?;
+        prepare_game_creator_private_path_for_read(&path, true, "本地项目目录")?;
     }
 
     let index_path = root.join("game/index.html");
-    if !index_path.exists() {
-        fs::write(&index_path, DEFAULT_GAME_INDEX_HTML)
-            .map_err(|error| format!("写入默认游戏入口失败：{}: {error}", index_path.display()))?;
+    if !prepare_game_creator_private_path_for_read(&index_path, false, "默认游戏入口")? {
+        crate::write_game_creator_private_file(
+            &index_path,
+            DEFAULT_GAME_INDEX_HTML.as_bytes(),
+            "默认游戏入口",
+        )?;
     }
 
     let agent_db_path = root.join(".agent/agent.db");
@@ -430,12 +457,9 @@ pub(crate) fn init_local_game_project_at(
     }
 
     for relative in [".agent/logs", ".agent/runtime"] {
-        fs::create_dir_all(root.join(relative)).map_err(|error| {
-            format!(
-                "创建本地项目目录失败：{}: {error}",
-                root.join(relative).display()
-            )
-        })?;
+        let path = root.join(relative);
+        ensure_game_creator_private_directory_tree(&path, "本地项目目录")?;
+        prepare_game_creator_private_path_for_read(&path, true, "本地项目目录")?;
     }
 
     let manifest_path = root.join(".agent/manifest.json");
@@ -466,8 +490,15 @@ pub(crate) fn import_local_godot_project_at(
     if project_path_has_control_chars(root) {
         return Err("项目目录不能包含控制字符".to_string());
     }
-    if !root.is_dir() {
-        return Err("Godot 工作区目录不存在或不是文件夹".to_string());
+    // The user explicitly selected this workspace as a project root.  Route it
+    // through the project-root ACL entry so an owner-correct inherited DACL (or
+    // a foreign owner that requires UAC) is repaired before discovery; once the
+    // AGC marker is written, descendants use the stricter managed-root policy.
+    prepare_game_creator_project_root_for_read(root, true, "Godot 工作区目录")?;
+    let root_metadata = fs::symlink_metadata(root)
+        .map_err(|error| format!("读取 Godot 工作区目录失败：{}: {error}", root.display()))?;
+    if root_metadata.file_type().is_symlink() || !root_metadata.is_dir() {
+        return Err("Godot 工作区目录不存在或不是普通文件夹".to_string());
     }
     let godot_project_root = discover_local_godot_project_root(root)?.ok_or_else(|| {
         "所选工作区未在根目录或一层子目录发现有效的普通文件 project.godot".to_string()
@@ -508,12 +539,9 @@ pub(crate) fn import_local_godot_project_at(
     }
 
     for relative in [".agent/logs", ".agent/runtime"] {
-        fs::create_dir_all(root.join(relative)).map_err(|error| {
-            format!(
-                "创建 Godot 项目 Agent 目录失败：{}: {error}",
-                root.join(relative).display()
-            )
-        })?;
+        let path = root.join(relative);
+        ensure_game_creator_private_directory_tree(&path, "Godot 项目 Agent 目录")?;
+        prepare_game_creator_private_path_for_read(&path, true, "Godot 项目 Agent 目录")?;
     }
 
     let mut manifest = new_game_creation_app_manifest(project_id, name);
@@ -1162,8 +1190,8 @@ pub(crate) fn mutate_manifest_at<T>(
     }
     let manifest_path = root.join(".agent/manifest.json");
     if let Some(parent) = manifest_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建 manifest 目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "manifest 目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "manifest 目录")?;
     }
     let _write_lock = acquire_manifest_write_lock(&manifest_path)?;
     let (_, mut manifest) = read_or_create_manifest(root)?;
@@ -1182,6 +1210,7 @@ fn manifest_backup_path(path: &Path) -> PathBuf {
 }
 
 pub(crate) fn manifest_storage_exists(path: &Path) -> Result<bool, String> {
+    let _ = prepare_game_creator_private_path_for_read(path, false, "manifest")?;
     match fs::symlink_metadata(path) {
         Ok(_) => Ok(true),
         Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
@@ -1219,6 +1248,7 @@ fn remove_manifest_backup(path: &Path) -> Result<(), String> {
 
 pub(crate) fn read_manifest(path: &Path) -> Result<GameCreationAppManifest, String> {
     let backup_path = manifest_backup_path(path);
+    let _ = prepare_game_creator_private_path_for_read(path, false, "manifest")?;
     let (source_path, metadata, is_backup) = match fs::symlink_metadata(path) {
         Ok(metadata) => (path, metadata, false),
         Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
@@ -1255,6 +1285,8 @@ pub(crate) fn read_manifest(path: &Path) -> Result<GameCreationAppManifest, Stri
         "manifest"
     };
 
+    prepare_game_creator_private_path_for_read(source_path, false, label)?;
+
     let mut options = fs::OpenOptions::new();
     options.read(true);
     #[cfg(unix)]
@@ -1364,8 +1396,8 @@ where
     validate_manifest_godot_project_root(manifest.godot_project_root.as_deref())
         .map_err(|error| format!("校验 manifest Godot 项目根失败：{error}"))?;
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建 manifest 目录失败：{}: {error}", parent.display()))?;
+        ensure_game_creator_private_directory_tree(parent, "manifest 目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "manifest 目录")?;
     }
     let _write_lock = acquire_manifest_write_lock(path)?;
     after_lock();
@@ -1413,13 +1445,13 @@ fn write_manifest_locked(path: &Path, manifest: &GameCreationAppManifest) -> Res
             .unwrap_or_default()
             .as_nanos()
     ));
-    fs::write(&temp_path, format!("{payload}\n")).map_err(|error| {
-        format!(
-            "写入 manifest 临时文件失败：{}: {error}",
-            temp_path.display()
-        )
-    })?;
+    crate::write_game_creator_private_file(
+        &temp_path,
+        format!("{payload}\n").as_bytes(),
+        "manifest 临时文件",
+    )?;
     install_manifest_temp_with(path, &temp_path, |from, to| fs::rename(from, to))?;
+    prepare_game_creator_private_path_for_read(path, false, "manifest")?;
     let installed = read_manifest(path)?;
     if installed != *manifest {
         return Err("manifest 安装后回读与待写入内容不一致".to_string());
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/memory.rs b/apps/ai-game-creator-shell/src-tauri/src/project/memory.rs
index a8551c0f2..c18ff0b8c 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/memory.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/memory.rs
@@ -5,6 +5,15 @@ pub(crate) fn read_local_game_memory_at(
     scope: &str,
 ) -> Result<LocalGameMemoryResult, String> {
     let (scope, path) = memory_file_path(root, scope)?;
+    let prepared = prepare_game_creator_private_path_for_read(&path, false, "游戏记忆")?;
+    if !prepared {
+        return Ok(LocalGameMemoryResult {
+            scope: scope.to_string(),
+            path: path.to_string_lossy().into_owned(),
+            content: String::new(),
+            exists: false,
+        });
+    }
     match fs::read_to_string(&path) {
         Ok(content) => Ok(LocalGameMemoryResult {
             scope: scope.to_string(),
@@ -28,6 +37,15 @@ pub(crate) fn read_local_agent_memory_at(
 ) -> Result<LocalAgentMemoryResult, String> {
     let relative_path = agent_role_memory_relative_path_for_task(task_id)?;
     let path = resolve_local_project_path(root, &relative_path)?;
+    let prepared = prepare_game_creator_private_path_for_read(&path, false, "Agent 记忆")?;
+    if !prepared {
+        return Ok(LocalAgentMemoryResult {
+            task_id: task_id.to_string(),
+            path: path.to_string_lossy().into_owned(),
+            content: String::new(),
+            exists: false,
+        });
+    }
     match fs::read_to_string(&path) {
         Ok(content) => Ok(LocalAgentMemoryResult {
             task_id: task_id.to_string(),
@@ -52,12 +70,7 @@ pub(crate) fn write_local_agent_memory_at(
 ) -> Result<LocalAgentMemoryResult, String> {
     let relative_path = agent_role_memory_relative_path_for_task(task_id)?;
     let path = resolve_local_project_path(root, &relative_path)?;
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建 Agent 记忆目录失败：{}: {error}", parent.display()))?;
-    }
-    fs::write(&path, content)
-        .map_err(|error| format!("写入 Agent 记忆失败：{}: {error}", path.display()))?;
+    crate::write_game_creator_private_file(&path, content.as_bytes(), "Agent 记忆")?;
     Ok(LocalAgentMemoryResult {
         task_id: task_id.to_string(),
         path: path.to_string_lossy().into_owned(),
@@ -72,12 +85,7 @@ pub(crate) fn write_local_game_memory_at(
     content: &str,
 ) -> Result<LocalGameMemoryResult, String> {
     let (scope, path) = memory_file_path(root, scope)?;
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建记忆目录失败：{}: {error}", parent.display()))?;
-    }
-    fs::write(&path, content)
-        .map_err(|error| format!("写入记忆失败：{}: {error}", path.display()))?;
+    crate::write_game_creator_private_file(&path, content.as_bytes(), "游戏记忆")?;
     Ok(LocalGameMemoryResult {
         scope: scope.to_string(),
         path: path.to_string_lossy().into_owned(),
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/resource_editor.rs b/apps/ai-game-creator-shell/src-tauri/src/project/resource_editor.rs
index d9cefa8e4..bb8296f32 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/resource_editor.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/resource_editor.rs
@@ -1016,7 +1016,7 @@ fn read_stable_resource_edit_file(
     reject_sensitive_project_file_read(&normalized)?;
     let absolute = resolve_local_project_path(root, &normalized)?;
     validate_agent_runtime_inspection_ancestors(root, &absolute)?;
-    let (mut file, initial_metadata) = open_project_snapshot_regular_file(&absolute, label)?;
+    let (mut file, initial_metadata) = open_project_private_regular_file(&absolute, label)?;
     if initial_metadata.len() > max_bytes as u64 {
         return Err(format!("{label}不能超过 {} MiB", max_bytes / 1024 / 1024));
     }
@@ -1527,9 +1527,10 @@ fn write_resource_edit_staging(
 ) -> Result<(), String> {
     let path = resolve_local_project_path(root, &resource_edit_staging_path(operation_id))?;
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建资源编辑 staging 目录失败：{error}"))?;
+        ensure_game_creator_private_directory_tree(parent, "资源编辑 staging 目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "资源编辑 staging 目录")?;
     }
+    prepare_game_creator_private_path_for_read(&path, false, "资源编辑 staging")?;
     match fs::symlink_metadata(&path) {
         Ok(metadata) if metadata.file_type().is_symlink() || !metadata.is_file() => {
             return Err("资源编辑 staging 必须是普通文件".to_string());
@@ -1553,16 +1554,30 @@ fn write_resource_edit_staging(
         options.custom_flags(libc::O_NOFOLLOW);
         options.mode(0o600);
     }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
     let mut file = options
         .open(&path)
         .map_err(|error| format!("创建资源编辑 staging 失败：{error}"))?;
+    if let Err(error) = harden_new_game_creator_private_path(&path, false, "资源编辑 staging") {
+        drop(file);
+        let _ = fs::remove_file(&path);
+        return Err(error);
+    }
     file.write_all(bytes)
         .and_then(|_| file.sync_data())
-        .map_err(|error| format!("写入资源编辑 staging 失败：{error}"))
+        .map_err(|error| {
+            let _ = fs::remove_file(&path);
+            format!("写入资源编辑 staging 失败：{error}")
+        })
 }
 
 fn read_resource_edit_staging(root: &Path, operation_id: &str) -> Result<Vec<u8>, String> {
     let path = resolve_local_project_path(root, &resource_edit_staging_path(operation_id))?;
+    prepare_game_creator_private_path_for_read(&path, false, "资源编辑 staging")?;
     let metadata = fs::symlink_metadata(&path)
         .map_err(|error| format!("读取资源编辑 staging 失败：{error}"))?;
     if metadata.file_type().is_symlink() || !metadata.is_file() {
@@ -1576,6 +1591,10 @@ fn read_optional_resource_edit_staging(
     operation_id: &str,
 ) -> Result<Option<Vec<u8>>, String> {
     let path = resolve_local_project_path(root, &resource_edit_staging_path(operation_id))?;
+    let prepared = prepare_game_creator_private_path_for_read(&path, false, "资源编辑 staging")?;
+    if !prepared {
+        return Ok(None);
+    }
     match fs::symlink_metadata(&path) {
         Ok(metadata) if metadata.file_type().is_symlink() || !metadata.is_file() => {
             Err("资源编辑 staging 必须是普通文件".to_string())
@@ -2322,10 +2341,7 @@ fn resource_edit_remote_request(
                     },
                 });
             }
-            Ok((
-                "/api/editor/character-animations/generations",
-                body,
-            ))
+            Ok(("/api/editor/character-animations/generations", body))
         }
         LocalProjectResourceEditKind::Video => {
             let mut body = serde_json::json!({
@@ -2372,10 +2388,7 @@ fn resource_edit_remote_request(
                     "placeholder": external_canvas_placeholder("1:1"),
                 });
             }
-            Ok((
-                "/api/editor/audios/sound-effects/generations",
-                body,
-            ))
+            Ok(("/api/editor/audios/sound-effects/generations", body))
         }
         LocalProjectResourceEditKind::BackgroundMusic => {
             let mut body = serde_json::json!({
@@ -2392,10 +2405,7 @@ fn resource_edit_remote_request(
                     "placeholder": external_canvas_placeholder("1:1"),
                 });
             }
-            Ok((
-                "/api/editor/audios/background-music/generations",
-                body,
-            ))
+            Ok(("/api/editor/audios/background-music/generations", body))
         }
         _ => Err("当前资源类型不是远端媒体派生".to_string()),
     }
@@ -3861,8 +3871,10 @@ fn install_resource_edit_final_media(
 ) -> Result<(), String> {
     let absolute_path = resolve_local_project_path(root, relative_path)?;
     if let Some(parent) = absolute_path.parent() {
-        fs::create_dir_all(parent).map_err(|error| format!("创建派生资源目录失败：{error}"))?;
+        ensure_game_creator_private_directory_tree(parent, "派生资源目录")?;
+        prepare_game_creator_private_path_for_read(parent, true, "派生资源目录")?;
     }
+    prepare_game_creator_private_path_for_read(&absolute_path, false, "派生资源")?;
     let mut options = fs::OpenOptions::new();
     options.write(true).create_new(true);
     #[cfg(unix)]
@@ -3871,12 +3883,26 @@ fn install_resource_edit_final_media(
         options.custom_flags(libc::O_NOFOLLOW);
         options.mode(0o600);
     }
+    #[cfg(windows)]
+    {
+        use std::os::windows::fs::OpenOptionsExt;
+        options.custom_flags(PROJECT_FILE_FLAG_OPEN_REPARSE_POINT);
+    }
     let mut file = options
         .open(&absolute_path)
         .map_err(|error| format!("创建派生资源失败：{error}"))?;
+    if let Err(error) = harden_new_game_creator_private_path(&absolute_path, false, "派生资源")
+    {
+        drop(file);
+        let _ = fs::remove_file(&absolute_path);
+        return Err(error);
+    }
     file.write_all(bytes)
         .and_then(|_| file.sync_data())
-        .map_err(|error| format!("写入派生资源失败：{error}"))
+        .map_err(|error| {
+            let _ = fs::remove_file(&absolute_path);
+            format!("写入派生资源失败：{error}")
+        })
 }
 
 fn commit_resource_edit_asset_internal(
@@ -8273,10 +8299,7 @@ mod tests {
             Some(&canvas_context),
         )
         .expect("build create video request");
-        assert_eq!(
-            create_video_endpoint,
-            "/api/editor/videos/generations"
-        );
+        assert_eq!(create_video_endpoint, "/api/editor/videos/generations");
         assert!(create_video_body.get("referenceVideoSrcs").is_none());
         assert_eq!(
             create_video_body["projectId"],
@@ -8521,9 +8544,7 @@ mod tests {
                             "assetObjectId": "source-video-object"
                         }}}),
                     );
-                } else if request_line
-                    .starts_with("POST /api/editor/videos/generations ")
-                {
+                } else if request_line.starts_with("POST /api/editor/videos/generations ") {
                     assert!(request_lower
                         .contains("authorization: bearer resource-editor-external-key"));
                     assert!(request_lower.contains("idempotency-key:"));
diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/verification.rs b/apps/ai-game-creator-shell/src-tauri/src/project/verification.rs
index f30dd9710..acc780b40 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/project/verification.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/project/verification.rs
@@ -15,6 +15,7 @@ pub(crate) fn run_limited_local_command_at(
     }
 
     let game_index_path = root.join("game/index.html");
+    prepare_game_creator_private_path_for_read(&game_index_path, false, "游戏入口")?;
     let html = fs::read_to_string(&game_index_path)
         .map_err(|error| format!("读取游戏入口失败：{}: {error}", game_index_path.display()))?;
     if !html.contains("<html") && !html.contains("<!doctype html") {
@@ -24,18 +25,9 @@ pub(crate) fn run_limited_local_command_at(
 
     let output = format!("通过：game/index.html，{} 字节", html.len());
     let log_path = root.join(".agent/logs/command.log");
-    if let Some(parent) = log_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建命令日志目录失败：{}: {error}", parent.display()))?;
-    }
     let updated_at = unix_timestamp();
     let line = format!("{updated_at} command.run_limited {command_id}: {output}\n");
-    fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(&log_path)
-        .and_then(|mut file| file.write_all(line.as_bytes()))
-        .map_err(|error| format!("写入命令日志失败：{}: {error}", log_path.display()))?;
+    append_game_creator_private_file(&log_path, line.as_bytes(), "命令日志")?;
 
     record_command_run(
         root,
@@ -298,6 +290,7 @@ pub(crate) fn resolve_project_verification_spec_at(
             PROJECT_VERIFICATION_PACKAGE_MAX_BYTES
         ));
     }
+    prepare_game_creator_private_path_for_read(&package_path, false, "package.json")?;
     let package_content = fs::read_to_string(&package_path).map_err(|error| {
         format!(
             "读取 package.json 失败：{}: {error}",
@@ -621,10 +614,6 @@ where
     let command_id = format!("project.verify.{}", spec.script);
     let updated_at = unix_timestamp();
     let log_path = resolve_local_project_path(root, ".agent/logs/command.log")?;
-    if let Some(parent) = log_path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建命令日志目录失败：{}: {error}", parent.display()))?;
-    }
     let log_entry = format!(
         "{updated_at} project.verify {} {status} manager={} exitCode={} timedOut={} durationMs={} sandboxBackend={} sandboxMode={} networkAccess={} sandboxProfileVersion={} sandboxEstablishment={} targetExec={} launchFailureKind={}\n{}\n",
         spec.script,
@@ -644,12 +633,7 @@ where
         process.launch_failure_kind.as_deref().unwrap_or("none"),
         process.output
     );
-    fs::OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(&log_path)
-        .and_then(|mut file| file.write_all(log_entry.as_bytes()))
-        .map_err(|error| format!("写入命令日志失败：{}: {error}", log_path.display()))?;
+    append_game_creator_private_file(&log_path, log_entry.as_bytes(), "命令日志")?;
     record_command_run(
         root,
         GameCreationAppCommandRunState {
@@ -719,6 +703,7 @@ pub(crate) fn read_project_permission_policy_at(
             policy: ProjectPermissionPolicy::default(),
         });
     }
+    prepare_game_creator_private_path_for_read(&path, false, "项目权限策略")?;
     let content = fs::read_to_string(&path)
         .map_err(|error| format!("读取项目权限策略失败：{}: {error}", path.display()))?;
     let policy = serde_json::from_str::<ProjectPermissionPolicy>(&content)
@@ -736,14 +721,13 @@ pub(crate) fn write_project_permission_policy_at(
     validate_project_root(root)?;
     let policy = normalize_project_permission_policy(policy)?;
     let path = root.join(PROJECT_PERMISSION_POLICY_PATH);
-    if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent)
-            .map_err(|error| format!("创建项目权限策略目录失败：{}: {error}", parent.display()))?;
-    }
     let content = serde_json::to_string_pretty(&policy)
         .map_err(|error| format!("序列化项目权限策略失败：{error}"))?;
-    fs::write(&path, format!("{content}\n"))
-        .map_err(|error| format!("写入项目权限策略失败：{}: {error}", path.display()))?;
+    crate::write_game_creator_private_file(
+        &path,
+        format!("{content}\n").as_bytes(),
+        "项目权限策略",
+    )?;
     append_agent_db_record(
         root,
         serde_json::json!({
diff --git a/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs b/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
index 00a8521a5..1b1ecd5a6 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/tests/project.rs
@@ -1495,7 +1495,7 @@ fn automatic_local_game_project_rejects_symlinked_projects_root() {
     let error = create_automatic_local_game_project_at(&projects_root)
         .expect_err("symlinked automatic workspace root must fail");
 
-    assert!(error.contains("普通文件夹"));
+    assert!(error.contains("不能包含符号链接"));
     assert!(fs::read_dir(&target).expect("read target").next().is_none());
     fs::remove_dir_all(container).ok();
 }
diff --git a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
index c8b24793d..8211684b9 100644
--- a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
+++ b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
@@ -169,6 +169,7 @@ Supervisor 认领该回执后，由父 run 自己为每个原 delivery 逐一创
 
 - Windows AppData 安全迁移：首次创建客户端 AppData 时必须以进程 `TokenUser` SID 显式设置 owner，并写入当前用户私有 DACL，不能把可能为 Administrators 的 `TokenOwner` 当作用户身份。发现历史目录 owner 不属于当前 `TokenUser` 时，不在原目录上放宽权限，而是拒绝 reparse point / junction / symlink 后，将旧目录原子重命名到同级唯一 `.owner-mismatch-backup-*` 备份，再新建并验证当前用户 owner 与私有 DACL；迁移或备份失败必须失败关闭，不覆盖旧配置。
 - Windows 私有文件初始化：父目录已归当前 `TokenUser` 后，新建 `.agent/.manifest.json.lock`、`agent-runner.lock`、endpoint 临时文件、project-owner 诊断临时文件与 real-E2E 私有文件的 owner 仍可能采用 token 默认 owner `Administrators`。manifest 固定锁和 Runner 固定 stale lock 只有在 Windows 不共享独占句柄已取得、且句柄确认普通文件、非 reparse point、链接数为一时才允许初始化或修复为当前 `TokenUser`，随后必须再次复核句柄并按既有 owner/DACL 门禁验证；其它临时文件只允许在本进程 `create_new` 成功且仍持有同一独占句柄时初始化 `TokenUser` owner / DACL，再写入、原子安装并严格复核，初始化失败必须清理刚创建的文件。既有 durable endpoint / diagnostic 读取不得自动接管；活锁不得截断，只有 sharing / lock violation `32/33` 表示占用，access denied 等其它错误立即返回。父进程观察到 Runner 子进程退出后立即返回错误，不等待完整 30 秒 deadline。
+- Windows ACL 提权边界：自定义 `--config-dir` 的启动前置检查必须把 `managed / user-selected` scope 一并传入提权子进程，不能依赖父进程内存中的配置目录覆盖；native picker 返回的文件或项目目录在同一进程登记短时授权，后续导入 / 项目操作只对登记路径（目录可覆盖其后代）允许 `user-selected` 自动提权，直接伪造 IPC 绝对路径不得获得该能力。项目文件列表 / 索引递归逐项拒绝 symlink 与 Windows reparse point，并在 metadata / read 前先完成 ACL 准备。
 - 启动恢复和续跑边界：本条取代上一条中“只有 accepted 才可恢复”的窄口径。若进程在 Supervisor 用户消息已持久、accepted 未持久之间崩溃，只读 preflight 可以把该 `preparing` 识别为可恢复，但不改写 task/conversation；真实 resume 持有 Agent 锁后必须先幂等补写 accepted，再提升为 `pending / queued`。用户消息或 accepted conversation 已落盘而辅助审计失败时，以 conversation 为公开真相继续入队，不留下“已接收但永不执行”的任务；根终态首次公开写入的瞬时失败必须在终态投影后用相同 message ID 重试。receipt / isolated-join 等带 parent 的 Supervisor continuation 不再另写 Session 终态，只保留单一后端公开事件；`runtime-task-*` 与 `runtime-public-status-*` 共享同 run 的不透明关联摘要，秒级时间戳下多个连续任务必须按实际 run 对应的 `user -> accepted -> terminal` 顺序交错展示。
 - ready-task 启动活性：`background_task.queued`、`autonomous_ready_task.scheduled`、Runner heartbeat 或执行锁已移交都不等于 child 已启动。实际持有执行权的 Runner 必须在释放项目写锁后同步写入 child 的 running task、`turn.started` 与 started journal，再把已启动 state 和 per-Agent 执行锁交给已确认开始轮询的独立 execution worker；同步启动或 worker 接管失败时，要在仍持有执行锁期间依次把 child 和 manifest Graph 节点明确落为 failed，再释放锁并让 parent 收到调度错误。`autonomous_ready_task.scheduled` 只作诊断审计，其写入失败不能阻断 durable child 启动；external client 只 wake Runner，不在客户端抢占执行。Supervisor 进度卡通过 durable `startedAt`（旧 Run 从完整 task journal 恢复，最新 task-record fallback 保持 0）显示真实持续时间，并以父 Run 与当前关联专业 Agent 的最大事件时间计算运行态活跃度：运行超过 5 分钟无新事件时显示“运行中 · 疑似停滞”和静默时长；等待用户、等待确认、Provider retry、视觉资产、进程会话、pausing 与 paused 不误报。父 Run terminal 后，持续时间冻结在父 Run 自身最后活动，不随 child 晚到收口事件增长。消息时间统一校验为 JavaScript 可表示的 Date；越界值显示“时间未知”且不写无效 `datetime`。实时回复只显示 response stream 自己的 `updatedAt`，缺失时同样显示“时间未知”，不能借用其它 Runtime 活动时间或随前端时钟漂移。该提示只提供可观测性，不改变 Runtime/manifest 正式状态。
 - ready-task 对账取消续跑：未知工具结果仍停在 `needs-reconciliation` 且禁止自动重放；人工核对后显式取消原 child，保留 cancel tombstone，旧 child 和旧父 Run 按真实终态收口。若随后创建同 Session、同 Supervisor source、同有效任务语义的 continuation，新完成合同只对同时具有历史 `failed / needs-reconciliation`、最终 `cancelled` 和 durable tombstone 的 ready-task，把当前 manifest 对应 failed 节点恢复为 pending，并由 scheduler 创建全新 child Run。manifest 的读取、failed 筛选、每任务一次的 child journal 索引、证据重验和写回必须位于同一项目写锁域；较新的无 child 根 Run 只有在 durable journal 精确表明为旧 failed Graph 在进入调度前即失败时才能跨过，scheduler 自身失败必须阻断借用更老 tombstone。普通失败、无 tombstone、不同 source/Session/任务语义或证据冲突均保持失败关闭；不得复活旧 pending action、补造 observation 或把取消任务标成 completed。

From 6d2c275d325c3d2645f91583b3d72f0570ad92f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8E=8B=E5=BE=B7=E5=AE=87?= <kvtodev@outlook.com>
Date: Mon, 31 Aug 2026 18:58:54 +0800
Subject: [PATCH 4/8] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E9=A1=B9=E7=9B=AE?=
 =?UTF-8?q?=E9=A1=B5=E5=B8=83=E5=B1=80=E9=AB=98=E5=BA=A6=20(#228)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

项目页父级改为纵向 flex 并填满可用高度
项目列表容器与表格占满剩余空间

before:
![shotmd-1788154666.jpg](/attachments/3a02fdae-22b1-49d7-9f20-6739fddb88b9)
![shotmd-1788143842.png](/attachments/7522543f-7f58-46f1-aa72-ee5d13d2819f)

after:
![shotmd-1788154694.jpg](/attachments/cd3fb3ea-fd55-4343-9e11-210af6fc767a)
![shotmd-1788155214.jpg](/attachments/2d39b273-57be-427e-9e08-2ffe994531fb)

---------

Co-authored-by: 段舒康 <kdletters@qq.com>
Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/228
Co-authored-by: 王德宇 <kvtodev@outlook.com>
Co-committed-by: 王德宇 <kvtodev@outlook.com>
---
 apps/ai-game-creator-shell/src/styles.css | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/apps/ai-game-creator-shell/src/styles.css b/apps/ai-game-creator-shell/src/styles.css
index c733e6704..250193272 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -821,11 +821,12 @@ textarea {
 }
 
 .launcher-projects-page {
-  align-content: start;
-  grid-template-rows: auto minmax(0, 1fr);
+  display: flex;
+  flex-direction: column;
   gap: 18px;
   width: calc(100vw - var(--launcher-sidebar-width));
   max-width: none;
+  flex: 1 1 auto;
   height: 100dvh;
   min-height: 0;
   margin: 0;
@@ -834,6 +835,8 @@ textarea {
 }
 
 .launcher-main:has(.launcher-projects-page) {
+  display: flex;
+  flex-direction: column;
   height: 100dvh;
   min-height: 0;
   padding-bottom: 0;
@@ -1005,8 +1008,9 @@ textarea {
 }
 
 .launcher-project-list-shell {
-  display: grid;
-  grid-template-rows: 42px minmax(0, 1fr);
+  display: flex;
+  flex-direction: column;
+  flex: 1 1 auto;
   min-height: 0;
   overflow: hidden;
   border: 1px solid var(--platform-surface-border);
@@ -1027,6 +1031,7 @@ textarea {
 
 .launcher-project-table-header {
   height: 42px;
+  flex-shrink: 0;
   padding: 0 14px;
   border-bottom: 1px solid var(--platform-surface-border);
   background: color-mix(
@@ -1047,6 +1052,7 @@ textarea {
 .launcher-project-table {
   display: grid;
   align-content: start;
+  flex: 1 1 auto;
   min-height: 0;
   overflow-y: auto;
 }

From d7fc4c5b6f70bdb6e4a0f2fd9afe67ed9a602b09 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AD=94=E4=BB=A4=E5=BC=98?= <ink29535@proton.me>
Date: Mon, 31 Aug 2026 19:47:23 +0800
Subject: [PATCH 5/8] =?UTF-8?q?=E8=AE=A9=20Direct=20=E9=A6=96=E8=BD=AE?=
 =?UTF-8?q?=E5=B8=A6=E4=B8=8A=E6=9C=AC=E8=BD=AE=E9=99=84=E4=BB=B6=E7=9A=84?=
 =?UTF-8?q?=E9=A1=B9=E7=9B=AE=E8=B7=AF=E5=BE=84=E6=98=A0=E5=B0=84=20(#223)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

抽出 Home/Project 共用的 DirectCodexTurnAttachment 与渲染函数
Direct command 在进 Codex 前拼接有界 sidecar，jsonl 与气泡仍写用户原文
首页建项 latch 把导入附件传给 Direct 首轮，后续手打消息不带 attachments
做方案首轮仍走 Supervisor，不注入 sidecar
补齐 Rust 渲染测试与 home.suite 附件断言
记录路径映射合同与决策

Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/223
Co-authored-by: 孔令弘 <ink29535@proton.me>
Co-committed-by: 孔令弘 <ink29535@proton.me>
---
 .../src-tauri/src/agent.rs                    |    4 +
 .../src-tauri/src/agent/codex_app_server.rs   |   34 +-
 .../src/agent/direct_codex_attachments.rs     |  431 +++++
 .../src-tauri/src/agent/direct_codex_audit.rs | 1458 +++++++++++++++++
 .../src-tauri/src/agent/direct_runtime.rs     |  192 +--
 apps/ai-game-creator-shell/src/App.tsx        |   62 +-
 apps/ai-game-creator-shell/src/app/types.ts   |    1 +
 .../features/app-shell/WorkspaceLauncher.tsx  |    1 +
 .../app-shell/directCodexTurnAttachments.ts   |   38 +
 .../src/features/app-shell/model.ts           |    7 +-
 .../app-shell/useHomeProjectCreation.ts       |    2 +
 .../tests/appSurface/home.suite.ts            |  137 ++
 .../tests/directCodexTurnAttachments.test.ts  |   45 +
 docs/README.md                                |    2 +
 .../shared-memory/decision-log.md             |   17 +
 .../shared-memory/document-map.md             |   10 +-
 ...��】DirectProject本轮附件路径映射-2026-08-31.md |  262 +++
 ...术方案】Direct回合行为审计账本-2026-08-31.md |  389 +++++
 ...irectProject未消费用户上传权威文档-2026-08-30.md |    1 +
 19 files changed, 2923 insertions(+), 170 deletions(-)
 create mode 100644 apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs
 create mode 100644 apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_audit.rs
 create mode 100644 apps/ai-game-creator-shell/src/features/app-shell/directCodexTurnAttachments.ts
 create mode 100644 apps/ai-game-creator-shell/tests/directCodexTurnAttachments.test.ts
 create mode 100644 docs/technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md
 create mode 100644 docs/technical/【技术方案】Direct回合行为审计账本-2026-08-31.md

diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent.rs b/apps/ai-game-creator-shell/src-tauri/src/agent.rs
index 78d3e3ee0..bc2bedb87 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent.rs
@@ -12,6 +12,8 @@ use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 mod codex_app_server;
 mod codex_cli;
 mod codex_provider_proxy;
+mod direct_codex_attachments;
+mod direct_codex_audit;
 mod direct_runtime;
 mod direct_tool_bridge;
 mod direct_tools_mcp;
@@ -34,6 +36,8 @@ pub(crate) use codex_cli::{
     game_creator_codex_cli_executable_path, game_creator_codex_cli_version_identity,
 };
 pub(crate) use codex_provider_proxy::*;
+pub(crate) use direct_codex_attachments::*;
+pub(crate) use direct_codex_audit::*;
 pub(crate) use direct_runtime::*;
 pub(crate) use direct_tool_bridge::*;
 pub(crate) use direct_tools_mcp::*;
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs
index 5a1d30e9f..6d3aa6237 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs
@@ -1905,8 +1905,15 @@ impl CodexAppServerConnection {
         request: LlmRunRequest,
         on_agent_message_delta: Option<&mut (dyn FnMut(&platform_llm::LlmStreamDelta) + Send)>,
     ) -> Result<platform_llm::LlmRunResponse, platform_llm::LlmError> {
-        self.run_turn_with_direct_observer(snapshot, llm, request, on_agent_message_delta, None)
-            .await
+        self.run_turn_with_direct_observer(
+            snapshot,
+            llm,
+            request,
+            on_agent_message_delta,
+            None,
+            None,
+        )
+        .await
     }
 
     async fn run_turn_with_direct_observer(
@@ -1916,6 +1923,7 @@ impl CodexAppServerConnection {
         request: LlmRunRequest,
         mut on_agent_message_delta: Option<&mut (dyn FnMut(&platform_llm::LlmStreamDelta) + Send)>,
         mut direct_observer: Option<&mut (dyn FnMut(DirectCodexTurnObservation) + Send)>,
+        mut audit: Option<&mut DirectCodexTurnAudit>,
     ) -> Result<platform_llm::LlmRunResponse, platform_llm::LlmError> {
         let _turn_guard = self.inner.turn_gate.lock().await;
         let thread_lease = self.thread_for(snapshot, &request, llm).await?;
@@ -2085,6 +2093,11 @@ impl CodexAppServerConnection {
                                     completed,
                                     &params,
                                 );
+                                if completed {
+                                    if let Some(audit) = audit.as_mut() {
+                                        audit.observe_item(&params);
+                                    }
+                                }
                             }
                             if item_type == "agentMessage" {
                                 if let Some(text) = item
@@ -2796,8 +2809,14 @@ pub(crate) async fn direct_game_creator_codex_chat_at(
     system_prompt: String,
     user_prompt: String,
 ) -> Result<String, String> {
-    direct_game_creator_codex_chat_at_with_optional_observer(root, system_prompt, user_prompt, None)
-        .await
+    direct_game_creator_codex_chat_at_with_optional_observer(
+        root,
+        system_prompt,
+        user_prompt,
+        None,
+        None,
+    )
+    .await
 }
 
 pub(crate) async fn direct_game_creator_codex_chat_at_with_observer(
@@ -2811,6 +2830,7 @@ pub(crate) async fn direct_game_creator_codex_chat_at_with_observer(
         system_prompt,
         user_prompt,
         Some(observer),
+        None,
     )
     .await
 }
@@ -2861,11 +2881,12 @@ fn direct_codex_project_identity_digest(path_identity: &[u8], project_id: &[u8])
     format!("{:x}", digest.finalize())
 }
 
-async fn direct_game_creator_codex_chat_at_with_optional_observer(
+pub(crate) async fn direct_game_creator_codex_chat_at_with_optional_observer(
     root: &std::path::Path,
     system_prompt: String,
     user_prompt: String,
     observer: Option<&mut (dyn FnMut(DirectCodexTurnObservation) + Send)>,
+    audit: Option<&mut DirectCodexTurnAudit>,
 ) -> Result<String, String> {
     // Resolve project authority before deriving the pool/thread identity.  A
     // caller may hold a stable symlink path whose target changes between
@@ -2917,7 +2938,7 @@ async fn direct_game_creator_codex_chat_at_with_optional_observer(
     .await
     .map_err(|error| error.to_string())?;
     connection
-        .run_turn_with_direct_observer(&snapshot, &config.llm, request, None, observer)
+        .run_turn_with_direct_observer(&snapshot, &config.llm, request, None, observer, audit)
         .await
         .map(|value| value.text)
         .map_err(|error| error.to_string())
@@ -4245,6 +4266,7 @@ while IFS= read -r line; do :; done
                 tool_request(),
                 Some(&mut on_delta),
                 Some(&mut observer),
+                None,
             )
             .await
             .expect("run fake app-server turn");
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs
new file mode 100644
index 000000000..8cf49e017
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs
@@ -0,0 +1,431 @@
+//! Direct Codex 本轮附件 sidecar：Home 与 Project 共用同一 DTO 和渲染函数。
+//! 有项目路径或导入状态时输出路径映射；否则保持首页元数据文案。不灌正文。
+
+pub(crate) const MAX_DIRECT_CODEX_ATTACHMENTS: usize = 8;
+const MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS: usize = 160;
+const MAX_DIRECT_CODEX_ATTACHMENT_MEDIA_TYPE_CHARS: usize = 96;
+const MAX_DIRECT_CODEX_ATTACHMENT_LOCAL_PATH_CHARS: usize = 512;
+
+const HOME_ATTACHMENT_HEADER: &str =
+    "[首页附件说明：当前尚未打开项目，以下仅为附件元数据，附件内容尚不可读取]";
+const PROJECT_ATTACHMENT_HEADER: &str =
+    "[本轮用户附件：已复制到当前项目。请用「项目路径」读取；原文件名不是磁盘路径。]";
+
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DirectCodexTurnAttachment {
+    pub(crate) name: String,
+    pub(crate) media_type: String,
+    #[serde(default)]
+    pub(crate) size: u64,
+    #[serde(default)]
+    pub(crate) local_path: Option<String>,
+    #[serde(default)]
+    pub(crate) status: Option<String>,
+}
+
+pub(crate) fn sanitize_attachment_name(value: &str) -> String {
+    let basename = value.rsplit(['/', '\\']).next().unwrap_or_default().trim();
+    let sanitized = basename
+        .chars()
+        .filter(|character| !character.is_control())
+        .take(MAX_DIRECT_CODEX_ATTACHMENT_NAME_CHARS)
+        .collect::<String>();
+    if sanitized.is_empty() {
+        "未命名附件".to_string()
+    } else {
+        sanitized
+    }
+}
+
+pub(crate) fn sanitize_attachment_media_type(value: &str) -> String {
+    let value = value.trim();
+    if value.is_empty()
+        || value.chars().any(|character| {
+            !(character.is_ascii_alphanumeric() || matches!(character, '/' | '+' | '-' | '.' | '_'))
+        })
+    {
+        "application/octet-stream".to_string()
+    } else {
+        value
+            .chars()
+            .take(MAX_DIRECT_CODEX_ATTACHMENT_MEDIA_TYPE_CHARS)
+            .collect()
+    }
+}
+
+pub(crate) fn sanitize_attachment_status(value: Option<&str>) -> Option<&'static str> {
+    match value.map(str::trim) {
+        Some("imported") => Some("imported"),
+        Some("failed") => Some("failed"),
+        _ => None,
+    }
+}
+
+pub(crate) fn sanitize_attachment_local_path(value: &str) -> Option<String> {
+    let trimmed = value.trim();
+    if trimmed.is_empty()
+        || trimmed.chars().count() > MAX_DIRECT_CODEX_ATTACHMENT_LOCAL_PATH_CHARS
+        || trimmed.chars().any(char::is_control)
+    {
+        return None;
+    }
+
+    let normalized = trimmed.replace('\\', "/");
+    if normalized.starts_with('/') {
+        return None;
+    }
+
+    let mut chars = normalized.chars();
+    if let (Some(letter), Some(':')) = (chars.next(), chars.next()) {
+        if letter.is_ascii_alphabetic() {
+            return None;
+        }
+    }
+
+    let mut segments = Vec::new();
+    for segment in normalized.split('/') {
+        if segment.is_empty() || segment == "." {
+            continue;
+        }
+        if segment == ".." {
+            return None;
+        }
+        segments.push(segment);
+    }
+    let first = segments.first()?;
+    if *first == ".agent" || *first == ".git" {
+        return None;
+    }
+    let path = segments.join("/");
+    if path.chars().count() > MAX_DIRECT_CODEX_ATTACHMENT_LOCAL_PATH_CHARS {
+        return None;
+    }
+    Some(path)
+}
+
+pub(crate) fn attachments_use_project_mapping(attachments: &[DirectCodexTurnAttachment]) -> bool {
+    attachments.iter().any(|attachment| {
+        attachment
+            .local_path
+            .as_deref()
+            .is_some_and(|value| !value.trim().is_empty())
+            || sanitize_attachment_status(attachment.status.as_deref()).is_some()
+    })
+}
+
+fn render_project_attachment_line(attachment: &DirectCodexTurnAttachment) -> String {
+    let name = sanitize_attachment_name(&attachment.name);
+    let media_type = sanitize_attachment_media_type(&attachment.media_type);
+    let raw_path = attachment
+        .local_path
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+    let sanitized_path = raw_path.and_then(sanitize_attachment_local_path);
+    let path_rejected = raw_path.is_some() && sanitized_path.is_none();
+    let status = if path_rejected {
+        Some("failed")
+    } else {
+        sanitize_attachment_status(attachment.status.as_deref())
+    };
+
+    let mut parts = vec![format!("原文件名：{name}")];
+    if let Some(path) = sanitized_path {
+        parts.push(format!("项目路径：{path}"));
+    }
+    parts.push(format!("类型：{media_type}"));
+    parts.push(format!("大小：{} 字节", attachment.size));
+    if let Some(status) = status {
+        parts.push(format!("状态：{status}"));
+    }
+    format!("- {}", parts.join("；"))
+}
+
+pub(crate) fn render_direct_codex_user_prompt(
+    prompt: &str,
+    attachments: &[DirectCodexTurnAttachment],
+) -> Result<String, String> {
+    let prompt = prompt.trim();
+    if prompt.is_empty() && attachments.is_empty() {
+        return Err("聊天内容不能为空".to_string());
+    }
+    if attachments.is_empty() {
+        return Ok(prompt.to_string());
+    }
+
+    let mut sections = Vec::new();
+    if !prompt.is_empty() {
+        sections.push(prompt.to_string());
+        sections.push(String::new());
+    }
+    if attachments_use_project_mapping(attachments) {
+        sections.push(PROJECT_ATTACHMENT_HEADER.to_string());
+        for attachment in attachments.iter().take(MAX_DIRECT_CODEX_ATTACHMENTS) {
+            sections.push(render_project_attachment_line(attachment));
+        }
+    } else {
+        sections.push(HOME_ATTACHMENT_HEADER.to_string());
+        for attachment in attachments.iter().take(MAX_DIRECT_CODEX_ATTACHMENTS) {
+            sections.push(format!(
+                "- {}；类型：{}；大小：{} 字节",
+                sanitize_attachment_name(&attachment.name),
+                sanitize_attachment_media_type(&attachment.media_type),
+                attachment.size,
+            ));
+        }
+    }
+    if attachments.len() > MAX_DIRECT_CODEX_ATTACHMENTS {
+        sections.push(format!(
+            "- 另有 {} 个附件未展开",
+            attachments.len() - MAX_DIRECT_CODEX_ATTACHMENTS
+        ));
+    }
+    Ok(sections.join("\n"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn home_attachment(name: &str, media_type: &str, size: u64) -> DirectCodexTurnAttachment {
+        DirectCodexTurnAttachment {
+            name: name.to_string(),
+            media_type: media_type.to_string(),
+            size,
+            local_path: None,
+            status: None,
+        }
+    }
+
+    fn project_attachment(
+        name: &str,
+        media_type: &str,
+        size: u64,
+        local_path: Option<&str>,
+        status: Option<&str>,
+    ) -> DirectCodexTurnAttachment {
+        DirectCodexTurnAttachment {
+            name: name.to_string(),
+            media_type: media_type.to_string(),
+            size,
+            local_path: local_path.map(str::to_string),
+            status: status.map(str::to_string),
+        }
+    }
+
+    #[test]
+    fn plain_prompt_is_trimmed_and_empty_prompt_without_attachments_is_rejected() {
+        assert_eq!(
+            render_direct_codex_user_prompt("  你好  ", &[]).expect("plain prompt"),
+            "你好"
+        );
+        assert_eq!(
+            render_direct_codex_user_prompt("", &[]).expect_err("empty prompt"),
+            "聊天内容不能为空"
+        );
+    }
+
+    #[test]
+    fn home_user_prompt_preserves_the_message_and_adds_only_bounded_attachment_metadata() {
+        let attachments = vec![home_attachment(
+            r"C:\Users\secret\角色参考.png",
+            "image/png\nBearer secret",
+            3,
+        )];
+
+        let prompt = render_direct_codex_user_prompt("  先看看这个附件  ", &attachments)
+            .expect("home prompt");
+
+        assert_eq!(
+            prompt,
+            "先看看这个附件\n\n[首页附件说明：当前尚未打开项目，以下仅为附件元数据，附件内容尚不可读取]\n- 角色参考.png；类型：application/octet-stream；大小：3 字节"
+        );
+        assert!(!prompt.contains("C:\\Users"));
+        assert!(!prompt.contains("\nBearer secret"));
+    }
+
+    #[test]
+    fn home_user_prompt_keeps_plain_messages_plain_and_caps_attachment_count() {
+        assert_eq!(
+            render_direct_codex_user_prompt("你好", &[]).expect("plain prompt"),
+            "你好"
+        );
+        let attachments = (0..MAX_DIRECT_CODEX_ATTACHMENTS + 2)
+            .map(|index| home_attachment(&format!("asset-{index}.png"), "image/png", index as u64))
+            .collect::<Vec<_>>();
+        let prompt =
+            render_direct_codex_user_prompt("看看素材", &attachments).expect("bounded attachments");
+        assert!(prompt.contains("asset-7.png"));
+        assert!(!prompt.contains("asset-8.png"));
+        assert!(prompt.contains("另有 2 个附件未展开"));
+        assert!(render_direct_codex_user_prompt("", &attachments).is_ok());
+        assert!(render_direct_codex_user_prompt("", &[]).is_err());
+    }
+
+    #[test]
+    fn home_json_without_path_or_status_still_deserializes() {
+        let attachment: DirectCodexTurnAttachment =
+            serde_json::from_str(r#"{"name":"a.png","mediaType":"image/png","size":3}"#)
+                .expect("home json");
+        assert!(attachment.local_path.is_none());
+        assert!(attachment.status.is_none());
+        assert_eq!(attachment.size, 3);
+    }
+
+    #[test]
+    fn project_prompt_keeps_user_text_and_maps_original_name_to_project_path() {
+        let attachments = vec![project_attachment(
+            "fast_gdd.md",
+            "text/markdown",
+            7944,
+            Some("assets/uploads/upload-1788083777445-fast_gdd.md"),
+            Some("imported"),
+        )];
+        let prompt = render_direct_codex_user_prompt("请根据附件做游戏", &attachments)
+            .expect("project prompt");
+
+        assert_eq!(
+            prompt,
+            "请根据附件做游戏\n\n[本轮用户附件：已复制到当前项目。请用「项目路径」读取；原文件名不是磁盘路径。]\n- 原文件名：fast_gdd.md；项目路径：assets/uploads/upload-1788083777445-fast_gdd.md；类型：text/markdown；大小：7944 字节；状态：imported"
+        );
+        assert!(!prompt.contains("GDD"));
+        assert!(!prompt.contains("规格"));
+        assert!(!prompt.contains("权威"));
+        assert!(!prompt.contains("必须读取"));
+    }
+
+    #[test]
+    fn project_png_and_markdown_share_the_same_line_shape() {
+        let attachments = vec![
+            project_attachment(
+                "角色参考.png",
+                "image/png",
+                12,
+                Some("assets/uploads/upload-1-角色参考.png"),
+                Some("imported"),
+            ),
+            project_attachment(
+                "notes.md",
+                "text/markdown",
+                80,
+                Some("assets/uploads/upload-2-notes.md"),
+                Some("imported"),
+            ),
+        ];
+        let prompt =
+            render_direct_codex_user_prompt("看这两个附件", &attachments).expect("mixed types");
+        let lines: Vec<_> = prompt
+            .lines()
+            .filter(|line| line.starts_with("- 原文件名："))
+            .collect();
+        assert_eq!(lines.len(), 2);
+        for line in &lines {
+            assert!(line.contains("；项目路径：assets/uploads/"));
+            assert!(line.contains("；类型："));
+            assert!(line.contains("；大小："));
+            assert!(line.contains("；状态：imported"));
+        }
+        assert!(lines[0].contains("角色参考.png"));
+        assert!(lines[0].contains("image/png"));
+        assert!(lines[1].contains("notes.md"));
+        assert!(lines[1].contains("text/markdown"));
+    }
+
+    #[test]
+    fn failed_attachment_without_path_has_status_and_no_error_body() {
+        let attachments = vec![project_attachment(
+            "lost.bin",
+            "application/octet-stream",
+            2,
+            None,
+            Some("failed"),
+        )];
+        let prompt =
+            render_direct_codex_user_prompt("附件失败了", &attachments).expect("failed prompt");
+        assert!(prompt.contains(PROJECT_ATTACHMENT_HEADER));
+        assert!(prompt.contains("原文件名：lost.bin"));
+        assert!(prompt.contains("状态：failed"));
+        assert!(!prompt.contains("项目路径："));
+        assert!(!prompt.contains("error"));
+        assert!(!prompt.contains("失败原因"));
+    }
+
+    #[test]
+    fn illegal_local_paths_are_omitted_and_marked_failed() {
+        let attachments = vec![
+            project_attachment(
+                "up.md",
+                "text/markdown",
+                1,
+                Some("../secret.md"),
+                Some("imported"),
+            ),
+            project_attachment(
+                "agent.md",
+                "text/markdown",
+                1,
+                Some(".agent/conversations/x.md"),
+                Some("imported"),
+            ),
+            project_attachment(
+                "abs.md",
+                "text/markdown",
+                1,
+                Some(r"C:\tmp\abs.md"),
+                Some("imported"),
+            ),
+            project_attachment(
+                "unix.md",
+                "text/markdown",
+                1,
+                Some("/tmp/unix.md"),
+                Some("imported"),
+            ),
+        ];
+        let prompt =
+            render_direct_codex_user_prompt("非法路径", &attachments).expect("illegal paths");
+        assert!(!prompt.contains("../secret.md"));
+        assert!(!prompt.contains(".agent/conversations/x.md"));
+        assert!(!prompt.contains("C:\\tmp\\abs.md"));
+        assert!(!prompt.contains("/tmp/unix.md"));
+        assert!(!prompt.contains("项目路径："));
+        assert_eq!(prompt.matches("状态：failed").count(), 4);
+        assert!(!prompt.contains("状态：imported"));
+    }
+
+    #[test]
+    fn empty_prompt_with_project_attachments_still_renders() {
+        let attachments = vec![project_attachment(
+            "ref.png",
+            "image/png",
+            4,
+            Some("assets/uploads/upload-1-ref.png"),
+            Some("imported"),
+        )];
+        let prompt = render_direct_codex_user_prompt("   ", &attachments).expect("empty user text");
+        assert!(prompt.starts_with(PROJECT_ATTACHMENT_HEADER));
+        assert!(prompt.contains("项目路径：assets/uploads/upload-1-ref.png"));
+    }
+
+    #[test]
+    fn unknown_error_field_is_not_forwarded_to_the_model() {
+        let attachment: DirectCodexTurnAttachment = serde_json::from_str(
+            r#"{"name":"a.md","mediaType":"text/markdown","size":1,"status":"failed","error":"secret boom"}"#,
+        )
+        .expect("extra error field");
+        let prompt = render_direct_codex_user_prompt("x", &[attachment]).expect("render");
+        assert!(!prompt.contains("secret boom"));
+        assert!(!prompt.contains("error"));
+    }
+
+    #[test]
+    fn unknown_status_keeps_home_attachment_metadata_shape() {
+        let attachment =
+            project_attachment("pending.md", "text/markdown", 1, None, Some("pending"));
+        let prompt = render_direct_codex_user_prompt("x", &[attachment]).expect("render");
+        assert!(prompt.contains(HOME_ATTACHMENT_HEADER));
+        assert!(!prompt.contains(PROJECT_ATTACHMENT_HEADER));
+        assert!(!prompt.contains("状态："));
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_audit.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_audit.rs
new file mode 100644
index 000000000..bc34a6b4c
--- /dev/null
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_audit.rs
@@ -0,0 +1,1458 @@
+//! Direct Codex GUI 回合行为账本：把 item/completed 抽成项目内有界时间线。
+//! 不灌附件正文、不落 stdout / patch / MCP result，不进入前端观察者。
+
+use super::*;
+use serde_json::{json, Map, Value};
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const DIRECT_CODEX_AUDIT_HASH_MAX_BYTES: u64 = 2 * 1024 * 1024;
+const DIRECT_CODEX_AUDIT_MAX_ITEMS: usize = 256;
+const DIRECT_CODEX_AUDIT_COMMAND_CHARS: usize = 240;
+const DIRECT_CODEX_AUDIT_BRIEF_CHARS: usize = 4000;
+const DIRECT_CODEX_AUDIT_PREVIEW_CHARS: usize = 240;
+const DIRECT_CODEX_AUDIT_QUERY_CHARS: usize = 400;
+const DIRECT_CODEX_AUDIT_LIST_QUERY_CHARS: usize = 120;
+const DIRECT_CODEX_AUDIT_ID_LIST_MAX: usize = 8;
+const DIRECT_CODEX_AUDIT_TURN_LOG_DIR: &str = ".agent/runtime/direct-codex/turns";
+
+const SKIPPED_ITEM_TYPES: &[&str] = &[
+    "agentMessage",
+    "userMessage",
+    "plan",
+    "reasoning",
+    "contextCompaction",
+    "hookPrompt",
+];
+
+const DESIGN_MCP_TOOLS: &[&str] = &[
+    "taonier_prepare_game_art",
+    "agc_generate_image",
+    "agc_edit_image",
+    "agc_create_or_derive_resource",
+];
+
+struct OfferedAttachment {
+    local_path: String,
+    content_sha256: Option<String>,
+    read: bool,
+    content_sha256_match: Option<bool>,
+}
+
+pub(crate) struct DirectCodexTurnAudit {
+    root: PathBuf,
+    client_turn_id: String,
+    log_path: PathBuf,
+    turn_log_relative: String,
+    sidecar_present: bool,
+    offered: Vec<OfferedAttachment>,
+    item_count: usize,
+    items_truncated: bool,
+    truncated_written: bool,
+    first_design: Option<Value>,
+    audit_write_failed: bool,
+    finished: bool,
+}
+
+impl DirectCodexTurnAudit {
+    pub(crate) fn start(
+        root: &Path,
+        client_turn_id: &str,
+        original_prompt: &str,
+        attachments: &[DirectCodexTurnAttachment],
+    ) -> Self {
+        let turn_log_relative = format!("{DIRECT_CODEX_AUDIT_TURN_LOG_DIR}/{client_turn_id}.jsonl");
+        let log_path = root.join(&turn_log_relative);
+        let sidecar_present = attachments_use_project_mapping(attachments);
+        let (attachment_values, offered) = project_audit_attachments(root, attachments);
+        let mut audit = Self {
+            root: root.to_path_buf(),
+            client_turn_id: client_turn_id.to_string(),
+            log_path,
+            turn_log_relative,
+            sidecar_present,
+            offered,
+            item_count: 0,
+            items_truncated: false,
+            truncated_written: false,
+            first_design: None,
+            audit_write_failed: false,
+            finished: false,
+        };
+        let omitted = attachments
+            .len()
+            .saturating_sub(MAX_DIRECT_CODEX_ATTACHMENTS);
+        let mut record = json!({
+            "recordType": "direct.codex.turn_start",
+            "clientTurnId": client_turn_id,
+            "sidecarPresent": sidecar_present,
+            "promptSha256": sha256_hex(original_prompt.as_bytes()),
+            "promptChars": original_prompt.chars().count(),
+            "attachments": attachment_values,
+        });
+        if omitted > 0 {
+            record["attachmentsOmitted"] = json!(omitted);
+        }
+        audit.append_record(record);
+        audit
+    }
+
+    pub(crate) fn observe_item(&mut self, params: &Value) {
+        if self.finished {
+            return;
+        }
+        let Some(item) = params.get("item") else {
+            return;
+        };
+        let item_type = item
+            .get("type")
+            .and_then(Value::as_str)
+            .unwrap_or("unknown");
+        if SKIPPED_ITEM_TYPES.contains(&item_type) {
+            return;
+        }
+        if self.item_count >= DIRECT_CODEX_AUDIT_MAX_ITEMS {
+            self.items_truncated = true;
+            if !self.truncated_written {
+                self.truncated_written = true;
+                self.append_record(json!({
+                    "recordType": "direct.codex.items_truncated",
+                    "clientTurnId": self.client_turn_id,
+                    "droppedAfter": DIRECT_CODEX_AUDIT_MAX_ITEMS,
+                }));
+            }
+            return;
+        }
+
+        self.item_count = self.item_count.saturating_add(1);
+        let seq = self.item_count;
+        let mut record = json!({
+            "recordType": "direct.codex.item",
+            "clientTurnId": self.client_turn_id,
+            "seq": seq,
+            "itemType": item_type,
+        });
+        if let Some(item_id) = item
+            .get("id")
+            .and_then(Value::as_str)
+            .filter(|id| !id.is_empty())
+        {
+            record["itemId"] = json!(item_id);
+        }
+        if let Some(status) = item.get("status").and_then(Value::as_str) {
+            record["status"] = json!(status);
+        } else {
+            record["status"] = json!("completed");
+        }
+
+        match item_type {
+            "commandExecution" => self.fill_command_execution(&mut record, item),
+            "mcpToolCall" => self.fill_mcp_tool_call(&mut record, item, seq),
+            "fileChange" => self.fill_file_change(&mut record, item, seq),
+            "imageView" => self.fill_image_view(&mut record, item),
+            "functionCallOutput" => fill_function_call_output(&mut record, item),
+            "webSearch" => fill_web_search(&mut record, item),
+            _ => {}
+        }
+
+        self.append_record(record);
+    }
+
+    pub(crate) fn finish(&mut self, completed: bool) {
+        if self.finished {
+            return;
+        }
+        self.finished = true;
+        let offered_read = self.offered_read_values();
+        let record = json!({
+            "recordType": "direct.codex.turn_end",
+            "clientTurnId": self.client_turn_id,
+            "completed": completed,
+            "itemCount": self.item_count,
+            "itemsTruncated": self.items_truncated,
+            "offeredRead": offered_read,
+            "firstDesign": self.first_design.clone(),
+        });
+        self.append_record(record);
+        let summary = json!({
+            "recordType": "direct.codex.turn",
+            "clientTurnId": self.client_turn_id,
+            "turnLog": self.turn_log_relative,
+            "sidecarPresent": self.sidecar_present,
+            "offeredCount": self.offered.len(),
+            "offeredRead": offered_read,
+            "firstDesign": self.first_design.clone(),
+            "itemCount": self.item_count,
+            "itemsTruncated": self.items_truncated,
+            "completed": completed,
+            "auditWriteFailed": self.audit_write_failed,
+        });
+        if append_agent_db_record(&self.root, summary).is_err() {
+            self.audit_write_failed = true;
+        }
+    }
+
+    fn fill_command_execution(&mut self, record: &mut Value, item: &Value) {
+        let mut path_rejected = false;
+        let mut actions = Vec::new();
+        if let Some(raw_actions) = item.get("commandActions").and_then(Value::as_array) {
+            for action in raw_actions {
+                let action_type = action
+                    .get("type")
+                    .and_then(Value::as_str)
+                    .unwrap_or("unknown");
+                match action_type {
+                    "read" => {
+                        let (entry, rejected) = self.read_action_entry(action);
+                        path_rejected |= rejected;
+                        actions.push(entry);
+                    }
+                    "listFiles" => {
+                        let mut entry = json!({ "type": "listFiles" });
+                        match optional_action_path(&self.root, action) {
+                            ActionPath::Missing => {}
+                            ActionPath::Rejected => {
+                                path_rejected = true;
+                                entry["pathRejected"] = json!(true);
+                            }
+                            ActionPath::Ok(path) => entry["path"] = json!(path),
+                        }
+                        actions.push(entry);
+                    }
+                    "search" => {
+                        let mut entry = json!({ "type": "search" });
+                        if let Some(query) = action.get("query").and_then(Value::as_str) {
+                            entry["query"] =
+                                json!(truncate_chars(query, DIRECT_CODEX_AUDIT_QUERY_CHARS));
+                        }
+                        match optional_action_path(&self.root, action) {
+                            ActionPath::Missing => {}
+                            ActionPath::Rejected => {
+                                path_rejected = true;
+                                entry["pathRejected"] = json!(true);
+                            }
+                            ActionPath::Ok(path) => entry["path"] = json!(path),
+                        }
+                        actions.push(entry);
+                    }
+                    _ => actions.push(json!({ "type": "unknown" })),
+                }
+            }
+        }
+        record["actions"] = json!(actions);
+        if let Some(exit_code) = item.get("exitCode").and_then(Value::as_i64) {
+            record["exitCode"] = json!(exit_code);
+        }
+        if let Some(duration_ms) = item.get("durationMs").and_then(Value::as_i64) {
+            record["durationMs"] = json!(duration_ms);
+        }
+        let command = item.get("command").and_then(Value::as_str).unwrap_or("");
+        if path_rejected || command_contains_host_absolute_path(command) {
+            record["commandRedacted"] = json!(true);
+        } else if !command.is_empty() {
+            record["command"] = json!(truncate_chars(command, DIRECT_CODEX_AUDIT_COMMAND_CHARS));
+        }
+    }
+
+    fn read_action_entry(&mut self, action: &Value) -> (Value, bool) {
+        let Some(raw_path) = action.get("path").and_then(Value::as_str) else {
+            return (json!({ "type": "read", "pathRejected": true }), true);
+        };
+        match relativize_project_path(&self.root, raw_path) {
+            Some(path) => {
+                let (content_sha256, hash_skipped) = hash_project_file(&self.root, &path);
+                self.mark_offered_read(&path, content_sha256.as_deref());
+                let mut entry = json!({ "type": "read", "path": path });
+                insert_hash_fields(&mut entry, content_sha256, hash_skipped);
+                (entry, false)
+            }
+            None => (json!({ "type": "read", "pathRejected": true }), true),
+        }
+    }
+
+    fn fill_mcp_tool_call(&mut self, record: &mut Value, item: &Value, seq: usize) {
+        let tool = item.get("tool").and_then(Value::as_str).unwrap_or("");
+        record["tool"] = json!(tool);
+        if let Some(server) = item
+            .get("server")
+            .and_then(Value::as_str)
+            .filter(|server| !server.is_empty() && *server != "agc_tools")
+        {
+            record["server"] = json!(server);
+        }
+        if let Some(duration_ms) = item.get("durationMs").and_then(Value::as_i64) {
+            record["durationMs"] = json!(duration_ms);
+        }
+        if item.get("error").is_some() {
+            record["errorKind"] = json!(item
+                .pointer("/error/code")
+                .and_then(Value::as_str)
+                .or_else(|| item.pointer("/error/type").and_then(Value::as_str))
+                .unwrap_or("error"));
+        }
+        let arguments = item.get("arguments").cloned().unwrap_or(Value::Null);
+        let extracted = extract_mcp_arguments(&self.root, tool, &arguments);
+        if let Some(path) = extracted
+            .get("path")
+            .and_then(Value::as_str)
+            .map(str::to_string)
+        {
+            self.mark_offered_read(&path, None);
+        }
+        if let Some(local_paths) = extracted.get("localPaths").and_then(Value::as_array) {
+            for path in local_paths {
+                if let Some(path) = path.as_str() {
+                    self.mark_offered_read(path, None);
+                }
+            }
+        }
+        if extracted
+            .as_object()
+            .is_some_and(|object| !object.is_empty())
+        {
+            record["arguments"] = extracted.clone();
+        }
+        if self.first_design.is_none() {
+            if DESIGN_MCP_TOOLS.contains(&tool) {
+                let mut design = json!({
+                    "kind": format!("mcp:{tool}"),
+                    "seq": seq,
+                    "tool": tool,
+                });
+                let preview = extracted
+                    .get("brief")
+                    .or_else(|| extracted.get("prompt"))
+                    .and_then(Value::as_str)
+                    .map(|text| truncate_chars(text, DIRECT_CODEX_AUDIT_PREVIEW_CHARS));
+                if let Some(preview) = preview {
+                    design["briefPreview"] = json!(preview);
+                }
+                self.first_design = Some(design);
+            } else if tool == "agc_write_file" {
+                if let Some(path) = extracted.get("path").and_then(Value::as_str) {
+                    if is_design_write_path(path) {
+                        self.first_design = Some(json!({
+                            "kind": format!("write:{path}"),
+                            "seq": seq,
+                            "path": path,
+                        }));
+                    }
+                }
+            }
+        }
+    }
+
+    fn fill_file_change(&mut self, record: &mut Value, item: &Value, seq: usize) {
+        let mut changes = Vec::new();
+        if let Some(raw_changes) = item.get("changes").and_then(Value::as_array) {
+            for change in raw_changes {
+                let kind = file_change_kind(change);
+                let mut entry = json!({ "kind": kind });
+                match change.get("path").and_then(Value::as_str) {
+                    Some(raw) => match relativize_project_path(&self.root, raw) {
+                        Some(path) => {
+                            if self.first_design.is_none() && is_design_write_path(&path) {
+                                self.first_design = Some(json!({
+                                    "kind": format!("fileChange:{path}"),
+                                    "seq": seq,
+                                    "path": path,
+                                }));
+                            }
+                            entry["path"] = json!(path);
+                        }
+                        None => entry["pathRejected"] = json!(true),
+                    },
+                    None => entry["pathRejected"] = json!(true),
+                }
+                changes.push(entry);
+            }
+        }
+        record["changes"] = json!(changes);
+    }
+
+    fn fill_image_view(&mut self, record: &mut Value, item: &Value) {
+        match item.get("path").and_then(Value::as_str) {
+            Some(raw) => match relativize_project_path(&self.root, raw) {
+                Some(path) => {
+                    let (content_sha256, hash_skipped) = hash_project_file(&self.root, &path);
+                    self.mark_offered_read(&path, content_sha256.as_deref());
+                    record["path"] = json!(path);
+                    insert_hash_fields(record, content_sha256, hash_skipped);
+                }
+                None => record["pathRejected"] = json!(true),
+            },
+            None => record["pathRejected"] = json!(true),
+        }
+    }
+
+    fn mark_offered_read(&mut self, path: &str, content_sha256: Option<&str>) {
+        for offered in &mut self.offered {
+            if offered.local_path != path {
+                continue;
+            }
+            offered.read = true;
+            match (offered.content_sha256.as_deref(), content_sha256) {
+                (Some(expected), Some(actual)) => {
+                    let matches = expected == actual;
+                    offered.content_sha256_match =
+                        Some(offered.content_sha256_match.unwrap_or(true) && matches);
+                }
+                _ => {}
+            }
+        }
+    }
+
+    fn offered_read_values(&self) -> Vec<Value> {
+        self.offered
+            .iter()
+            .map(|offered| {
+                let mut value = json!({
+                    "localPath": offered.local_path,
+                    "read": offered.read,
+                });
+                if let Some(matches) = offered.content_sha256_match {
+                    value["contentSha256Match"] = json!(matches);
+                }
+                value
+            })
+            .collect()
+    }
+
+    fn append_record(&mut self, mut record: Value) {
+        #[cfg(test)]
+        if test_fail_audit_write(&self.root) {
+            self.audit_write_failed = true;
+            return;
+        }
+        if let Some(object) = record.as_object_mut() {
+            object.insert(
+                "recordedAtMs".to_string(),
+                json!(u64::try_from(unix_millis()).unwrap_or(u64::MAX)),
+            );
+        }
+        let Ok(line) = serde_json::to_string(&record) else {
+            self.audit_write_failed = true;
+            return;
+        };
+        if append_jsonl_line(&self.log_path, &line, "Direct 回合审计记录").is_err() {
+            self.audit_write_failed = true;
+        }
+    }
+}
+
+impl Drop for DirectCodexTurnAudit {
+    fn drop(&mut self) {
+        if !self.finished {
+            self.finish(false);
+        }
+    }
+}
+
+enum ActionPath {
+    Missing,
+    Rejected,
+    Ok(String),
+}
+
+fn optional_action_path(root: &Path, action: &Value) -> ActionPath {
+    let Some(raw) = action.get("path").and_then(Value::as_str) else {
+        return ActionPath::Missing;
+    };
+    if raw.trim().is_empty() {
+        return ActionPath::Missing;
+    }
+    match relativize_project_path(root, raw) {
+        Some(path) => ActionPath::Ok(path),
+        None => ActionPath::Rejected,
+    }
+}
+
+fn project_audit_attachments(
+    root: &Path,
+    attachments: &[DirectCodexTurnAttachment],
+) -> (Vec<Value>, Vec<OfferedAttachment>) {
+    let mut values = Vec::new();
+    let mut offered = Vec::new();
+    for attachment in attachments.iter().take(MAX_DIRECT_CODEX_ATTACHMENTS) {
+        let name = sanitize_attachment_name(&attachment.name);
+        let media_type = sanitize_attachment_media_type(&attachment.media_type);
+        let raw_path = attachment
+            .local_path
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty());
+        let sanitized_path = raw_path.and_then(sanitize_attachment_local_path);
+        let path_rejected = raw_path.is_some() && sanitized_path.is_none();
+        let status = if path_rejected {
+            Some("failed")
+        } else {
+            sanitize_attachment_status(attachment.status.as_deref())
+        };
+        let mut value = json!({
+            "name": name,
+            "mediaType": media_type,
+            "size": attachment.size,
+        });
+        if let Some(path) = sanitized_path {
+            value["localPath"] = json!(path.clone());
+            let (content_sha256, hash_skipped) = hash_project_file(root, &path);
+            insert_hash_fields(&mut value, content_sha256.clone(), hash_skipped);
+            offered.push(OfferedAttachment {
+                local_path: path,
+                content_sha256,
+                read: false,
+                content_sha256_match: None,
+            });
+        }
+        if let Some(status) = status {
+            value["status"] = json!(status);
+        }
+        values.push(value);
+    }
+    (values, offered)
+}
+
+fn extract_mcp_arguments(root: &Path, tool: &str, arguments: &Value) -> Value {
+    let Some(object) = arguments.as_object() else {
+        return json!({});
+    };
+    let mut out = Map::new();
+    match tool {
+        "agc_list_project_files" => {
+            copy_sanitized_path(root, object, "path", &mut out);
+            copy_truncated_string(
+                object,
+                "query",
+                DIRECT_CODEX_AUDIT_LIST_QUERY_CHARS,
+                &mut out,
+            );
+            copy_string(object, "kind", &mut out);
+            copy_number(object, "offset", &mut out);
+            copy_number(object, "limit", &mut out);
+        }
+        "agc_write_file" => {
+            copy_sanitized_path(root, object, "path", &mut out);
+            if let Some(content) = object.get("content").and_then(Value::as_str) {
+                out.insert("contentChars".to_string(), json!(content.chars().count()));
+            }
+        }
+        "taonier_prepare_game_art" => {
+            copy_string(object, "mode", &mut out);
+            copy_text_with_hash(
+                object,
+                "brief",
+                "brief",
+                DIRECT_CODEX_AUDIT_BRIEF_CHARS,
+                &mut out,
+            );
+        }
+        "agc_generate_image" => {
+            copy_string(object, "kind", &mut out);
+            copy_string(object, "aspectRatio", &mut out);
+            copy_string(object, "imageSize", &mut out);
+            copy_string(object, "assetName", &mut out);
+            copy_sanitized_path(root, object, "outputPath", &mut out);
+            copy_text_with_hash(
+                object,
+                "prompt",
+                "prompt",
+                DIRECT_CODEX_AUDIT_BRIEF_CHARS,
+                &mut out,
+            );
+        }
+        "agc_edit_image" => {
+            copy_string(object, "sourceLocalAssetId", &mut out);
+            copy_string(object, "assetName", &mut out);
+            copy_text_with_hash(
+                object,
+                "prompt",
+                "prompt",
+                DIRECT_CODEX_AUDIT_BRIEF_CHARS,
+                &mut out,
+            );
+        }
+        "agc_create_or_derive_resource" => {
+            copy_string(object, "kind", &mut out);
+            copy_string(object, "mode", &mut out);
+            copy_string(object, "sourceLocalAssetId", &mut out);
+            copy_string(object, "assetName", &mut out);
+            copy_text_with_hash(
+                object,
+                "prompt",
+                "prompt",
+                DIRECT_CODEX_AUDIT_BRIEF_CHARS,
+                &mut out,
+            );
+        }
+        "agc_list_registered_assets" => {
+            copy_string(object, "kind", &mut out);
+            copy_string(object, "assetId", &mut out);
+            if let Some(flag) = object.get("includeSequenceFrames").and_then(Value::as_bool) {
+                out.insert("includeSequenceFrames".to_string(), json!(flag));
+            }
+            copy_number(object, "offset", &mut out);
+            copy_number(object, "limit", &mut out);
+        }
+        "agc_list_account_assets" => {
+            copy_string(object, "folderId", &mut out);
+            copy_truncated_string(
+                object,
+                "query",
+                DIRECT_CODEX_AUDIT_LIST_QUERY_CHARS,
+                &mut out,
+            );
+            copy_number(object, "offset", &mut out);
+            copy_number(object, "limit", &mut out);
+        }
+        "agc_import_account_assets" => {
+            if let Some(ids) = object.get("assetIds").and_then(Value::as_array) {
+                let kept: Vec<Value> = ids
+                    .iter()
+                    .filter_map(Value::as_str)
+                    .take(DIRECT_CODEX_AUDIT_ID_LIST_MAX)
+                    .map(Value::from)
+                    .collect();
+                let omitted = ids.len().saturating_sub(kept.len());
+                out.insert("assetIds".to_string(), json!(kept));
+                if omitted > 0 {
+                    out.insert("assetIdsOmitted".to_string(), json!(omitted));
+                }
+            }
+            if let Some(paths) = object.get("localPaths").and_then(Value::as_array) {
+                let kept: Vec<Value> = paths
+                    .iter()
+                    .filter_map(Value::as_str)
+                    .filter_map(|path| relativize_project_path(root, path))
+                    .take(DIRECT_CODEX_AUDIT_ID_LIST_MAX)
+                    .map(Value::from)
+                    .collect();
+                out.insert("localPaths".to_string(), json!(kept));
+            }
+        }
+        "agc_remove_background" => {
+            copy_string(object, "sourceLocalAssetId", &mut out);
+            copy_string(object, "assetName", &mut out);
+        }
+        "agc_browser_playtest" => copy_number(object, "attempt", &mut out),
+        "agc_web_search" => {
+            copy_truncated_string(object, "query", DIRECT_CODEX_AUDIT_QUERY_CHARS, &mut out);
+            copy_number(object, "maxResults", &mut out);
+        }
+        "agc_read_skill_resource" => {
+            copy_string(object, "skillName", &mut out);
+            copy_string(object, "relativePath", &mut out);
+        }
+        _ => {}
+    }
+    Value::Object(out)
+}
+
+fn fill_function_call_output(record: &mut Value, item: &Value) {
+    if let Some(name) = item.get("name").and_then(Value::as_str) {
+        record["name"] = json!(name);
+    }
+    if let Some(namespace) = item.get("namespace").and_then(Value::as_str) {
+        record["namespace"] = json!(namespace);
+    }
+}
+
+fn fill_web_search(record: &mut Value, item: &Value) {
+    if let Some(query) = item.get("query").and_then(Value::as_str) {
+        record["query"] = json!(truncate_chars(query, DIRECT_CODEX_AUDIT_QUERY_CHARS));
+    }
+}
+
+fn copy_string(source: &Map<String, Value>, key: &str, out: &mut Map<String, Value>) {
+    if let Some(value) = source
+        .get(key)
+        .and_then(Value::as_str)
+        .filter(|value| !value.is_empty())
+    {
+        out.insert(key.to_string(), json!(value));
+    }
+}
+
+fn copy_truncated_string(
+    source: &Map<String, Value>,
+    key: &str,
+    max_chars: usize,
+    out: &mut Map<String, Value>,
+) {
+    if let Some(value) = source.get(key).and_then(Value::as_str) {
+        out.insert(key.to_string(), json!(truncate_chars(value, max_chars)));
+    }
+}
+
+fn copy_number(source: &Map<String, Value>, key: &str, out: &mut Map<String, Value>) {
+    if let Some(value) = source.get(key).and_then(Value::as_i64) {
+        out.insert(key.to_string(), json!(value));
+    }
+}
+
+fn copy_sanitized_path(
+    root: &Path,
+    source: &Map<String, Value>,
+    key: &str,
+    out: &mut Map<String, Value>,
+) {
+    let Some(raw) = source.get(key).and_then(Value::as_str) else {
+        return;
+    };
+    match relativize_project_path(root, raw) {
+        Some(path) => {
+            out.insert(key.to_string(), json!(path));
+        }
+        None => {
+            out.insert(format!("{key}Rejected"), json!(true));
+        }
+    }
+}
+
+fn copy_text_with_hash(
+    source: &Map<String, Value>,
+    source_key: &str,
+    dest_key: &str,
+    max_chars: usize,
+    out: &mut Map<String, Value>,
+) {
+    let Some(text) = source.get(source_key).and_then(Value::as_str) else {
+        return;
+    };
+    out.insert(format!("{dest_key}Chars"), json!(text.chars().count()));
+    out.insert(
+        format!("{dest_key}Sha256"),
+        json!(sha256_hex(text.as_bytes())),
+    );
+    out.insert(dest_key.to_string(), json!(truncate_chars(text, max_chars)));
+}
+
+fn file_change_kind(change: &Value) -> &'static str {
+    let kind = change.get("kind");
+    let label = kind
+        .and_then(Value::as_str)
+        .or_else(|| {
+            kind.and_then(|value| value.get("type"))
+                .and_then(Value::as_str)
+        })
+        .unwrap_or("update");
+    match label {
+        "add" => "add",
+        "delete" => "delete",
+        _ => "update",
+    }
+}
+
+fn is_design_write_path(path: &str) -> bool {
+    path == "index.html"
+        || path.starts_with("game/")
+        || path.rsplit('/').next() == Some("index.html")
+}
+
+fn insert_hash_fields(
+    target: &mut Value,
+    content_sha256: Option<String>,
+    hash_skipped: Option<&str>,
+) {
+    if let Some(content_sha256) = content_sha256 {
+        target["contentSha256"] = json!(content_sha256);
+    }
+    if let Some(hash_skipped) = hash_skipped {
+        target["hashSkipped"] = json!(hash_skipped);
+    }
+}
+
+fn sha256_hex(bytes: &[u8]) -> String {
+    format!("{:x}", Sha256::digest(bytes))
+}
+
+fn truncate_chars(value: &str, max_chars: usize) -> String {
+    value.chars().take(max_chars).collect()
+}
+
+fn hash_project_file(root: &Path, relative: &str) -> (Option<String>, Option<&'static str>) {
+    if reject_agent_runtime_private_control_path(relative).is_err()
+        || reject_sensitive_project_file_read(relative).is_err()
+    {
+        return (None, Some("missing"));
+    }
+    let path = match resolve_local_project_path(root, relative) {
+        Ok(path) => path,
+        Err(_) => return (None, Some("missing")),
+    };
+    let metadata = match fs::metadata(&path) {
+        Ok(metadata) if metadata.is_file() => metadata,
+        _ => return (None, Some("missing")),
+    };
+    if metadata.len() > DIRECT_CODEX_AUDIT_HASH_MAX_BYTES {
+        return (None, Some("too-large"));
+    }
+    match fs::read(&path) {
+        Ok(bytes) => (Some(sha256_hex(&bytes)), None),
+        Err(_) => (None, Some("missing")),
+    }
+}
+
+fn posix_path_text(path: &Path) -> String {
+    let text = path.to_string_lossy();
+    let text = text
+        .strip_prefix(r"\\?\")
+        .or_else(|| text.strip_prefix("//?/"))
+        .unwrap_or(&text);
+    text.replace('\\', "/").trim_end_matches('/').to_string()
+}
+
+fn relativize_project_path(root: &Path, raw: &str) -> Option<String> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return None;
+    }
+    if let Some(relative) = sanitize_attachment_local_path(trimmed) {
+        return accept_relative_path(&relative);
+    }
+    if let Some(relative) = strip_absolute_root_prefix(root, trimmed) {
+        return sanitize_attachment_local_path(&relative)
+            .and_then(|path| accept_relative_path(&path));
+    }
+    None
+}
+
+fn strip_absolute_root_prefix(root: &Path, raw: &str) -> Option<String> {
+    if let (Ok(root_canon), Ok(raw_canon)) = (root.canonicalize(), Path::new(raw).canonicalize()) {
+        if let Ok(stripped) = raw_canon.strip_prefix(&root_canon) {
+            let relative = posix_path_text(stripped);
+            if !relative.is_empty() {
+                return Some(relative);
+            }
+        }
+    }
+    let root_text = posix_path_text(root);
+    let raw_text = posix_path_text(Path::new(raw));
+    let rest = if cfg!(windows) {
+        let root_lower = root_text.to_ascii_lowercase();
+        let raw_lower = raw_text.to_ascii_lowercase();
+        let suffix = raw_lower.strip_prefix(&root_lower)?;
+        raw_text
+            .get(raw_text.len().saturating_sub(suffix.len())..)
+            .unwrap_or(suffix)
+            .to_string()
+    } else {
+        raw_text.strip_prefix(&root_text)?.to_string()
+    };
+    let rest = rest.trim_start_matches('/').to_string();
+    (!rest.is_empty()).then_some(rest)
+}
+
+fn accept_relative_path(relative: &str) -> Option<String> {
+    if reject_agent_runtime_private_control_path(relative).is_err()
+        || reject_sensitive_project_file_read(relative).is_err()
+    {
+        return None;
+    }
+    Some(relative.to_string())
+}
+
+fn command_contains_host_absolute_path(command: &str) -> bool {
+    if command.contains("\\\\") || command.contains("/Users/") || command.contains("/home/") {
+        return true;
+    }
+    let bytes = command.as_bytes();
+    let mut index = 0;
+    while index + 2 < bytes.len() {
+        if bytes[index].is_ascii_alphabetic()
+            && bytes[index + 1] == b':'
+            && matches!(bytes[index + 2], b'\\' | b'/')
+        {
+            return true;
+        }
+        index += 1;
+    }
+    false
+}
+
+#[cfg(test)]
+fn test_fail_audit_write(root: &Path) -> bool {
+    root.join(".agent/runtime/test-fail-direct-codex-audit")
+        .is_file()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixture_project(name: &str) -> tempfile::TempDir {
+        let directory = tempfile::tempdir().expect("temp project");
+        init_local_game_project_at(directory.path(), name, "审计测试项目").expect("init project");
+        directory
+    }
+
+    fn attachment_json(
+        name: &str,
+        media_type: &str,
+        size: u64,
+        local_path: Option<&str>,
+        status: Option<&str>,
+    ) -> DirectCodexTurnAttachment {
+        let mut value = json!({
+            "name": name,
+            "mediaType": media_type,
+            "size": size,
+        });
+        if let Some(local_path) = local_path {
+            value["localPath"] = json!(local_path);
+        }
+        if let Some(status) = status {
+            value["status"] = json!(status);
+        }
+        serde_json::from_value(value).expect("attachment")
+    }
+
+    fn read_turn_log(root: &Path, client_turn_id: &str) -> Vec<Value> {
+        let path = root
+            .join(DIRECT_CODEX_AUDIT_TURN_LOG_DIR)
+            .join(format!("{client_turn_id}.jsonl"));
+        fs::read_to_string(path)
+            .unwrap_or_default()
+            .lines()
+            .filter(|line| !line.trim().is_empty())
+            .map(|line| serde_json::from_str::<Value>(line).expect("audit jsonl"))
+            .collect()
+    }
+
+    fn read_agent_db(root: &Path) -> Vec<Value> {
+        fs::read_to_string(root.join(".agent/agent.db"))
+            .unwrap_or_default()
+            .lines()
+            .filter(|line| !line.trim().is_empty())
+            .filter_map(|line| serde_json::from_str::<Value>(line).ok())
+            .collect()
+    }
+
+    fn start_audit(
+        root: &Path,
+        prompt: &str,
+        attachments: &[DirectCodexTurnAttachment],
+    ) -> DirectCodexTurnAudit {
+        DirectCodexTurnAudit::start(root, "turn-01", prompt, attachments)
+    }
+
+    #[test]
+    fn turn_start_hashes_original_prompt_and_sanitizes_attachment_paths() {
+        let project = fixture_project("audit-start");
+        let root = project.path();
+        let upload = "assets/uploads/upload-1-fast_gdd.md";
+        fs::create_dir_all(root.join("assets/uploads")).expect("uploads dir");
+        fs::write(root.join(upload), "脉冲余烬").expect("write gdd");
+        let attachments = vec![
+            attachment_json(
+                "fast_gdd.md",
+                "text/markdown",
+                12,
+                Some(upload),
+                Some("imported"),
+            ),
+            attachment_json(
+                "secret.md",
+                "text/markdown",
+                1,
+                Some("../secret.md"),
+                Some("imported"),
+            ),
+        ];
+        let mut audit = start_audit(root, "请根据附件做游戏", &attachments);
+        audit.finish(true);
+        let records = read_turn_log(root, "turn-01");
+        let start = records
+            .iter()
+            .find(|record| record["recordType"] == "direct.codex.turn_start")
+            .expect("turn_start");
+        assert_eq!(
+            start["promptSha256"],
+            json!(sha256_hex("请根据附件做游戏".as_bytes()))
+        );
+        assert_eq!(start["sidecarPresent"], json!(true));
+        let listed = start["attachments"].as_array().expect("attachments");
+        assert_eq!(listed[0]["localPath"], json!(upload));
+        assert_eq!(
+            listed[0]["contentSha256"],
+            json!(sha256_hex("脉冲余烬".as_bytes()))
+        );
+        assert!(listed[1].get("localPath").is_none());
+        assert_eq!(listed[1]["status"], json!("failed"));
+        assert!(!serde_json::to_string(start).expect("json").contains(".."));
+    }
+
+    #[test]
+    fn turn_start_without_attachments_sets_sidecar_absent() {
+        let project = fixture_project("audit-empty");
+        let mut audit = start_audit(project.path(), "继续改游戏", &[]);
+        audit.finish(true);
+        let start = &read_turn_log(project.path(), "turn-01")[0];
+        assert_eq!(start["sidecarPresent"], json!(false));
+        assert_eq!(start["attachments"], json!([]));
+    }
+
+    #[test]
+    fn attachment_hash_skips_missing_and_too_large_files() {
+        let project = fixture_project("audit-hash");
+        let root = project.path();
+        fs::create_dir_all(root.join("assets/uploads")).expect("uploads");
+        let large_path = "assets/uploads/upload-1-big.bin";
+        let missing_path = "assets/uploads/upload-1-missing.md";
+        fs::write(
+            root.join(large_path),
+            vec![0_u8; (DIRECT_CODEX_AUDIT_HASH_MAX_BYTES as usize) + 1],
+        )
+        .expect("large file");
+        let attachments = vec![
+            attachment_json(
+                "big.bin",
+                "application/octet-stream",
+                3,
+                Some(large_path),
+                Some("imported"),
+            ),
+            attachment_json(
+                "missing.md",
+                "text/markdown",
+                1,
+                Some(missing_path),
+                Some("imported"),
+            ),
+        ];
+        let mut audit = start_audit(root, "x", &attachments);
+        audit.finish(true);
+        let start = &read_turn_log(root, "turn-01")[0];
+        let listed = start["attachments"].as_array().expect("attachments");
+        assert_eq!(listed[0]["hashSkipped"], json!("too-large"));
+        assert!(listed[0].get("contentSha256").is_none());
+        assert_eq!(listed[1]["hashSkipped"], json!("missing"));
+    }
+
+    #[test]
+    fn command_read_relativizes_absolute_path_and_drops_stdout() {
+        let project = fixture_project("audit-read");
+        let root = project.path();
+        let relative = "assets/uploads/upload-1-fast_gdd.md";
+        fs::create_dir_all(root.join("assets/uploads")).expect("uploads");
+        fs::write(root.join(relative), "裂脉炮").expect("gdd");
+        let absolute = root.join(relative);
+        let mut audit = start_audit(
+            root,
+            "做游戏",
+            &[attachment_json(
+                "fast_gdd.md",
+                "text/markdown",
+                9,
+                Some(relative),
+                Some("imported"),
+            )],
+        );
+        audit.observe_item(&json!({
+            "item": {
+                "id": "item-read",
+                "type": "commandExecution",
+                "command": "type assets/uploads/upload-1-fast_gdd.md",
+                "status": "completed",
+                "exitCode": 0,
+                "aggregatedOutput": "裂脉炮 SECRET",
+                "commandActions": [{
+                    "type": "read",
+                    "name": "fast_gdd.md",
+                    "path": absolute.to_string_lossy(),
+                    "command": format!("type {}", absolute.display())
+                }]
+            }
+        }));
+        audit.finish(true);
+        let item = read_turn_log(root, "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        let dumped = serde_json::to_string(&item).expect("item json");
+        assert!(!dumped.contains("aggregatedOutput"));
+        assert!(!dumped.contains("裂脉炮 SECRET"));
+        assert_eq!(item["actions"][0]["path"], json!(relative));
+        assert_eq!(
+            item["actions"][0]["contentSha256"],
+            json!(sha256_hex("裂脉炮".as_bytes()))
+        );
+        let end = read_turn_log(root, "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.turn_end")
+            .expect("end");
+        assert_eq!(end["offeredRead"][0]["read"], json!(true));
+        assert_eq!(end["offeredRead"][0]["contentSha256Match"], json!(true));
+    }
+
+    #[test]
+    fn rejected_read_path_does_not_persist_host_absolute_path() {
+        let project = fixture_project("audit-reject");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "type": "commandExecution",
+                "command": r"type C:\Users\secret\fast_gdd.md",
+                "aggregatedOutput": "nope",
+                "commandActions": [{
+                    "type": "read",
+                    "path": r"C:\Users\secret\fast_gdd.md"
+                }]
+            }
+        }));
+        audit.finish(true);
+        let dumped = fs::read_to_string(
+            project
+                .path()
+                .join(DIRECT_CODEX_AUDIT_TURN_LOG_DIR)
+                .join("turn-01.jsonl"),
+        )
+        .expect("log");
+        assert!(!dumped.contains(r"C:\Users"));
+        assert!(!dumped.contains("Users"));
+        let item = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        assert_eq!(item["actions"][0]["pathRejected"], json!(true));
+        assert_eq!(item["commandRedacted"], json!(true));
+        assert!(item.get("command").is_none());
+        assert!(item.get("aggregatedOutput").is_none());
+    }
+
+    #[test]
+    fn mcp_art_brief_is_kept_and_result_is_dropped() {
+        let project = fixture_project("audit-art");
+        let mut audit = start_audit(project.path(), "做游戏", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "id": "art-1",
+                "type": "mcpToolCall",
+                "server": "agc_tools",
+                "tool": "taonier_prepare_game_art",
+                "status": "completed",
+                "arguments": { "brief": "俯视角收集冒险小游戏", "mode": "reuse-or-create" },
+                "result": { "secret": "do-not-store" },
+                "error": null
+            }
+        }));
+        audit.finish(true);
+        let item = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        assert_eq!(item["arguments"]["brief"], json!("俯视角收集冒险小游戏"));
+        assert!(item.get("result").is_none());
+        let dumped = serde_json::to_string(&item).expect("json");
+        assert!(!dumped.contains("do-not-store"));
+        let end = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.turn_end")
+            .expect("end");
+        assert_eq!(
+            end["firstDesign"]["kind"],
+            json!("mcp:taonier_prepare_game_art")
+        );
+        assert_eq!(
+            end["firstDesign"]["briefPreview"],
+            json!("俯视角收集冒险小游戏")
+        );
+    }
+
+    #[test]
+    fn agc_write_file_keeps_path_and_content_chars_not_body() {
+        let project = fixture_project("audit-write");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "type": "mcpToolCall",
+                "tool": "agc_write_file",
+                "arguments": {
+                    "path": "game/index.html",
+                    "content": "<html>秘密正文</html>"
+                }
+            }
+        }));
+        audit.finish(true);
+        let item = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        assert_eq!(item["arguments"]["path"], json!("game/index.html"));
+        assert_eq!(
+            item["arguments"]["contentChars"],
+            json!("<html>秘密正文</html>".chars().count())
+        );
+        let dumped = serde_json::to_string(&item).expect("json");
+        assert!(!dumped.contains("秘密正文"));
+        assert!(item["arguments"].get("content").is_none());
+    }
+
+    #[test]
+    fn generate_image_prompt_is_truncated_with_hash() {
+        let project = fixture_project("audit-image");
+        let prompt = "收".repeat(5000);
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "type": "mcpToolCall",
+                "tool": "agc_generate_image",
+                "arguments": { "prompt": prompt, "kind": "icon-spec" }
+            }
+        }));
+        audit.finish(true);
+        let item = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        let stored = item["arguments"]["prompt"].as_str().expect("prompt");
+        assert_eq!(stored.chars().count(), DIRECT_CODEX_AUDIT_BRIEF_CHARS);
+        assert_eq!(item["arguments"]["promptChars"], json!(5000));
+        assert_eq!(
+            item["arguments"]["promptSha256"],
+            json!(sha256_hex("收".repeat(5000).as_bytes()))
+        );
+    }
+
+    #[test]
+    fn file_change_keeps_path_and_kind_without_diff() {
+        let project = fixture_project("audit-patch");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "type": "fileChange",
+                "status": "completed",
+                "changes": [{
+                    "path": "game/index.html",
+                    "kind": { "type": "add" },
+                    "diff": "*** SECRET PATCH"
+                }]
+            }
+        }));
+        audit.finish(true);
+        let item = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        assert_eq!(item["changes"][0]["path"], json!("game/index.html"));
+        assert_eq!(item["changes"][0]["kind"], json!("add"));
+        let dumped = serde_json::to_string(&item).expect("json");
+        assert!(!dumped.contains("SECRET PATCH"));
+        assert!(!dumped.contains("diff"));
+    }
+
+    #[test]
+    fn list_or_search_does_not_count_as_reading_offered_attachment() {
+        let project = fixture_project("audit-list");
+        let root = project.path();
+        let relative = "assets/uploads/upload-1-fast_gdd.md";
+        fs::create_dir_all(root.join("assets/uploads")).expect("uploads");
+        fs::write(root.join(relative), "x").expect("gdd");
+        let mut audit = start_audit(
+            root,
+            "做游戏",
+            &[attachment_json(
+                "fast_gdd.md",
+                "text/markdown",
+                1,
+                Some(relative),
+                Some("imported"),
+            )],
+        );
+        audit.observe_item(&json!({
+            "item": {
+                "type": "commandExecution",
+                "command": "rg fast_gdd assets",
+                "commandActions": [{
+                    "type": "search",
+                    "query": "fast_gdd",
+                    "path": "assets"
+                }]
+            }
+        }));
+        audit.observe_item(&json!({
+            "item": {
+                "type": "commandExecution",
+                "command": "ls assets/uploads",
+                "commandActions": [{ "type": "listFiles", "path": "assets/uploads" }]
+            }
+        }));
+        audit.finish(true);
+        let end = read_turn_log(root, "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.turn_end")
+            .expect("end");
+        assert_eq!(end["offeredRead"][0]["read"], json!(false));
+        assert!(end["offeredRead"][0].get("contentSha256Match").is_none());
+        assert!(end["firstDesign"].is_null());
+    }
+
+    #[test]
+    fn first_design_skips_reads_and_uses_later_art_item_seq() {
+        let project = fixture_project("audit-order");
+        let root = project.path();
+        let relative = "assets/uploads/upload-1-fast_gdd.md";
+        fs::create_dir_all(root.join("assets/uploads")).expect("uploads");
+        fs::write(root.join(relative), "x").expect("gdd");
+        let mut audit = start_audit(
+            root,
+            "做游戏",
+            &[attachment_json(
+                "fast_gdd.md",
+                "text/markdown",
+                1,
+                Some(relative),
+                Some("imported"),
+            )],
+        );
+        audit.observe_item(&json!({
+            "item": {
+                "type": "commandExecution",
+                "command": "type assets/uploads/upload-1-fast_gdd.md",
+                "commandActions": [{ "type": "read", "path": relative }]
+            }
+        }));
+        audit.observe_item(&json!({
+            "item": {
+                "type": "mcpToolCall",
+                "tool": "taonier_prepare_game_art",
+                "arguments": { "brief": "收集冒险" }
+            }
+        }));
+        audit.finish(true);
+        let end = read_turn_log(root, "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.turn_end")
+            .expect("end");
+        assert_eq!(
+            end["firstDesign"]["kind"],
+            json!("mcp:taonier_prepare_game_art")
+        );
+        assert_eq!(end["firstDesign"]["seq"], json!(2));
+        assert_eq!(end["offeredRead"][0]["read"], json!(true));
+    }
+
+    #[test]
+    fn item_cap_writes_truncated_marker() {
+        let project = fixture_project("audit-cap");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        for index in 0..(DIRECT_CODEX_AUDIT_MAX_ITEMS + 2) {
+            audit.observe_item(&json!({
+                "item": {
+                    "id": format!("item-{index}"),
+                    "type": "commandExecution",
+                    "command": "ls",
+                    "commandActions": [{ "type": "unknown" }]
+                }
+            }));
+        }
+        audit.finish(true);
+        let records = read_turn_log(project.path(), "turn-01");
+        let items = records
+            .iter()
+            .filter(|record| record["recordType"] == "direct.codex.item")
+            .count();
+        assert_eq!(items, DIRECT_CODEX_AUDIT_MAX_ITEMS);
+        assert!(records
+            .iter()
+            .any(|record| record["recordType"] == "direct.codex.items_truncated"));
+        let end = records
+            .iter()
+            .find(|record| record["recordType"] == "direct.codex.turn_end")
+            .expect("end");
+        assert_eq!(end["itemsTruncated"], json!(true));
+        assert_eq!(end["itemCount"], json!(DIRECT_CODEX_AUDIT_MAX_ITEMS));
+    }
+
+    #[test]
+    fn agent_db_summary_points_at_relative_turn_log() {
+        let project = fixture_project("audit-db");
+        let mut audit = start_audit(project.path(), "做游戏", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "type": "mcpToolCall",
+                "tool": "taonier_prepare_game_art",
+                "arguments": { "brief": "俯视角收集冒险小游戏" }
+            }
+        }));
+        audit.finish(true);
+        let summary = read_agent_db(project.path())
+            .into_iter()
+            .rev()
+            .find(|record| record["recordType"] == "direct.codex.turn")
+            .expect("summary");
+        assert_eq!(
+            summary["turnLog"],
+            json!(format!("{DIRECT_CODEX_AUDIT_TURN_LOG_DIR}/turn-01.jsonl"))
+        );
+        assert_eq!(
+            summary["firstDesign"]["briefPreview"],
+            json!("俯视角收集冒险小游戏")
+        );
+        assert_eq!(summary["completed"], json!(true));
+        assert!(!summary["turnLog"].as_str().expect("path").contains('\\'));
+    }
+
+    #[test]
+    fn write_failure_does_not_panic_or_surface_through_finish() {
+        let project = fixture_project("audit-fail");
+        fs::create_dir_all(project.path().join(".agent/runtime")).expect("runtime");
+        fs::write(
+            project
+                .path()
+                .join(".agent/runtime/test-fail-direct-codex-audit"),
+            "1",
+        )
+        .expect("marker");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": { "type": "unknownTool" }
+        }));
+        audit.finish(true);
+        assert!(!project
+            .path()
+            .join(DIRECT_CODEX_AUDIT_TURN_LOG_DIR)
+            .join("turn-01.jsonl")
+            .is_file());
+    }
+
+    #[test]
+    fn unknown_item_type_keeps_only_public_fields() {
+        let project = fixture_project("audit-unknown");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": {
+                "id": "mystery",
+                "type": "secretNewItem",
+                "payload": { "token": "leak-me" },
+                "aggregatedOutput": "nope"
+            }
+        }));
+        audit.finish(true);
+        let item = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .find(|record| record["recordType"] == "direct.codex.item")
+            .expect("item");
+        assert_eq!(item["itemType"], json!("secretNewItem"));
+        assert_eq!(item["itemId"], json!("mystery"));
+        let dumped = serde_json::to_string(&item).expect("json");
+        assert!(!dumped.contains("leak-me"));
+        assert!(!dumped.contains("payload"));
+        assert!(!dumped.contains("aggregatedOutput"));
+    }
+
+    #[test]
+    fn agent_messages_are_skipped() {
+        let project = fixture_project("audit-skip");
+        let mut audit = start_audit(project.path(), "x", &[]);
+        audit.observe_item(&json!({
+            "item": { "type": "agentMessage", "text": "已按 GDD 完成" }
+        }));
+        audit.finish(true);
+        let items = read_turn_log(project.path(), "turn-01")
+            .into_iter()
+            .filter(|record| record["recordType"] == "direct.codex.item")
+            .count();
+        assert_eq!(items, 0);
+    }
+}
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs
index e515babc1..798bac52e 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs
@@ -7,9 +7,6 @@ use std::path::{Path, PathBuf};
 use std::sync::{Mutex, OnceLock};
 
 const MAX_DIRECT_SYSTEM_PROMPT_CHARS: usize = 16 * 1024;
-const MAX_DIRECT_HOME_ATTACHMENTS: usize = 8;
-const MAX_DIRECT_HOME_ATTACHMENT_NAME_CHARS: usize = 160;
-const MAX_DIRECT_HOME_ATTACHMENT_MEDIA_TYPE_CHARS: usize = 96;
 const MIN_DIRECT_CLIENT_TURN_ID_CHARS: usize = 6;
 const MAX_DIRECT_CLIENT_TURN_ID_CHARS: usize = 160;
 const DIRECT_TAONIER_IDENTITY_GUIDANCE: &str = "对外身份合同：你是“陶泥儿”，是 Genarrative 的游戏创作助手。用户询问你是谁、你的名称或能力时，以陶泥儿的身份回答；不要把 Codex、ChatGPT、OpenAI、模型、通用 AI 助手或内部执行智能体当作自己的名称或对外身份。Codex app-server 仅是客户端内部执行技术；只有用户明确询问底层实现时才可如实说明，同时仍以陶泥儿自称。";
@@ -2177,9 +2174,7 @@ fn direct_registered_taonier_slice_paths(root: &Path) -> Vec<String> {
 fn direct_game_sources_referenced_taonier_assets(root: &Path) -> Vec<String> {
     let sources = direct_codex_game_outputs(root)
         .into_iter()
-        .filter_map(|(relative_path, _, _)| {
-            std::fs::read_to_string(root.join(relative_path)).ok()
-        })
+        .filter_map(|(relative_path, _, _)| std::fs::read_to_string(root.join(relative_path)).ok())
         .collect::<Vec<_>>();
     let mut available_paths = Vec::new();
     if direct_taonier_art_base_is_valid(root) {
@@ -2267,9 +2262,7 @@ fn direct_browser_evidence_needs_art_repair(
 fn direct_game_output_completion_error(root: &Path) -> Option<String> {
     let entry = agent_runtime_game_entry_relative_path(root);
     if !root.join(entry).is_file() {
-        return Some(format!(
-            "Codex 返回后未找到 {entry}，项目未进入可运行状态"
-        ));
+        return Some(format!("Codex 返回后未找到 {entry}，项目未进入可运行状态"));
     }
     if !direct_game_sources_reference_taonier_art_package(root) {
         return Some(
@@ -3718,14 +3711,6 @@ pub(crate) fn build_direct_codex_home_system_prompt() -> String {
     .join("\n")
 }
 
-#[derive(Clone, Debug, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct DirectCodexHomeAttachment {
-    name: String,
-    media_type: String,
-    size: u64,
-}
-
 #[derive(Clone, Debug, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct DirectCodexHomeReply {
@@ -3758,78 +3743,11 @@ fn parse_direct_codex_home_reply(reply: String) -> DirectCodexHomeReply {
     }
 }
 
-fn direct_codex_home_attachment_name(value: &str) -> String {
-    let basename = value.rsplit(['/', '\\']).next().unwrap_or_default().trim();
-    let sanitized = basename
-        .chars()
-        .filter(|character| !character.is_control())
-        .take(MAX_DIRECT_HOME_ATTACHMENT_NAME_CHARS)
-        .collect::<String>();
-    if sanitized.is_empty() {
-        "未命名附件".to_string()
-    } else {
-        sanitized
-    }
-}
-
-fn direct_codex_home_attachment_media_type(value: &str) -> String {
-    let value = value.trim();
-    if value.is_empty()
-        || value.chars().any(|character| {
-            !(character.is_ascii_alphanumeric() || matches!(character, '/' | '+' | '-' | '.' | '_'))
-        })
-    {
-        "application/octet-stream".to_string()
-    } else {
-        value
-            .chars()
-            .take(MAX_DIRECT_HOME_ATTACHMENT_MEDIA_TYPE_CHARS)
-            .collect()
-    }
-}
-
-fn render_direct_codex_home_user_prompt(
-    prompt: &str,
-    attachments: &[DirectCodexHomeAttachment],
-) -> Result<String, String> {
-    let prompt = prompt.trim();
-    if prompt.is_empty() && attachments.is_empty() {
-        return Err("聊天内容不能为空".to_string());
-    }
-    if attachments.is_empty() {
-        return Ok(prompt.to_string());
-    }
-
-    let mut sections = Vec::new();
-    if !prompt.is_empty() {
-        sections.push(prompt.to_string());
-        sections.push(String::new());
-    }
-    sections.push(
-        "[首页附件说明：当前尚未打开项目，以下仅为附件元数据，附件内容尚不可读取]".to_string(),
-    );
-    for attachment in attachments.iter().take(MAX_DIRECT_HOME_ATTACHMENTS) {
-        sections.push(format!(
-            "- {}；类型：{}；大小：{} 字节",
-            direct_codex_home_attachment_name(&attachment.name),
-            direct_codex_home_attachment_media_type(&attachment.media_type),
-            attachment.size,
-        ));
-    }
-    if attachments.len() > MAX_DIRECT_HOME_ATTACHMENTS {
-        sections.push(format!(
-            "- 另有 {} 个附件未展开",
-            attachments.len() - MAX_DIRECT_HOME_ATTACHMENTS
-        ));
-    }
-    Ok(sections.join("\n"))
-}
-
 pub(crate) async fn run_direct_game_creator_home_turn(
     prompt: &str,
-    attachments: &[DirectCodexHomeAttachment],
+    attachments: &[DirectCodexTurnAttachment],
 ) -> Result<DirectCodexHomeReply, String> {
-    let user_prompt = render_direct_codex_home_user_prompt(prompt, attachments)?;
+    let user_prompt = render_direct_codex_user_prompt(prompt, attachments)?;
     direct_game_creator_home_codex_chat(build_direct_codex_home_system_prompt(), user_prompt)
         .await
         .map(parse_direct_codex_home_reply)
@@ -3859,6 +3777,7 @@ pub(crate) async fn run_direct_game_creator_turn_at_with_creation_type(
         prompt,
         creation_type,
         None,
+        None,
     )
     .await
 }
@@ -3868,6 +3787,7 @@ async fn run_direct_game_creator_turn_at_with_creation_type_and_emitter(
     prompt: &str,
     creation_type: Option<&str>,
     turn_emitter: Option<&DirectGameCreatorTurnUpdateEmitter>,
+    audit: Option<&mut DirectCodexTurnAudit>,
 ) -> Result<String, String> {
     if !root.is_absolute() || !root.is_dir() {
         return Err("当前项目目录不存在或不是绝对路径".to_string());
@@ -3883,7 +3803,8 @@ async fn run_direct_game_creator_turn_at_with_creation_type_and_emitter(
     if let Some(emitter) = turn_emitter {
         emitter.emit("accepted", Some("request-accepted"), None);
     }
-    match run_direct_game_creator_turn_inner(root, prompt, creation_type, turn_emitter).await {
+    match run_direct_game_creator_turn_inner(root, prompt, creation_type, turn_emitter, audit).await
+    {
         Ok(reply) => Ok(reply),
         Err(failure) => {
             let error = record_direct_codex_turn_failure(root, failure);
@@ -3900,6 +3821,7 @@ async fn run_direct_game_creator_turn_inner(
     prompt: &str,
     creation_type: Option<&str>,
     turn_emitter: Option<&DirectGameCreatorTurnUpdateEmitter>,
+    audit: Option<&mut DirectCodexTurnAudit>,
 ) -> Result<String, DirectCodexTurnFailure> {
     emit_direct_game_creator_progress(root, "codex.turn", "陶泥儿正在处理这条消息");
     if let Some(emitter) = turn_emitter {
@@ -3928,15 +3850,23 @@ async fn run_direct_game_creator_turn_inner(
                 );
             }
         };
-        direct_game_creator_codex_chat_at_with_observer(
+        direct_game_creator_codex_chat_at_with_optional_observer(
             root,
             system_prompt,
             prompt.to_string(),
-            &mut observer,
+            Some(&mut observer),
+            audit,
         )
         .await
     } else {
-        direct_game_creator_codex_chat_at(root, system_prompt, prompt.to_string()).await
+        direct_game_creator_codex_chat_at_with_optional_observer(
+            root,
+            system_prompt,
+            prompt.to_string(),
+            None,
+            audit,
+        )
+        .await
     }
     .map_err(|error| DirectCodexTurnFailure::new(DirectCodexFailureStage::CodeGeneration, error))?;
     if let Some(emitter) = turn_emitter {
@@ -4263,6 +4193,7 @@ pub(crate) async fn chat_with_game_creator_direct_codex(
     prompt: String,
     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())?;
@@ -4271,21 +4202,47 @@ 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 reply = run_direct_game_creator_turn_at_with_creation_type_and_emitter(
+    let mut audit = DirectCodexTurnAudit::start(
         root,
+        &turn_id,
         &prompt,
+        attachments.as_deref().unwrap_or_default(),
+    );
+    let user_prompt = match render_direct_codex_user_prompt(
+        &prompt,
+        attachments.as_deref().unwrap_or_default(),
+    ) {
+        Ok(prompt) => prompt,
+        Err(error) => {
+            audit.finish(false);
+            return Err(error);
+        }
+    };
+    let reply = match run_direct_game_creator_turn_at_with_creation_type_and_emitter(
+        root,
+        &user_prompt,
         creation_type.as_deref(),
         Some(&turn_emitter),
+        Some(&mut audit),
     )
-    .await?;
-    persist_direct_codex_assistant_reply_at(root, &turn_id, &reply).map_err(|error| {
+    .await
+    {
+        Ok(reply) => reply,
+        Err(error) => {
+            audit.finish(false);
+            return Err(error);
+        }
+    };
+    if let Err(error) = persist_direct_codex_assistant_reply_at(root, &turn_id, &reply) {
+        audit.finish(false);
         turn_emitter.emit("failed", Some("none"), None);
-        redact_agent_runtime_error(
+        return Err(redact_agent_runtime_error(
             root,
             &format!("Direct 成功回复持久化失败，已拒绝以未落盘状态返回：{error}"),
             500,
-        )
-    })?;
+        ));
+    }
+    audit.finish(true);
     turn_emitter.emit("completed", Some("none"), Some(reply.clone()));
     Ok(reply)
 }
@@ -4293,7 +4250,7 @@ pub(crate) async fn chat_with_game_creator_direct_codex(
 #[tauri::command]
 pub(crate) async fn chat_with_game_creator_home_direct_codex(
     prompt: String,
-    attachments: Option<Vec<DirectCodexHomeAttachment>>,
+    attachments: Option<Vec<DirectCodexTurnAttachment>>,
 ) -> Result<DirectCodexHomeReply, String> {
     run_direct_game_creator_home_turn(&prompt, attachments.as_deref().unwrap_or_default()).await
 }
@@ -4495,47 +4452,6 @@ mod tests {
         assert!(!prompt.contains("game/index.html"));
     }
 
-    #[test]
-    fn home_user_prompt_preserves_the_message_and_adds_only_bounded_attachment_metadata() {
-        let attachments = vec![DirectCodexHomeAttachment {
-            name: r"C:\Users\secret\角色参考.png".to_string(),
-            media_type: "image/png\nBearer secret".to_string(),
-            size: 3,
-        }];
-
-        let prompt = render_direct_codex_home_user_prompt("  先看看这个附件  ", &attachments)
-            .expect("home prompt");
-
-        assert!(prompt.starts_with("先看看这个附件\n\n[首页附件说明"));
-        assert!(prompt.contains("角色参考.png"));
-        assert!(prompt.contains("类型：application/octet-stream"));
-        assert!(prompt.contains("大小：3 字节"));
-        assert!(!prompt.contains("C:\\Users"));
-        assert!(!prompt.contains("\nBearer secret"));
-    }
-
-    #[test]
-    fn home_user_prompt_keeps_plain_messages_plain_and_caps_attachment_count() {
-        assert_eq!(
-            render_direct_codex_home_user_prompt("你好", &[]).expect("plain prompt"),
-            "你好"
-        );
-        let attachments = (0..MAX_DIRECT_HOME_ATTACHMENTS + 2)
-            .map(|index| DirectCodexHomeAttachment {
-                name: format!("asset-{index}.png"),
-                media_type: "image/png".to_string(),
-                size: index as u64,
-            })
-            .collect::<Vec<_>>();
-        let prompt = render_direct_codex_home_user_prompt("看看素材", &attachments)
-            .expect("bounded attachments");
-        assert!(prompt.contains("asset-7.png"));
-        assert!(!prompt.contains("asset-8.png"));
-        assert!(prompt.contains("另有 2 个附件未展开"));
-        assert!(render_direct_codex_home_user_prompt("", &attachments).is_ok());
-        assert!(render_direct_codex_home_user_prompt("", &[]).is_err());
-    }
-
     #[test]
     fn home_create_marker_is_accepted_only_as_the_first_reply_token() {
         let requested = parse_direct_codex_home_reply(format!(
diff --git a/apps/ai-game-creator-shell/src/App.tsx b/apps/ai-game-creator-shell/src/App.tsx
index 903debb7d..be8168f4e 100644
--- a/apps/ai-game-creator-shell/src/App.tsx
+++ b/apps/ai-game-creator-shell/src/App.tsx
@@ -60,6 +60,7 @@ import type {
   GenerateLocalGameDraftResult,
   ImportCanvasExportResult,
   InitLocalProjectResult,
+  LauncherImportedAttachment,
   LimitedLocalCommandResult,
   ListLocalProjectFilesResult,
   LocalAgentMemoryResult,
@@ -127,6 +128,10 @@ import {
   submitProjectSupervisorRuntimeTask,
   taskRowsFromManifest,
 } from './features/agent-runtime';
+import {
+  type DirectCodexTurnAttachment,
+  toDirectCodexTurnAttachments,
+} from './features/app-shell/directCodexTurnAttachments';
 import {
   isDeveloperMode,
   isTransientProjectOpenMessage,
@@ -407,6 +412,7 @@ type AppProps = {
   supervisorChatOnly?: boolean;
   initialSupervisorMessage?: string;
   initialCreationType?: HomeCreationType | null;
+  initialAttachments?: LauncherImportedAttachment[];
   playRequest?: ProjectSupervisorComponentProps['playRequest'];
   onPlayRequestHandled?: ProjectSupervisorComponentProps['onPlayRequestHandled'];
   onManifestChange?: (
@@ -422,6 +428,13 @@ type AppProps = {
   onMakeGameFromApprovedGdd?: (projectPath: string) => Promise<void>;
 };
 
+type ExecuteChatAgentReplyInput = {
+  prompt: string;
+  clientTurnId?: string;
+  creationType?: HomeCreationType | null;
+  attachments?: DirectCodexTurnAttachment[];
+};
+
 export function App({
   initialProjectPath: initialProjectPathOverride = '',
   initialProjectManifest,
@@ -432,6 +445,7 @@ export function App({
   supervisorChatOnly = false,
   initialSupervisorMessage = '',
   initialCreationType = null,
+  initialAttachments = [],
   playRequest = null,
   onPlayRequestHandled,
   onManifestChange,
@@ -495,6 +509,7 @@ export function App({
     projectPath: initialProjectPath,
     prompt: initialSupervisorMessage.trim(),
     creationType: initialCreationType,
+    attachments: toDirectCodexTurnAttachments(initialAttachments),
   });
   const handledPlayRequestRef = useRef<string | null>(null);
 
@@ -990,11 +1005,7 @@ export function App({
     | null
   >(null);
   const executeChatAgentReplyRef = useRef<
-    (
-      prompt: string,
-      directConversationTurnId?: string,
-      creationType?: HomeCreationType | null,
-    ) => Promise<void>
+    (input: ExecuteChatAgentReplyInput) => Promise<void>
   >(async () => undefined);
   const agentConversationSavingRef = useRef(false);
   const agentConversationBackgroundBusyRef = useRef(false);
@@ -2753,10 +2764,10 @@ export function App({
             return;
           }
           recoveredDirectCodexTurnClaimsRef.current.add(claimKey);
-          void executeChatAgentReply(
-            unansweredDirectTurn.prompt,
-            unansweredDirectTurn.turnId,
-          );
+          void executeChatAgentReply({
+            prompt: unansweredDirectTurn.prompt,
+            clientTurnId: unansweredDirectTurn.turnId,
+          });
         });
       }
     } catch (error) {
@@ -5225,7 +5236,7 @@ export function App({
       return;
     }
 
-    void executeChatAgentReply(prompt);
+    void executeChatAgentReply({ prompt });
   }
 
   async function executeLlmConfigStatus() {
@@ -5372,11 +5383,12 @@ export function App({
     }
   }
 
-  async function executeChatAgentReply(
-    prompt: string,
-    directConversationTurnId?: string,
-    creationType?: HomeCreationType | null,
-  ) {
+  async function executeChatAgentReply({
+    prompt,
+    clientTurnId: directConversationTurnId,
+    creationType,
+    attachments,
+  }: ExecuteChatAgentReplyInput) {
     // Product default: send the conversation directly to Codex app-server.
     // The legacy Supervisor/harness path remains below for rollback and tests.
     if (directCodexProductRuntime) {
@@ -5486,6 +5498,7 @@ export function App({
             prompt: string;
             clientTurnId: string;
             creationType?: HomeCreationType;
+            attachments?: DirectCodexTurnAttachment[];
           } = {
             projectPath: directProjectPath,
             prompt,
@@ -5494,6 +5507,9 @@ export function App({
           if (creationType) {
             directTurnInput.creationType = creationType;
           }
+          if (attachments?.length) {
+            directTurnInput.attachments = attachments;
+          }
           const reply = await directInvoke<string>(
             'chat_with_game_creator_direct_codex',
             directTurnInput,
@@ -5811,11 +5827,12 @@ export function App({
         updatedAt: Date.now(),
       },
     ]);
-    void executeChatAgentReplyRef.current(
-      latch.prompt,
-      directConversationTurnId,
-      latch.creationType,
-    );
+    void executeChatAgentReplyRef.current({
+      prompt: latch.prompt,
+      clientTurnId: directConversationTurnId,
+      creationType: latch.creationType,
+      attachments: latch.attachments,
+    });
   }, [
     chatAgentBusy,
     directCodexProductRuntime,
@@ -10826,7 +10843,10 @@ export function App({
         updatedAt: Date.now(),
       },
     ]);
-    void executeChatAgentReply(prompt, directConversationTurnId);
+    void executeChatAgentReply({
+      prompt,
+      clientTurnId: directConversationTurnId,
+    });
   }
 
   const visibleProfessionalAgentCards = agentStatusCards.filter(
diff --git a/apps/ai-game-creator-shell/src/app/types.ts b/apps/ai-game-creator-shell/src/app/types.ts
index 23474fb71..aaf922b5d 100644
--- a/apps/ai-game-creator-shell/src/app/types.ts
+++ b/apps/ai-game-creator-shell/src/app/types.ts
@@ -48,6 +48,7 @@ export type LauncherImportedAttachment = {
   localPath?: string;
   status: 'imported' | 'failed';
   error?: string;
+  size?: number;
 };
 
 export type LocalProjectKind = 'web' | 'godot';
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx b/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
index 501eca0b1..f39ce5eb3 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
+++ b/apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx
@@ -339,6 +339,7 @@ export function WorkspaceLauncherShell({
                 initialProjectKind={currentProjectContext.projectKind}
                 initialSupervisorMessage={currentProjectContext.initialPrompt}
                 initialCreationType={currentProjectContext.creationType}
+                initialAttachments={currentProjectContext.attachments}
                 orchestrationMode="single-supervisor"
                 projectSupervisorOnly
                 planningStartMode={
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/directCodexTurnAttachments.ts b/apps/ai-game-creator-shell/src/features/app-shell/directCodexTurnAttachments.ts
new file mode 100644
index 000000000..ece47fd13
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/app-shell/directCodexTurnAttachments.ts
@@ -0,0 +1,38 @@
+import type { LauncherImportedAttachment } from '../../app/types';
+
+export type DirectCodexTurnAttachment = {
+  name: string;
+  mediaType: string;
+  size?: number;
+  localPath?: string;
+  status?: 'imported' | 'failed';
+};
+
+export function toDirectCodexTurnAttachments(
+  imported: readonly LauncherImportedAttachment[] | null | undefined,
+): DirectCodexTurnAttachment[] {
+  if (!imported?.length) {
+    return [];
+  }
+  return imported.map((item) => {
+    const attachment: DirectCodexTurnAttachment = {
+      name: item.fileName,
+      mediaType: item.mediaType,
+    };
+    if (
+      typeof item.size === 'number' &&
+      Number.isFinite(item.size) &&
+      item.size >= 0
+    ) {
+      attachment.size = Math.trunc(item.size);
+    }
+    const localPath = item.localPath?.trim();
+    if (localPath) {
+      attachment.localPath = localPath;
+    }
+    if (item.status === 'imported' || item.status === 'failed') {
+      attachment.status = item.status;
+    }
+    return attachment;
+  });
+}
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/model.ts b/apps/ai-game-creator-shell/src/features/app-shell/model.ts
index eb8aa9f07..8d8283eba 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/model.ts
+++ b/apps/ai-game-creator-shell/src/features/app-shell/model.ts
@@ -5,7 +5,11 @@ import type {
   GameCreationAppManifest,
   GameCreationAppPreviewState,
 } from '../../../../../packages/shared/src/contracts/gameCreationApp';
-import type { ChatMessage, LocalProjectDirectoryStatus } from '../../app/types';
+import type {
+  ChatMessage,
+  LauncherImportedAttachment,
+  LocalProjectDirectoryStatus,
+} from '../../app/types';
 import type { HomeCreationType } from '../../view/home';
 import type { LauncherView } from '../../view/layout';
 import type {
@@ -32,6 +36,7 @@ export type ProjectSupervisorComponentProps = {
   initialProjectKind?: 'web' | 'godot';
   initialSupervisorMessage?: string;
   initialCreationType?: HomeCreationType | null;
+  initialAttachments?: LauncherImportedAttachment[];
   orchestrationMode?: 'single-supervisor' | 'professional-dag';
   projectSupervisorOnly?: boolean;
   planningStartMode?: boolean;
diff --git a/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts b/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts
index 366ddbf6f..df66b0f1b 100644
--- a/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts
+++ b/apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts
@@ -212,6 +212,7 @@ export function useHomeProjectCreation({
           mediaType,
           localPath: result.localPath,
           status: 'imported',
+          size: attachment.file.size,
         });
       } catch (error) {
         imported.push({
@@ -219,6 +220,7 @@ export function useHomeProjectCreation({
           mediaType,
           status: 'failed',
           error: error instanceof Error ? error.message : String(error),
+          size: attachment.file.size,
         });
       }
     }
diff --git a/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
index 520ff4666..a2fa4ed27 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/home.suite.ts
@@ -1529,11 +1529,44 @@ export function registerHomeProjectCreationTests() {
       prompt: '按这个角色做游戏',
       creationType: 'game',
       clientTurnId: expect.any(String),
+      attachments: [
+        {
+          name: '角色参考.png',
+          mediaType: 'image/png',
+          size: attachment.size,
+          localPath: 'assets/uploads/reference.png',
+          status: 'imported',
+        },
+      ],
     });
     expect(invoke).not.toHaveBeenCalledWith(
       'chat_with_game_creator_home_direct_codex',
       expect.anything(),
     );
+
+    expect(await screen.findByText('附件已经进入当前项目。')).not.toBeNull();
+    const followUpInput = screen.getByLabelText('陶泥儿对话内容');
+    fireEvent.change(followUpInput, { target: { value: '再补一句玩法' } });
+    fireEvent.submit(followUpInput.closest('form') as HTMLFormElement);
+    await waitFor(() => {
+      expect(
+        invoke.mock.calls.filter(
+          ([command]) => command === 'chat_with_game_creator_direct_codex',
+        ),
+      ).toHaveLength(2);
+    });
+    expect(invoke).toHaveBeenCalledWith('chat_with_game_creator_direct_codex', {
+      projectPath: automaticProjectPath,
+      prompt: '再补一句玩法',
+      clientTurnId: expect.any(String),
+    });
+    const followUpPayload = invoke.mock.calls.find(
+      ([command, args]) =>
+        command === 'chat_with_game_creator_direct_codex' &&
+        (args as Record<string, unknown> | undefined)?.prompt ===
+          '再补一句玩法',
+    )?.[1] as Record<string, unknown> | undefined;
+    expect(followUpPayload).not.toHaveProperty('attachments');
   });
 
   it('starts an automatic game project from the approved GDD', async () => {
@@ -1730,6 +1763,18 @@ export function registerHomeProjectCreationTests() {
       } else {
         expect(startCall?.[1]).not.toHaveProperty('source');
       }
+      expect(startCall?.[1]).not.toHaveProperty('attachments');
+      expect(JSON.stringify(startCall?.[1] ?? {})).not.toContain(
+        '本轮用户附件',
+      );
+      expect(invoke).not.toHaveBeenCalledWith(
+        'chat_with_game_creator_direct_codex',
+        expect.anything(),
+      );
+      expect(invoke).not.toHaveBeenCalledWith(
+        'chat_with_game_creator_agent',
+        expect.anything(),
+      );
       expect(
         invoke.mock.calls.filter(
           ([command]) => command === 'create_automatic_local_game_project',
@@ -1738,6 +1783,98 @@ export function registerHomeProjectCreationTests() {
     },
   );
 
+  it('keeps 做方案 first turn on Supervisor without a Direct attachment sidecar', async () => {
+    const projectPath = '/tmp/home-planning-attachment';
+    const manifest = createGameCreationAppManifest(
+      'home-planning-attachment',
+      '首页策划附件',
+    );
+    const supervisorHarness = createProjectSupervisorRuntimeHarness({
+      projectPath,
+      expectedRunProfile: 'standard',
+    });
+    const fileBytes = Array.from(new TextEncoder().encode('png'));
+    const invoke = vi.fn(
+      async (command: string, args?: Record<string, unknown>) => {
+        if (command === 'create_automatic_local_game_project') {
+          return {
+            projectPath,
+            manifestPath: `${projectPath}/.agent/manifest.json`,
+            manifest,
+          };
+        }
+        if (command === 'upload_local_asset') {
+          return {
+            id: 'asset-upload-plan-1',
+            localPath: 'assets/uploads/reference.png',
+            absolutePath: `${projectPath}/assets/uploads/reference.png`,
+            manifestPath: `${projectPath}/.agent/manifest.json`,
+          };
+        }
+        return supervisorHarness.invoke(command, args);
+      },
+    );
+    window.__TAURI__ = {
+      core: { invoke },
+      event: { listen: supervisorHarness.listen },
+    };
+    renderLauncherAt('/?launcher', 'home', true);
+
+    fireEvent.click(screen.getByRole('button', { name: '做方案' }));
+    const fileInput =
+      document.querySelector<HTMLInputElement>('input[type="file"]');
+    expect(fileInput).not.toBeNull();
+    const attachment = new File(['png'], '角色参考.png', {
+      type: 'image/png',
+      lastModified: 1,
+    });
+    Object.defineProperty(attachment, 'arrayBuffer', {
+      value: async () => new Uint8Array(fileBytes).buffer,
+    });
+    fireEvent.change(fileInput!, { target: { files: [attachment] } });
+
+    const promptInput = screen.getByLabelText('创作想法');
+    nativeClipboardMock.text = '整理一份可玩原型';
+    fireEvent.paste(promptInput);
+    await waitFor(() => {
+      expect(promptInput.textContent).toContain('整理一份可玩原型');
+      expect(promptInput.textContent).toContain('角色参考.png');
+    });
+    fireEvent.click(screen.getByRole('button', { name: '进入立项策划' }));
+
+    await waitFor(() => {
+      expect(invoke).toHaveBeenCalledWith(
+        'start_game_creator_supervisor_runtime_task',
+        expect.objectContaining({
+          projectPath,
+          source: PROJECT_SUPERVISOR_PLAN_SOURCE,
+        }),
+      );
+    });
+    expect(invoke).toHaveBeenCalledWith('upload_local_asset', {
+      projectPath,
+      fileName: '角色参考.png',
+      mediaType: 'image/png',
+      bytes: fileBytes,
+    });
+    const startCall = invoke.mock.calls.find(
+      ([command]) => command === 'start_game_creator_supervisor_runtime_task',
+    );
+    expect(startCall?.[1]).not.toHaveProperty('attachments');
+    expect(JSON.stringify(startCall?.[1] ?? {})).not.toContain('本轮用户附件');
+    expect(JSON.stringify(startCall?.[1] ?? {})).not.toContain(
+      'assets/uploads/reference.png',
+    );
+    expect(invoke).not.toHaveBeenCalledWith(
+      'chat_with_game_creator_direct_codex',
+      expect.anything(),
+    );
+    expect(invoke).not.toHaveBeenCalledWith(
+      'chat_with_game_creator_agent',
+      expect.anything(),
+    );
+  });
+
   it('surfaces the planning clarification card after 做方案 creates the project from home', async () => {
     // 上面那条只断言到「run 起来了、source 对」。真实故障恰好落在它之后：plan 根 run
     // 停在 waiting-for-user-input 并带回澄清请求，而工作台一直停在前端本地的占位文案，
diff --git a/apps/ai-game-creator-shell/tests/directCodexTurnAttachments.test.ts b/apps/ai-game-creator-shell/tests/directCodexTurnAttachments.test.ts
new file mode 100644
index 000000000..7ddc3a0c1
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/directCodexTurnAttachments.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+
+import { toDirectCodexTurnAttachments } from '../src/features/app-shell/directCodexTurnAttachments';
+
+describe('toDirectCodexTurnAttachments', () => {
+  it('maps imported files and omits error plus empty localPath', () => {
+    expect(
+      toDirectCodexTurnAttachments([
+        {
+          fileName: '角色参考.png',
+          mediaType: 'image/png',
+          localPath: 'assets/uploads/upload-1-角色参考.png',
+          status: 'imported',
+          size: 12,
+        },
+        {
+          fileName: 'lost.bin',
+          mediaType: 'application/octet-stream',
+          status: 'failed',
+          error: '磁盘不可写',
+          size: 2,
+        },
+      ]),
+    ).toEqual([
+      {
+        name: '角色参考.png',
+        mediaType: 'image/png',
+        size: 12,
+        localPath: 'assets/uploads/upload-1-角色参考.png',
+        status: 'imported',
+      },
+      {
+        name: 'lost.bin',
+        mediaType: 'application/octet-stream',
+        size: 2,
+        status: 'failed',
+      },
+    ]);
+  });
+
+  it('returns an empty list when there is nothing to map', () => {
+    expect(toDirectCodexTurnAttachments(undefined)).toEqual([]);
+    expect(toDirectCodexTurnAttachments([])).toEqual([]);
+  });
+});
diff --git a/docs/README.md b/docs/README.md
index f937a964d..40195c0ae 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -20,6 +20,8 @@
 ## AI 游戏创作与 Agent Runtime
 
 - [AI 游戏创作智能体 App 实施计划](./technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md)：当前 DirectProject、受控语义工具、UI workflow、资源和运行时合同。
+- [DirectProject 本轮附件路径映射](./technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md)：Direct 首轮只映射附件原名与项目相对路径，不灌正文、不区别 GDD。
+- [Direct 回合行为审计账本](./technical/【技术方案】Direct回合行为审计账本-2026-08-31.md)：Direct GUI 回合把 native 读 / MCP / 写文件落成项目内有界时间线，用于判断有没有打开本轮附件。
 - [项目开发工作台 PRD](./prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md)：当前工作台页面和验收边界。
 - [立项策划 Agent（Fast GDD）](<./technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md>)：当前策划入口、审批和恢复合同。
 - [GameAgent 资源自由画板与快速编辑](./technical/【技术方案】GameAgent资源自由画板与快速编辑-2026-08-20.md)
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 5e0ee27db..2936ef7c9 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -25,6 +25,22 @@
 
 ---
 
+## 2026-08-31 Direct 回合把 Codex item 落成有界行为账本
+
+- 背景：sidecar 已让模型看见本轮附件路径，但 native 读 / MCP / 写文件只存在于隔离 `CODEX_HOME` 的瞬时 stdout，回合结束即删。无法判断「没读附件」还是「读了仍走默认收集类」。
+- 决策：GUI DirectProject 每个 `clientTurnId` 追加 `.agent/runtime/direct-codex/turns/<id>.jsonl`，并在 `agent.db` 写一条 `direct.codex.turn` 摘要。记 sidecar 提供的路径与文件 hash、`item/completed` 的 Read/List/Search/MCP/写文件（不含 stdout、patch、MCP result），以及 `offeredRead` / `firstDesign`。审计 fail-open，不阻断做游戏。Home、CLI、Supervisor 收据模型不接。不灌附件正文，不强制读取，不为 GDD 开特例。
+- 影响范围：`direct_codex_audit.rs`、Direct GUI command 边界、Codex collect 循环；前端 / jsonl 气泡 / sidecar 文案不变。
+- 验证方式：Rust fixture 覆盖 turn_start hash、绝对路径相对化、stdout/diff 不落盘、art brief 保留、list/search 不算已读、firstDesign 顺序、256 条截断、写盘失败不 panic；sidecar 渲染与 Direct 活动词测试保持通过。
+- 关联文档：`docs/technical/【技术方案】Direct回合行为审计账本-2026-08-31.md`、issue #212。
+
+## 2026-08-31 Direct 本轮附件只映射路径，不灌正文、不区别 GDD
+
+- 背景：issue #212。首页附件已经复制到 `assets/uploads/` 并登记，但 Direct 首轮只把用户原文发给 Codex，原文件名不是磁盘路径，模型会另起一套玩法。
+- 决策：Home 与 Project 共用 `DirectCodexTurnAttachment`。有项目路径或导入状态时，只在发给 Codex 的 user prompt 末尾附有界 sidecar（原名 → 项目相对路径、类型、大小、状态）；无路径且无状态时保持首页元数据文案。不灌正文、不强制读取、不按 GDD 开特例。做成游戏固定 prompt 不改，同一条 Direct 首轮附件链自动吃到 sidecar。jsonl 与工作台气泡仍只写用户原文。
+- 影响范围：`direct_codex_attachments.rs`、Direct command 边界、首页建项 latch、工作台首轮 invoke；Supervisor / 做方案首轮忽略附件 sidecar。
+- 验证方式：Rust 渲染测试（Home 逐字兼容、Project 映射、非法路径）；home.suite 附件 Direct invoke 含 `localPath`；无附件不出现 `attachments` 键；做方案首轮仍走 Supervisor 且无 sidecar；后续手打消息不带 attachments。
+- 关联文档：`docs/technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md`、issue #212。
+
 ## 2026-08-26 运行中自主扩图提案留在编排层
 
 - 背景：`agent-runtime-orchestration` 已能构造和调度动态 DAG，但 LLM 在执行中发现缺少步骤时没有通用的安全扩图合同。
@@ -39,6 +55,7 @@
 - 产品边界：16 个游戏任务、六组角色、产物/验收条件、Evaluator Markdown 和中文语义路由继续留在 `platform-agent`；AGC 组合根使用公共层校验任务图与 `AgentCatalog`。Runtime store、Runner、Provider、权限、ToolHost、委派 journal、isolated write scope 和 `.agent/runtime/**` 不迁移、不双写。
 - 验证方式：非游戏 conformance 覆盖并行分支、汇合、repair closure、AgentCatalog 和非法图失败关闭；`platform-agent` 锁定种子 DAG 与现役波次/返工顺序，并验证环拒绝和 catalog 注入。根检查脚本必须执行新 crate 测试。
 - 关联文档：`docs/technical/【技术方案】AI游戏创作Agent Runtime V1.1-2026-07-12.md` V1.54。
+
 ## 2026-08-27 `plan.submit_gdd` 拒绝无审批决定的 `user_revision`
 
 - 背景：结构校验允许 `round=0 + user_revision + confirmed`，提交闸原先只做结构、身份和 Session CAS。Provider 可在首次 collecting、澄清续跑或提交前质量返工里把未确认项标成用户审批修改，审批卡显示「已确认」。
diff --git a/docs/project-memory/shared-memory/document-map.md b/docs/project-memory/shared-memory/document-map.md
index 5fbb8fe37..db230fbc1 100644
--- a/docs/project-memory/shared-memory/document-map.md
+++ b/docs/project-memory/shared-memory/document-map.md
@@ -1,6 +1,6 @@
 # 文档地图与阅读索引
 
-更新时间：`2026-08-25`
+更新时间：`2026-08-31`
 
 ## 阅读顺序
 
@@ -24,9 +24,11 @@ AI 游戏创作 / DirectProject / UI workflow：
 1. `docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md`
 2. `docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md`
 3. `docs/technical/【技术方案】立项策划Agent（Fast GDD）-2026-08-10.md`
-4. `docs/technical/【技术方案】GameAgent资源自由画板与快速编辑-2026-08-20.md`
-5. `docs/【技术方案】UI工作流资源桥接与Runtime执行-2026-08-24.md`
-6. UI 编辑器、宿主壳和当前测试专题文档
+4. `docs/technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md`
+5. `docs/technical/【技术方案】Direct回合行为审计账本-2026-08-31.md`
+6. `docs/technical/【技术方案】GameAgent资源自由画板与快速编辑-2026-08-20.md`
+7. `docs/【技术方案】UI工作流资源桥接与Runtime执行-2026-08-24.md`
+8. UI 编辑器、宿主壳和当前测试专题文档
 
 图片画布 / 媒体生成：
 
diff --git a/docs/technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md b/docs/technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md
new file mode 100644
index 000000000..a0c1f88cb
--- /dev/null
+++ b/docs/technical/【技术方案】DirectProject本轮附件路径映射-2026-08-31.md
@@ -0,0 +1,262 @@
+# DirectProject 本轮附件路径映射
+
+- 日期：2026-08-31
+- 状态：现行合同（已按本文落地）
+- 问题：Gitea issue #212（DirectProject 未消费用户上传权威文档）
+- 关联入口：PR #210「批准 GDD 回填做游戏入口」（`feat/create_entrance`，未合入时仍按该 PR 的调用链理解）
+- 原则：落地后代码简洁可维护，不为了 diff 最小而打补丁；附件一律同等对待，不给 GDD 开协议特例
+
+## 0. 一句话
+
+首页带进项目的附件已经复制并登记，但 Direct 首轮只拿到用户原文。本方案让 Direct 回合在发给 Codex 的 user prompt 末尾附上**有界路径映射**（原文件名 → 项目相对路径），不灌正文、不强制读取、不改做方案注入。
+
+## 1. 目标与非目标
+
+### 目标
+
+1. Direct 首轮知道本轮用户附件的原文件名、项目相对路径、媒体类型、大小和导入状态。
+2. 用户原文不被改写；路径映射是独立 sidecar。
+3. 图片、Markdown、其它文件走同一条协议。
+4. 做成游戏（PR #210：读 `game/fast_gdd.md` → 当成 `fast_gdd.md` 附件 → `createHomeDraftAutomatically`）自动吃到效果，因为那条链就是「带附件的 Direct 首轮」。
+
+### 非目标
+
+- 不改 PR #210 的按钮、固定 prompt、`startGameFromApprovedGdd`、读 `game/fast_gdd.md` 的方式。
+- 不改 `approvedGddRef`、审批 receipt、策划项目里的 `game/fast_gdd.md` 投影。
+- 不改上传命名 `assets/uploads/upload-<ts>-<name>`。
+- 不把附件全文拼进 prompt，不按扩展名决定是否读取。
+- 不把「没读到就阻断」做成门禁。
+- 不扫 manifest 里历史 `kind=uploaded`。
+- 不做 native 读取审计；该项由 [`【技术方案】Direct回合行为审计账本-2026-08-31.md`](./【技术方案】Direct回合行为审计账本-2026-08-31.md) 承接。
+- 不改 DirectHome 在「无项目路径」时的现有文案和列表格式。
+- 不改 `enterCreatedHomeProject` 的空正文兜底句（与做方案共用）。
+
+## 2. 现行断点
+
+```text
+Home 附件 / 做成游戏 File(fast_gdd.md)
+  → upload_local_asset
+  → LauncherProjectContext.attachments          // 已有，只给资源画布
+  → ProjectSupervisor                            // 无 attachments 字段
+  → chat_with_game_creator_direct_codex
+      { projectPath, prompt, clientTurnId, creationType? }
+```
+
+做成游戏的固定 prompt 仍写「附件中的 `fast_gdd.md`」，磁盘文件却是 `assets/uploads/upload-<ts>-fast_gdd.md`。映射没有进 Direct。
+
+DirectHome 已有 `{ name, mediaType, size }` 元数据注入，但标明「尚未打开项目，内容尚不可读取」。项目已落盘后这条元数据被丢掉。
+
+## 3. 目标合同
+
+### 3.1 唯一 DTO
+
+Home 与 Project 共用一个附件结构，缺省字段表示 Home 现状：
+
+```ts
+{
+  name: string;                 // 原文件名
+  mediaType: string;
+  size?: number;                // 缺省按 0
+  localPath?: string;           // 仅已落入项目时出现
+  status?: 'imported' | 'failed';
+}
+```
+
+- 不把 `error` 字符串送给模型。
+- 前端 `LauncherImportedAttachment` 继续给画布；invoke 前映射成上述瘦 DTO。
+- `importHomeAttachments` 把 `File.size` 写入可选 `size`，不改 `upload_local_asset` 返回值。
+
+Rust：
+
+```rust
+struct DirectCodexTurnAttachment {
+    name: String,
+    media_type: String,
+    #[serde(default)]
+    size: u64,
+    #[serde(default)]
+    local_path: Option<String>,
+    #[serde(default)]
+    status: Option<String>, // 只接受 imported | failed，其它忽略
+}
+```
+
+`DirectCodexHomeAttachment` 删除，Home command 改用同一类型。现有 Home JSON（无 `localPath` / `status`）继续能反序列化。
+
+### 3.2 渲染
+
+一个函数 `render_direct_codex_user_prompt(prompt, attachments) -> Result<String, String>`：
+
+| 输入 | 输出 |
+|---|---|
+| 无附件 | `prompt.trim()`；若也空则 `Err("聊天内容不能为空")` |
+| 附件都没有 `localPath` 且都没有 `status` | 保持现有 Home 文案与行格式，测试须逐字兼容 |
+| 任一条有 `localPath` 或 `status` | Project 头 + Project 行格式 |
+
+Home 行（禁止改字）：
+
+```text
+[首页附件说明：当前尚未打开项目，以下仅为附件元数据，附件内容尚不可读取]
+- {name}；类型：{mediaType}；大小：{n} 字节
+```
+
+Project 头与行（禁止出现 GDD / 规格 / 权威 / 必须读取）：
+
+```text
+<用户原文>
+
+[本轮用户附件：已复制到当前项目。请用「项目路径」读取；原文件名不是磁盘路径。]
+- 原文件名：fast_gdd.md；项目路径：assets/uploads/upload-1788083777445-fast_gdd.md；类型：text/markdown；大小：7944 字节；状态：imported
+```
+
+规则：
+
+- 条数上限仍为 8，超出写 `- 另有 N 个附件未展开`。
+- 名字清洗沿用 Home：basename、去掉控制字符、最多 160 字、空则「未命名附件」。
+- 媒体类型清洗沿用 Home。
+- `localPath` 只接受项目相对 POSIX 路径：无 `..`、无盘符/根路径、首段不是 `.agent` / `.git`，`\` 归一为 `/`，最长 512；不合法则该条不输出路径，状态按 `failed`。
+- 有附件时允许原文为空（Home 已如此）。Direct 内层若仍要求非空，在 command 边界先渲染再下传，避免空原文 + 有附件被拒。
+
+不在 sidecar 里写「若用户要求按附件实施请先读取」。意图留在用户原文；做成游戏的固定 prompt 已经在说这件事。
+
+### 3.3 谁渲染、谁看见
+
+- sidecar **只在进 Codex 前由 Rust 拼装**。
+- `.agent/conversations/project.jsonl` 继续写用户原文（现有 `append_local_conversation_message`）。
+- 工作台气泡继续显示 latch / 输入框原文，不把 sidecar 画进 UI。
+- 未完成首轮的 hydration 重放目前只带 prompt：本期不把附件写进 jsonl，进程重启后的未完成首轮可能丢映射。完整成功首轮不受影响。不为此新增会话 schema。
+
+## 4. 数据流
+
+```text
+Home 上传 / 做成游戏 File
+  → upload_local_asset（已有）
+  → LauncherProjectContext.attachments（已有）
+  → ProjectSupervisor.initialAttachments
+  → 首轮 latch（与 prompt、creationType 同级）
+  → 仅 chat_with_game_creator_direct_codex.attachments
+  → render_direct_codex_user_prompt
+  → 现有 Direct turn（cwd = 项目根）
+```
+
+Supervisor / 做方案首轮忽略 `attachments`，行为不变。
+
+后续工作台手打消息不带 `attachments`。附件是这一轮带来的，不是项目终身上下文。
+
+## 5. 代码落地（按最终结构，不按最小补丁）
+
+### 5.1 Rust
+
+新增 [`apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs)：
+
+- DTO、清洗、上限常量、`render_direct_codex_user_prompt`
+- 单元测试（见第 6 节）
+
+[`agent.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent.rs) 增加 `mod direct_codex_attachments`。
+
+[`direct_runtime.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs)：
+
+- 删除 Home 专用 struct / sanitizer / `render_direct_codex_home_user_prompt`
+- `run_direct_game_creator_home_turn` 改为调用共享渲染
+- `chat_with_game_creator_direct_codex` 增加 `attachments: Option<Vec<DirectCodexTurnAttachment>>`，先渲染再调用现有 `run_direct_game_creator_turn_at_with_creation_type_and_emitter`
+- 把现有 Home 渲染测试迁到新文件；本文件不再保留一份平行实现
+
+不要把 attachments 顺着 inner turn / emitter / CLI 往下传。CLI `run_direct_game_creator_turn_at` 不变。
+
+### 5.2 前端
+
+[`model.ts`](../../apps/ai-game-creator-shell/src/features/app-shell/model.ts) `ProjectSupervisorComponentProps` 增加：
+
+```ts
+initialAttachments?: LauncherImportedAttachment[];
+```
+
+[`WorkspaceLauncher.tsx`](../../apps/ai-game-creator-shell/src/features/app-shell/WorkspaceLauncher.tsx)：
+
+```ts
+initialAttachments={currentProjectContext.attachments}
+```
+
+[`App.tsx`](../../apps/ai-game-creator-shell/src/App.tsx)：
+
+- props / latch 增加 `attachments`（默认 `[]`）
+- `executeChatAgentReply` 不要再加第 5 个位置参数，收成：
+
+```ts
+{
+  prompt: string;
+  clientTurnId?: string;
+  creationType?: HomeCreationType | null;
+  attachments?: DirectCodexTurnAttachment[];
+}
+```
+
+- Direct invoke：有 `creationType` 才写该字段（现有）；`attachments?.length` 才写 `attachments`
+- Supervisor 分支完全不读 `attachments`
+- 现有 `executeChatAgentReply(prompt)` / 恢复未完成 turn 的调用改为对象形式，不传 attachments
+
+瘦映射不要写在 1 万行的 `App.tsx` 里，放到例如 [`apps/ai-game-creator-shell/src/features/app-shell/directCodexTurnAttachments.ts`](../../apps/ai-game-creator-shell/src/features/app-shell/directCodexTurnAttachments.ts)：`toDirectCodexTurnAttachments(imported)`，去掉 `error`，空 `localPath` 不输出该键。
+
+[`useHomeProjectCreation.ts`](../../apps/ai-game-creator-shell/src/features/app-shell/useHomeProjectCreation.ts)：`importHomeAttachments` 写入 `size: attachment.file.size`。不改 `initialPrompt` 兜底句，不改做成游戏（即便本分支尚未合入 PR #210，也不预埋 GDD 字段）。
+
+[`types.ts`](../../apps/ai-game-creator-shell/src/app/types.ts)：`LauncherImportedAttachment` 增加可选 `size?: number`。
+
+### 5.3 文档
+
+落地提交时（不是本方案文件自身）：
+
+- 本文件标为现行合同
+- `docs/README.md`、`docs/project-memory/shared-memory/document-map.md` 增加条目
+- `decision-log.md` 记一条：Direct 本轮附件只映射路径，不灌正文、不区别 GDD
+- 不把 issue #212 技术说明改写成「已修复」，等代码合入后再改状态
+
+## 6. 测试
+
+### Rust（新文件）
+
+1. 无附件：原文 trim 后原样返回；空原文报错。
+2. Home 形态（无 path、无 status）：与迁过来的两条现有测试逐字一致（含路径剥离、非法 mediaType、8 条上限）。
+3. Project 形态：原文保留；含原名与 `assets/uploads/...`；**断言不得出现「GDD」「规格」「权威」**。
+4. 同一列表里 png 与 md 行格式相同（只是 name/path/type 不同）。
+5. `status=failed` 且无 path：有状态、无项目路径、无 error 正文。
+6. 非法 `localPath`（`../`、`.agent/x`、绝对路径）不出现在输出中。
+7. 空原文 + 有附件：成功，且含 Project 头。
+
+### 前端
+
+1. [`home.suite.ts`](../../apps/ai-game-creator-shell/tests/appSurface/home.suite.ts)「imports home attachments…」：Direct invoke 必须带 `attachments`，其中 `name` 为 `角色参考.png`、`localPath` 为 upload 返回路径、`status: 'imported'`。用 png 证明不是 md 特例。
+2. 无附件的 Direct invoke 仍不得出现 `attachments` 键（或等价：不传该字段）。
+3. `planningStartMode` 首轮仍走 Supervisor，`chat_with_game_creator_agent` 的 payload 不含附件 sidecar。
+4. 工作台后发的普通消息：`chat_with_game_creator_direct_codex` 只有 `projectPath/prompt/clientTurnId`（及既有 creationType 规则），不带 attachments。
+5. 若本分支已能跑 PR #210 的 home.suite / plan-gdd 做成游戏用例：只断言它仍调用 `createHomeDraftAutomatically` / 仍使用原固定 prompt；**不要**给做成游戏加第二条附件协议。sidecar 由通用 Direct 断言覆盖。
+
+### 不测
+
+- 不把「必须生成弹幕射击」写成单测。
+- 不测 native `file.read` 是否进 `agent.db`。
+
+## 7. 做成游戏为什么不用改
+
+PR #210 `startGameFromApprovedGdd`：
+
+1. 读策划项目 `game/fast_gdd.md`
+2. `new File([content], 'fast_gdd.md')`
+3. `createHomeDraftAutomatically({ creationType: 'game', prompt: APPROVED_GDD_BUILD_PROMPT, attachments }, 'direct-build')`
+
+之后与首页拖一个 md 完全相同。sidecar 见到的是「原文件名 `fast_gdd.md` + 新项目 `assets/uploads/upload-…-fast_gdd.md`」。固定 prompt 继续说「读附件中的 fast_gdd.md」，映射补上真实路径。
+
+## 8. 验收
+
+1. 首页做游戏：上传任意文本或图片 + 一句话，Direct 首轮 prompt 含原名和 `assets/uploads/...`。
+2. 做成游戏（PR #210 合入后或该分支上）：固定 prompt 一字不改，同时出现改写后的项目路径。
+3. 做方案首轮：Supervisor 行为与现在一致，无 sidecar。
+4. 无附件：Direct 入参与现在一致。
+5. `npm run check:encoding`、`git diff --check`、相关 `home.suite` / Direct Rust 测试通过。
+
+## 9. 实现顺序
+
+1. Rust 共享渲染 + 迁 Home 测试 + Direct command 接 `attachments`
+2. 前端 latch / invoke / 映射 / `size`
+3. 改 `home.suite` 附件断言
+4. encoding 与定向测试
+5. 合入时补 decision-log 与文档索引
diff --git a/docs/technical/【技术方案】Direct回合行为审计账本-2026-08-31.md b/docs/technical/【技术方案】Direct回合行为审计账本-2026-08-31.md
new file mode 100644
index 000000000..bd84378b9
--- /dev/null
+++ b/docs/technical/【技术方案】Direct回合行为审计账本-2026-08-31.md
@@ -0,0 +1,389 @@
+# Direct 回合行为审计账本
+
+- 日期：2026-08-31
+- 状态：现行合同（已按本文落地）
+- 问题：Gitea issue #212 的第二段（Direct 原生读 / 工具行为无法从项目产物判断）；用于分析「附件已映射仍未按文档实施」
+- 关联：[`【技术方案】DirectProject本轮附件路径映射-2026-08-31.md`](./【技术方案】DirectProject本轮附件路径映射-2026-08-31.md)、[`【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md`](./【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md)
+- 原则：落地后代码简洁可维护；审计是 Direct 行为时间线，不是 GDD 特例，也不替代 sidecar
+
+## 0. 一句话
+
+Direct GUI 回合已经能看见 Codex `item/completed`，但只收成 UI 活动词，隔离 `CODEX_HOME` 随后删除。本方案在项目内留下有界、可共享的回合账本：本轮提供了哪些附件路径、按什么顺序做了读/搜/列表/MCP/写文件，以及第一次定玩法的动作是什么。用来区分「没读附件」和「读了仍走默认收集类」，不灌正文、不强制读取、不拷会话目录。
+
+## 1. 目标与非目标
+
+### 目标
+
+一次带 `clientTurnId` 的 DirectProject GUI 回合结束后，只凭项目目录应能回答：
+
+1. 本轮 sidecar 是否发出，原名映射到哪些项目相对路径，文件当时的 `contentSha256`。
+2. 模型是否用 native 命令 / 列表 / 搜索 / 看图 / MCP 打开过那些路径（路径 + 当时磁盘 hash，不是 stdout）。
+3. **顺序**：读附件是在第一次美术 brief / 第一次写 `game/` 之前还是之后。
+4. 第一次「定玩法」动作是什么（优先 `taonier_prepare_game_art.brief`，否则其它生成类 MCP 或对 `game/` 的写入）。
+
+覆盖后续手打回合：只要 GUI Direct 有 `clientTurnId` 就记账本，附件可以为空。
+
+### 非目标
+
+- 不证明「理解并按 GDD 实施」。那是对照 `game/index.html`、美术产物做的产品判断；账本只提供行为时间线。
+- 不把 issue #212 原文的 NLP / 「关键内容进入上下文」做成自动判决。
+- 不灌附件正文进 prompt，不强制先读再继续，不为 GDD 开协议特例。
+- 不改 sidecar 文案、jsonl 用户原文、工作台气泡。
+- 不改做成游戏固定 prompt / PR #210 注入。
+- 不复用 Supervisor `agent.runtime.action_receipt` / `file.read`。
+- 不拷隔离 `CODEX_HOME`、不落 `auth.json`、不落 `aggregated_output` / MCP `result` / patch `diff` / `FunctionCallOutput` 正文。
+- 不把原始 item JSON 送进 Tauri 前端事件（现有 `DirectCodexTurnObservation` 仍只允许安全活动词和流式正文）。
+- 不扫 `kind=uploaded` 历史附件；只记本轮 sidecar 提供的集合。
+- DirectHome、ToolHost、CLI `--direct-codex-chat`（无 `clientTurnId`）本期不写这份账本。
+- 本期不改 UI，不在聊天面板展示审计。
+- 不把 issue #212 标成已修复；sidecar 与本账本是两段工作。
+
+## 2. 现状
+
+```text
+Codex item/completed
+  commandExecution / mcpToolCall / fileChange / imageView / …
+        │
+        ├─ 现用：收成 Activity("validation"|"controlled-tool"|…)
+        │         → Tauri 进度，不落盘
+        └─ 不用：隔离 CODEX_HOME session（含 stdout）→ tempdir Drop 删除
+```
+
+项目里现有：
+
+| 产物 | 记下的 | 缺的 |
+|---|---|---|
+| `.agent/conversations/project.jsonl` | 用户原文 + 助手终稿 | sidecar、工具调用 |
+| `.agent/agent.db` | init / upload / 美术登记 / 对话指针 | native 读、MCP 调用、`agc_write_file` |
+| `.agent/logs/command.log` | 权限确认 | 原生命令 |
+| `asset.register` / `canvas.asset_generate` | 路径、切片、部分 `source.prompt` | 与读附件的先后 |
+| 隔离 `CODEX_HOME` | Codex 自己的 session | 回合结束即删 |
+
+Codex app-server 协议里，`commandExecution.commandActions` 已分类为 `Read | ListFiles | Search | Unknown`，`Read.path` 在协议侧会拼成 cwd 绝对路径。Direct cwd 就是项目根（`resolve_direct_codex_project_authority` 不再强制 `game/` 子目录）。抽取时把绝对路径收回项目相对 POSIX，失败则丢路径，不写宿主绝对路径。
+
+`agc_write_file` 经 tool bridge 落盘，当前不写 `agent.db`。不给每个 MCP 单独打点；统一在 `item/completed` 抽一次。
+
+## 3. 分析用判据（相对 issue 收窄）
+
+落地后，对类似 `gameagent-9baa5293` 的 run，应能三分：
+
+| 时间线 | 结论 | 下一刀不该打哪 |
+|---|---|---|
+| `offeredRead.read=false`，`firstDesign` 已是 `taonier_prepare_game_art` 且 brief 是收集类 | 没打开附件就定了玩法 | 不是「GDD 解析不够」 |
+| 先 `Read` 且 hash 对上，brief 仍是收集类 | 读了但没用 | sidecar 已够；看四切片 / icon-spec「收集物」/ 完成合同 |
+| 只有 `ListFiles` / `Search` 命中 uploads，没有 `Read` | 发现了没读正文 | 映射可能够，缺的是读 |
+| `Read` 的 path 是 `fast_gdd.md` 而不是 `assets/uploads/…` | sidecar 没被当成磁盘路径 | 还是路径合同 |
+
+不在账本里写「已遵循 GDD」或「未遵循 GDD」布尔。
+
+## 4. 落点
+
+两层，都在项目 `.agent/` 控制面内，模型读不到：
+
+1. **权威时间线**（每回合一个 jsonl，只追加）
+   `.agent/runtime/direct-codex/turns/<clientTurnId>.jsonl`
+2. **总索引一条摘要**（方便继续翻现有 `agent.db`）
+   `recordType: "direct.codex.turn"`
+
+`clientTurnId` 沿用现有规则：trim 后 6–160 位 ASCII 字母数字或连字符，首位字母或数字。文件名用规范化后的 id，不再二次编码。
+
+不升级 `GAME_CREATOR_AGENT_DB_SCHEMA_VERSION`；新 `recordType` 走 Ordinary 追加。`updatedAt` / `schemaVersion` 仍由 `serialize_agent_db_record` 写入。
+
+jsonl 每条自带 `recordedAtMs`（`unix_millis`）。同一 `clientTurnId` 若再次进入（当前 GUI 运行中互斥，结束后理论上可再来）：只追加，不截断；后一次 `turn_start` 视为新 attempt。读摘要时按文件内最后一次 `turn_start` 到对应 `turn_end` 计算 `offeredRead`。`agent.db` 每次 `turn_end` 再追加一条摘要，分析取该 `clientTurnId` 最后一条。
+
+## 5. 记录合同
+
+camelCase JSON。禁止出现附件正文、命令 stdout、patch diff、宿主绝对路径、Token、URL 签名。
+
+### 5.1 `turn_start`
+
+在 sidecar **已经渲染之后**、Codex turn **启动之前**写入。`promptSha256` 哈希的是 **用户原文**（command 入参 `prompt`），不是带 sidecar 的全文。
+
+```json
+{
+  "recordType": "direct.codex.turn_start",
+  "clientTurnId": "Abc123-def",
+  "sidecarPresent": true,
+  "promptSha256": "<sha256 hex of original user text UTF-8>",
+  "promptChars": 120,
+  "attachments": [
+    {
+      "name": "fast_gdd.md",
+      "localPath": "assets/uploads/upload-1788164530559-fast_gdd.md",
+      "mediaType": "text/markdown",
+      "size": 8119,
+      "status": "imported",
+      "contentSha256": "<sha256 hex or omit>",
+      "hashSkipped": null
+    }
+  ]
+}
+```
+
+- `attachments` 清洗复用 sidecar：`sanitize_attachment_name` / `media_type` / `status` / `local_path`。把这些函数改成 `pub(crate)`，审计模块不要复制一份。
+- 条数上限仍 8；超出只在 sidecar 文案里写「另有 N 个未展开」，账本 `attachments` 同样只留前 8，另加 `attachmentsOmitted: N`。
+- `sidecarPresent`：本轮渲染走了 Project 头（任一条有合法 path 或 status）。Home 形态不会出现在本账本（Home 不记账）。
+- `contentSha256`：对清洗后的 `localPath` 读项目文件做 SHA-256 小写 hex。文件不存在则省略 hash，`hashSkipped: "missing"`。超过 `DIRECT_CODEX_AUDIT_HASH_MAX_BYTES`（2 MiB）则 `hashSkipped: "too-large"`。`.agent` / `.git` / `..` 路径本来就不会出现在 sidecar 输出里。
+
+无附件：`attachments: []`，`sidecarPresent: false`，仍然写 `turn_start`。
+
+### 5.2 `item`
+
+仅 `item/completed`。`item/started` 和 `outputDelta` 不落盘。
+
+公共字段：
+
+```json
+{
+  "recordType": "direct.codex.item",
+  "clientTurnId": "Abc123-def",
+  "seq": 1,
+  "itemId": "item-…",
+  "itemType": "commandExecution",
+  "status": "completed"
+}
+```
+
+`seq` 从 1 起，按成功写入的 item 递增。`itemType` 取 Codex `item.type` 原词；未知类型仍记账 `itemType`，不附带未清洗 payload。
+
+按类型附加字段：
+
+| `item.type` | 追加 | 禁止 |
+|---|---|---|
+| `commandExecution` | `command` 截断 240 字；`exitCode`；`durationMs`；`actions[]` | `aggregatedOutput` |
+| `mcpToolCall` | `tool`、`server`（可省略默认 `agc_tools`）、`durationMs`、§5.4 参数 | `result`、`error` 原文（只留 `status` / `errorKind`） |
+| `fileChange` | `changes: [{ path, kind }]`，`kind` 为 `add` / `delete` / `update` | `diff`、`movePath` 的宿主绝对路径（相对化失败则整条 change 丢 path） |
+| `imageView` | `path` | 图像字节 |
+| `functionCallOutput` | `name`、`namespace` | `output` |
+| `webSearch` | `query` 截断 400 字 | 结果页正文 |
+| `agentMessage` / `userMessage` / `plan` / `reasoning` / `contextCompaction` / `hookPrompt` | **整类跳过**（终稿已在 jsonl；推理正文不是本账本） | — |
+| 其它未知 | 只留公共字段 | 原始 `item` 对象 |
+
+`commandExecution.actions[]`：
+
+```json
+{ "type": "read", "path": "assets/uploads/upload-…-fast_gdd.md", "contentSha256": "…", "hashSkipped": null }
+{ "type": "listFiles", "path": "assets" }
+{ "type": "search", "query": "fast_gdd", "path": null }
+{ "type": "unknown" }
+```
+
+- `Read.path` 先相对化再清洗；失败则该 action 记 `{ "type": "read", "pathRejected": true }`，不写绝对路径。
+- 相对化成功后，对磁盘文件按 §5.1 同一套 hash 规则补 `contentSha256`。
+- `command` 里若相对化失败，把 `command` 整段丢掉，改 `commandRedacted: true`（避免 `type C:\Users\…\fast_gdd.md` 进账本）。
+
+### 5.3 MCP 参数白名单
+
+只抄这些键，其它键丢弃。字符串再经 path 清洗或截断。
+
+| 工具 | 落盘参数 | 正文类字段 |
+|---|---|---|
+| `agc_list_project_files` | `path`、`query`（120）、`kind`、`offset`、`limit` | 无 |
+| `agc_write_file` | `path`、`contentChars`（`content` 的字符数，不是正文） | 不落 `content` |
+| `taonier_prepare_game_art` | `mode`、`brief`（截断 4000）、`briefChars`、`briefSha256` | **要 brief 原文**（分析定玩法的吸烟枪；上限已是 MCP 合同） |
+| `agc_generate_image` | `kind`、`aspectRatio`、`imageSize`、`assetName`、`outputPath`、`prompt` 截断 4000、`promptChars`、`promptSha256` | 不落 32k 全文 |
+| `agc_edit_image` | `sourceLocalAssetId`、`assetName`、`prompt` 截断 4000、`promptChars`、`promptSha256` | 同上 |
+| `agc_create_or_derive_resource` | `kind`、`mode`、`sourceLocalAssetId`、`assetName`、`prompt` 截断 4000、`promptChars`、`promptSha256` | MCP 上限已是 4000 |
+| `agc_list_registered_assets` | `kind`、`assetId`、`includeSequenceFrames`、`offset`、`limit` | 无 |
+| `agc_list_account_assets` | `folderId`、`query`、`offset`、`limit` | 无 |
+| `agc_import_account_assets` | `assetIds`（最多 8 个 id，超出 `assetIdsOmitted`）、`localPaths`（清洗后相对路径，最多 8） | 无 |
+| `agc_remove_background` | `sourceLocalAssetId`、`assetName` | 无 |
+| `agc_browser_playtest` | `attempt` | 无 |
+| `agc_web_search` | `query` 截断 400、`maxResults` | 无 |
+| `agc_read_skill_resource` | `skillName`、`relativePath` | 不落 Skill 正文 |
+| 未知 MCP 名 | 只留 `tool` + `status` | 不落 `arguments` |
+
+`brief` / 截断后的 `prompt` 是 **模型自己写的设计文本**，不是用户 GDD 转储。这是分析「仍走收集类」的关键，允许进 jsonl。`agent.db` 摘要只留 `briefPreview` 240 字。
+
+### 5.4 `turn_end`
+
+派生摘要，不是第二真相。字段必须能从本文件已写入的 `turn_start` + `item` 重算出来。
+
+```json
+{
+  "recordType": "direct.codex.turn_end",
+  "clientTurnId": "Abc123-def",
+  "completed": true,
+  "itemCount": 17,
+  "itemsTruncated": false,
+  "offeredRead": [
+    {
+      "localPath": "assets/uploads/upload-1788164530559-fast_gdd.md",
+      "read": false
+    }
+  ],
+  "firstDesign": {
+    "kind": "mcp:taonier_prepare_game_art",
+    "seq": 3,
+    "tool": "taonier_prepare_game_art",
+    "briefPreview": "俯视角收集冒险小游戏…"
+  }
+}
+```
+
+`offeredRead.read=true` 当且仅当本 attempt 内存在 `actions.type=read` 或 `imageView` 或 MCP 参数里的 `path` / `localPaths`，清洗后与 `localPath` 字符串相等。hash 对不上仍记 `read: true`，另加 `contentSha256Match: false`（读了另一份同路径文件或读时文件已变）。没有 hash 可对则省略 `contentSha256Match`。
+
+`firstDesign`：本 attempt 第一条满足任一条件的 item：
+
+1. MCP：`taonier_prepare_game_art` / `agc_generate_image` / `agc_edit_image` / `agc_create_or_derive_resource`
+2. `agc_write_file` 且 path 以 `game/` 开头或文件名是 `index.html`
+3. `fileChange` 且任一条 change path 满足 2
+
+列表、搜索、读、Skill 读取、账户素材查询、playtest、web_search **不算** firstDesign。没有则 `firstDesign: null`。
+
+`kind` 取值：`mcp:<tool>` / `write:<path>` / `fileChange:<path>`。
+
+### 5.5 `agent.db` 摘要
+
+```json
+{
+  "recordType": "direct.codex.turn",
+  "clientTurnId": "Abc123-def",
+  "turnLog": ".agent/runtime/direct-codex/turns/Abc123-def.jsonl",
+  "sidecarPresent": true,
+  "offeredCount": 1,
+  "offeredRead": [ { "localPath": "assets/uploads/…-fast_gdd.md", "read": false } ],
+  "firstDesign": { "kind": "mcp:taonier_prepare_game_art", "seq": 3, "briefPreview": "…" },
+  "itemCount": 17,
+  "itemsTruncated": false,
+  "completed": true,
+  "auditWriteFailed": false
+}
+```
+
+`turnLog` 必须是项目相对 POSIX。不要把 jsonl 全文复制进 `agent.db`。单条仍受 Ordinary 1 MiB 限制；摘要本身应远小于此。
+
+### 5.6 上限
+
+| 项 | 值 |
+|---|---|
+| 每回合 item 条数 | 256；超出再写一条 `recordType: "direct.codex.items_truncated"`，之后 item 丢弃但仍把 `turn_end.itemsTruncated=true` |
+| `command` | 240 字 |
+| `brief` / 生成类 `prompt` 落盘 | 4000 字 |
+| `briefPreview` | 240 字 |
+| 文件 hash | 2 MiB |
+| 附件条数 | 8（与 sidecar 相同） |
+| jsonl 单行 | 沿用现有 jsonl 追加上限；超长截断正文类字段，不截断结构 |
+
+## 6. 调用链
+
+```text
+chat_with_game_creator_direct_codex
+  规范化 clientTurnId
+  DirectCodexTurnAudit::start(root, clientTurnId, originalPrompt, attachments)
+      → 写 turn_start（fail-open）
+  render_direct_codex_user_prompt          // 现有 sidecar，不变
+  run_direct_game_creator_turn_at_with_creation_type_and_emitter(..., audit)
+      → Codex collect 循环在 DirectProject + item/completed 调 audit.observe_item
+  Ok/Err 都 audit.finish(completed)
+      → 写 turn_end + agent.db 摘要
+```
+
+- CLI `run_direct_game_creator_turn_at` **不** 接 audit（无 `clientTurnId`）。
+- Home command 不接 audit。
+- 不要把 attachments / audit 顺着 CLI inner、pool、ToolHost 往下传。
+- `DirectCodexTurnObservation` **不** 增加原始 `params`。审计走独立 `DirectCodexTurnAudit`，避免 stdout 正文进入 Tauri 事件。
+
+`direct_game_creator_codex_chat_at_with_optional_observer` 增加可选 `audit: Option<&mut DirectCodexTurnAudit>`，再传到 `run_turn_with_direct_observer`。仅 `workspace_mode == DirectProject` 且 `audit` 为 Some 时抽取。
+
+`run_direct_game_creator_turn_inner` 的 UI observer 保持只处理 `AccumulatedText` / `Activity`。
+
+回合失败（生成失败、浏览器试玩失败、回复落盘失败）：只要 `start` 过就 `finish(false)`，保留已观察到的 item。Codex 尚未启动则 `itemCount=0`。
+
+## 7. 失败语义
+
+审计 **不得** 把做游戏打失败。所有写盘包在 sink 内：
+
+- 单次追加失败：记内存 `audit_write_failed=true`，后续 item 仍尝试写；`finish` 时摘要带 `auditWriteFailed: true`。
+- 连摘要都写不进去：只在 Direct debug / 现有进度通道能承受的前提下忽略；不新增用户可见报错文案。
+- 不引入新的 Tauri 事件名。
+
+与 `conversation.write` 失败不同：助手终稿落盘失败仍按现有逻辑拒绝返回。审计失败不走那条。
+
+## 8. 安全
+
+- 路径：与 sidecar 同一套相对 POSIX 清洗；相对化失败不写原绝对路径。
+- 控制面：hash / 读文件只用 `resolve_local_project_path`；拒绝 `.agent` / `.git` / 敏感文件。这些路径若出现在 commandActions 里，只记 `pathRejected`。
+- 不把 `aggregated_output`、MCP result、function output、diff 暂存在内存再截断——抽取函数根本不读这些键。
+- jsonl 位于 `.agent/runtime/**`，现有 Direct 控制面边界禁止模型当普通项目文档读。
+- 前端观察者和审计 sink 分叉，禁止图省事 `observer(Item { params })`。
+
+## 9. 代码落地
+
+新增 [`apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_audit.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_audit.rs)：
+
+- `DirectCodexTurnAudit`
+- `start` / `observe_item` / `finish`
+- 相对化、hash、MCP 白名单、`firstDesign` / `offeredRead` 派生
+- 单元测试（见 §11）
+
+[`agent.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent.rs)：`mod direct_codex_audit` + `pub(crate) use`。
+
+[`direct_codex_attachments.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent/direct_codex_attachments.rs)：清洗函数改 `pub(crate)`，行为不变。
+
+[`codex_app_server.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs)：
+
+- `run_turn_with_direct_observer` / `direct_game_creator_codex_chat_at_with_optional_observer` 增加 `audit: Option<&mut DirectCodexTurnAudit>`
+- collect 循环 `Item { completed: true, .. }` 且 DirectProject 时 `audit.observe_item(&params)`
+- **不要** 把 `params` 塞进 `DirectCodexTurnObservation`
+- 现有 Home / ToolHost / 安全活动词测试保持逐字
+
+[`direct_runtime.rs`](../../apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs)：
+
+- `chat_with_game_creator_direct_codex` 创建 audit（原文 + attachments），Ok/Err 都 `finish`
+- 把 audit 传入 `run_direct_game_creator_turn_at_with_creation_type_and_emitter`
+- 该函数和 inner 增加可选 audit；CLI 入口签名不变
+
+不要给 `agc_write_file` / 每个 MCP handler 再写一份平行审计。
+
+前端、DTO、sidecar 文案、home.suite 附件断言：本期不改。不新增 UI。
+
+文档：落地提交时把本文状态改为「现行合同（已按本文落地）」；`decision-log.md` 记一条；不要把 08-30 技术说明改成已修复。
+
+## 10. 测试
+
+全部是 Rust 单元测试，用 fixture item JSON，不拉真 Codex。
+
+1. `turn_start`：原文 hash 稳定；sidecar 路径清洗后出现；非法 `../` 不进 attachments；无附件 `sidecarPresent=false`。
+2. 附件文件写入临时项目后 `contentSha256` 与直接 hash 一致；缺文件 `hashSkipped=missing`；超过 2 MiB `too-large`。
+3. `commandExecution` + `commandActions: [{type:read, path: <abs>}]` → 相对路径 + hash；`aggregatedOutput` 即使在 fixture 里也不出现在落盘 JSON。
+4. `Read` 相对化失败 → `pathRejected`，落盘 JSON 不含 `C:\\` / `Users`。
+5. `mcpToolCall` `taonier_prepare_game_art`：`brief` 保留；`result` 丢掉。
+6. `agc_write_file`：有 path 与 `contentChars`，无 content。
+7. `agc_generate_image`：32k prompt 只留 4000 + `promptChars` + sha256。
+8. `fileChange`：path + kind，无 diff。
+9. `offeredRead`：读路径等于 offered → `read=true`；只 list/search → `read=false`。
+10. `firstDesign`：先 read 再 art → kind 是 mcp art，seq 是 art 那条；只有 read → `null`。
+11. 第 257 条 item 触发 truncated，`turn_end.itemsTruncated=true`。
+12. `agent.db` 摘要含 `turnLog` 相对路径、`offeredRead`、`firstDesign.briefPreview`。
+13. 写盘注入失败：`finish` 不 panic、不返回 Err 给调用方（sink 方法是 `()`）。
+14. 未知 `item.type` 只留公共字段。
+15. 现有 DirectHome 活动词测试、sidecar 渲染测试不受影响。
+
+不测：真模型是否读 GDD、是否生成弹幕射击、浏览器验收文案。
+
+## 11. 验收（方案落地后的人工分析）
+
+用一次「上传 md + 做成游戏 / 首页做游戏」的本地项目：
+
+1. 存在 `.agent/runtime/direct-codex/turns/<clientTurnId>.jsonl`。
+2. `agent.db` 有对应 `direct.codex.turn`。
+3. `turn_start.attachments[].localPath` 与 sidecar 项目路径一致。
+4. jsonl **没有** GDD 正文、没有 `aggregatedOutput`、没有 patch。
+5. 能根据 `offeredRead` + `firstDesign` 填上 §3 四行表的其中一行，而不用猜隔离 session。
+6. 工作台气泡仍是用户原文；jsonl 对话仍无 sidecar。
+7. `npm run check:encoding`、`git diff --check`、相关 Rust 单测通过。
+
+## 12. 实现顺序
+
+1. `direct_codex_audit.rs` + 清洗函数 `pub(crate)` + fixture 测试
+2. `codex_app_server` collect 接 sink；观察者枚举不变
+3. GUI Direct command 创建 / finish sink
+4. encoding 与定向 `cargo test`
+5. 合入时改本文状态、decision-log、sidecar 文档里「native 审计另排期」那一行改为指向本文
+
+## 13. 与 sidecar / issue 的边界
+
+- sidecar：让模型 **知道路径**。已落地，合同不变。
+- 本账本：让人 **看见模型做了什么**。不替代 sidecar，也不在本方案里做强制读取。
+- issue #212 主问题仍是消费失败；本账本是为下一刀修复提供证据，不是把 212 关单。
diff --git a/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md b/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md
index 4de2f960b..4ac032b68 100644
--- a/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md
+++ b/docs/technical/【技术说明】DirectProject未消费用户上传权威文档-2026-08-30.md
@@ -206,6 +206,7 @@ Direct app-server 使用 ephemeral thread。stdout 中的 `item/started`、`item
 - 策划 run ID：`gameagent-cd7f6c81`
 - 做游戏 run ID：`gameagent-77b5aa31`
 - 上传 GDD（项目相对路径）：`assets/uploads/upload-1788083777445-fast_gdd.md`
+- 审计账本方案（已落地，不关闭本 Issue）：[`【技术方案】Direct回合行为审计账本-2026-08-31.md`](./【技术方案】Direct回合行为审计账本-2026-08-31.md)
 - 建议随 Issue 附上或引用对应 run 的以下复核材料：
   - Direct 对话：`.agent/conversations/project.jsonl`
   - Direct Agent DB：`.agent/agent.db`

From 933da91fa3ed2466575dcfbe01a259c568719ce5 Mon Sep 17 00:00:00 2001
From: Linghong <ink29535@proton.me>
Date: Tue, 1 Sep 2026 10:30:23 +0800
Subject: [PATCH 6/8] =?UTF-8?q?=E6=B8=85=E9=99=A4=E7=AD=96=E5=88=92agent?=
 =?UTF-8?q?=E4=B8=8D=E5=8F=AF=E8=BE=BE=E5=88=86=E6=94=AF=20(#234)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/234
Co-authored-by: Linghong <ink29535@proton.me>
Co-committed-by: Linghong <ink29535@proton.me>
---
 .../provider_request_builders.rs              | 154 ++++++++++--------
 .../runtime_protocol/planning_approval.rs     |  24 ---
 .../runtime_protocol/planning_storage.rs      |  38 ++---
 .../agent/runtime_protocol/planning_submit.rs |  52 +++---
 apps/ai-game-creator-shell/src/App.tsx        |  14 --
 .../ProjectWorkspaceChatPane.tsx              |  68 ++------
 .../tests/appSurface/plan-gdd.suite.ts        |  23 ++-
 7 files changed, 149 insertions(+), 224 deletions(-)

diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
index 030b89231..51e452b0f 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
@@ -715,36 +715,6 @@ fn build_game_creator_agent_background_tool_plan_request_at(
     ))
 }
 
-pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request(
-    root: &Path,
-    agent_id: &str,
-    session_id: &str,
-    run_id: &str,
-    task: &str,
-    observations: &[AgentRuntimeToolObservation],
-    loop_index: usize,
-) -> Result<
-    (
-        GameCreatorLlmConfig,
-        String,
-        LlmRunRequest,
-        String,
-        AgentRuntimeToolPlanRequestSnapshot,
-    ),
-    String,
-> {
-    build_game_creator_agent_background_tool_plan_request_at(
-        root,
-        None,
-        agent_id,
-        session_id,
-        run_id,
-        task,
-        observations,
-        loop_index,
-    )
-}
-
 pub(in crate::agent) fn build_game_creator_agent_background_tool_plan_request_locked(
     root: &Path,
     project_lock: &ProjectWriteLock,
@@ -972,17 +942,20 @@ mod tests {
     use crate::{update_manifest_task_status_at, GameCreationAppTaskStatus};
 
     use super::{
+        acquire_game_creator_agent_provider_plan_project_write_lock_with_wait,
         agent_runtime_root_source_at, bind_game_creator_agent_runtime_run_profile_at,
         build_game_creator_agent_background_final_reply_request,
-        build_game_creator_agent_background_tool_plan_request,
+        build_game_creator_agent_background_tool_plan_request_locked,
         game_creator_agent_context_preload_notice,
         game_creator_agent_runtime_run_profile_binding_path,
         game_creator_project_supervisor_chat_system_prompt, init_local_game_project_at,
         new_game_creation_app_seed_tasks, provider_command_exec_contract,
-        provider_command_start_contract, render_relaxed_autonomous_manifest_ready_task_background_prompt,
+        provider_command_start_contract,
+        render_relaxed_autonomous_manifest_ready_task_background_prompt,
         required_runtime_prompt_section, start_game_creator_agent_runtime_task_at,
         AgentRuntimeGoalContractAcceptanceNodeDraft, AgentRuntimeGoalContractDraft,
         AgentRuntimeTaskLink, AgentRuntimeToolObservation, AgentRuntimeToolPlan,
+        AgentRuntimeToolPlanRequestSnapshot, GameCreatorLlmConfig,
         AGENT_RUNTIME_AUTONOMOUS_PRE_MUTATION_LOOP_LIMIT,
         AGENT_RUNTIME_COMPLETION_BLOCKER_TOOL_PLAN_PROTOCOL,
         AGENT_RUNTIME_PLAN_AUTONOMOUS_PROFILE_UNSUPPORTED_KIND,
@@ -996,6 +969,40 @@ mod tests {
         RUNTIME_PROMPT_SUPERVISOR_CHAT_COMPOSITION,
     };
 
+    fn build_game_creator_agent_background_tool_plan_request_for_test(
+        root: &std::path::Path,
+        agent_id: &str,
+        session_id: &str,
+        run_id: &str,
+        task: &str,
+        observations: &[AgentRuntimeToolObservation],
+        loop_index: usize,
+    ) -> Result<
+        (
+            GameCreatorLlmConfig,
+            String,
+            platform_llm::LlmRunRequest,
+            String,
+            AgentRuntimeToolPlanRequestSnapshot,
+        ),
+        String,
+    > {
+        let lock = acquire_game_creator_agent_provider_plan_project_write_lock_with_wait(
+            root,
+            "test.provider_request.build.tool_plan",
+        )?;
+        build_game_creator_agent_background_tool_plan_request_locked(
+            root,
+            &lock,
+            agent_id,
+            session_id,
+            run_id,
+            task,
+            observations,
+            loop_index,
+        )
+    }
+
     fn native_input_required_fields(
         request: &platform_llm::LlmRunRequest,
         tool: &str,
@@ -1066,7 +1073,7 @@ mod tests {
             summary: "结构化计划更新被 Runtime 拒绝".to_string(),
             detail: Some("计划状态回退".to_string()),
         };
-        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request_for_test(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -1155,16 +1162,17 @@ mod tests {
         // Relaxed orchestration does not convert an idle planning counter into
         // a tool-removal gate; the Provider remains free to choose its next
         // action.
-        let (_, _, baseline, _, _) = build_game_creator_agent_background_tool_plan_request(
-            &root,
-            &state.agent_id,
-            &state.session_id,
-            &state.run_id,
-            &state.current_task,
-            &[],
-            1,
-        )
-        .expect("build baseline request");
+        let (_, _, baseline, _, _) =
+            build_game_creator_agent_background_tool_plan_request_for_test(
+                &root,
+                &state.agent_id,
+                &state.session_id,
+                &state.run_id,
+                &state.current_task,
+                &[],
+                1,
+            )
+            .expect("build baseline request");
         assert!(baseline
             .function_tools
             .iter()
@@ -1175,7 +1183,7 @@ mod tests {
         crate::agent::write_game_creator_agent_runtime_state(&root, &idle_state)
             .expect("persist idle rounds");
 
-        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request_for_test(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -1256,7 +1264,7 @@ mod tests {
             vec!["交付当前 manifest task".to_string()],
         )
         .expect("start autonomous ready child task");
-        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request_for_test(
             &root,
             agent_id,
             &state.session_id,
@@ -1506,7 +1514,7 @@ mod tests {
             vec!["冻结 Goal Contract".to_string()],
         )
         .expect("start trusted root");
-        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, request, _, _) = build_game_creator_agent_background_tool_plan_request_for_test(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -1566,7 +1574,7 @@ mod tests {
         )
         .expect("start plan root");
 
-        let (_, _, first, _, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, first, _, _) = build_game_creator_agent_background_tool_plan_request_for_test(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -1633,7 +1641,7 @@ mod tests {
             },
         )
         .expect("freeze plan contract");
-        let (_, _, later, _, _) = build_game_creator_agent_background_tool_plan_request(
+        let (_, _, later, _, _) = build_game_creator_agent_background_tool_plan_request_for_test(
             &root,
             &state.agent_id,
             &state.session_id,
@@ -1719,7 +1727,7 @@ mod tests {
         )
         .expect("start supervisor runtime state");
         let (_, _, supervisor_request, _, _) =
-            build_game_creator_agent_background_tool_plan_request(
+            build_game_creator_agent_background_tool_plan_request_for_test(
                 &root,
                 GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
                 &supervisor_state.session_id,
@@ -1865,16 +1873,17 @@ mod tests {
             vec!["核对普通说明".to_string()],
         )
         .expect("start ordinary runtime state");
-        let (_, _, ordinary_request, _, _) = build_game_creator_agent_background_tool_plan_request(
-            &root,
-            "code-prototype",
-            &ordinary_state.session_id,
-            &ordinary_state.run_id,
-            &ordinary_state.current_task,
-            &[],
-            0,
-        )
-        .expect("build ordinary planning request");
+        let (_, _, ordinary_request, _, _) =
+            build_game_creator_agent_background_tool_plan_request_for_test(
+                &root,
+                "code-prototype",
+                &ordinary_state.session_id,
+                &ordinary_state.run_id,
+                &ordinary_state.current_task,
+                &[],
+                0,
+            )
+            .expect("build ordinary planning request");
         assert!(ordinary_request.messages[0]
             .content
             .contains("你正在使用 Genarrative AI 游戏创作多智能体 Runtime"));
@@ -1989,16 +1998,17 @@ mod tests {
             vec!["读取需求并准备澄清".to_string()],
         )
         .expect("start planning child");
-        let (_, _, planning_request, _, _) = build_game_creator_agent_background_tool_plan_request(
-            &root,
-            GAME_CREATOR_PROJECT_PLANNING_AGENT_ID,
-            &planning_state.session_id,
-            &planning_state.run_id,
-            &planning_state.current_task,
-            &[],
-            0,
-        )
-        .expect("build planning request");
+        let (_, _, planning_request, _, _) =
+            build_game_creator_agent_background_tool_plan_request_for_test(
+                &root,
+                GAME_CREATOR_PROJECT_PLANNING_AGENT_ID,
+                &planning_state.session_id,
+                &planning_state.run_id,
+                &planning_state.current_task,
+                &[],
+                0,
+            )
+            .expect("build planning request");
         let planning_system_prompt = &planning_request.messages[0].content;
         let planning_brief_marker = "你是“立项策划 Agent”（`agentId=project-planning`）";
         assert!(planning_system_prompt.contains(planning_brief_marker));
@@ -2074,7 +2084,7 @@ mod tests {
         )
         .expect("start supervisor");
         let (_, _, supervisor_request, _, _) =
-            build_game_creator_agent_background_tool_plan_request(
+            build_game_creator_agent_background_tool_plan_request_for_test(
                 &root,
                 GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
                 &supervisor_state.session_id,
@@ -2183,7 +2193,7 @@ mod tests {
             },
         ];
         let (_, _, request, _, request_snapshot) =
-            build_game_creator_agent_background_tool_plan_request(
+            build_game_creator_agent_background_tool_plan_request_for_test(
                 &root,
                 GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
                 &state.session_id,
@@ -2209,7 +2219,7 @@ mod tests {
             ),
         });
         let (_, _, _, _, settled_request_snapshot) =
-            build_game_creator_agent_background_tool_plan_request(
+            build_game_creator_agent_background_tool_plan_request_for_test(
                 &root,
                 GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
                 &state.session_id,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_approval.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_approval.rs
index 691ddb02d..5a8e66b50 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_approval.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_approval.rs
@@ -216,23 +216,6 @@ pub(crate) fn pending_matches_receipt(
 /// Construct the independent planning pending projection after an external
 /// acceptance gate has succeeded.  M1C-1 does not decide whether the gate
 /// passed; the caller must supply that fact and the exact GDD identity.
-pub(crate) fn create_plan_gdd_approval_pending_at(
-    root: &Path,
-    gdd: &PlanGddV1,
-) -> Result<(), PlanningStorageError> {
-    if !crate::config::game_creator_planning_capability_enabled()
-        .map_err(|error| approval_error("PLAN_CAPABILITY_DISABLED", error))?
-    {
-        return Err(approval_error(
-            "PLAN_CAPABILITY_DISABLED",
-            "立项策划能力当前已停用",
-        ));
-    }
-    let _lock = acquire_project_write_lock(root, "planning.approval-pending.create")
-        .map_err(|error| approval_error("PLAN_DURABILITY_FAILED", error))?;
-    create_plan_gdd_approval_pending_locked(root, gdd)
-}
-
 pub(crate) fn create_plan_gdd_approval_pending_locked(
     root: &Path,
     gdd: &PlanGddV1,
@@ -2357,13 +2340,6 @@ pub(crate) fn plan_gdd_typed_completion_blocker_at_locked(
             ),
         ));
     }
-    if session.phase == "recovery_required" {
-        return Some(plan_gdd_completion_blocker(
-            "needs-reconciliation",
-            "planning session 仍处于 recovery_required，不能收束任务",
-            format!("gddVersion={}", latest.version),
-        ));
-    }
     None
 }
 
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_storage.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_storage.rs
index fba95f5d6..889d85f06 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_storage.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_storage.rs
@@ -2408,8 +2408,7 @@ pub(crate) fn validate_plan_session_successor(
         && next.active_run_id.is_some()
         && next.last_run_id == next.active_run_id.clone().unwrap_or_default();
     if next.run_profile_binding_fingerprint != previous.run_profile_binding_fingerprint
-        && (!active_run_changed
-            || !matches!(next.phase.as_str(), "collecting" | "revision_requested"))
+        && !active_run_changed
     {
         return Err(conflict(
             "session 只有在绑定新的 active planning child 时才能更换 Run Profile binding fingerprint",
@@ -2712,18 +2711,6 @@ pub(crate) fn canonical_plan_submit_gdd_input_bytes(
     Ok(bytes)
 }
 
-pub(crate) fn parse_plan_submit_gdd_input_bytes(
-    bytes: &[u8],
-) -> Result<PlanSubmitGddInputV1, PlanningStorageError> {
-    let value = parse_strict_canonical::<PlanSubmitGddInputV1>(
-        bytes,
-        "plan.submit_gdd input",
-        PLAN_GDD_MAX_BYTES,
-    )?;
-    validate_plan_submit_gdd_input(&value)?;
-    Ok(value)
-}
-
 pub(crate) fn validate_plan_gdd_chain(values: &[PlanGddV1]) -> Result<(), PlanningStorageError> {
     if values.len() > PLAN_MAX_VERSIONS as usize {
         return Err(PlanningStorageError::new(
@@ -5067,22 +5054,23 @@ mod tests {
     fn submit_input_has_strict_canonical_parser_and_runtime_field_boundary() {
         let value = golden_submit_input();
         let bytes = canonical_plan_submit_gdd_input_bytes(&value).expect("submit input bytes");
-        assert_eq!(
-            parse_plan_submit_gdd_input_bytes(&bytes).expect("parse input"),
-            value
-        );
+        let parse = |bytes: &[u8]| -> Result<PlanSubmitGddInputV1, PlanningStorageError> {
+            let value = parse_strict_canonical::<PlanSubmitGddInputV1>(
+                bytes,
+                "plan.submit_gdd input",
+                PLAN_GDD_MAX_BYTES,
+            )?;
+            validate_plan_submit_gdd_input(&value)?;
+            Ok(value)
+        };
+        assert_eq!(parse(&bytes).expect("parse input"), value);
         let mut newline = bytes.clone();
         newline.push(b'\n');
-        assert_eq!(
-            parse_plan_submit_gdd_input_bytes(&newline)
-                .unwrap_err()
-                .code(),
-            "PLAN_NON_CANONICAL_BYTES"
-        );
+        assert_eq!(parse(&newline).unwrap_err().code(), "PLAN_NON_CANONICAL_BYTES");
         let mut object = serde_json::from_slice::<serde_json::Value>(&bytes).expect("input json");
         object["projectId"] = serde_json::Value::String("forged-project".to_string());
         let forged = serde_json::to_vec(&object).expect("forged input");
-        assert!(parse_plan_submit_gdd_input_bytes(&forged).is_err());
+        assert!(parse(&forged).is_err());
     }
 
     #[test]
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_submit.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_submit.rs
index dfb10dbc6..94953a186 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_submit.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_submit.rs
@@ -1166,15 +1166,7 @@ fn validate_current_session_cas(
             "plan.submit_gdd 必须绑定当前活跃策划子 Run",
         ));
     }
-    // 这条 phase 判据实际只可能看到 `collecting`：上面的 activeRunId 判据要求
-    // session 绑着当前策划子 run，而 schema 不变量禁止 `awaiting_user_input`、
-    // `awaiting_gdd_approval`、`revision_requested`、`approved`、`rejected`、
-    // `recovery_required` 保留 activeRunId（planning_storage.rs 的
-    // 「session 进入审批/终态/recovery_required 后不得保留 activeRunId」）。
-    // 因此 revise/reject 之后能不能重做，不由这条门决定，而由 M1C-2b 的 continuation
-    // 起点 writer 决定——它必须以新 activeRunId 写 revision+1 successor，phase 只能落回
-    // `collecting`。这里保留 `revision_requested` 作为既有冗余，不再新增更多不可达分支。
-    if !matches!(session.phase.as_str(), "collecting" | "revision_requested") {
+    if session.phase != "collecting" {
         return Err(submit_error(
             "PLAN_PENDING_GDD_EXISTS",
             "当前 planning session 仍有未决 GDD",
@@ -1641,11 +1633,7 @@ fn project_submit_successors_locked(
         let source_session_matches_gdd = session_identity_matches_gdd
             && previous_session.session_revision == gdd.source_session_revision
             && previous_session.session_fingerprint == gdd.source_session_fingerprint
-            && previous_session.active_run_id.as_deref() == Some(gdd.created_by_run_id.as_str())
-            && matches!(
-                previous_session.phase.as_str(),
-                "collecting" | "revision_requested"
-            );
+            && previous_session.active_run_id.as_deref() == Some(gdd.created_by_run_id.as_str());
         if !session_identity_matches_gdd {
             recovery_pending = true;
         } else if same_ref {
@@ -1896,6 +1884,15 @@ mod tests {
     use std::fs;
     use std::path::PathBuf;
 
+    fn create_plan_gdd_approval_pending_for_test(
+        root: &std::path::Path,
+        gdd: &PlanGddV1,
+    ) -> Result<(), PlanningStorageError> {
+        let _lock = acquire_project_write_lock(root, "test.planning.approval-pending.create")
+            .map_err(|error| PlanningStorageError::new("PLAN_DURABILITY_FAILED", error))?;
+        create_plan_gdd_approval_pending_locked(root, gdd)
+    }
+
     fn valid_input() -> PlanSubmitGddInputV1 {
         PlanSubmitGddInputV1 {
             schema_version: PLAN_SUBMIT_INPUT_SCHEMA.to_string(),
@@ -3628,7 +3625,7 @@ mod tests {
             .expect("read submitted GDD")
             .pop()
             .expect("GDD exists");
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         let decision_input = approval_input(
             &gdd,
             "approve",
@@ -3654,13 +3651,13 @@ mod tests {
             .pop()
             .expect("GDD exists");
 
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         let pending = read_plan_gdd_approval_pending_locked(&root)
             .expect("read approval pending")
             .expect("pending exists");
         assert_eq!(pending.status, "awaiting_decision");
         // Recreating the exact card is an idempotent replay.
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("replay approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("replay approval pending");
 
         let mut forged_next = gdd.clone();
         forged_next.version = 2;
@@ -3669,7 +3666,7 @@ mod tests {
             "gdd-approval-00000000-0000-4000-8000-000000000003".to_string();
         forged_next.action_fingerprint = "4".repeat(64);
         forged_next.fingerprint = plan_gdd_fingerprint(&forged_next).expect("next fingerprint");
-        let stale = create_plan_gdd_approval_pending_at(&root, &forged_next)
+        let stale = create_plan_gdd_approval_pending_for_test(&root, &forged_next)
             .expect_err("a non-latest GDD cannot receive an approval card");
         assert_eq!(stale.code(), "PLAN_STALE_APPROVAL");
 
@@ -3684,7 +3681,7 @@ mod tests {
         )
         .expect("commit approval receipt");
         assert_eq!(decision.outcome, "committed");
-        let after_receipt = create_plan_gdd_approval_pending_at(&root, &gdd)
+        let after_receipt = create_plan_gdd_approval_pending_for_test(&root, &gdd)
             .expect_err("a receipt must close awaiting_decision recreation");
         assert_eq!(after_receipt.code(), "PLAN_STALE_APPROVAL");
         cleanup_fixture(root);
@@ -3698,7 +3695,7 @@ mod tests {
             .expect("read submitted GDD")
             .pop()
             .expect("GDD exists");
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
 
         let task_path =
             game_creator_agent_runtime_task_path(&root, GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID);
@@ -3738,7 +3735,7 @@ mod tests {
             .expect("read submitted GDD")
             .pop()
             .expect("GDD exists");
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         let _config_guard = crate::tests::write_test_local_config(
             r#"{"planning":{"capabilityEnabled":false}}"#.to_string(),
         );
@@ -3802,7 +3799,7 @@ mod tests {
         assert_eq!(blocker.status, "needs-reconciliation");
         assert!(blocker.summary.contains("审批 pending"));
 
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         let blocker = plan_gdd_completion_blocker_at_locked(
             &root,
             GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID,
@@ -3955,7 +3952,7 @@ mod tests {
             .expect("read submitted GDD")
             .pop()
             .expect("GDD exists");
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         decide_plan_gdd_at(
             &root,
             &approval_input(
@@ -4089,7 +4086,7 @@ mod tests {
     #[test]
     fn a_revision_comment_reaches_the_supervisor_conversation_once() {
         let (root, gdd, _root_runtime) = acceptance_gate_fixture(true);
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         decide_plan_gdd_at(
             &root,
             &approval_input(
@@ -4143,7 +4140,7 @@ mod tests {
             .expect("read submitted GDD")
             .pop()
             .expect("GDD exists");
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         decide_plan_gdd_at(
             &root,
             &approval_input(
@@ -4230,7 +4227,8 @@ mod tests {
                 .expect("read submitted GDD")
                 .pop()
                 .expect("GDD exists");
-            create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+            create_plan_gdd_approval_pending_for_test(&root, &gdd)
+                .expect("create approval pending");
             let first_input = approval_input(
                 &gdd,
                 action,
@@ -4461,7 +4459,7 @@ mod tests {
             .expect("read submitted GDD")
             .pop()
             .expect("GDD exists");
-        create_plan_gdd_approval_pending_at(&root, &gdd).expect("create approval pending");
+        create_plan_gdd_approval_pending_for_test(&root, &gdd).expect("create approval pending");
         let decision_input = approval_input(
             &gdd,
             "approve",
diff --git a/apps/ai-game-creator-shell/src/App.tsx b/apps/ai-game-creator-shell/src/App.tsx
index be8168f4e..f923269b7 100644
--- a/apps/ai-game-creator-shell/src/App.tsx
+++ b/apps/ai-game-creator-shell/src/App.tsx
@@ -11037,20 +11037,6 @@ export function App({
         projectSupervisorRuntime={projectSupervisorRuntime}
         projectSupervisorRuntimeError={projectSupervisorRuntimeError}
         projectSupervisorTransientReply={projectSupervisorTransientReply}
-        planGddState={planGddState}
-        planGddHydrateBusy={planGddHydrateBusy}
-        planGddDecisionBusy={planGddDecisionBusy}
-        planGddError={planGddError}
-        onPlanGddRefresh={() => void hydratePlanGddState()}
-        onPlanGddDecision={decidePlanGdd}
-        onMakeGameFromApprovedGdd={
-          onMakeGameFromApprovedGdd
-            ? () =>
-                onMakeGameFromApprovedGdd(
-                  localProject?.projectPath ?? projectPath,
-                )
-            : undefined
-        }
         queueAgentRunControlFromPanel={queueAgentRunControlFromPanel}
         queueOrExecuteProjectIndex={queueOrExecuteProjectIndex}
         queuePendingCommand={queuePendingCommand}
diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx b/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx
index 126e08dc3..f70d648c7 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/ProjectWorkspaceChatPane.tsx
@@ -25,8 +25,6 @@ import type {
   MemoryScope,
   PendingCommand,
   PendingUiConfirmation,
-  PlanGddDecisionAction,
-  PlanGddStateViewV1,
 } from '../../app/types';
 import type { ProjectAgentResultSummary } from '../../view/project-development';
 import {
@@ -47,13 +45,10 @@ import {
   taskGroupLabels,
   taskStatusLabels,
 } from '../project-summary/projectSummary';
-import { PlanGddSurface } from './GddApprovalCard';
 import {
   pendingCommandDetail,
   pendingCommandTitle,
 } from './pendingCommandPresentation';
-import { isPlanningLaneRuntime } from './planningLane';
-import { PlanningLaneRuntimeStrip } from './PlanningLaneRuntimeStrip';
 import { resolvePendingCommandProjectPath } from './projectCommandPolicy';
 
 type ProjectWorkspaceChatPaneProps = {
@@ -180,16 +175,6 @@ type ProjectWorkspaceChatPaneProps = {
   projectSupervisorRuntime: AgentRuntimeState | null;
   projectSupervisorRuntimeError: string;
   projectSupervisorTransientReply: string;
-  planGddState: PlanGddStateViewV1 | null;
-  planGddHydrateBusy: boolean;
-  planGddDecisionBusy: boolean;
-  planGddError: string | null;
-  onPlanGddRefresh: () => void;
-  onPlanGddDecision: (
-    action: PlanGddDecisionAction,
-    comment: string | null,
-  ) => Promise<void>;
-  onMakeGameFromApprovedGdd?: () => Promise<void>;
   queueAgentRunControlFromPanel: (action: 'kill' | 'retry' | 'resume') => void;
   queueOrExecuteProjectIndex: () => Promise<void>;
   queuePendingCommand: (command: PendingCommand) => void;
@@ -273,13 +258,6 @@ export function ProjectWorkspaceChatPane({
   projectSupervisorRuntime,
   projectSupervisorRuntimeError,
   projectSupervisorTransientReply,
-  planGddState,
-  planGddHydrateBusy,
-  planGddDecisionBusy,
-  planGddError,
-  onPlanGddRefresh,
-  onPlanGddDecision,
-  onMakeGameFromApprovedGdd,
   queueAgentRunControlFromPanel,
   queueOrExecuteProjectIndex,
   queuePendingCommand,
@@ -369,17 +347,6 @@ export function ProjectWorkspaceChatPane({
             </button>
           </div>
         </header>
-        <PlanGddSurface
-          state={planGddState}
-          active={isPlanningLaneRuntime(projectSupervisorRuntime)}
-          projectPath={projectPath}
-          hydrateBusy={planGddHydrateBusy}
-          decisionBusy={planGddDecisionBusy}
-          error={planGddError}
-          onRefresh={onPlanGddRefresh}
-          onDecision={onPlanGddDecision}
-          onMakeGame={onMakeGameFromApprovedGdd}
-        />
         <div className="chat-quick-actions" aria-label="预览快捷操作">
           <button
             type="button"
@@ -865,29 +832,18 @@ export function ProjectWorkspaceChatPane({
             </p>
           ) : null}
         </div>
-        {isPlanningLaneRuntime(projectSupervisorRuntime) ? (
-          <PlanningLaneRuntimeStrip
-            runtime={projectSupervisorRuntime}
-            error={projectSupervisorRuntimeError}
-            controlBusy={chatAgentBusy}
-            onSupervisorRetry={handleProjectSupervisorRetry}
-            onUserInput={handleProjectSupervisorUserInput}
-          />
-        ) : (
-          <ProjectSupervisorRuntimePanel
-            runtime={projectSupervisorRuntime}
-            error={projectSupervisorRuntimeError}
-            runtimeByAgentId={agentRuntimeById}
-            controlBusy={chatAgentBusy}
-            planGddAwaitingDecision={Boolean(planGddState?.pendingApproval)}
-            professionalResultsByAgentId={professionalAgentResultsById}
-            onToolAction={handleProjectSupervisorToolAction}
-            onSupervisorRetry={handleProjectSupervisorRetry}
-            onProfessionalToolAction={handleProjectProfessionalAgentToolAction}
-            onProfessionalRetry={handleProjectProfessionalAgentRetry}
-            onUserInput={handleProjectSupervisorUserInput}
-          />
-        )}
+        <ProjectSupervisorRuntimePanel
+          runtime={projectSupervisorRuntime}
+          error={projectSupervisorRuntimeError}
+          runtimeByAgentId={agentRuntimeById}
+          controlBusy={chatAgentBusy}
+          professionalResultsByAgentId={professionalAgentResultsById}
+          onToolAction={handleProjectSupervisorToolAction}
+          onSupervisorRetry={handleProjectSupervisorRetry}
+          onProfessionalToolAction={handleProjectProfessionalAgentToolAction}
+          onProfessionalRetry={handleProjectProfessionalAgentRetry}
+          onUserInput={handleProjectSupervisorUserInput}
+        />
         {pendingCommand ? (
           <div className="pending-command">
             <span>
diff --git a/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts
index 1960bd5cd..e87da4da5 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/plan-gdd.suite.ts
@@ -4,21 +4,34 @@ import { resolve } from 'node:path';
 import { PlanGddStageProgress } from '../../src/features/project-workspace/GddApprovalCard';
 import {
   agentRuntimeUserInputRequest,
+  App,
   createPlanGddStateView,
   createProjectSupervisorRuntimeHarness,
   expect,
   fireEvent,
   it,
-  openMainProject,
   React,
   render,
-  renderAppAt,
   screen,
   vi,
   waitFor,
   within,
 } from './harness';
 
+function mountFormalSupervisor(
+  harness: ReturnType<typeof createProjectSupervisorRuntimeHarness>,
+) {
+  window.history.pushState({}, '', '/');
+  render(
+    React.createElement(App, {
+      initialProjectPath: harness.projectPath,
+      orchestrationMode: 'single-supervisor',
+      planningStartMode: true,
+      projectSupervisorOnly: true,
+    }),
+  );
+}
+
 async function mountApprovalCard(
   harness: ReturnType<typeof createProjectSupervisorRuntimeHarness>,
 ) {
@@ -26,8 +39,7 @@ async function mountApprovalCard(
     core: { invoke: harness.invoke },
     event: { listen: harness.listen },
   };
-  renderAppAt('/');
-  await openMainProject(harness.projectPath);
+  mountFormalSupervisor(harness);
   return await screen.findByLabelText('GDD 审批卡');
 }
 
@@ -38,8 +50,7 @@ async function mountPlanningSurface(
     core: { invoke: harness.invoke },
     event: { listen: harness.listen },
   };
-  renderAppAt('/');
-  await openMainProject(harness.projectPath);
+  mountFormalSupervisor(harness);
   return await screen.findByLabelText('立项策划阶段进度');
 }
 

From f0142f70193e624e520e0879638e363ed52a9252 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=91=A3=E7=BE=BD=E7=A7=A6?= <suzmii@qq.com>
Date: Tue, 1 Sep 2026 14:27:39 +0800
Subject: [PATCH 7/8] =?UTF-8?q?Close213/215=20=E6=9C=AC=E5=9C=B0=E8=B5=84?=
 =?UTF-8?q?=E6=BA=90=E6=B3=A8=E5=86=8C=E4=B8=8E=E5=90=8E=E5=8F=B0=E8=A1=A8?=
 =?UTF-8?q?=E6=9F=A5=E8=AF=A2=20(#232)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## 关联 Issue

- Close #213：补充本地资源注册类型
- Close #215：后台表查询添加字段查询

## 背景

本 PR 合并处理两个规模较小、已完成统一 review 的客户端与后台能力改动，整体已基于远端最新 master。

## 本地资源注册（#213）

- AGC 本地项目资源支持图片、字体、音频、视频、文档和代码类型。
- 支持 PNG/JPEG/WEBP/GIF/SVG/AVIF/BMP、TTF/OTF/WOFF/WOFF2、MP3/WAV/OGG/FLAC/M4A/AAC/OPUS、MP4/WEBM/MOV，以及常见文本、配置和源码扩展名。
- 同步更新 Direct Tool Bridge、MCP schema、Runtime/Provider Prompt、AGC Skill 文档和技术方案。
- 保留项目相对路径、敏感目录、符号链接、文件大小、字体解析、UTF-8、项目锁、manifest/revision 和幂等语义。
- 修复从 game 等目录复制到 assets/uploads 时扩展名退化为 .bin 的问题。

## 后台表查询（#215）

- 使用结构化筛选条件替换手写筛选 JSON。
- 支持多条件、比较、包含、前后缀、列表、空值和旧 JSON object 兼容。
- 优化预览表格、详情复制、Toast、JSON 预览和排序交互。
- 修复数字范围筛选，包括数据库字符串化数字的数值比较。
- 补充前后端回归测试与文档。

## 验证

- AGC 本地资源导入测试：6/6
- AGC Direct/MCP 工具测试：8/8
- 本地资源扩展名与 Prompt 映射回归测试通过
- 后台 admin 数据库测试：17/17
- 后台页面 Vitest：16/16
- `npm run admin-web:typecheck`
- `npm run admin-web:build`
- `npm run check:encoding`
- `git diff --check`
- `rustfmt --edition 2024 --check server-rs/crates/api-server/src/admin.rs`

## 限制

- 未执行真实生产 SpacetimeDB、OSS 或其它付费服务验证。
- Native shell CI 及其它 PR CI 以最新 head 的远端结果为准。
- 当前 PR 保持 WIP，待 reviewer 基于最新 head 重新 review。

Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/232
Co-authored-by: 董羽秦 <suzmii@qq.com>
Co-committed-by: 董羽秦 <suzmii@qq.com>
---
 .../admin-database-table-query-2026-05-08.md  |   7 +-
 .../pages/AdminDatabaseTablesPage.test.tsx    | 407 +++++++-
 .../src/pages/AdminDatabaseTablesPage.tsx     | 939 ++++++++++++++++--
 apps/admin-web/src/styles/admin.css           | 679 ++++++++++++-
 apps/admin-web/src/styles/admin.test.ts       |  35 +-
 .../agc-skills/agc-client-projection/SKILL.md |   2 +-
 .../references/projection-contract.md         |   2 +-
 .../agc-skills/agc-project-structure/SKILL.md |   2 +-
 .../references/structure-contract.md          |   2 +-
 .../resources/agc-skills/manifest.json        |   4 +-
 .../src-tauri/src/agent/direct_runtime.rs     |   2 +-
 .../src-tauri/src/agent/direct_tool_bridge.rs |  46 +-
 .../src-tauri/src/agent/direct_tools_mcp.rs   |  17 +-
 .../src/agent/generation/prompt_context.rs    |  41 +-
 .../provider_request_builders.rs              |   4 +-
 .../src/agent/runtime_tools/context.rs        |   4 +-
 .../src-tauri/src/agent_native_tools.rs       |   2 +-
 .../src-tauri/src/assets.rs                   | 123 ++-
 .../src-tauri/src/commands.rs                 | 307 +++++-
 ...�案】AI游戏创作智能体App实施计划-2026-06-24.md |   2 +-
 ...发运维】本地开发验证与生产运维-2026-05-15.md |   4 +-
 server-rs/crates/api-server/src/admin.rs      | 525 +++++++++-
 .../crates/shared-contracts/src/admin.rs      |   4 +
 23 files changed, 2912 insertions(+), 248 deletions(-)

diff --git a/.codex/skills/genarrative-admin-backoffice/references/admin-database-table-query-2026-05-08.md b/.codex/skills/genarrative-admin-backoffice/references/admin-database-table-query-2026-05-08.md
index 63ba34365..0f9adf8b9 100644
--- a/.codex/skills/genarrative-admin-backoffice/references/admin-database-table-query-2026-05-08.md
+++ b/.codex/skills/genarrative-admin-backoffice/references/admin-database-table-query-2026-05-08.md
@@ -2,7 +2,7 @@
 
 ## 需求落点
 - 后台“总览”页的表统计仍保留，只把每张表的表名改成可点击跳转到 `#tables?table=<name>`。
-- 新增独立 `#tables` 页承载表选择、关键词搜索、JSON filters、limit、行详情弹窗。
+- 新增独立 `#tables` 页承载表选择、关键词搜索、结构化字段筛选、limit、行详情弹窗（详情内保留字段复制，列头漏斗按钮可按列添加条件；每条条件可勾选启用或停用，停用时保留字段和值；`in` / `notIn` 使用逐项值标签，支持粘贴多行值，逗号不再作为隐式分隔符）。
 
 ## 后端实现要点
 - 新增只读接口：
@@ -13,12 +13,13 @@
 - `search` / `filters` 不进入 SQL 字符串：
   - SQL 只负责 `SELECT * FROM {table_name} LIMIT {limit}`
   - 返回后在 api-server 内存中过滤
-  - `filters` 仅接受 JSON object，按列名匹配；非 object 直接 400
+  - `filters` 接受两种 JSON 形式：object（列名到等值，如 `{"user_id":"u1"}`）与条件数组（如 `[{"column":"points","op":"gt","value":"5"}]`，运算符含 `eq`、`ne`、`gt`、`gte`、`lt`、`lte`、`contains`、`notContains`、`startsWith`、`endsWith`、`in`、`notIn`、`isEmpty`、`isNotEmpty`，允许同列多条件，条件间为 AND）；非 object 且非数组直接 400，未知运算符或 value 形态不匹配也 400。数组中的 `eq` / `ne` 和其他标量运算符一样必须提供 `value`；显式空值判断使用 `isEmpty` / `isNotEmpty`
 - SpacetimeDB HTTP SQL 返回可能是 statement array + rows，解析时要兼容这一层结构。
 
 ## 前端实现要点
 - `adminRoutes` 必须新增 `tables`，`AdminShell.routeIcons` 也要同步覆盖。
 - `AdminApp` 需要显式渲染 `AdminDatabaseTablesPage`。
+- 预览表格数据行直接点击（或行自身聚焦后按 Enter / Space）打开详情，行内按钮 / 输入控件的键盘操作不冒泡打开详情；详情按钮不单独占列。详情字段仅提供复制操作，成功、剪贴板失败和空字段复制都使用右下角自动消失的 Toast，JSON 预览与平台亮色 / 暗色主题保持一致，表头保持单行并在空间不足时省略显示。表单和标题区查询按钮共用筛选完整性校验。
 - worktree 下可能没有本地 `node_modules/typescript/bin/tsc`，而根目录有依赖；在验证前可以临时把根目录 `node_modules` 软链到 worktree 再执行 `npm run admin-web:typecheck`，验证后删除软链，避免污染 git 状态。
 
 ## 验证结果
@@ -26,4 +27,4 @@
 - `cargo fmt --manifest-path Cargo.toml -p api-server -p shared-contracts --check` 通过。
 - `npm run admin-web:typecheck` 通过。
 - `npm run admin-web:build` 通过。
-- `npm run check:encoding` 通过。
\ No newline at end of file
+- `npm run check:encoding` 通过。
diff --git a/apps/admin-web/src/pages/AdminDatabaseTablesPage.test.tsx b/apps/admin-web/src/pages/AdminDatabaseTablesPage.test.tsx
index d6bf2e71f..d246812c6 100644
--- a/apps/admin-web/src/pages/AdminDatabaseTablesPage.test.tsx
+++ b/apps/admin-web/src/pages/AdminDatabaseTablesPage.test.tsx
@@ -8,6 +8,7 @@ import {
   getAdminDatabaseTableRows,
   getAdminDatabaseTables,
 } from '../api/adminApiClient';
+import type { AdminDatabaseTableRowsResponse } from '../api/adminApiTypes';
 import {
   AdminDatabaseTablesPage,
   resolveAdminDatabaseUserReference,
@@ -23,7 +24,10 @@ vi.mock('../api/adminApiClient', () => ({
 }));
 
 vi.mock('../components/AdminUserReferenceButton', () => ({
-  AdminUserReferenceButton: ({ userId, publicUserCode }: {
+  AdminUserReferenceButton: ({
+    userId,
+    publicUserCode,
+  }: {
     userId?: string;
     publicUserCode?: string;
   }) => (
@@ -68,6 +72,7 @@ const referralRows = [
 ];
 
 beforeEach(() => {
+  vi.clearAllMocks();
   window.location.hash = '#tables?table=profile_referral_relation';
   vi.mocked(getAdminDatabaseTables).mockResolvedValue({
     fetchErrors: [],
@@ -124,7 +129,10 @@ test('后台表查询页通过页面级固定栏翻页并提示扫描结果可
     ),
   ).toBeTruthy();
 
-  await user.type(screen.getByRole('textbox', { name: '关键词' }), '未执行条件');
+  await user.type(
+    screen.getByRole('textbox', { name: '关键词' }),
+    '未执行条件',
+  );
   await user.click(screen.getByRole('button', { name: '下一页' }));
 
   await waitFor(() => {
@@ -141,6 +149,53 @@ test('后台表查询页通过页面级固定栏翻页并提示扫描结果可
   });
 });
 
+test('后台表查询页不会让旧表请求覆盖新表结果', async () => {
+  const user = userEvent.setup();
+  let resolveFirstRequest!: (response: AdminDatabaseTableRowsResponse) => void;
+  const firstRequest = new Promise<AdminDatabaseTableRowsResponse>(
+    (resolve) => {
+      resolveFirstRequest = resolve;
+    },
+  );
+  const oldTableResponse = {
+    columns: ['id'],
+    limit: 100,
+    page: 1,
+    rows: [{ cells: { id: 'old-row' }, raw: ['old-row'] }],
+    scannedCount: 1,
+    scanLimit: 50000,
+    scanLimitReached: false,
+    tableName: 'profile_referral_relation',
+    totalMatched: 1,
+    totalReturned: 1,
+  } satisfies AdminDatabaseTableRowsResponse;
+  const newTableResponse = {
+    ...oldTableResponse,
+    rows: [{ cells: { id: 'new-row' }, raw: ['new-row'] }],
+    tableName: 'profile_wallet',
+  } satisfies AdminDatabaseTableRowsResponse;
+  vi.mocked(getAdminDatabaseTables).mockResolvedValueOnce({
+    fetchErrors: [],
+    tables: ['profile_referral_relation', 'profile_wallet'],
+  });
+  vi.mocked(getAdminDatabaseTableRows)
+    .mockImplementationOnce(() => firstRequest)
+    .mockResolvedValueOnce(newTableResponse);
+
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+  const tableSelect = await screen.findByRole('combobox');
+  await user.selectOptions(tableSelect, 'profile_wallet');
+
+  expect(await screen.findByText('new-row')).toBeTruthy();
+  resolveFirstRequest(oldTableResponse);
+  await waitFor(() => {
+    expect(screen.queryByText('old-row')).toBeNull();
+  });
+  expect(screen.getByText('new-row')).toBeTruthy();
+});
+
 test('后台表查询页把表头排序交给后端并从第一页展示排序结果', async () => {
   const user = userEvent.setup();
   const { container } = render(
@@ -165,7 +220,9 @@ test('后台表查询页把表头排序交给后端并从第一页展示排序
   ).toBe('原始表名：profile_referral_relation。邀请关系记录表。');
   expect(
     screen.getByRole('button', { name: '被邀请人ID' }).getAttribute('title'),
-  ).toBe('原始字段名：invitee_user_id。被邀请人的用户标识。点击可按此列排序。');
+  ).toBe(
+    '原始字段名：invitee_user_id。被邀请人的用户标识。点击列名可在正序、倒序和不排序之间循环切换。 当前状态：不排序。',
+  );
   expect(readFirstColumnValues(container)).toEqual(['u-b', 'u-a', 'u-c']);
 
   vi.mocked(getAdminDatabaseTableRows).mockResolvedValueOnce({
@@ -219,6 +276,88 @@ test('后台表查询页把表头排序交给后端并从第一页展示排序
     );
     expect(readFirstColumnValues(container)).toEqual(['u-a', 'u-b', 'u-c']);
   });
+
+  vi.mocked(getAdminDatabaseTableRows).mockResolvedValueOnce({
+    columns: ['invitee_user_id', 'inviter_user_id', 'invite_code', 'bound_at'],
+    limit: 100,
+    page: 1,
+    rows: referralRows,
+    scannedCount: 3,
+    scanLimit: 50000,
+    scanLimitReached: false,
+    tableName: 'profile_referral_relation',
+    totalMatched: 3,
+    totalReturned: 3,
+  });
+  await user.click(screen.getByRole('button', { name: '邀请人ID' }));
+  await waitFor(() => {
+    expect(getAdminDatabaseTableRows).toHaveBeenLastCalledWith(
+      'admin-token',
+      'profile_referral_relation',
+      expect.objectContaining({
+        page: 1,
+        sortColumn: undefined,
+        sortDirection: undefined,
+      }),
+    );
+    expect(
+      screen
+        .getAllByRole('columnheader', { name: '邀请人ID' })
+        .filter((header) => header.textContent?.trim() === '邀请人ID')
+        .some((header) => header.getAttribute('aria-sort') === 'none'),
+    ).toBe(true);
+  });
+});
+
+test('后台表查询页行详情将对象值以语法高亮 JSON 预览', async () => {
+  const user = userEvent.setup();
+  const writeText = vi.fn().mockResolvedValue(undefined);
+  Object.defineProperty(navigator, 'clipboard', {
+    configurable: true,
+    value: { writeText },
+  });
+  vi.mocked(getAdminDatabaseTableRows).mockResolvedValueOnce({
+    columns: ['id', 'metadata'],
+    limit: 100,
+    page: 1,
+    rows: [
+      {
+        cells: {
+          id: 'row-1',
+          metadata: { enabled: true, count: 2, label: 'demo' },
+        },
+        raw: ['row-1', { enabled: true, count: 2, label: 'demo' }],
+      },
+    ],
+    scannedCount: 1,
+    scanLimit: 50000,
+    scanLimitReached: false,
+    tableName: 'profile_referral_relation',
+    totalMatched: 1,
+    totalReturned: 1,
+  });
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('row-1');
+  expect(screen.queryByRole('button', { name: /^详情$/ })).toBeNull();
+  await user.click(screen.getByRole('row', { name: /row-1/ }));
+
+  const jsonPreview = document.querySelector('pre.admin-json-preview');
+  expect(jsonPreview).toBeTruthy();
+  expect(jsonPreview?.querySelector('.admin-json-token-key')).toBeTruthy();
+  expect(jsonPreview?.querySelector('.admin-json-token-boolean')).toBeTruthy();
+  expect(jsonPreview?.querySelector('.admin-json-token-number')).toBeTruthy();
+  expect(jsonPreview?.querySelector('.admin-json-token-string')).toBeTruthy();
+  expect(screen.getAllByRole('button', { name: /^复制/ })).toHaveLength(2);
+  await user.click(screen.getByRole('button', { name: '复制元数据' }));
+  await waitFor(() => {
+    expect(writeText).toHaveBeenCalledWith(
+      JSON.stringify({ enabled: true, count: 2, label: 'demo' }, null, 2),
+    );
+  });
+  expect(screen.getByRole('status').textContent).toBe('已复制 元数据');
 });
 
 test('数据库用户字段显示查看按钮且点击不会打开行详情', async () => {
@@ -227,11 +366,28 @@ test('数据库用户字段显示查看按钮且点击不会打开行详情', as
     <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
   );
 
-  const userButton = await screen.findByRole('button', { name: '查看用户 u-b' });
+  const userButton = await screen.findByRole('button', {
+    name: '查看用户 u-b',
+  });
   await user.click(userButton);
   expect(screen.queryByRole('dialog')).toBeNull();
 });
 
+test('数据库用户查看按钮上的键盘操作不会同时打开行详情', async () => {
+  const user = userEvent.setup();
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  const userButton = await screen.findByRole('button', {
+    name: '查看用户 u-b',
+  });
+  userButton.focus();
+  await user.keyboard('{Enter}');
+
+  expect(screen.queryByRole('dialog')).toBeNull();
+});
+
 test('数据库用户字段识别会排除后台操作者与合成邀请码字段', () => {
   expect(
     resolveAdminDatabaseUserReference('profile_wallet', 'owner_user_id', 'u-1'),
@@ -250,13 +406,254 @@ test('数据库用户字段识别会排除后台操作者与合成邀请码字
     resolveAdminDatabaseUserReference('audit_log', 'admin_user_id', 'u-1'),
   ).toBeNull();
   expect(
-    resolveAdminDatabaseUserReference('profile_wallet', 'user_id', 'admin:root'),
+    resolveAdminDatabaseUserReference(
+      'profile_wallet',
+      'user_id',
+      'admin:root',
+    ),
   ).toBeNull();
   expect(
     resolveAdminDatabaseUserReference('profile_invite_code', 'user_id', 'u-1'),
   ).toBeNull();
 });
 
+test('后台表查询页字段条件构建后透传 filters 并支持列表值', async () => {
+  const user = userEvent.setup();
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('u-b');
+
+  await user.click(screen.getByRole('button', { name: '添加条件' }));
+  expect(screen.getAllByRole('columnheader', { name: '字段' })).toHaveLength(1);
+  expect(screen.getAllByRole('columnheader', { name: '条件' })).toHaveLength(1);
+  expect(screen.getAllByRole('columnheader', { name: '值' })).toHaveLength(1);
+  await user.selectOptions(
+    screen.getByRole('combobox', { name: '条件 1 字段' }),
+    'invite_code',
+  );
+  await user.type(
+    screen.getByRole('textbox', { name: '条件 1 值' }),
+    'INV-1001',
+  );
+  await user.click(screen.getByRole('button', { name: '添加条件' }));
+  await user.selectOptions(
+    screen.getByRole('combobox', { name: '条件 2 字段' }),
+    'inviter_user_id',
+  );
+  await user.selectOptions(
+    screen.getByRole('combobox', { name: '条件 2 运算符' }),
+    'in',
+  );
+  expect(screen.getByLabelText('条件 2 值列表').className).toContain(
+    'admin-database-filter-list-editor',
+  );
+  await user.type(
+    screen.getByRole('textbox', { name: '条件 2 值输入' }),
+    'u-a,b',
+  );
+  await user.click(screen.getByRole('button', { name: '添加条件 2 的值' }));
+  await user.type(
+    screen.getByRole('textbox', { name: '条件 2 值输入' }),
+    'u-c',
+  );
+  await user.click(screen.getByRole('button', { name: '添加条件 2 的值' }));
+  expect(
+    screen.getByText('u-a,b').closest('.admin-database-filter-values-row'),
+  ).toBeTruthy();
+  expect(
+    screen
+      .getAllByText('u-c')
+      .some((element) => element.closest('.admin-database-filter-values-row')),
+  ).toBe(true);
+  await user.click(getFormSubmitQueryButton());
+
+  await waitFor(() => {
+    expect(getAdminDatabaseTableRows).toHaveBeenLastCalledWith(
+      'admin-token',
+      'profile_referral_relation',
+      expect.objectContaining({
+        filters: JSON.stringify([
+          { column: 'invite_code', op: 'eq', value: 'INV-1001' },
+          {
+            column: 'inviter_user_id',
+            op: 'in',
+            value: ['u-a,b', 'u-c'],
+          },
+        ]),
+        page: 1,
+      }),
+    );
+  });
+});
+
+test('后台表查询页可以勾选或取消勾选条件来切换筛选组合', async () => {
+  const user = userEvent.setup();
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('u-b');
+
+  await user.click(screen.getByRole('button', { name: '添加条件' }));
+  await user.selectOptions(
+    screen.getByRole('combobox', { name: '条件 1 字段' }),
+    'invite_code',
+  );
+  await user.type(
+    screen.getByRole('textbox', { name: '条件 1 值' }),
+    'INV-1001',
+  );
+  await user.click(screen.getByRole('button', { name: '添加条件' }));
+  await user.selectOptions(
+    screen.getByRole('combobox', { name: '条件 2 字段' }),
+    'inviter_user_id',
+  );
+  await user.type(screen.getByRole('textbox', { name: '条件 2 值' }), 'u-a');
+  await user.click(screen.getByRole('checkbox', { name: '启用条件 2' }));
+  await user.click(getFormSubmitQueryButton());
+
+  await waitFor(() => {
+    expect(getAdminDatabaseTableRows).toHaveBeenLastCalledWith(
+      'admin-token',
+      'profile_referral_relation',
+      expect.objectContaining({
+        filters: JSON.stringify([
+          { column: 'invite_code', op: 'eq', value: 'INV-1001' },
+        ]),
+        page: 1,
+      }),
+    );
+  });
+});
+
+test('后台表查询页会提示未完成的启用条件而不是静默忽略', async () => {
+  const user = userEvent.setup();
+  const rowsRequest = vi.mocked(getAdminDatabaseTableRows);
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('u-b');
+  rowsRequest.mockClear();
+  await user.click(screen.getByRole('button', { name: '添加条件' }));
+  await user.click(getFormSubmitQueryButton());
+
+  expect(await screen.findByText('条件 1 未完成，请补充后再查询')).toBeTruthy();
+  expect(rowsRequest).not.toHaveBeenCalled();
+});
+
+test('后台表查询页顶部查询按钮会提示未完成的启用条件而不是静默忽略', async () => {
+  const user = userEvent.setup();
+  const rowsRequest = vi.mocked(getAdminDatabaseTableRows);
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('u-b');
+  rowsRequest.mockClear();
+  await user.click(screen.getByRole('button', { name: '添加条件' }));
+  await user.click(getHeadingQueryButton());
+
+  expect(await screen.findByText('条件 1 未完成，请补充后再查询')).toBeTruthy();
+  expect(rowsRequest).not.toHaveBeenCalled();
+});
+
+test('后台表查询页列头筛选按钮会带字段添加条件', async () => {
+  const user = userEvent.setup();
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('u-b');
+
+  await user.click(
+    screen.getByRole('button', { name: '按被邀请人ID添加条件' }),
+  );
+  const columnSelect = screen.getByRole('combobox', {
+    name: '条件 1 字段',
+  }) as HTMLSelectElement;
+  expect(columnSelect.value).toBe('invitee_user_id');
+  await user.type(screen.getByRole('textbox', { name: '条件 1 值' }), 'u-b');
+  await user.click(getFormSubmitQueryButton());
+
+  await waitFor(() => {
+    expect(getAdminDatabaseTableRows).toHaveBeenLastCalledWith(
+      'admin-token',
+      'profile_referral_relation',
+      expect.objectContaining({
+        filters: JSON.stringify([
+          { column: 'invitee_user_id', op: 'eq', value: 'u-b' },
+        ]),
+        page: 1,
+      }),
+    );
+  });
+});
+
+test('后台表查询页行详情仅保留复制操作', async () => {
+  const user = userEvent.setup();
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('u-b');
+  await user.click(screen.getByText('INV-1001').closest('tr')!);
+  expect(await screen.findByRole('dialog')).toBeTruthy();
+  expect(screen.queryByRole('button', { name: '按邀请码筛选' })).toBeNull();
+  expect(screen.getAllByRole('button', { name: /^复制/ })).toHaveLength(4);
+});
+
+test('后台表查询页空字段详情复制会明确提示无法复制空值', async () => {
+  const user = userEvent.setup();
+  const writeText = vi.fn();
+  Object.defineProperty(navigator, 'clipboard', {
+    configurable: true,
+    value: { writeText },
+  });
+  vi.mocked(getAdminDatabaseTableRows).mockResolvedValueOnce({
+    columns: ['id', 'deleted_at'],
+    limit: 100,
+    page: 1,
+    rows: [
+      {
+        cells: {
+          id: 'row-null',
+          deleted_at: null,
+        },
+        raw: ['row-null', null],
+      },
+    ],
+    scannedCount: 1,
+    scanLimit: 50000,
+    scanLimitReached: false,
+    tableName: 'profile_referral_relation',
+    totalMatched: 1,
+    totalReturned: 1,
+  });
+  render(
+    <AdminDatabaseTablesPage token="admin-token" onUnauthorized={vi.fn()} />,
+  );
+
+  await screen.findByText('row-null');
+  await user.click(screen.getByText('row-null').closest('tr')!);
+  await user.click(screen.getByRole('button', { name: '复制删除时间' }));
+
+  expect(screen.getByRole('alert').textContent).toBe('该字段为空，无法复制');
+  expect(writeText).not.toHaveBeenCalled();
+});
+
+function getFormSubmitQueryButton() {
+  const buttons = screen.getAllByRole('button', { name: '查询' });
+  return buttons[buttons.length - 1]!;
+}
+
+function getHeadingQueryButton() {
+  const buttons = screen.getAllByRole('button', { name: '查询' });
+  return buttons[0]!;
+}
+
 function readFirstColumnValues(container: HTMLElement) {
   return Array.from(container.querySelectorAll('tbody tr')).map(
     (row) => row.querySelector('td')?.textContent?.trim() ?? '',
diff --git a/apps/admin-web/src/pages/AdminDatabaseTablesPage.tsx b/apps/admin-web/src/pages/AdminDatabaseTablesPage.tsx
index f0d114373..22478cf32 100644
--- a/apps/admin-web/src/pages/AdminDatabaseTablesPage.tsx
+++ b/apps/admin-web/src/pages/AdminDatabaseTablesPage.tsx
@@ -4,13 +4,16 @@ import {
   ArrowUpDown,
   ChevronLeft,
   ChevronRight,
-  Eye,
+  Filter,
+  Plus,
   RefreshCcw,
   Search,
   X,
 } from 'lucide-react';
 import {
+  ClipboardEvent,
   FormEvent,
+  KeyboardEvent,
   useEffect,
   useLayoutEffect,
   useMemo,
@@ -36,6 +39,11 @@ interface AdminDatabaseTablesPageProps {
 
 type SortDirection = 'asc' | 'desc';
 
+type AdminCopyToast = {
+  message: string;
+  tone: 'success' | 'error';
+};
+
 export function AdminDatabaseTablesPage({
   token,
   onUnauthorized,
@@ -48,10 +56,11 @@ export function AdminDatabaseTablesPage({
     sortColumn: '',
     sortDirection: 'asc' as SortDirection,
   });
+  const rowsRequestIdRef = useRef(0);
   const [tables, setTables] = useState<string[]>([]);
   const [tableName, setTableName] = useState(() => readHashTableName());
   const [search, setSearch] = useState('');
-  const [filters, setFilters] = useState('');
+  const [conditions, setConditions] = useState<DatabaseFilterCondition[]>([]);
   const [limit, setLimit] = useState('100');
   const [result, setResult] = useState<AdminDatabaseTableRowsResponse | null>(
     null,
@@ -59,7 +68,7 @@ export function AdminDatabaseTablesPage({
   const [detailRow, setDetailRow] =
     useState<AdminDatabaseTableRowPayload | null>(null);
   const [errorMessage, setErrorMessage] = useState('');
-  const [copyMessage, setCopyMessage] = useState('');
+  const [copyToast, setCopyToast] = useState<AdminCopyToast | null>(null);
   const [sortColumn, setSortColumn] = useState('');
   const [sortDirection, setSortDirection] = useState<SortDirection>('asc');
   const [isLoadingTables, setIsLoadingTables] = useState(false);
@@ -99,6 +108,14 @@ export function AdminDatabaseTablesPage({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [tableName]);
 
+  useEffect(() => {
+    if (!copyToast) {
+      return;
+    }
+    const timer = window.setTimeout(() => setCopyToast(null), 2200);
+    return () => window.clearTimeout(timer);
+  }, [copyToast]);
+
   useLayoutEffect(() => {
     const pageElement = pageRef.current;
     if (!pageElement) {
@@ -147,6 +164,26 @@ export function AdminDatabaseTablesPage({
     return firstRow ? Object.keys(firstRow.cells) : [];
   }, [result]);
 
+  const detailFields = useMemo(() => {
+    if (!detailRow) {
+      return [];
+    }
+    const cells = detailRow.cells;
+    if (typeof cells !== 'object' || cells === null || Array.isArray(cells)) {
+      return [];
+    }
+    return Object.entries(cells).map(([column, value]) => {
+      const columnHeader = getDatabaseTableColumnHeader(tableName, column);
+      return {
+        cellValue: formatCellValue(value, column),
+        column,
+        description: columnHeader.description,
+        jsonPreview: getJsonPreviewText(value),
+        label: columnHeader.label,
+      };
+    });
+  }, [detailRow, tableName]);
+
   const tableOptions = useMemo(() => {
     const optionNames =
       tableName && !tables.includes(tableName)
@@ -211,10 +248,12 @@ export function AdminDatabaseTablesPage({
       return;
     }
     const querySearch = options.search ?? search;
-    const queryFilters = options.filters ?? filters;
+    const queryFilters =
+      options.filters ?? buildDatabaseFiltersJson(conditions);
     const queryLimit = options.limit ?? limit;
     const querySortColumn = options.sortColumn ?? sortColumn;
     const querySortDirection = options.sortDirection ?? sortDirection;
+    const requestId = ++rowsRequestIdRef.current;
     setIsLoadingRows(true);
     setErrorMessage('');
     try {
@@ -230,6 +269,9 @@ export function AdminDatabaseTablesPage({
           sortDirection: querySortColumn ? querySortDirection : undefined,
         },
       );
+      if (requestId !== rowsRequestIdRef.current) {
+        return;
+      }
       appliedQueryRef.current = {
         search: querySearch,
         filters: queryFilters,
@@ -240,22 +282,42 @@ export function AdminDatabaseTablesPage({
       setSortColumn(querySortColumn);
       setSortDirection(querySortDirection);
       setResult(response);
-      setCopyMessage('');
+      setCopyToast(null);
     } catch (error: unknown) {
+      if (requestId !== rowsRequestIdRef.current) {
+        return;
+      }
       handlePageError(error, onUnauthorized, setErrorMessage);
     } finally {
-      setIsLoadingRows(false);
+      if (requestId === rowsRequestIdRef.current) {
+        setIsLoadingRows(false);
+      }
     }
   }
 
   function handleSearch(event: FormEvent<HTMLFormElement>) {
     event.preventDefault();
+    const validationMessage = getDatabaseFilterValidationMessage(conditions);
+    if (validationMessage) {
+      setErrorMessage(validationMessage);
+      return;
+    }
+    void refreshRows(tableName, { page: 1 });
+  }
+
+  function handleQueryRows() {
+    const validationMessage = getDatabaseFilterValidationMessage(conditions);
+    if (validationMessage) {
+      setErrorMessage(validationMessage);
+      return;
+    }
     void refreshRows(tableName, { page: 1 });
   }
 
   function handleTableChange(nextTableName: string) {
     setSortColumn('');
     setSortDirection('asc');
+    setConditions([]);
     setTableName(nextTableName);
     const nextHash = `#tables?table=${encodeURIComponent(nextTableName)}`;
     if (window.location.hash !== nextHash) {
@@ -265,7 +327,7 @@ export function AdminDatabaseTablesPage({
 
   function handleResetQuery() {
     setSearch('');
-    setFilters('');
+    setConditions([]);
     setLimit('100');
     setSortColumn('');
     setSortDirection('asc');
@@ -279,36 +341,194 @@ export function AdminDatabaseTablesPage({
     });
   }
 
+  function handleAddCondition(column = '') {
+    const nextConditions = [
+      ...conditions,
+      {
+        column,
+        op: 'eq' as DatabaseFilterOperator,
+        value: '',
+        values: [],
+        enabled: true,
+      },
+    ];
+    setConditions(nextConditions);
+    focusConditionControl(
+      nextConditions.length - 1,
+      column ? 'value' : 'column',
+    );
+  }
+
+  function handleUpdateCondition(
+    index: number,
+    patch: Partial<DatabaseFilterCondition>,
+  ) {
+    setErrorMessage('');
+    setConditions((current) =>
+      current.map((condition, conditionIndex) =>
+        conditionIndex === index ? { ...condition, ...patch } : condition,
+      ),
+    );
+  }
+
+  function handleConditionOperatorChange(
+    index: number,
+    op: DatabaseFilterOperator,
+  ) {
+    setErrorMessage('');
+    setConditions((current) =>
+      current.map((condition, conditionIndex) => {
+        if (conditionIndex !== index) {
+          return condition;
+        }
+        const nextOption = getDatabaseFilterOperatorOption(op);
+        const previousOption = getDatabaseFilterOperatorOption(condition.op);
+        const nextValues = nextOption?.listValue
+          ? condition.values.length
+            ? condition.values
+            : condition.value.trim()
+              ? [condition.value.trim()]
+              : []
+          : condition.values;
+        return {
+          ...condition,
+          op,
+          value:
+            nextOption?.listValue && !previousOption?.listValue
+              ? ''
+              : condition.value,
+          values: nextValues,
+        };
+      }),
+    );
+  }
+
+  function handleAddConditionListValue(index: number) {
+    setConditions((current) =>
+      current.map((condition, conditionIndex) => {
+        if (conditionIndex !== index) {
+          return condition;
+        }
+        const value = condition.value.trim();
+        return value
+          ? { ...condition, value: '', values: [...condition.values, value] }
+          : condition;
+      }),
+    );
+    setErrorMessage('');
+  }
+
+  function handleRemoveConditionListValue(index: number, valueIndex: number) {
+    setConditions((current) =>
+      current.map((condition, conditionIndex) =>
+        conditionIndex === index
+          ? {
+              ...condition,
+              values: condition.values.filter(
+                (_, currentValueIndex) => currentValueIndex !== valueIndex,
+              ),
+            }
+          : condition,
+      ),
+    );
+    setErrorMessage('');
+  }
+
+  function handlePasteConditionListValues(
+    index: number,
+    event: ClipboardEvent<HTMLInputElement>,
+  ) {
+    const pastedText = event.clipboardData.getData('text');
+    if (!pastedText.includes('\n')) {
+      return;
+    }
+    event.preventDefault();
+    const pastedValues = pastedText
+      .split(/\r?\n/)
+      .map((value) => value.trim())
+      .filter(Boolean);
+    if (!pastedValues.length) {
+      return;
+    }
+    setConditions((current) =>
+      current.map((condition, conditionIndex) =>
+        conditionIndex === index
+          ? {
+              ...condition,
+              values: [...condition.values, ...pastedValues],
+            }
+          : condition,
+      ),
+    );
+    setErrorMessage('');
+  }
+
+  function handleRemoveCondition(index: number) {
+    setConditions((current) =>
+      current.filter((_, conditionIndex) => conditionIndex !== index),
+    );
+  }
+
   function handlePageChange(page: number) {
     void refreshRows(tableName, { ...appliedQueryRef.current, page });
   }
 
+  function handleRowKeyDown(
+    event: KeyboardEvent<HTMLTableRowElement>,
+    row: AdminDatabaseTableRowPayload,
+  ) {
+    if (event.key !== 'Enter' && event.key !== ' ') {
+      return;
+    }
+    if (isInteractiveFormControl(event.target)) {
+      return;
+    }
+    event.preventDefault();
+    setDetailRow(row);
+  }
+
   function handleSortColumn(column: string) {
-    const nextDirection =
-      sortColumn === column && sortDirection === 'asc' ? 'desc' : 'asc';
+    let nextSortColumn = column;
+    let nextDirection: SortDirection = 'asc';
+    if (sortColumn === column) {
+      if (sortDirection === 'asc') {
+        nextDirection = 'desc';
+      } else {
+        nextSortColumn = '';
+      }
+    }
     void refreshRows(tableName, {
       ...appliedQueryRef.current,
       page: 1,
-      sortColumn: column,
+      sortColumn: nextSortColumn,
       sortDirection: nextDirection,
     });
   }
 
-  async function handleCopyDetailJson() {
-    if (!detailRow) {
+  async function handleCopyDetailField(column: string, value: unknown) {
+    const copiedText = stringifyDetailValue(value);
+    if (
+      value === null ||
+      typeof value === 'undefined' ||
+      copiedText.trim() === ''
+    ) {
+      setCopyToast({
+        message: '该字段为空，无法复制',
+        tone: 'error',
+      });
       return;
     }
-
-    const copiedText = JSON.stringify(
-      detailRow.raw ?? detailRow.cells,
-      null,
-      2,
-    );
     try {
       await navigator.clipboard.writeText(copiedText);
-      setCopyMessage('已复制 JSON');
+      setCopyToast({
+        message: `已复制 ${getDatabaseTableColumnLabel(column)}`,
+        tone: 'success',
+      });
     } catch {
-      setCopyMessage('复制失败，请手动选中后复制');
+      setCopyToast({
+        message: '复制失败，请手动选中后复制',
+        tone: 'error',
+      });
     }
   }
 
@@ -336,7 +556,7 @@ export function AdminDatabaseTablesPage({
             className="admin-primary-button"
             disabled={!tableName || isLoadingRows}
             type="button"
-            onClick={() => void refreshRows(tableName, { page: 1 })}
+            onClick={handleQueryRows}
           >
             <Search size={17} aria-hidden="true" />
             <span>{isLoadingRows ? '查询中' : '查询'}</span>
@@ -367,14 +587,6 @@ export function AdminDatabaseTablesPage({
               onChange={(event) => setSearch(event.target.value)}
             />
           </label>
-          <label className="admin-field">
-            <span>筛选 JSON</span>
-            <input
-              placeholder='{"user_id":"u1"}'
-              value={filters}
-              onChange={(event) => setFilters(event.target.value)}
-            />
-          </label>
           <label className="admin-field admin-field-compact">
             <span>每页条数</span>
             <input
@@ -392,6 +604,256 @@ export function AdminDatabaseTablesPage({
             <span>{isLoadingRows ? '查询中' : '查询'}</span>
           </button>
         </div>
+        {conditions.length ? (
+          <div
+            className="admin-database-filter-grid"
+            role="table"
+            aria-label="字段筛选条件"
+          >
+            <div className="admin-database-filter-header" role="row">
+              <span role="columnheader">启用</span>
+              <span role="columnheader">字段</span>
+              <span role="columnheader">条件</span>
+              <span role="columnheader">值</span>
+              <span role="columnheader">操作</span>
+            </div>
+            <div className="admin-database-filter-list" role="rowgroup">
+              {conditions.map((condition, index) => {
+                const operatorOption = getDatabaseFilterOperatorOption(
+                  condition.op,
+                );
+                const validationError =
+                  getDatabaseFilterValidationError(condition);
+                return (
+                  <div
+                    className="admin-database-filter-item"
+                    key={index}
+                    role="row"
+                  >
+                    <div
+                      className="admin-database-filter-row"
+                      data-enabled={condition.enabled ? 'true' : 'false'}
+                    >
+                      <label className="admin-database-filter-toggle">
+                        <input
+                          id={`admin-filter-condition-enabled-${index}`}
+                          aria-label={`启用条件 ${index + 1}`}
+                          type="checkbox"
+                          checked={condition.enabled}
+                          onChange={(event) =>
+                            handleUpdateCondition(index, {
+                              enabled: event.target.checked,
+                            })
+                          }
+                        />
+                      </label>
+                      <label className="admin-field">
+                        <select
+                          id={`admin-filter-condition-column-${index}`}
+                          aria-label={`条件 ${index + 1} 字段`}
+                          aria-invalid={validationError === '请选择字段'}
+                          value={condition.column}
+                          onChange={(event) =>
+                            handleUpdateCondition(index, {
+                              column: event.target.value,
+                            })
+                          }
+                        >
+                          <option value="">选择字段</option>
+                          {condition.column &&
+                          !visibleColumns.includes(condition.column) ? (
+                            <option value={condition.column}>
+                              {condition.column}
+                            </option>
+                          ) : null}
+                          {visibleColumns.map((column) => {
+                            const columnHeader = getDatabaseTableColumnHeader(
+                              tableName,
+                              column,
+                            );
+                            return (
+                              <option
+                                key={column}
+                                title={columnHeader.description}
+                                value={column}
+                              >
+                                {`${columnHeader.label}（${column}）`}
+                              </option>
+                            );
+                          })}
+                        </select>
+                      </label>
+                      <label className="admin-field">
+                        <select
+                          id={`admin-filter-condition-op-${index}`}
+                          aria-label={`条件 ${index + 1} 运算符`}
+                          value={condition.op}
+                          onChange={(event) =>
+                            handleConditionOperatorChange(
+                              index,
+                              event.target.value as DatabaseFilterOperator,
+                            )
+                          }
+                        >
+                          {databaseFilterOperatorOptions.map(
+                            ({ op, label }) => (
+                              <option key={op} value={op}>
+                                {label}
+                              </option>
+                            ),
+                          )}
+                        </select>
+                      </label>
+                      {operatorOption?.listValue ? (
+                        <div
+                          className="admin-database-filter-list-editor"
+                          aria-label={`条件 ${index + 1} 值列表`}
+                        >
+                          <div className="admin-database-filter-list-input-row">
+                            <input
+                              id={`admin-filter-condition-value-${index}`}
+                              aria-label={`条件 ${index + 1} 值输入`}
+                              aria-invalid={Boolean(validationError)}
+                              placeholder="输入值后按 Enter 添加；可粘贴多行"
+                              value={condition.value}
+                              onChange={(event) =>
+                                handleUpdateCondition(index, {
+                                  value: event.target.value,
+                                })
+                              }
+                              onKeyDown={(event) => {
+                                if (event.key === 'Enter') {
+                                  event.preventDefault();
+                                  handleAddConditionListValue(index);
+                                }
+                              }}
+                              onPaste={(event) =>
+                                handlePasteConditionListValues(index, event)
+                              }
+                            />
+                            <button
+                              className="admin-secondary-button admin-database-filter-add-value"
+                              aria-label={`添加条件 ${index + 1} 的值`}
+                              type="button"
+                              onClick={() => handleAddConditionListValue(index)}
+                            >
+                              <Plus size={14} aria-hidden="true" />
+                              <span>添加</span>
+                            </button>
+                          </div>
+                        </div>
+                      ) : operatorOption?.needsValue ? (
+                        <label className="admin-field">
+                          <input
+                            id={`admin-filter-condition-value-${index}`}
+                            aria-label={`条件 ${index + 1} 值`}
+                            aria-invalid={Boolean(validationError)}
+                            placeholder="输入值"
+                            value={condition.value}
+                            onChange={(event) =>
+                              handleUpdateCondition(index, {
+                                value: event.target.value,
+                              })
+                            }
+                          />
+                        </label>
+                      ) : (
+                        <div
+                          className="admin-database-filter-value-slot"
+                          aria-label={`条件 ${index + 1} 值`}
+                        >
+                          <span className="admin-database-filter-no-value">
+                            无需填写
+                          </span>
+                        </div>
+                      )}
+                      <button
+                        className="admin-ghost-button admin-database-filter-remove"
+                        aria-label={`删除条件 ${index + 1}`}
+                        title="删除条件"
+                        type="button"
+                        onClick={() => handleRemoveCondition(index)}
+                      >
+                        <X size={16} aria-hidden="true" />
+                      </button>
+                    </div>
+                    {operatorOption?.listValue && condition.values.length ? (
+                      <div className="admin-database-filter-values-row">
+                        <span className="admin-database-filter-values-label">
+                          已添加
+                        </span>
+                        <div className="admin-database-filter-value-chips">
+                          {condition.values.map((value, valueIndex) => (
+                            <span
+                              className="admin-database-filter-value-chip"
+                              key={`${value}-${valueIndex}`}
+                            >
+                              <span title={value}>{value}</span>
+                              <button
+                                aria-label={`删除条件 ${index + 1} 的值 ${valueIndex + 1}`}
+                                type="button"
+                                onClick={() =>
+                                  handleRemoveConditionListValue(
+                                    index,
+                                    valueIndex,
+                                  )
+                                }
+                              >
+                                <X size={12} aria-hidden="true" />
+                              </button>
+                            </span>
+                          ))}
+                        </div>
+                      </div>
+                    ) : null}
+                    {condition.enabled && validationError ? (
+                      <div
+                        className="admin-database-filter-error"
+                        role="status"
+                      >
+                        {validationError}
+                      </div>
+                    ) : null}
+                  </div>
+                );
+              })}
+            </div>
+          </div>
+        ) : null}
+        {conditions.length ? (
+          <div className="admin-database-filter-summary">
+            <span className="admin-database-filter-summary-label">
+              当前生效
+            </span>
+            {conditions.filter((condition) => condition.enabled).length ? (
+              conditions
+                .filter((condition) => condition.enabled)
+                .map((condition, index) => (
+                  <span
+                    className="admin-database-filter-summary-chip"
+                    key={`${condition.column}-${condition.op}-${index}`}
+                  >
+                    {formatDatabaseFilterSummary(condition)}
+                  </span>
+                ))
+            ) : (
+              <span className="admin-database-filter-summary-empty">
+                未启用筛选，查询全部数据
+              </span>
+            )}
+          </div>
+        ) : null}
+        <div className="admin-action-row admin-database-filter-actions">
+          <button
+            className="admin-secondary-button"
+            disabled={isLoadingRows}
+            type="button"
+            onClick={() => handleAddCondition()}
+          >
+            <Plus size={16} aria-hidden="true" />
+            <span>添加条件</span>
+          </button>
+        </div>
         <div className="admin-action-row admin-query-action-row">
           <button
             className="admin-ghost-button admin-query-reset-button"
@@ -406,6 +868,14 @@ export function AdminDatabaseTablesPage({
               已选表：{selectedTableHeader.optionLabel}
             </span>
             <span>显示列：{visibleColumns.length}</span>
+            {conditions.length ? (
+              <span>
+                筛选：
+                {
+                  conditions.filter((condition) => condition.enabled).length
+                } / {conditions.length} 个条件已启用
+              </span>
+            ) : null}
           </div>
         </div>
       </form>
@@ -423,7 +893,7 @@ export function AdminDatabaseTablesPage({
         </section>
       ) : null}
 
-      <section className="admin-panel">
+      <section className="admin-panel admin-database-result-panel">
         <div className="admin-panel-heading">
           <h3 title={resultTableHeader.description}>
             {resultTableHeader.label}
@@ -446,32 +916,43 @@ export function AdminDatabaseTablesPage({
                           ? sortDirection === 'asc'
                             ? 'ascending'
                             : 'descending'
-                          : undefined
+                          : 'none'
                       }
                     >
-                      <button
-                        className="admin-table-sort-button"
-                        data-active={isSorted ? 'true' : 'false'}
-                        title={description}
-                        type="button"
-                        disabled={isLoadingRows}
-                        onClick={() => handleSortColumn(column)}
-                      >
-                        <span>{label}</span>
-                        {isSorted ? (
-                          sortDirection === 'asc' ? (
-                            <ArrowUp size={14} aria-hidden="true" />
+                      <div className="admin-database-column-header">
+                        <button
+                          className="admin-table-sort-button"
+                          data-active={isSorted ? 'true' : 'false'}
+                          title={`${description} 当前状态：${isSorted ? (sortDirection === 'asc' ? '正序' : '倒序') : '不排序'}。`}
+                          type="button"
+                          disabled={isLoadingRows}
+                          onClick={() => handleSortColumn(column)}
+                        >
+                          <span>{label}</span>
+                          {isSorted ? (
+                            sortDirection === 'asc' ? (
+                              <ArrowUp size={14} aria-hidden="true" />
+                            ) : (
+                              <ArrowDown size={14} aria-hidden="true" />
+                            )
                           ) : (
-                            <ArrowDown size={14} aria-hidden="true" />
-                          )
-                        ) : (
-                          <ArrowUpDown size={14} aria-hidden="true" />
-                        )}
-                      </button>
+                            <ArrowUpDown size={14} aria-hidden="true" />
+                          )}
+                        </button>
+                        <button
+                          className="admin-table-filter-button"
+                          aria-label={`按${label}添加条件`}
+                          title={`按 ${label} 添加筛选条件`}
+                          type="button"
+                          disabled={isLoadingRows}
+                          onClick={() => handleAddCondition(column)}
+                        >
+                          <Filter size={13} aria-hidden="true" />
+                        </button>
+                      </div>
                     </th>
                   );
                 })}
-                <th>详情</th>
               </tr>
             </thead>
             <tbody>
@@ -480,13 +961,13 @@ export function AdminDatabaseTablesPage({
                   <tr
                     key={buildRowKey(row, rowIndex)}
                     data-clickable="true"
+                    tabIndex={0}
                     onClick={() => setDetailRow(row)}
+                    onKeyDown={(event) => handleRowKeyDown(event, row)}
                   >
                     {visibleColumns.map((column) => {
-                      const cellValue = formatCellValue(
-                        row.cells[column],
-                        column,
-                      );
+                      const rawValue = row.cells[column];
+                      const cellValue = formatCellValue(rawValue, column);
                       const userReference = resolveAdminDatabaseUserReference(
                         result.tableName,
                         column,
@@ -499,7 +980,15 @@ export function AdminDatabaseTablesPage({
                               className="admin-table-cell-ellipsis"
                               title={cellValue.fullText}
                             >
-                              {cellValue.content}
+                              {getJsonTablePreviewText(rawValue) ? (
+                                <span className="admin-table-json-preview">
+                                  {renderJsonSyntax(
+                                    getJsonTablePreviewText(rawValue) ?? '',
+                                  )}
+                                </span>
+                              ) : (
+                                cellValue.content
+                              )}
                             </span>
                             {userReference ? (
                               <AdminUserReferenceButton
@@ -512,26 +1001,11 @@ export function AdminDatabaseTablesPage({
                         </td>
                       );
                     })}
-                    <td>
-                      <button
-                        className="admin-secondary-button"
-                        type="button"
-                        onClick={(event) => {
-                          event.stopPropagation();
-                          setDetailRow(row);
-                        }}
-                      >
-                        <Eye size={16} aria-hidden="true" />
-                        <span>详情</span>
-                      </button>
-                    </td>
                   </tr>
                 ))
               ) : (
                 <tr>
-                  <td colSpan={Math.max(visibleColumns.length + 1, 1)}>
-                    暂无数据
-                  </td>
+                  <td colSpan={Math.max(visibleColumns.length, 1)}>暂无数据</td>
                 </tr>
               )}
             </tbody>
@@ -574,6 +1048,17 @@ export function AdminDatabaseTablesPage({
         </nav>
       ) : null}
 
+      {copyToast ? (
+        <div
+          className="admin-toast"
+          data-tone={copyToast.tone}
+          role={copyToast.tone === 'error' ? 'alert' : 'status'}
+          aria-live={copyToast.tone === 'error' ? 'assertive' : 'polite'}
+        >
+          {copyToast.message}
+        </div>
+      ) : null}
+
       {detailRow ? (
         <div className="admin-confirm-backdrop" role="presentation">
           <section
@@ -584,13 +1069,6 @@ export function AdminDatabaseTablesPage({
             <div className="admin-panel-heading">
               <h3>行详情</h3>
               <div className="admin-detail-actions">
-                <button
-                  className="admin-secondary-button"
-                  type="button"
-                  onClick={() => void handleCopyDetailJson()}
-                >
-                  <span>复制 JSON</span>
-                </button>
                 <button
                   className="admin-ghost-button"
                   title="关闭"
@@ -601,12 +1079,66 @@ export function AdminDatabaseTablesPage({
                 </button>
               </div>
             </div>
-            {copyMessage ? (
-              <div className="admin-status admin-status-ok">{copyMessage}</div>
-            ) : null}
-            <pre className="admin-code-block">
-              {JSON.stringify(detailRow.raw ?? detailRow.cells, null, 2)}
-            </pre>
+            <div className="admin-database-detail-table" role="table">
+              <div className="admin-database-detail-table-header" role="row">
+                <span role="columnheader">字段</span>
+                <span role="columnheader">值</span>
+                <span role="columnheader">操作</span>
+              </div>
+              <div className="admin-database-detail-field-list" role="rowgroup">
+                {detailFields.map(
+                  ({ column, label, description, cellValue, jsonPreview }) => (
+                    <div
+                      className="admin-database-detail-field"
+                      key={column}
+                      role="row"
+                    >
+                      <div
+                        className="admin-database-detail-field-name"
+                        role="rowheader"
+                        title={description}
+                      >
+                        {label}
+                      </div>
+                      <div
+                        className="admin-database-detail-field-value"
+                        role="cell"
+                        title={cellValue.fullText}
+                      >
+                        {jsonPreview ? (
+                          <pre
+                            className="admin-json-preview"
+                            aria-label={`${label} JSON`}
+                          >
+                            {renderJsonSyntax(jsonPreview)}
+                          </pre>
+                        ) : (
+                          cellValue.content
+                        )}
+                      </div>
+                      <div role="cell">
+                        <div className="admin-database-detail-row-actions">
+                          <button
+                            className="admin-secondary-button"
+                            aria-label={`复制${label}`}
+                            title={`复制 ${label}`}
+                            type="button"
+                            onClick={() =>
+                              void handleCopyDetailField(
+                                column,
+                                detailRow?.cells[column],
+                              )
+                            }
+                          >
+                            <span>复制</span>
+                          </button>
+                        </div>
+                      </div>
+                    </div>
+                  ),
+                )}
+              </div>
+            </div>
           </section>
         </div>
       ) : null}
@@ -630,6 +1162,152 @@ function parseLimit(value: string) {
   return Number.isFinite(parsed) ? parsed : 100;
 }
 
+type DatabaseFilterOperator =
+  | 'eq'
+  | 'ne'
+  | 'gt'
+  | 'gte'
+  | 'lt'
+  | 'lte'
+  | 'contains'
+  | 'notContains'
+  | 'startsWith'
+  | 'endsWith'
+  | 'in'
+  | 'notIn'
+  | 'isEmpty'
+  | 'isNotEmpty';
+
+interface DatabaseFilterCondition {
+  column: string;
+  op: DatabaseFilterOperator;
+  value: string;
+  values: string[];
+  enabled: boolean;
+}
+
+interface DatabaseFilterOperatorOption {
+  op: DatabaseFilterOperator;
+  label: string;
+  needsValue: boolean;
+  listValue: boolean;
+}
+
+const databaseFilterOperatorOptions: DatabaseFilterOperatorOption[] = [
+  { op: 'eq', label: '等于', needsValue: true, listValue: false },
+  { op: 'ne', label: '不等于', needsValue: true, listValue: false },
+  { op: 'contains', label: '包含', needsValue: true, listValue: false },
+  { op: 'notContains', label: '不包含', needsValue: true, listValue: false },
+  { op: 'startsWith', label: '开头是', needsValue: true, listValue: false },
+  { op: 'endsWith', label: '结尾是', needsValue: true, listValue: false },
+  { op: 'gt', label: '大于', needsValue: true, listValue: false },
+  { op: 'gte', label: '大于等于', needsValue: true, listValue: false },
+  { op: 'lt', label: '小于', needsValue: true, listValue: false },
+  { op: 'lte', label: '小于等于', needsValue: true, listValue: false },
+  { op: 'in', label: '在列表中', needsValue: true, listValue: true },
+  { op: 'notIn', label: '不在列表中', needsValue: true, listValue: true },
+  { op: 'isEmpty', label: '为空', needsValue: false, listValue: false },
+  { op: 'isNotEmpty', label: '不为空', needsValue: false, listValue: false },
+];
+
+function getDatabaseFilterOperatorOption(op: DatabaseFilterOperator) {
+  return databaseFilterOperatorOptions.find((option) => option.op === op);
+}
+
+function buildDatabaseFiltersJson(conditions: DatabaseFilterCondition[]) {
+  const entries = conditions.flatMap((condition) => {
+    if (!condition.enabled) {
+      return [];
+    }
+    const entry = buildDatabaseFilterEntry(condition);
+    return entry ? [entry] : [];
+  });
+  return entries.length ? JSON.stringify(entries) : '';
+}
+
+function buildDatabaseFilterEntry(condition: DatabaseFilterCondition) {
+  const column = condition.column.trim();
+  if (!column) {
+    return null;
+  }
+  const operatorOption = getDatabaseFilterOperatorOption(condition.op);
+  if (!operatorOption) {
+    return null;
+  }
+  if (!operatorOption.needsValue) {
+    return { column, op: condition.op };
+  }
+  if (operatorOption.listValue) {
+    return condition.values.length
+      ? { column, op: condition.op, value: condition.values }
+      : null;
+  }
+  const value = condition.value.trim();
+  if (!value) {
+    return null;
+  }
+  return { column, op: condition.op, value };
+}
+
+function getDatabaseFilterValidationError(condition: DatabaseFilterCondition) {
+  if (!condition.enabled) {
+    return null;
+  }
+  if (!condition.column.trim()) {
+    return '请选择字段';
+  }
+  const operatorOption = getDatabaseFilterOperatorOption(condition.op);
+  if (!operatorOption) {
+    return '请选择有效的条件';
+  }
+  if (operatorOption.listValue && !condition.values.length) {
+    return '请至少添加一个值';
+  }
+  if (operatorOption.needsValue && !operatorOption.listValue) {
+    return condition.value.trim() ? null : '请输入筛选值';
+  }
+  return null;
+}
+
+function getDatabaseFilterValidationMessage(
+  conditions: DatabaseFilterCondition[],
+) {
+  const invalidIndex = conditions.findIndex(
+    (condition) => getDatabaseFilterValidationError(condition) !== null,
+  );
+  return invalidIndex >= 0
+    ? `条件 ${invalidIndex + 1} 未完成，请补充后再查询`
+    : null;
+}
+
+function formatDatabaseFilterSummary(condition: DatabaseFilterCondition) {
+  const column = condition.column.trim() || '未选择字段';
+  const operatorOption = getDatabaseFilterOperatorOption(condition.op);
+  const operator = operatorOption?.label ?? condition.op;
+  if (operatorOption?.listValue) {
+    return `${column} ${operator} ${condition.values.length ? `[${condition.values.join('、')}]` : '[]'}`;
+  }
+  if (!operatorOption?.needsValue) {
+    return `${column} ${operator}`;
+  }
+  return `${column} ${operator} ${condition.value.trim() || '（未填写）'}`;
+}
+
+function focusConditionControl(index: number, target: 'column' | 'value') {
+  window.setTimeout(() => {
+    document
+      .getElementById(`admin-filter-condition-${target}-${index}`)
+      ?.focus();
+  }, 0);
+}
+
+function isInteractiveFormControl(target: EventTarget | null) {
+  return (
+    target instanceof HTMLElement &&
+    target.closest('button, a, input, select, textarea') !== null
+  );
+}
+
 function getDatabaseTableHeader(tableName: string): DatabaseTableHeader {
   const normalizedName = tableName.trim();
   if (!normalizedName) {
@@ -710,7 +1388,7 @@ function getDatabaseTableColumnDescription(
   const exactDescription = databaseTableColumnDescriptionMap[column];
   const description =
     exactDescription ?? `当前表 ${tableName || '未知'} 中的 ${label} 字段`;
-  return `原始字段名：${column}。${description}。点击可按此列排序。`;
+  return `原始字段名：${column}。${description}。点击列名可在正序、倒序和不排序之间循环切换。`;
 }
 
 function buildRowKey(row: AdminDatabaseTableRowPayload, rowIndex: number) {
@@ -744,13 +1422,10 @@ export function resolveAdminDatabaseUserReference(
     normalizedColumn === 'public_user_code' ||
     normalizedColumn.endsWith('_public_user_code')
   ) {
-    return {publicUserCode: normalizedValue};
+    return { publicUserCode: normalizedValue };
   }
-  if (
-    normalizedColumn === 'user_id' ||
-    normalizedColumn.endsWith('_user_id')
-  ) {
-    return {userId: normalizedValue};
+  if (normalizedColumn === 'user_id' || normalizedColumn.endsWith('_user_id')) {
+    return { userId: normalizedValue };
   }
   return null;
 }
@@ -780,6 +1455,73 @@ function formatCellValue(value: unknown, column = ''): FormattedTableCellValue {
   };
 }
 
+function getJsonPreviewText(value: unknown) {
+  if (value === null || typeof value !== 'object') {
+    if (typeof value !== 'string') {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      return parsed !== null && typeof parsed === 'object'
+        ? stringifyPrettyUnknownValue(parsed)
+        : null;
+    } catch {
+      return null;
+    }
+  }
+  return stringifyPrettyUnknownValue(value);
+}
+
+function getJsonTablePreviewText(value: unknown) {
+  if (value === null || typeof value !== 'object') {
+    if (typeof value !== 'string') {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      return parsed !== null && typeof parsed === 'object'
+        ? stringifyUnknownValue(parsed)
+        : null;
+    } catch {
+      return null;
+    }
+  }
+  return stringifyUnknownValue(value);
+}
+
+function renderJsonSyntax(text: string) {
+  const tokenPattern =
+    /("(?:\\.|[^"\\])*")(?=\s*:)|("(?:\\.|[^"\\])*")|(-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b)|(\btrue\b|\bfalse\b)|(\bnull\b)/gi;
+  const parts = [];
+  let lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = tokenPattern.exec(text))) {
+    if (match.index > lastIndex) {
+      parts.push(text.slice(lastIndex, match.index));
+    }
+    const token = match[0];
+    const className = match[1]
+      ? 'admin-json-token-key'
+      : match[2]
+        ? 'admin-json-token-string'
+        : match[3]
+          ? 'admin-json-token-number'
+          : match[4]
+            ? 'admin-json-token-boolean'
+            : 'admin-json-token-null';
+    parts.push(
+      <span className={className} key={`${match.index}-${token}`}>
+        {token}
+      </span>,
+    );
+    lastIndex = tokenPattern.lastIndex;
+  }
+  if (lastIndex < text.length) {
+    parts.push(text.slice(lastIndex));
+  }
+  return parts;
+}
+
 function formatReadableTimestampValue(
   value: string | number | boolean,
   column: string,
@@ -899,6 +1641,19 @@ function stringifyUnknownValue(value: unknown) {
   }
 }
 
+function stringifyDetailValue(value: unknown) {
+  if (value === null || typeof value === 'undefined') {
+    return '';
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return stringifyPrettyUnknownValue(value);
+}
+
 interface DatabaseTableHeader {
   name: string;
   label: string;
@@ -1040,7 +1795,9 @@ const databaseTableColumnLabelMap: Record<string, string> = {
   record_id: '记录ID',
   created_by: '创建人',
   updated_by: '更新人',
+  updated_by_admin_user_id: '更新管理员',
   operator_user_id: '操作人ID',
+  writeridentity: '写入身份',
   total_count: '总数',
   max_uses: '最大使用次数',
   global_used_count: '全局使用次数',
diff --git a/apps/admin-web/src/styles/admin.css b/apps/admin-web/src/styles/admin.css
index 719ecf714..e72017719 100644
--- a/apps/admin-web/src/styles/admin.css
+++ b/apps/admin-web/src/styles/admin.css
@@ -696,7 +696,7 @@ button:disabled {
 
 .admin-table-query-grid {
   display: grid;
-  grid-template-columns: minmax(180px, 1fr) minmax(160px, 1fr) minmax(220px, 1.2fr) minmax(96px, 0.45fr) auto;
+  grid-template-columns: minmax(180px, 1fr) minmax(160px, 1fr) minmax(96px, 0.45fr) auto;
   gap: 12px;
   align-items: end;
 }
@@ -1084,15 +1084,17 @@ button:disabled {
 
 .admin-detail-panel {
   display: grid;
-  width: min(100%, 760px);
-  max-height: min(90dvh, 760px);
-  gap: 16px;
+  width: min(100%, 960px);
+  max-height: min(90dvh, 820px);
+  gap: 14px;
   overflow: auto;
+  scrollbar-width: none;
+  -ms-overflow-style: none;
   border: 1px solid #e1ccbb;
-  border-radius: 10px;
+  border-radius: 14px;
   background: #ffffff;
   box-shadow: 0 22px 60px rgba(112, 57, 30, 0.24);
-  padding: 18px;
+  padding: 20px;
 }
 
 .admin-user-detail-backdrop {
@@ -1362,10 +1364,20 @@ button:disabled {
 .admin-table-wrap {
   max-width: 100%;
   overflow: auto;
-  scrollbar-gutter: stable;
+  scrollbar-width: none;
+  -ms-overflow-style: none;
+  scrollbar-gutter: auto;
   -webkit-overflow-scrolling: touch;
 }
 
+.admin-table-wrap::-webkit-scrollbar,
+.admin-detail-panel::-webkit-scrollbar,
+.admin-json-preview::-webkit-scrollbar {
+  display: none;
+  width: 0;
+  height: 0;
+}
+
 .admin-table {
   width: 100%;
   min-width: 620px;
@@ -1819,20 +1831,82 @@ button:disabled {
   width: max-content;
   min-width: 100%;
   table-layout: fixed;
+  border-collapse: separate;
+  border-spacing: 0;
+}
+
+.admin-database-result-panel {
+  gap: 0;
+  overflow: hidden;
+  border-color: #ead8ca;
+  background: #fffdf9;
+  box-shadow: 0 12px 28px rgba(112, 57, 30, 0.08);
+}
+
+.admin-database-result-panel > .admin-panel-heading {
+  padding: 2px 0 14px;
+}
+
+.admin-database-result-panel > .admin-panel-heading span {
+  color: #9c8373;
+  font-size: 12px;
+  font-weight: 750;
+}
+
+.admin-database-table thead {
+  position: sticky;
+  top: 0;
+  z-index: 2;
 }
 
 .admin-database-table th,
 .admin-database-table td {
-  width: 220px;
-  min-width: 220px;
-  max-width: 220px;
+  width: 164px;
+  min-width: 164px;
+  max-width: 164px;
+  padding: 12px 13px;
+  border-bottom: 1px solid #eee2d8;
+  color: #4d3327;
+  font-size: 13px;
+  line-height: 1.4;
 }
 
-.admin-database-table th:last-child,
-.admin-database-table td:last-child {
-  width: 112px;
-  min-width: 112px;
-  max-width: 112px;
+.admin-database-table th {
+  border-bottom-color: #e4d3c5;
+  color: #8f7868;
+  background: #f8efe8;
+  font-size: 11px;
+  letter-spacing: 0.03em;
+  text-transform: uppercase;
+}
+
+.admin-database-table tbody tr[data-clickable="true"] {
+  cursor: pointer;
+  transition: background-color 140ms ease;
+}
+
+.admin-database-table tbody tr:nth-child(even) {
+  background: #fffbf7;
+}
+
+.admin-database-table tbody tr[data-clickable="true"]:hover {
+  background: #fff3e9;
+}
+
+.admin-database-table tbody tr:last-child td {
+  border-bottom: 0;
+}
+
+.admin-table-json-preview {
+  display: block;
+  max-width: 100%;
+  overflow: hidden;
+  color: inherit;
+  font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+  font-size: 11px;
+  line-height: 1.35;
+  white-space: nowrap;
+  text-overflow: ellipsis;
 }
 
 .admin-database-tables-page {
@@ -1861,6 +1935,8 @@ button:disabled {
 
 .admin-table-sort-button {
   display: inline-flex;
+  min-width: 0;
+  flex: 1 1 auto;
   align-items: center;
   gap: 6px;
   max-width: 100%;
@@ -1871,12 +1947,15 @@ button:disabled {
   text-align: left;
   font-size: 12px;
   font-weight: 800;
+  overflow: hidden;
+  white-space: nowrap;
 }
 
 .admin-table-sort-button span {
   min-width: 0;
   overflow: hidden;
   text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
 .admin-table-sort-button svg {
@@ -1898,20 +1977,535 @@ button:disabled {
   outline: none;
 }
 
-.admin-json-preview {
-  max-width: 360px;
-  max-height: 160px;
-  margin: 0;
-  overflow: auto;
-  color: #4b2412;
-  font-family:
-    "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
+.admin-database-column-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 4px;
+}
+
+.admin-table-filter-button {
+  display: inline-flex;
+  flex: 0 0 auto;
+  align-items: center;
+  border: 0;
+  color: #b6a396;
+  background: transparent;
+  padding: 2px;
+}
+
+.admin-table-filter-button:hover,
+.admin-table-filter-button:focus-visible {
+  color: #8f3f27;
+  outline: none;
+}
+
+.admin-database-filter-grid {
+  min-width: 0;
+  margin-top: 12px;
+  overflow-x: auto;
+  padding: 2px 2px 4px;
+}
+
+.admin-database-filter-header,
+.admin-database-filter-row {
+  display: grid;
+  grid-template-columns:
+    52px
+    minmax(180px, 1.1fr)
+    minmax(120px, 0.75fr)
+    minmax(260px, 1.8fr)
+    42px;
+  min-width: 720px;
+  gap: 10px;
+  align-items: center;
+}
+
+.admin-database-filter-header {
+  border-bottom: 1px solid #eaded2;
+  padding: 0 11px 8px;
+  color: #9c8373;
+  font-size: 11px;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.admin-database-filter-header > span:first-child,
+.admin-database-filter-header > span:last-child {
+  text-align: center;
+}
+
+.admin-database-filter-list {
+  display: grid;
+  gap: 2px;
+}
+
+.admin-database-filter-item {
+  display: grid;
+  gap: 4px;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  padding: 8px 10px;
+  transition:
+    background-color 160ms ease,
+    opacity 160ms ease;
+}
+
+.admin-database-filter-item:focus-within {
+  background: #fffaf5;
+}
+
+.admin-database-filter-row {
+  width: 100%;
+}
+
+.admin-database-filter-row[data-enabled='false'] {
+  opacity: 0.58;
+}
+
+.admin-database-filter-row .admin-field {
+  gap: 0;
+}
+
+.admin-database-filter-toggle {
+  display: inline-flex;
+  min-height: 38px;
+  align-items: center;
+  justify-content: center;
+  padding: 0 4px;
+}
+
+.admin-database-filter-toggle input {
+  width: 16px;
+  height: 16px;
+  accent-color: #8f3f27;
+}
+
+.admin-database-filter-field-label {
+  display: block;
+  margin-bottom: 4px;
+  color: #9c8373;
+  font-size: 11px;
+  font-weight: 800;
+  letter-spacing: 0.02em;
+}
+
+.admin-database-filter-list-editor {
+  display: block;
+  min-width: 0;
+  min-height: 38px;
+}
+
+.admin-database-filter-list-input-row {
+  display: flex;
+  flex: 1 1 240px;
+  min-width: 240px;
+  align-items: center;
+  gap: 6px;
+}
+
+.admin-database-filter-list-input-row input {
+  flex: 1 1 auto;
+  width: 100%;
+  min-width: 0;
+  min-height: 34px;
+  border: 1px solid #dfc8b7;
+  border-radius: 7px;
+  color: #3d1f10;
+  background: #ffffff;
+  padding: 7px 9px;
+  outline: none;
+}
+
+.admin-database-filter-list-input-row input:focus {
+  border-color: #b6623f;
+  box-shadow: 0 0 0 3px rgba(204, 117, 76, 0.14);
+}
+
+.admin-database-filter-add-value {
+  min-height: 38px;
+  padding: 7px 10px;
+}
+
+.admin-database-filter-value-chips {
+  display: flex;
+  min-width: 0;
+  flex-wrap: wrap;
+  gap: 5px;
+  min-height: 28px;
+  align-items: center;
+}
+
+.admin-database-filter-values-row {
+  display: grid;
+  grid-column: 1 / -1;
+  grid-template-columns: 52px minmax(0, 1fr);
+  gap: 10px;
+  align-items: start;
+  padding-top: 2px;
+}
+
+.admin-database-filter-values-label {
+  padding-top: 6px;
+  color: #a08b7d;
+  font-size: 11px;
+  font-weight: 750;
+  text-align: center;
+}
+
+.admin-database-filter-value-chip {
+  display: inline-flex;
+  min-width: 0;
+  max-width: 100%;
+  align-items: center;
+  gap: 4px;
+  border: 1px solid #e5c7b5;
+  border-radius: 999px;
+  color: #6d321f;
+  background: #fff3ea;
+  padding: 5px 6px 5px 9px;
   font-size: 12px;
-  line-height: 1.45;
+  line-height: 1.2;
+}
+
+.admin-database-filter-value-chip > span {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.admin-database-filter-value-chip button {
+  display: inline-flex;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  border-radius: 50%;
+  color: #9c6751;
+  background: transparent;
+  padding: 2px;
+}
+
+.admin-database-filter-value-chip button:hover,
+.admin-database-filter-value-chip button:focus-visible {
+  color: #6d321f;
+  background: rgba(143, 63, 39, 0.12);
+  outline: none;
+}
+
+.admin-database-filter-value-slot {
+  display: grid;
+  align-content: center;
+  min-height: 38px;
+}
+
+.admin-database-filter-no-value {
+  color: #b09a8b;
+  font-size: 13px;
+}
+
+.admin-database-filter-error {
+  margin-left: 34px;
+  color: #a13b2b;
+  font-size: 12px;
+  font-weight: 700;
+}
+
+.admin-database-filter-summary {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  margin-top: 10px;
+  color: #755a49;
+  font-size: 12px;
+}
+
+.admin-database-filter-summary-label {
+  margin-right: 2px;
+  color: #9c8373;
+  font-weight: 800;
+}
+
+.admin-database-filter-summary-chip {
+  max-width: min(420px, 100%);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  border: 1px solid #eaded2;
+  border-radius: 999px;
+  background: #fffaf5;
+  padding: 4px 9px;
+}
+
+.admin-database-filter-summary-empty {
+  color: #a08b7d;
+}
+
+.admin-database-filter-remove {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 36px;
+  min-height: 38px;
+  padding: 0;
+}
+
+.admin-database-filter-actions {
+  margin-top: 10px;
+  justify-content: flex-start;
+}
+
+.admin-database-detail-table {
+  display: grid;
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid #eaded2;
+  border-radius: 10px;
+  background: #fffdf9;
+}
+
+.admin-database-detail-table-header,
+.admin-database-detail-field {
+  display: grid;
+  grid-template-columns: minmax(120px, 0.32fr) minmax(0, 1fr) auto;
+  gap: 14px;
+  align-items: center;
+}
+
+.admin-database-detail-table-header {
+  padding: 10px 14px;
+  border-bottom: 1px solid #eaded2;
+  color: #9c8373;
+  background: #f8efe8;
+  font-size: 11px;
+  font-weight: 800;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+
+.admin-database-detail-table-header > span:last-child {
+  min-width: 58px;
+  text-align: center;
+}
+
+.admin-database-detail-field-list {
+  display: grid;
+  min-width: 0;
+}
+
+.admin-database-detail-field {
+  min-width: 0;
+  padding: 12px 14px;
+  border-bottom: 1px solid #f0e5dc;
+}
+
+.admin-database-detail-field:last-child {
+  border-bottom: 0;
+}
+
+.admin-database-detail-field:nth-child(even) {
+  background: #fffbf7;
+}
+
+.admin-database-detail-field-name {
+  min-width: 0;
+  color: #8f7868;
+  font-size: 12px;
+  font-weight: 800;
+  overflow-wrap: anywhere;
+}
+
+.admin-database-detail-field-value {
+  min-width: 0;
+  color: #3d1f10;
+  font-size: 13.5px;
+  line-height: 1.5;
   white-space: pre-wrap;
   overflow-wrap: anywhere;
 }
 
+.admin-database-detail-field-value > div {
+  min-width: 0;
+}
+
+.admin-database-detail-field .admin-secondary-button {
+  min-width: 58px;
+  padding: 7px 9px;
+}
+
+.admin-database-detail-row-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 6px;
+}
+
+.admin-json-preview {
+  max-width: 100%;
+  max-height: 240px;
+  margin: 0;
+  overflow: auto;
+  scrollbar-width: thin;
+  scrollbar-color: #d1b09a transparent;
+  border: 1px solid #ead8ca;
+  border-radius: 8px;
+  color: #4d3327;
+  background: #fffaf5;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.7);
+  font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+  font-size: 12px;
+  line-height: 1.55;
+  padding: 11px 13px;
+  white-space: pre;
+  tab-size: 2;
+}
+
+.admin-json-preview::-webkit-scrollbar {
+  display: block;
+  width: 6px;
+  height: 6px;
+  background: transparent;
+}
+
+.admin-json-preview::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.admin-json-preview::-webkit-scrollbar-thumb {
+  border: 1px solid transparent;
+  border-radius: 999px;
+  background: #d1b09a;
+  background-clip: content-box;
+}
+
+.admin-json-token-key {
+  color: #a34b2f;
+}
+
+.admin-json-token-string {
+  color: #2e7a52;
+}
+
+.admin-json-token-number {
+  color: #236b9b;
+}
+
+.admin-json-token-boolean {
+  color: #6a42a3;
+}
+
+.admin-json-token-null {
+  color: #a03f55;
+}
+
+.admin-toast {
+  position: fixed;
+  right: 24px;
+  bottom: 24px;
+  z-index: 120;
+  max-width: min(360px, calc(100vw - 32px));
+  border: 1px solid #b9dfc2;
+  border-radius: 10px;
+  color: #27663a;
+  background: rgba(241, 252, 243, 0.96);
+  box-shadow: 0 14px 32px rgba(69, 47, 35, 0.16);
+  padding: 10px 14px;
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 1.4;
+  pointer-events: none;
+  animation: admin-toast-in 160ms ease-out;
+}
+
+.admin-toast[data-tone='error'] {
+  border-color: #efb9aa;
+  color: #8f3f27;
+  background: rgba(255, 242, 237, 0.97);
+}
+
+@keyframes admin-toast-in {
+  from {
+    opacity: 0;
+    transform: translateY(6px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.platform-theme--dark .admin-json-preview,
+[data-theme='dark'] .admin-json-preview,
+.admin-theme-dark .admin-json-preview {
+  border-color: #4c3a3f;
+  color: #f7eee8;
+  background: #2d2427;
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
+}
+
+.platform-theme--dark .admin-json-preview,
+[data-theme='dark'] .admin-json-preview,
+.admin-theme-dark .admin-json-preview {
+  scrollbar-color: #8c7180 transparent;
+}
+
+.platform-theme--dark .admin-json-preview::-webkit-scrollbar-thumb,
+[data-theme='dark'] .admin-json-preview::-webkit-scrollbar-thumb,
+.admin-theme-dark .admin-json-preview::-webkit-scrollbar-thumb {
+  background: #8c7180;
+  background-clip: content-box;
+}
+
+.platform-theme--dark .admin-json-token-key,
+[data-theme='dark'] .admin-json-token-key,
+.admin-theme-dark .admin-json-token-key {
+  color: #f6c177;
+}
+
+.platform-theme--dark .admin-json-token-string,
+[data-theme='dark'] .admin-json-token-string,
+.admin-theme-dark .admin-json-token-string {
+  color: #b9e6b1;
+}
+
+.platform-theme--dark .admin-json-token-number,
+[data-theme='dark'] .admin-json-token-number,
+.admin-theme-dark .admin-json-token-number {
+  color: #a9d9ff;
+}
+
+.platform-theme--dark .admin-json-token-boolean,
+[data-theme='dark'] .admin-json-token-boolean,
+.admin-theme-dark .admin-json-token-boolean {
+  color: #d2b5ff;
+}
+
+.platform-theme--dark .admin-json-token-null,
+[data-theme='dark'] .admin-json-token-null,
+.admin-theme-dark .admin-json-token-null {
+  color: #f09aa5;
+}
+
+.platform-theme--dark .admin-toast,
+[data-theme='dark'] .admin-toast,
+.admin-theme-dark .admin-toast {
+  border-color: #446d50;
+  color: #c9f2d0;
+  background: rgba(35, 54, 41, 0.96);
+}
+
+.platform-theme--dark .admin-toast[data-tone='error'],
+[data-theme='dark'] .admin-toast[data-tone='error'],
+.admin-theme-dark .admin-toast[data-tone='error'] {
+  border-color: #7c4a43;
+  color: #ffc5bb;
+  background: rgba(67, 39, 38, 0.96);
+}
+
 .admin-contract-card {
   display: grid;
   gap: 12px;
@@ -2050,8 +2644,7 @@ button:disabled {
   background: #3d1f10;
   color: #fdf9f5;
   padding: 14px;
-  font-family:
-    "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
+  font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
   font-size: 12px;
   line-height: 1.5;
   white-space: pre-wrap;
@@ -2135,7 +2728,6 @@ button:disabled {
   padding: 5px 8px;
 }
 
-
 .admin-bottom-nav {
   display: none;
 }
@@ -2183,6 +2775,32 @@ button:disabled {
     grid-template-columns: 1fr;
   }
 
+  .admin-database-filter-grid {
+    margin-right: -2px;
+    margin-left: -2px;
+  }
+
+  .admin-database-filter-header,
+  .admin-database-filter-row {
+    min-width: 680px;
+    grid-template-columns:
+      48px
+      minmax(160px, 1.1fr)
+      minmax(112px, 0.75fr)
+      minmax(230px, 1.8fr)
+      40px;
+  }
+
+  .admin-database-filter-item {
+    padding: 9px;
+  }
+
+  .admin-database-detail-table-header,
+  .admin-database-detail-field {
+    grid-template-columns: minmax(92px, 0.34fr) minmax(0, 1fr) auto;
+    gap: 9px;
+  }
+
   .admin-permission-grid {
     grid-template-columns: repeat(2, minmax(0, 1fr));
   }
@@ -2254,6 +2872,11 @@ button:disabled {
     padding: 10px 14px;
   }
 
+  .admin-toast {
+    right: 16px;
+    bottom: calc(var(--admin-bottom-nav-height, 64px) + 16px);
+  }
+
   .admin-database-tables-page {
     padding-bottom: calc(
       var(--admin-bottom-nav-height, 64px) +
@@ -2272,7 +2895,7 @@ button:disabled {
     font-weight: 700;
   }
 
-  .admin-bottom-nav-button[data-active="true"] {
+.admin-bottom-nav-button[data-active="true"] {
     color: #8f3f27;
     background: #f4e5d7;
   }
diff --git a/apps/admin-web/src/styles/admin.test.ts b/apps/admin-web/src/styles/admin.test.ts
index 50ac07c9d..2e030f439 100644
--- a/apps/admin-web/src/styles/admin.test.ts
+++ b/apps/admin-web/src/styles/admin.test.ts
@@ -21,7 +21,9 @@ describe('admin shell scrolling contract', () => {
   });
 
   test('mobile navigation stays in one horizontally scrollable row', () => {
-    const mobileStyles = stylesheet.slice(stylesheet.indexOf('@media (max-width: 980px)'));
+    const mobileStyles = stylesheet.slice(
+      stylesheet.indexOf('@media (max-width: 980px)'),
+    );
     expect(mobileStyles).toContain('.admin-bottom-nav {');
     expect(mobileStyles).toContain('display: flex');
     expect(mobileStyles).toContain('overflow-x: auto');
@@ -30,6 +32,37 @@ describe('admin shell scrolling contract', () => {
     );
     expect(mobileStyles).toContain('flex: 0 0 76px');
   });
+
+  test('database preview headers stay on one line and expose ellipsis', () => {
+    const sortButton = ruleFor('.admin-table-sort-button');
+    const sortLabel = ruleFor('.admin-table-sort-button span');
+    expect(sortButton).toContain('white-space: nowrap');
+    expect(sortButton).toContain('overflow: hidden');
+    expect(sortLabel).toContain('text-overflow: ellipsis');
+    expect(sortLabel).toContain('white-space: nowrap');
+  });
+
+  test('copy feedback uses an auto-dismissing toast surface', () => {
+    const toast = ruleFor('.admin-toast');
+    expect(toast).toContain('position: fixed');
+    expect(toast).toContain('z-index: 120');
+    expect(toast).toContain('pointer-events: none');
+    expect(toast).toContain('animation: admin-toast-in');
+    expect(stylesheet).toContain(".admin-toast[data-tone='error']");
+  });
+
+  test('detail JSON keeps only a slim scrollbar thumb', () => {
+    const json = ruleFor('.admin-json-preview');
+    expect(json).toContain('scrollbar-width: thin');
+    expect(json).toContain('scrollbar-color: #d1b09a transparent');
+    expect(stylesheet).toContain(
+      '.admin-json-preview::-webkit-scrollbar-track',
+    );
+    expect(stylesheet).toContain('background: transparent');
+    expect(stylesheet).toContain(
+      '.admin-json-preview::-webkit-scrollbar-thumb',
+    );
+  });
 });
 
 function ruleFor(selector: string) {
diff --git a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/SKILL.md b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/SKILL.md
index 2ad081566..bc4fa72f6 100644
--- a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/SKILL.md
+++ b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/SKILL.md
@@ -10,7 +10,7 @@ Let the client derive projections from real disk changes and trusted tool result
 ## Workflow
 
 1. Write executable source to `index.html`, `style.css`, and `game.js` in the current cwd. Use only relative paths returned by approved tools for media.
-2. Before using or deriving an existing registered asset, call `agc_list_registered_assets` and select its `localAssetId`. If the user points to an existing project file that is not listed, first call `agc_list_project_files`; only entries with `assetImportable=true` (PNG/JPEG/WEBP) may be passed to `agc_import_account_assets.localPaths`. Then re-read `agc_list_registered_assets`; never infer a source identity from a filename or fabricate a localAssetId.
+2. Before using or deriving an existing registered asset, call `agc_list_registered_assets` and select its `localAssetId`. If the user points to an existing project file that is not listed, first call `agc_list_project_files`; only entries with `assetImportable=true` (recognized image, font, audio, video, document, or code files) may be passed to `agc_import_account_assets.localPaths`. Then re-read `agc_list_registered_assets`; never infer a source identity from a filename or fabricate a localAssetId.
 3. Keep read scopes separate: `asset.list` is the current project manifest, `asset.library.list` is the signed-in account library, and the web project's canvas resource read model is the authoritative canvas list. The account library is not the complete canvas list.
 4. Use `canvas.asset_import` for safe account/canvas asset IDs or project-relative local paths. The client rechecks ownership and validates bytes; host absolute paths require native UI file-picker authorization.
 5. When the user explicitly asks to create or derive video, character animation, sound effect, or background music, call `agc_create_or_derive_resource`. Use `create` only for video/audio without a source and `derive` with a registered `sourceLocalAssetId`; character animation is always derived from an image.
diff --git a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/references/projection-contract.md b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/references/projection-contract.md
index 8bce1c850..15006410b 100644
--- a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/references/projection-contract.md
+++ b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-client-projection/references/projection-contract.md
@@ -8,7 +8,7 @@ The client projects three distinct facts:
 
 Do not collapse these facts. A playable file can exist before projection refresh, a registered image can exist without being used by the game, and browser success does not create platform provenance.
 
-`agc_list_project_files` is the bounded Direct discovery path for real project files. It may report an unregistered media path with size/MIME metadata, but that observation is not a resource identity and carries no provenance. Its `assetImportable` field is true only for PNG/JPEG/WEBP files accepted by the current local-image registration contract; GIF/SVG and non-image files remain discoverable but must not be passed to the image importer. `agc_import_account_assets.localPaths` is the controlled bridge that validates and registers an importable project-local image. `agc_list_registered_assets` remains the authoritative Direct read path for manifest resource identity; only its stable identifiers may be passed to generation/derivation tools.
+`agc_list_project_files` is the bounded Direct discovery path for real project files. It may report an unregistered project-relative path with size/MIME metadata, but that observation is not a resource identity and carries no provenance. Its `assetImportable` field is true for the file types accepted by the current local registration contract: PNG/JPEG/WEBP/GIF/SVG/AVIF/BMP images, TTF/OTF/WOFF fonts, MP3/WAV/OGG/FLAC/M4A/AAC/OPUS audio, MP4/WEBM/MOV video, recognized text documents, and recognized source-code files. `agc_import_account_assets.localPaths` is the controlled bridge that validates and registers an importable project-local resource. `agc_list_registered_assets` remains the authoritative Direct read path for manifest resource identity; only its stable identifiers may be passed to generation/derivation tools.
 
 Read scopes remain separate: `asset.list` is the current project's local manifest, `asset.library.list` is the signed-in account library, and the web project's canvas resource read model is authoritative for resources visible on that canvas. A library result must not be presented as the complete canvas list. `canvas.asset_import` accepts safe account/canvas asset IDs or project-relative local paths; receipts expose only bounded counts, safe IDs, relative paths, sources, redacted failures, and `revisionAdvanceCount`.
 
diff --git a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/SKILL.md b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/SKILL.md
index ad45a6cea..836ac2194 100644
--- a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/SKILL.md
+++ b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/SKILL.md
@@ -12,7 +12,7 @@ Treat the current working directory as the only project root.
 1. Inspect the existing files needed for the request before editing.
 2. The current working directory is the selected project root. Read and edit `index.html`, `style.css`, `game.js`, and `assets/` there unless the existing project deliberately uses a `game/` subdirectory for its source.
 3. To discover media or other existing project files, call `agc_list_project_files` with an optional project-relative scope. It returns safe project-relative paths (including `assets/` and `game/`) plus bounded metadata; an unregistered file is only a discovery candidate, not a manifest asset.
-4. Platform media and project-local media are exposed read-only through approved `agc_tools`; when a user asks to use an unregistered PNG/JPEG/WEBP, pass the returned project-relative path to `agc_import_account_assets.localPaths`, then re-read `agc_list_registered_assets` for the formal identity. Do not infer provenance or fabricate an asset ID from a filename.
+4. Platform media and project-local media are exposed read-only through approved `agc_tools`; when a user asks to use an unregistered recognized image, font, audio, video, document, or code file, pass the returned project-relative path to `agc_import_account_assets.localPaths`, then re-read `agc_list_registered_assets` for the formal identity. Do not infer provenance or fabricate an asset ID from a filename.
 5. Treat the parent `.agent/` directory as client-owned durable state. Do not read it with native file or shell tools; use the approved AGC tools when project identity or registered asset evidence is needed. Never hand-edit manifests, revisions, versions, ledgers, receipts, or provenance records.
 6. Reuse existing files and asset identities. Do not create a second project root, hidden harness, Supervisor workspace, or parallel implementation.
 7. Make the smallest coherent change that satisfies the user request, then inspect the actual changed files.
diff --git a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/references/structure-contract.md b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/references/structure-contract.md
index e2dab9c90..ad90265c9 100644
--- a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/references/structure-contract.md
+++ b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/agc-project-structure/references/structure-contract.md
@@ -5,7 +5,7 @@
 | `index.html` | Game source in the current cwd | Read and edit |
 | `style.css` | Game source in the current cwd | Read and edit |
 | `game.js` | Game source in the current cwd | Read and edit |
-| `assets/` | Project media in the current cwd | Read and edit; import an unregistered PNG/JPEG/WEBP through `agc_import_account_assets.localPaths`; formal identity comes only after manifest registration |
+| `assets/` | Project media in the current cwd | Read and edit; import an unregistered recognized resource through `agc_import_account_assets.localPaths`; formal identity comes only after manifest registration |
 | Other project-root-relative files | Existing project files | Discover with `agc_list_project_files` or `file.list`; do not treat a path as a registered asset or expose sensitive/control paths |
 | `.agent/` | AGC client state | Do not read or write with native tools |
 
diff --git a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/manifest.json b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/manifest.json
index a5d8a510d..6d38b0b09 100644
--- a/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/manifest.json
+++ b/apps/ai-game-creator-shell/src-tauri/resources/agc-skills/manifest.json
@@ -21,7 +21,7 @@
         "agents/openai.yaml",
         "references/structure-contract.md"
       ],
-      "sha256": "2556b40c4e73c8af5c027d1222b569d34129880dfeabff38b50ad248307b5c0c"
+      "sha256": "85dd861201d7b9a5d34b702b7b79ce18012e06784dddf2fb8e836e085fee4b00"
     },
     {
       "name": "taonier-art-assets",
@@ -106,7 +106,7 @@
         "agents/openai.yaml",
         "references/projection-contract.md"
       ],
-      "sha256": "2e11baf232bd1a786cc3189a9183e3a687b846c4e0816393e5b5687551a5eeb7"
+      "sha256": "7800e8ee4b5baa6f473b904f262197f5320a46150ae5e51c56a298fc21674e30"
     }
   ]
 }
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs
index 798bac52e..68c0234c2 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs
@@ -3969,7 +3969,7 @@ async fn run_direct_game_creator_turn_with_private_editor_credentials(
         DirectCodexTurnFailure::new(DirectCodexFailureStage::CodeGeneration, error)
     })?;
     if prepare_art {
-        system_prompt.push_str("\n本回合已由陶泥儿平台准备并登记真实美术资源。请按需读取当前 cwd 的游戏源码；正式素材先用 `agc_list_registered_assets` 选择。如果发现项目中实际存在但清单没有的 PNG/JPEG/WEBP，先用 `agc_list_project_files` 发现，再把项目相对路径交给 `agc_import_account_assets.localPaths` 登记，随后重新读取 `agc_list_registered_assets`；不要从文件名伪造 assetId/localAssetId，也不要假设四切片一定存在或伪造缺失衍生物。客户端会在回合后启动真实 desktop/mobile 浏览器试玩，把结构化截图、Canvas、控制台、网络和交互证据发回同一会话；请依据证据自行决定是否继续修复。");
+        system_prompt.push_str("\n本回合已由陶泥儿平台准备并登记真实资源。请按需读取当前 cwd 的游戏源码；正式素材先用 `agc_list_registered_assets` 选择。如果发现项目中实际存在但清单没有的已识别图片、字体、音频、视频、文档或代码文件，先用 `agc_list_project_files` 发现，再把项目相对路径交给 `agc_import_account_assets.localPaths` 登记，随后重新读取 `agc_list_registered_assets`；不要从文件名伪造 assetId/localAssetId，也不要假设四切片一定存在或伪造缺失衍生物。客户端会在回合后启动真实 desktop/mobile 浏览器试玩，把结构化截图、Canvas、控制台、网络和交互证据发回同一会话；请依据证据自行决定是否继续修复。");
         emit_direct_game_creator_progress(root, "codex.start", "美术素材已准备，正在生成游戏代码");
     } else {
         system_prompt.push_str("\n这是已有游戏的继续编辑回合：不要生成、下载或请求任何新美术，也不要创建新项目。直接读取当前 cwd 的游戏源码，并按用户需求最小修改；随后通过 `agc_browser_playtest` 获取真实 desktop/mobile 浏览器证据。客户端会把结构化证据回灌同一会话。");
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs
index 7330dd43b..813215a9b 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs
@@ -1268,6 +1268,8 @@ fn bridge_project_file_class(path: &str) -> (&'static str, Option<&'static str>)
         "png" => ("image", Some("image/png")),
         "jpg" | "jpeg" => ("image", Some("image/jpeg")),
         "webp" => ("image", Some("image/webp")),
+        "avif" => ("image", Some("image/avif")),
+        "bmp" => ("image", Some("image/bmp")),
         "gif" => ("image", Some("image/gif")),
         "svg" => ("image", Some("image/svg+xml")),
         "ttf" => ("font", Some("font/ttf")),
@@ -1279,15 +1281,26 @@ fn bridge_project_file_class(path: &str) -> (&'static str, Option<&'static str>)
         "ogg" => ("audio", Some("audio/ogg")),
         "flac" => ("audio", Some("audio/flac")),
         "m4a" => ("audio", Some("audio/mp4")),
+        "aac" => ("audio", Some("audio/aac")),
+        "opus" => ("audio", Some("audio/opus")),
         "mp4" => ("video", Some("video/mp4")),
         "webm" => ("video", Some("video/webm")),
         "mov" => ("video", Some("video/quicktime")),
+        "md" | "markdown" | "mdx" | "txt" | "json" | "yaml" | "yml" | "toml"
+        | "csv" | "ini" | "conf" | "xml" => ("document", Some(match extension.as_str() {
+            "json" => "application/json",
+            "yaml" | "yml" => "application/yaml",
+            "xml" => "application/xml",
+            _ => "text/plain",
+        })),
         "html" | "htm" => ("code", Some("text/html")),
-        "css" => ("code", Some("text/css")),
+        "css" | "scss" | "less" => ("code", Some("text/css")),
         "js" | "mjs" | "cjs" | "ts" | "tsx" => ("code", Some("text/javascript")),
-        "json" => ("code", Some("application/json")),
-        "md" | "txt" => ("code", Some("text/plain")),
-        "gd" => ("code", Some("text/plain")),
+        "gd" | "rs" | "py" | "go" | "java" | "kt" | "kts" | "c" | "cc" | "cpp"
+        | "h" | "hpp" | "cs" | "swift" | "php" | "rb" | "lua" | "sh" | "bash"
+        | "zsh" | "sql" | "graphql" | "gql" | "vue" | "svelte" => {
+            ("code", Some("text/plain"))
+        }
         _ => ("other", None),
     }
 }
@@ -1295,7 +1308,7 @@ fn bridge_project_file_class(path: &str) -> (&'static str, Option<&'static str>)
 fn bridge_project_file_is_asset_importable(path: &str) -> bool {
     matches!(
         bridge_project_file_class(path).1,
-        Some("image/png" | "image/jpeg" | "image/webp")
+        Some(_)
     )
 }
 
@@ -1332,7 +1345,7 @@ fn bridge_list_project_files(root: &Path, arguments: &Value) -> Value {
             .map(|value| value.to_lowercase());
         let requested_kind = bridge_optional_bounded_string(arguments, "kind", 16)?
             .unwrap_or_else(|| "all".to_string());
-        if !["all", "image", "font", "audio", "video", "code"].contains(&requested_kind.as_str()) {
+        if !["all", "image", "font", "audio", "video", "document", "code"].contains(&requested_kind.as_str()) {
             return Err("工具参数 kind 不是受支持的项目文件类别".to_string());
         }
         let (offset, limit) = bridge_account_asset_page(arguments)?;
@@ -1396,7 +1409,7 @@ fn bridge_list_project_files(root: &Path, arguments: &Value) -> Value {
             "limit": limit,
             "nextOffset": next_offset,
             "files": page,
-            "next": "仅把未登记且 assetImportable=true 的 PNG/JPEG/WEBP path 作为项目相对 localPaths 交给 agc_import_account_assets；登记后再用 agc_list_registered_assets 获取 localAssetId。"
+            "next": "仅把未登记且 assetImportable=true 的项目相对路径交给 agc_import_account_assets；登记后再用 agc_list_registered_assets 获取 localAssetId。"
         }))
     })();
     match result {
@@ -1542,7 +1555,7 @@ async fn bridge_list_account_assets(state: &DirectToolBridgeState, arguments: &V
             "limit": limit,
             "nextOffset": next_offset,
             "assets": page,
-            "next": "账户素材或 project-canvas 资源使用返回的 assetId/resourceId 调用 agc_import_account_assets；项目内本地图片先用 agc_list_project_files；不要提交 objectKey、URL 或宿主绝对路径"
+            "next": "账户素材或 project-canvas 资源使用返回的 assetId/resourceId 调用 agc_import_account_assets；项目内本地资源先用 agc_list_project_files；不要提交 objectKey、URL 或宿主绝对路径"
         }))
     }
     .await;
@@ -1590,7 +1603,7 @@ async fn bridge_import_account_assets(state: &DirectToolBridgeState, arguments:
             }
         }
         if !local_paths.is_empty() {
-            match import_local_project_image_assets_for_agent(&state.root, &local_paths) {
+            match import_local_project_assets_for_agent(&state.root, &local_paths) {
                 Ok(result) => imported.extend(result.assets.into_iter().map(|asset| {
                     json!({
                         "id": asset.id,
@@ -2407,15 +2420,22 @@ mod tests {
                 "supported raster image should be importable: {path}"
             );
         }
+        for path in ["assets/theme.bin", "assets/unknown.xyz"] {
+            assert!(
+                !bridge_project_file_is_asset_importable(path),
+                "unsupported project file must not be advertised as importable: {path}"
+            );
+        }
         for path in [
             "assets/hero.gif",
             "assets/hero.svg",
             "assets/theme.mp3",
             "game/index.html",
+            "assets/design.md",
         ] {
             assert!(
-                !bridge_project_file_is_asset_importable(path),
-                "unsupported project file must not be advertised as importable: {path}"
+                bridge_project_file_is_asset_importable(path),
+                "recognized project file should be advertised as importable: {path}"
             );
         }
     }
@@ -2463,8 +2483,8 @@ mod tests {
             })
             .collect::<BTreeMap<_, _>>();
         assert_eq!(importability.get("assets/hero.png"), Some(&true));
-        assert_eq!(importability.get("assets/preview.gif"), Some(&false));
-        assert_eq!(importability.get("assets/vector.svg"), Some(&false));
+        assert_eq!(importability.get("assets/preview.gif"), Some(&true));
+        assert_eq!(importability.get("assets/vector.svg"), Some(&true));
     }
 
     #[test]
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs
index 7c896bd3a..624ea552a 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs
@@ -212,7 +212,7 @@ fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value {
         }),
         json!({
                 "name": "agc_list_project_files",
-                "description": "列出当前 AGC 项目根下真实存在的安全项目文件，包括尚未登记的本地图片。结果只返回项目相对路径、大小、文件类别、是否已登记及 assetImportable；不会读取或返回文件内容、宿主绝对路径、.agent 控制面或凭据。仅把 assetImportable=true 的 PNG/JPEG/WEBP 项目相对路径交给 agc_import_account_assets.localPaths。",
+                "description": "列出当前 AGC 项目根下真实存在的安全项目文件，包括尚未登记的本地资源。结果只返回项目相对路径、大小、文件类别、是否已登记及 assetImportable；不会读取或返回文件内容、宿主绝对路径、.agent 控制面或凭据。仅把 assetImportable=true 的项目相对路径交给 agc_import_account_assets.localPaths。",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
@@ -229,7 +229,7 @@ fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value {
                         },
                         "kind": {
                             "type": "string",
-                            "enum": ["all", "image", "font", "audio", "video", "code"]
+                            "enum": ["all", "image", "font", "audio", "video", "document", "code"]
                         },
                         "offset": { "type": "integer", "minimum": 0, "maximum": 500 },
                         "limit": { "type": "integer", "minimum": 1, "maximum": 100 }
@@ -239,7 +239,7 @@ fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value {
         }),
         json!({
                 "name": "agc_list_account_assets",
-                "description": "查询当前登录账户网页/云端素材库，以及当前项目已绑定网页画布 project.resources 中的静态图片安全投影。客户端重新校验当前账号并隐藏 objectKey、URL、签名地址、宿主路径和凭据；结果中的 assetId/resourceId 可交给 agc_import_account_assets；项目内本地图片另用 agc_list_project_files 发现。",
+                "description": "查询当前登录账户网页/云端素材库，以及当前项目已绑定网页画布 project.resources 中的静态图片安全投影。客户端重新校验当前账号并隐藏 objectKey、URL、签名地址、宿主路径和凭据；结果中的 assetId/resourceId 可交给 agc_import_account_assets；项目内本地资源另用 agc_list_project_files 发现。",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
@@ -253,7 +253,7 @@ fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value {
         }),
         json!({
                 "name": "agc_import_account_assets",
-                "description": "导入账户图片、已绑定网页项目画布图片或项目内本地图片。assetIds 必须使用 agc_list_account_assets 返回的账户 assetId 或 project-canvas resourceId；本地图片只能使用 agc_list_project_files 返回的项目根相对 localPaths（包括 assets/ 与 game/），不得使用 .agent、父级穿越或宿主绝对路径。assetIds 与 localPaths 可混合提交；客户端负责账号/项目归属、换签下载、格式/大小校验、项目锁、manifest 与 revision，模型不得提交 objectKey、URL 或凭据。",
+                "description": "导入账户图片、已绑定网页项目画布图片或项目内本地资源。assetIds 必须使用 agc_list_account_assets 返回的账户 assetId 或 project-canvas resourceId；本地资源只能使用 agc_list_project_files 返回的项目根相对 localPaths（包括 assets/ 与 game/），不得使用 .agent、父级穿越或宿主绝对路径。assetIds 与 localPaths 可混合提交；客户端负责账号/项目归属、换签下载、格式/大小校验、项目锁、manifest 与 revision，模型不得提交 objectKey、URL 或凭据。",
                 "inputSchema": {
                     "type": "object",
                     "properties": {
@@ -569,7 +569,9 @@ fn validate_project_file_list_arguments(arguments: &Value) -> Result<(), String>
     }
     if arguments.get("kind").is_some() {
         let kind = bounded_tool_string(arguments, "kind", 16)?;
-        if !["all", "image", "font", "audio", "video", "code"].contains(&kind.as_str()) {
+        if !["all", "image", "font", "audio", "video", "document", "code"]
+            .contains(&kind.as_str())
+        {
             return Err("工具参数 kind 不是受支持的项目文件类别".to_string());
         }
     }
@@ -1344,6 +1346,11 @@ mod tests {
             "limit": 100
         }))
         .is_ok());
+        assert!(validate_project_file_list_arguments(&json!({
+            "path": "assets",
+            "kind": "document"
+        }))
+        .is_ok());
         assert!(validate_project_file_list_arguments(&json!({
             "path": "../outside"
         }))
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/generation/prompt_context.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/generation/prompt_context.rs
index e1b1a1aa5..2fb70fe5e 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/generation/prompt_context.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/generation/prompt_context.rs
@@ -159,10 +159,10 @@ pub(crate) fn render_local_asset_prompt_context(root: &Path) -> Result<String, S
         output.push_str(
             "# 项目内未登记媒体文件（仅发现，不是正式资产）\n\n\
 - 这些文件真实存在于当前项目，但尚未取得 manifest assetId/localAssetId、来源或 provenance。\n\
-- 只有 `assetImportable=true` 的 PNG/JPEG/WEBP 可交给当前图片导入工具；其它媒体只可发现。需要正式使用时，先用 `file.list`/`agc_list_project_files` 确认路径，再用受控导入工具登记；不要把路径文本当作已登记资源身份。\n",
+- 只有 `assetImportable=true` 的已识别图片、字体、音频、视频、文档或代码文件可交给当前资源导入工具；其它文件只可发现。需要正式使用时，先用 `file.list`/`agc_list_project_files` 确认路径，再用受控导入工具登记；不要把路径文本当作已登记资源身份。\n",
         );
         for (path, size, media_type) in unregistered.iter().take(48) {
-            let asset_importable = matches!(*media_type, "image/png" | "image/jpeg" | "image/webp");
+            let asset_importable = !media_type.is_empty();
             output.push_str(&format!(
                 "- {path} / {media_type} / {size} bytes / registered=false / assetImportable={asset_importable}\n"
             ));
@@ -200,6 +200,8 @@ fn prompt_context_media_type(path: &str) -> Option<&'static str> {
         "jpg" | "jpeg" => Some("image/jpeg"),
         "webp" => Some("image/webp"),
         "gif" => Some("image/gif"),
+        "avif" => Some("image/avif"),
+        "bmp" => Some("image/bmp"),
         "svg" => Some("image/svg+xml"),
         "ttf" => Some("font/ttf"),
         "otf" => Some("font/otf"),
@@ -210,13 +212,48 @@ fn prompt_context_media_type(path: &str) -> Option<&'static str> {
         "ogg" => Some("audio/ogg"),
         "flac" => Some("audio/flac"),
         "m4a" => Some("audio/mp4"),
+        "aac" => Some("audio/aac"),
+        "opus" => Some("audio/opus"),
         "mp4" => Some("video/mp4"),
         "webm" => Some("video/webm"),
         "mov" => Some("video/quicktime"),
+        "json" => Some("application/json"),
+        "yaml" | "yml" => Some("application/yaml"),
+        "xml" => Some("application/xml"),
+        "html" | "htm" => Some("text/html"),
+        "md" | "markdown" | "mdx" | "txt" | "toml" | "csv" | "ini" | "conf" => {
+            Some("text/plain")
+        }
+        "css" | "scss" | "less" => Some("text/css"),
+        "js" | "mjs" | "cjs" | "ts" | "tsx" | "gd" | "rs" | "py" | "go"
+        | "java" | "kt" | "kts" | "c" | "cc" | "cpp" | "h" | "hpp" | "cs"
+        | "swift" | "php" | "rb" | "lua" | "sh" | "bash" | "zsh" | "sql"
+        | "graphql" | "gql" | "vue" | "svelte" => Some("text/plain"),
         _ => None,
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::prompt_context_media_type;
+
+    #[test]
+    fn prompt_context_media_type_covers_all_importable_resource_categories() {
+        for (path, expected) in [
+            ("assets/icon.avif", "image/avif"),
+            ("assets/font.woff2", "font/woff2"),
+            ("assets/theme.opus", "audio/opus"),
+            ("assets/intro.mov", "video/quicktime"),
+            ("assets/data.json", "application/json"),
+            ("game/index.html", "text/html"),
+            ("game/main.rs", "text/plain"),
+        ] {
+            assert_eq!(prompt_context_media_type(path), Some(expected), "{path}");
+        }
+        assert_eq!(prompt_context_media_type("assets/unknown.bin"), None);
+    }
+}
+
 pub(crate) fn render_local_conversation_prompt_context(
     root: &Path,
     agent_id: Option<&str>,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
index 51e452b0f..7af11a305 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/provider_request_builders.rs
@@ -384,8 +384,8 @@ fn build_game_creator_agent_background_tool_plan_request_at(
             "file.list 使用 {{\"path\":\"\"}}，path 为空字符串时列出项目摘要；file.read 使用 {{\"path\":\"项目内相对路径\",\"startLine\":1,\"maxLines\":120}}；file.write 使用 {{\"path\":\"项目内相对路径\",\"content\":\"完整文件内容\"}}；file.patch 使用 {{\"path\":\"项目内相对路径\",\"oldText\":\"必须精确匹配的原文\",\"newText\":\"替换后的文本\",\"expectedReplacements\":1}}；file.delete 使用 {{\"path\":\"项目内相对路径\"}}，只删除项目内普通文件，不删除目录或任何 .agent 控制面文件。\n",
             "task.create 使用 {{\"taskId\":null,\"title\":\"任务标题\",\"group\":\"design|art|code|balance|audio|publishing\",\"role\":\"角色名\",\"dependencies\":[],\"artifacts\":[],\"acceptanceCriteria\":[\"验收标准\"],\"status\":\"pending|running|waiting-for-confirmation|completed|failed\"}}，需要自定义 taskId 时把 null 替换为合法 ID；task.update 使用 {{\"taskId\":\"manifest taskId\",\"status\":\"pending|running|waiting-for-confirmation|completed|failed\"}}；{limited_command_contract}\n",
             "canvas.asset_generate 使用 {{\"prompt\":\"图片描述\",\"outputPath\":null,\"aspectRatio\":null,\"imageSize\":null,\"assetKind\":null,\"assetLabel\":null,\"replaceExisting\":false}}；需要指定时，aspectRatio 只允许 1:1|2:3|3:2|9:16|16:9，imageSize 只允许 0.5K|1K|2K，assetKind 只允许 {canvas_asset_kind_catalog}。replaceExisting 只能在带 repairOfDelegationId 的唯一返工委派中设为 true，普通生成必须为 false，并通过配置的 External Editor API 同时写入画布、同名素材库目录和本地 assets。\n",
-            "asset.library.list 使用 {{\"folderId\":null,\"query\":null,\"offset\":0,\"limit\":100}} 查询当前登录账户的网页/云端静态图片，以及当前项目已绑定网页画布的 project.resources 图片；结果只含 assetId/resourceId 与安全展示元数据，不含 URL、objectKey、签名地址或凭据。账户或画布图片必须先查询再导入。file.list/asset.list 仍用于发现项目内尚未登记的本地图片。\n",
-            "canvas.asset_import 使用 {{\"assetIds\":[],\"localPaths\":[]}}；assetIds 必须来自最近一次 asset.library.list（账户素材或 project-canvas 资源均可），localPaths 必须是 file.list 返回的项目根内相对 PNG/JPEG/WEBP 路径（包括 assets/ 与 game/），不能提交 objectKey、URL、绝对路径或凭据。两类数组可以混合提交；导入成功后 Runtime 会下载/校验或登记本地图片、更新 manifest 并推进 revision。\n",
+            "asset.library.list 使用 {{\"folderId\":null,\"query\":null,\"offset\":0,\"limit\":100}} 查询当前登录账户的网页/云端静态图片，以及当前项目已绑定网页画布的 project.resources 图片；结果只含 assetId/resourceId 与安全展示元数据，不含 URL、objectKey、签名地址或凭据。账户或画布图片必须先查询再导入。file.list/asset.list 仍用于发现项目内尚未登记的本地资源。\n",
+            "canvas.asset_import 使用 {{\"assetIds\":[],\"localPaths\":[]}}；assetIds 必须来自最近一次 asset.library.list（账户素材或 project-canvas 资源均可），localPaths 必须是 file.list 返回的项目根内相对已识别资源路径（包括 assets/ 与 game/），不能提交 objectKey、URL、绝对路径或凭据。两类数组可以混合提交；导入成功后 Runtime 会下载/校验或登记本地资源、更新 manifest 并推进 revision。\n",
             "blackboard.write 使用 {{\"title\":\"标题\",\"content\":\"要共享给所有 Agent 的稳定结论\"}}；agent.message 使用 {{\"agentId\":\"目标 taskId\",\"content\":\"给目标 Agent 的定向消息\"}}；agent.delegate 使用 {{\"agentId\":\"目标 taskId\",\"task\":\"要委派的后台任务\",\"acceptanceCriteria\":[\"可核对的语义验收条件\"],\"expectedArtifacts\":[],\"repairOfDelegationId\":null,\"runId\":null}}，expectedArtifacts 无产物时传空数组且不接受 glob；返工时 repairOfDelegationId 指向已认领原 delivery 且 runId 必须为 null；agent.schedule_ready 使用 {{\"limit\":1}}；agent.run_status 使用 {{\"agentId\":null,\"scope\":\"all\",\"delegationId\":null}}，指定目标 Agent 或已认领 delegation 时把对应 null 替换为实际 ID；当前可信父 Run 传 delegationId 时读取自己已认领的未截断权威返工合同。\n",
             "只有 conversation.read、asset.list、project.index、project.checkpoint、task.list、preview.start 的 arguments.input 使用空对象 {{}}；asset.library.list 也允许使用其广告 schema 中的全 null/分页默认值；其他函数必须提交实际广告 schema 的全部 required 字段。如果已有观察足够，必须调用 respond_to_user 交付最终回复。"
         ),
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/context.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/context.rs
index 0580895f0..cbcc08d97 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/context.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/context.rs
@@ -475,7 +475,7 @@ fn runtime_asset_import_string_array(
                         .any(|part| part.eq_ignore_ascii_case(".codex"))
                     || reject_sensitive_project_file_read(text).is_err()
                 {
-                    return Err("localPaths 只能使用受控项目根内的项目相对图片路径".to_string());
+                    return Err("localPaths 只能使用受控项目根内的项目相对资源路径".to_string());
                 }
             }
             Ok(text.to_string())
@@ -579,7 +579,7 @@ pub(in crate::agent) async fn observe_agent_runtime_asset_import(
         }
     }
     if !local_paths.is_empty() {
-        match import_local_project_image_assets_for_agent(root, &local_paths) {
+        match import_local_project_assets_for_agent(root, &local_paths) {
             Ok(result) => imported.extend(result.assets.into_iter().map(|asset| {
                 serde_json::json!({
                     "id": asset.id,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs b/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs
index 8ef1b13d1..3f34dc890 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs
@@ -1356,7 +1356,7 @@ fn runtime_tool_description(tool: &str) -> &'static str {
             "读取当前登录账户的云端/网页素材库静态图片，以及当前项目已绑定网页画布 project.resources 图片安全投影；不返回 URL、objectKey、签名地址或凭据。"
         }
         "canvas.asset_import" => {
-            "把账户素材库/绑定网页项目画布中的 assetId（resourceId）或项目内 localPaths 图片导入当前项目并登记 manifest；两类输入可混合。账户与画布素材先用 asset.library.list 查询，本地图片先用 file.list 发现；客户端内部负责归属校验、换签下载、格式/大小校验、项目锁和 revision。"
+            "把账户素材库/绑定网页项目画布中的 assetId（resourceId）或项目内 localPaths 资源导入当前项目并登记 manifest；两类输入可混合。账户与画布素材先用 asset.library.list 查询，本地资源先用 file.list 发现；客户端内部负责归属校验、换签下载、格式/大小校验、项目锁和 revision。"
         }
         "project.index" => "刷新并读取有界仓库启动上下文。",
         "project.search" => "在项目文本文件中做有界字面量搜索。",
diff --git a/apps/ai-game-creator-shell/src-tauri/src/assets.rs b/apps/ai-game-creator-shell/src-tauri/src/assets.rs
index 2abccf8f7..d438bf0df 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/assets.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/assets.rs
@@ -1428,26 +1428,81 @@ pub(crate) fn percent_encode_query_component(value: &str) -> String {
 pub(crate) fn infer_file_extension(source: Option<&str>, media_type: &str) -> &'static str {
     if let Some(source) = source {
         let path = source.split('?').next().unwrap_or(source);
-        if path.ends_with(".png") {
-            return "png";
-        }
-        if path.ends_with(".jpg") || path.ends_with(".jpeg") {
-            return "jpg";
-        }
-        if path.ends_with(".webp") {
-            return "webp";
-        }
-        if path.ends_with(".gif") {
-            return "gif";
-        }
-        if path.ends_with(".mp3") {
-            return "mp3";
-        }
-        if path.ends_with(".wav") {
-            return "wav";
-        }
-        if path.ends_with(".mp4") {
-            return "mp4";
+        match Path::new(path)
+            .extension()
+            .and_then(|extension| extension.to_str())
+            .map(|extension| extension.to_ascii_lowercase())
+            .as_deref()
+        {
+            Some("png") => return "png",
+            Some("jpg" | "jpeg") => return "jpg",
+            Some("webp") => return "webp",
+            Some("gif") => return "gif",
+            Some("svg") => return "svg",
+            Some("avif") => return "avif",
+            Some("bmp") => return "bmp",
+            Some("ttf") => return "ttf",
+            Some("otf") => return "otf",
+            Some("woff") => return "woff",
+            Some("woff2") => return "woff2",
+            Some("mp3") => return "mp3",
+            Some("wav") => return "wav",
+            Some("ogg") => return "ogg",
+            Some("flac") => return "flac",
+            Some("m4a") => return "m4a",
+            Some("aac") => return "aac",
+            Some("opus") => return "opus",
+            Some("mp4") => return "mp4",
+            Some("webm") => return "webm",
+            Some("mov") => return "mov",
+            Some("md") => return "md",
+            Some("markdown") => return "markdown",
+            Some("mdx") => return "mdx",
+            Some("txt") => return "txt",
+            Some("json") => return "json",
+            Some("yaml") => return "yaml",
+            Some("yml") => return "yml",
+            Some("toml") => return "toml",
+            Some("csv") => return "csv",
+            Some("ini") => return "ini",
+            Some("conf") => return "conf",
+            Some("xml") => return "xml",
+            Some("html") => return "html",
+            Some("htm") => return "htm",
+            Some("css") => return "css",
+            Some("scss") => return "scss",
+            Some("less") => return "less",
+            Some("js") => return "js",
+            Some("mjs") => return "mjs",
+            Some("cjs") => return "cjs",
+            Some("ts") => return "ts",
+            Some("tsx") => return "tsx",
+            Some("gd") => return "gd",
+            Some("rs") => return "rs",
+            Some("py") => return "py",
+            Some("go") => return "go",
+            Some("java") => return "java",
+            Some("kt") => return "kt",
+            Some("kts") => return "kts",
+            Some("c") => return "c",
+            Some("cc") => return "cc",
+            Some("cpp") => return "cpp",
+            Some("h") => return "h",
+            Some("hpp") => return "hpp",
+            Some("cs") => return "cs",
+            Some("swift") => return "swift",
+            Some("php") => return "php",
+            Some("rb") => return "rb",
+            Some("lua") => return "lua",
+            Some("sh") => return "sh",
+            Some("bash") => return "bash",
+            Some("zsh") => return "zsh",
+            Some("sql") => return "sql",
+            Some("graphql") => return "graphql",
+            Some("gql") => return "gql",
+            Some("vue") => return "vue",
+            Some("svelte") => return "svelte",
+            _ => {}
         }
     }
     match media_type.split(';').next().unwrap_or(media_type).trim() {
@@ -1455,9 +1510,29 @@ pub(crate) fn infer_file_extension(source: Option<&str>, media_type: &str) -> &'
         "image/jpeg" => "jpg",
         "image/webp" => "webp",
         "image/gif" => "gif",
+        "image/svg+xml" => "svg",
+        "image/avif" => "avif",
+        "image/bmp" => "bmp",
+        "font/ttf" => "ttf",
+        "font/otf" => "otf",
+        "font/woff" => "woff",
+        "font/woff2" => "woff2",
         "audio/mpeg" => "mp3",
         "audio/wav" | "audio/x-wav" => "wav",
+        "audio/ogg" => "ogg",
+        "audio/flac" => "flac",
+        "audio/mp4" => "m4a",
+        "audio/aac" => "aac",
+        "audio/opus" => "opus",
         "video/mp4" => "mp4",
+        "video/webm" => "webm",
+        "video/quicktime" => "mov",
+        "application/json" => "json",
+        "application/yaml" => "yaml",
+        "application/xml" => "xml",
+        "text/html" => "html",
+        "text/css" => "css",
+        "text/plain" => "txt",
         _ => "bin",
     }
 }
@@ -1722,6 +1797,14 @@ mod tests {
     use super::*;
     use std::io::{Read, Write};
 
+    #[test]
+    fn infer_file_extension_preserves_supported_local_resource_extensions() {
+        assert_eq!(infer_file_extension(Some("game/Index.HTML"), "text/html"), "html");
+        assert_eq!(infer_file_extension(Some("assets/theme.MP3"), "audio/mpeg"), "mp3");
+        assert_eq!(infer_file_extension(Some("assets/font.woff2"), "font/woff2"), "woff2");
+        assert_eq!(infer_file_extension(None, "application/json"), "json");
+    }
+
     #[test]
     fn platform_session_maps_external_shaped_calls_to_first_party_routes() {
         assert_eq!(
diff --git a/apps/ai-game-creator-shell/src-tauri/src/commands.rs b/apps/ai-game-creator-shell/src-tauri/src/commands.rs
index 465d07443..bcf763784 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/commands.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/commands.rs
@@ -2818,7 +2818,7 @@ mod agent_asset_import_tests {
     }
 
     #[test]
-    fn local_project_image_import_registers_in_place_and_is_idempotent() {
+    fn local_project_asset_import_registers_multiple_types_and_is_idempotent() {
         let project = tempfile::tempdir().expect("create project directory");
         let root = project.path();
         init_local_game_project_at(root, "agent-local-import", "Agent local import")
@@ -2827,34 +2827,53 @@ mod agent_asset_import_tests {
         fs::create_dir_all(root.join("game")).expect("create game directory");
         fs::write(root.join("assets/in-place.png"), tiny_png()).expect("write in-place image");
         fs::write(root.join("game/copied.png"), tiny_png()).expect("write game image");
+        fs::write(root.join("assets/theme.mp3"), b"fake-mp3").expect("write audio");
+        fs::write(root.join("assets/intro.mp4"), b"fake-mp4").expect("write video");
+        fs::write(root.join("game/index.html"), b"<html></html>").expect("write code");
+        fs::write(root.join("assets/design.md"), b"# design").expect("write document");
 
         let revision_before = read_game_creator_agent_runtime_project_revision(root)
             .expect("read initial revision")
             .revision;
-        let first = import_local_project_image_assets_for_agent(
+        let first = import_local_project_assets_for_agent(
             root,
             &[
                 "assets/in-place.png".to_string(),
                 "game/copied.png".to_string(),
+                "assets/theme.mp3".to_string(),
+                "assets/intro.mp4".to_string(),
+                "game/index.html".to_string(),
+                "assets/design.md".to_string(),
             ],
         )
-        .expect("import local images");
-        assert_eq!(first.assets.len(), 2);
+        .expect("import local assets");
+        assert_eq!(first.assets.len(), 6);
         assert_eq!(first.assets[0].local_path, "assets/in-place.png");
         assert!(first.assets[1]
             .local_path
             .starts_with("assets/uploads/local-"));
+        assert!(first.assets[1].local_path.ends_with(".png"));
+        assert_eq!(first.assets[0].asset_kind.as_deref(), Some("ui"));
+        assert_eq!(first.assets[2].asset_kind.as_deref(), Some("audio"));
+        assert_eq!(first.assets[3].asset_kind.as_deref(), Some("video"));
+        assert_eq!(first.assets[4].asset_kind.as_deref(), Some("code"));
+        assert_eq!(first.assets[5].asset_kind.as_deref(), Some("document"));
+        assert!(first.assets[4].local_path.ends_with(".html"));
         assert!(root.join(&first.assets[1].local_path).is_file());
         let revision_after_first = read_game_creator_agent_runtime_project_revision(root)
             .expect("read imported revision")
             .revision;
-        assert_eq!(revision_after_first, revision_before + 2);
+        assert_eq!(revision_after_first, revision_before + 6);
 
-        let second = import_local_project_image_assets_for_agent(
+        let second = import_local_project_assets_for_agent(
             root,
             &[
                 "assets/in-place.png".to_string(),
                 "game/copied.png".to_string(),
+                "assets/theme.mp3".to_string(),
+                "assets/intro.mp4".to_string(),
+                "game/index.html".to_string(),
+                "assets/design.md".to_string(),
             ],
         )
         .expect("reimport local images");
@@ -2868,17 +2887,17 @@ mod agent_asset_import_tests {
     }
 
     #[test]
-    fn local_project_image_import_rejects_absolute_and_case_insensitive_agent_paths() {
+    fn local_project_asset_import_rejects_absolute_and_case_insensitive_agent_paths() {
         let project = tempfile::tempdir().expect("create project directory");
         let root = project.path();
         init_local_game_project_at(root, "agent-local-import", "Agent local import")
             .expect("initialize project");
-        assert!(import_local_project_image_assets_for_agent(
+        assert!(import_local_project_assets_for_agent(
             root,
             &[root.join("image.png").to_string_lossy().into_owned()]
         )
         .is_err());
-        assert!(import_local_project_image_assets_for_agent(
+        assert!(import_local_project_assets_for_agent(
             root,
             &[".AGENT/manifest.json".to_string()]
         )
@@ -2886,7 +2905,7 @@ mod agent_asset_import_tests {
     }
 
     #[test]
-    fn local_project_image_import_rejects_hidden_and_build_tree_sources() {
+    fn local_project_asset_import_rejects_hidden_and_build_tree_sources() {
         let project = tempfile::tempdir().expect("create project directory");
         let root = project.path();
         init_local_game_project_at(root, "agent-local-import", "Agent local import")
@@ -2909,11 +2928,32 @@ mod agent_asset_import_tests {
                 .expect("create forbidden source directory");
             fs::write(&source, tiny_png()).expect("write forbidden source image");
             assert!(
-                import_local_project_image_assets_for_agent(root, &[relative.clone()]).is_err(),
+                import_local_project_assets_for_agent(root, &[relative.clone()]).is_err(),
                 "forbidden source path should be rejected: {relative}"
             );
         }
     }
+
+    #[test]
+    fn local_project_asset_import_rejects_unknown_and_invalid_text_files() {
+        let project = tempfile::tempdir().expect("create project directory");
+        let root = project.path();
+        init_local_game_project_at(root, "agent-local-import", "Agent local import")
+            .expect("initialize project");
+        fs::create_dir_all(root.join("assets")).expect("create assets directory");
+        fs::write(root.join("assets/unknown.bin"), b"bytes").expect("write unknown file");
+        fs::write(root.join("assets/broken.js"), [0xff, 0xfe]).expect("write invalid source");
+        assert!(import_local_project_assets_for_agent(
+            root,
+            &["assets/unknown.bin".to_string()]
+        )
+        .is_err());
+        assert!(import_local_project_assets_for_agent(
+            root,
+            &["assets/broken.js".to_string()]
+        )
+        .is_err());
+    }
 }
 
 fn remote_asset_local_path(asset_id: &str, extension: &str) -> String {
@@ -3406,10 +3446,18 @@ pub(crate) async fn list_editor_assets_for_agent_at(
         "status": "completed",
         "total": assets.len(),
         "assets": assets,
-        "next": "账户素材使用 assetId；网页项目画布资源也使用返回的 resourceId/assetId；本地图片先用 file.list，再把项目相对路径交给 canvas.asset_import；不要提交 objectKey、URL 或本地绝对路径"
+        "next": "账户素材使用 assetId；网页项目画布资源也使用返回的 resourceId/assetId；本地资源先用 file.list，再把项目相对路径交给 canvas.asset_import；不要提交 objectKey、URL 或本地绝对路径"
     }))
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct AgentLocalProjectFileType {
+    category: &'static str,
+    asset_kind: &'static str,
+    media_type: &'static str,
+    max_file_size: u64,
+}
+
 fn agent_image_media_type(bytes: &[u8]) -> Option<&'static str> {
     if bytes.starts_with(b"\x89PNG\r\n\x1a\n") {
         Some("image/png")
@@ -3422,6 +3470,169 @@ fn agent_image_media_type(bytes: &[u8]) -> Option<&'static str> {
     }
 }
 
+fn agent_local_project_file_type(
+    relative_path: &str,
+    bytes: &[u8],
+) -> Result<AgentLocalProjectFileType, String> {
+    let extension = Path::new(relative_path)
+        .extension()
+        .and_then(|value| value.to_str())
+        .unwrap_or_default()
+        .to_ascii_lowercase();
+    let file_type = match extension.as_str() {
+        "png" | "jpg" | "jpeg" | "webp" | "gif" | "svg" | "avif" | "bmp" => {
+            let media_type = match extension.as_str() {
+                "png" => agent_image_media_type(bytes),
+                "jpg" | "jpeg" => {
+                    bytes.starts_with(&[0xff, 0xd8, 0xff]).then_some("image/jpeg")
+                }
+                "webp" => (bytes.len() >= 12
+                    && &bytes[..4] == b"RIFF"
+                    && &bytes[8..12] == b"WEBP")
+                    .then_some("image/webp"),
+                "gif" => (bytes.starts_with(b"GIF87a") || bytes.starts_with(b"GIF89a"))
+                    .then_some("image/gif"),
+                "svg" => std::str::from_utf8(bytes)
+                    .ok()
+                    .filter(|text| text.to_ascii_lowercase().contains("<svg"))
+                    .map(|_| "image/svg+xml"),
+                "avif" => (!bytes.is_empty()).then_some("image/avif"),
+                "bmp" => bytes.starts_with(b"BM").then_some("image/bmp"),
+                _ => None,
+            };
+            media_type.map(|media_type| AgentLocalProjectFileType {
+                category: "image",
+                asset_kind: "ui",
+                media_type,
+                max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+            })
+        }
+        "ttf" | "otf" | "woff" | "woff2" => Some(AgentLocalProjectFileType {
+            category: "font",
+            asset_kind: "font",
+            media_type: match extension.as_str() {
+                "ttf" => "font/ttf",
+                "otf" => "font/otf",
+                "woff" => "font/woff",
+                _ => "font/woff2",
+            },
+            max_file_size: UI_EDITOR_FONT_MAX_FILE_SIZE,
+        }),
+        "mp3" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/mpeg",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "wav" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/wav",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "ogg" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/ogg",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "flac" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/flac",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "m4a" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/mp4",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "aac" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/aac",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "opus" => Some(AgentLocalProjectFileType {
+            category: "audio",
+            asset_kind: "audio",
+            media_type: "audio/opus",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "mp4" => Some(AgentLocalProjectFileType {
+            category: "video",
+            asset_kind: "video",
+            media_type: "video/mp4",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "webm" => Some(AgentLocalProjectFileType {
+            category: "video",
+            asset_kind: "video",
+            media_type: "video/webm",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "mov" => Some(AgentLocalProjectFileType {
+            category: "video",
+            asset_kind: "video",
+            media_type: "video/quicktime",
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "md" | "markdown" | "mdx" | "txt" | "json" | "yaml" | "yml" | "toml"
+        | "csv" | "ini" | "conf" | "xml" => Some(AgentLocalProjectFileType {
+            category: "document",
+            asset_kind: "document",
+            media_type: if extension == "json" {
+                "application/json"
+            } else if matches!(extension.as_str(), "yaml" | "yml") {
+                "application/yaml"
+            } else if extension == "xml" {
+                "application/xml"
+            } else {
+                "text/plain"
+            },
+            max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+        }),
+        "html" | "htm" | "css" | "scss" | "less" | "js" | "mjs" | "cjs" | "ts"
+        | "tsx" | "gd" | "rs" | "py" | "go" | "java" | "kt" | "kts" | "c" | "cc"
+        | "cpp" | "h" | "hpp" | "cs" | "swift" | "php" | "rb" | "lua" | "sh"
+        | "bash" | "zsh" | "sql" | "graphql" | "gql" | "vue" | "svelte" => {
+            Some(AgentLocalProjectFileType {
+                category: "code",
+                asset_kind: "code",
+                media_type: if matches!(extension.as_str(), "html" | "htm") {
+                    "text/html"
+                } else if matches!(extension.as_str(), "css" | "scss" | "less") {
+                    "text/css"
+                } else {
+                    "text/plain"
+                },
+                max_file_size: UI_EDITOR_IMAGE_MAX_FILE_SIZE,
+            })
+        }
+        _ => None,
+    };
+    let file_type = file_type.ok_or_else(|| format!("本地文件类型不受支持：{relative_path}"))?;
+    if file_type.category == "font" {
+        FontAsset::from_verified_bytes(
+            "font-validation",
+            "assets/fonts/validation.ttf",
+            Path::new(relative_path)
+                .file_name()
+                .and_then(|value| value.to_str())
+                .unwrap_or("font"),
+            bytes,
+        )?;
+    } else if bytes.is_empty() {
+        return Err(format!("本地文件不能为空：{relative_path}"));
+    } else if matches!(file_type.category, "document" | "code")
+        && std::str::from_utf8(bytes).is_err()
+    {
+        return Err(format!("本地文本文件不是有效 UTF-8：{relative_path}"));
+    }
+    Ok(file_type)
+}
+
 fn local_agent_asset_destination(relative_path: &str, bytes: &[u8], extension: &str) -> String {
     let digest = format!("{:x}", Sha256::digest(bytes));
     let stem = Path::new(relative_path)
@@ -3437,30 +3648,30 @@ fn local_agent_asset_destination(relative_path: &str, bytes: &[u8], extension: &
     )
 }
 
-fn reject_agent_local_image_source_path(normalized_path: &str) -> Result<(), String> {
+fn reject_agent_local_resource_source_path(normalized_path: &str) -> Result<(), String> {
     if should_skip_project_snapshot_path(normalized_path)
         || normalized_path
             .split('/')
             .any(|part| part.eq_ignore_ascii_case(".codex"))
     {
-        return Err("本地图片导入不得访问隐藏、构建或工具控制目录".to_string());
+        return Err("本地资源导入不得访问隐藏、构建或工具控制目录".to_string());
     }
     Ok(())
 }
 
-/// 从当前项目根目录内的相对路径导入未登记图片。Agent 不能提交宿主绝对路径，
+/// 从当前项目根目录内的相对路径导入未登记资源。Agent 不能提交宿主绝对路径，
 /// 也不能穿越项目根；路径外文件仍由 UI 原生文件选择器导入。
-pub(crate) fn import_local_project_image_assets_for_agent(
+pub(crate) fn import_local_project_assets_for_agent(
     root: &Path,
     relative_paths: &[String],
 ) -> Result<RemoteImportResult, String> {
     enforce_project_permission_policy(root, "canvas.asset_import")?;
     validate_project_root(root)?;
     if relative_paths.is_empty() {
-        return Err("本地图片导入至少需要一个项目相对路径".to_string());
+        return Err("本地资源导入至少需要一个项目相对路径".to_string());
     }
     if relative_paths.len() > UI_EDITOR_IMAGE_MAX_COUNT {
-        return Err(format!("一次最多导入 {} 张图片", UI_EDITOR_IMAGE_MAX_COUNT));
+        return Err(format!("一次最多导入 {} 个本地资源", UI_EDITOR_IMAGE_MAX_COUNT));
     }
     let mut seen = std::collections::BTreeSet::new();
     let mut destinations = std::collections::BTreeSet::new();
@@ -3470,31 +3681,30 @@ pub(crate) fn import_local_project_image_assets_for_agent(
         let normalized = normalize_relative_path(raw_path.trim())?;
         reject_agent_runtime_private_control_path(&normalized)?;
         reject_sensitive_project_file_read(&normalized)?;
-        reject_agent_local_image_source_path(&normalized)?;
+        reject_agent_local_resource_source_path(&normalized)?;
         let source = resolve_local_project_path(root, &normalized)?;
-        prepare_game_creator_private_path_for_read(&source, false, "本地图片")?;
+        prepare_game_creator_private_path_for_read(&source, false, "本地资源")?;
         let metadata =
-            fs::symlink_metadata(&source).map_err(|_| format!("本地图片不存在：{normalized}"))?;
+            fs::symlink_metadata(&source).map_err(|_| format!("本地资源不存在：{normalized}"))?;
         if metadata.file_type().is_symlink() || !metadata.is_file() {
-            return Err(format!("本地素材只能是普通图片文件：{normalized}"));
+            return Err(format!("本地素材只能是普通文件：{normalized}"));
         }
-        if metadata.len() > UI_EDITOR_IMAGE_MAX_FILE_SIZE {
+        let bytes = fs::read(&source).map_err(|_| format!("读取本地资源失败：{normalized}"))?;
+        let file_type = agent_local_project_file_type(&normalized, &bytes)?;
+        if metadata.len() > file_type.max_file_size {
             return Err(format!(
-                "本地图片超过单文件 {} 字节限制",
-                UI_EDITOR_IMAGE_MAX_FILE_SIZE
+                "本地资源超过单文件 {} 字节限制：{normalized}",
+                file_type.max_file_size
             ));
         }
-        let bytes = fs::read(&source).map_err(|_| format!("读取本地图片失败：{normalized}"))?;
-        let media_type = agent_image_media_type(&bytes)
-            .ok_or_else(|| format!("本地文件不是受支持的 PNG/JPEG/WEBP 图片：{normalized}"))?;
         total_size = total_size
             .checked_add(bytes.len() as u64)
             .filter(|size| *size <= UI_EDITOR_IMAGE_MAX_TOTAL_SIZE)
-            .ok_or_else(|| "本地图片批次总量超过 256 MiB 限制".to_string())?;
+            .ok_or_else(|| "本地资源批次总量超过 256 MiB 限制".to_string())?;
         if !seen.insert(normalized.clone()) {
             continue;
         }
-        let extension = infer_file_extension(Some(&normalized), media_type);
+        let extension = infer_file_extension(Some(&normalized), file_type.media_type);
         let local_path = if normalized.starts_with("assets/") {
             normalized.clone()
         } else {
@@ -3503,13 +3713,18 @@ pub(crate) fn import_local_project_image_assets_for_agent(
         if !destinations.insert(local_path.clone()) {
             continue;
         }
-        inputs.push((normalized, local_path, media_type.to_string(), bytes));
+        inputs.push((
+            local_path,
+            file_type.asset_kind.to_string(),
+            file_type.media_type.to_string(),
+            bytes,
+        ));
     }
 
     let _lock = acquire_project_write_lock(root, "canvas.asset_import")?;
     let manifest = read_existing_manifest_for_project(root)?;
     let mut imported = Vec::with_capacity(inputs.len());
-    for (source_path, local_path, media_type, bytes) in inputs {
+    for (local_path, asset_kind, media_type, bytes) in inputs {
         let target = resolve_local_project_path(root, &local_path)?;
         if let Some(existing) = manifest
             .assets
@@ -3524,15 +3739,15 @@ pub(crate) fn import_local_project_image_assets_for_agent(
             continue;
         }
         if target.exists() {
-            prepare_game_creator_private_path_for_read(&target, false, "目标图片")?;
-            let existing_bytes = fs::read(&target).map_err(|_| "读取目标图片失败".to_string())?;
+            prepare_game_creator_private_path_for_read(&target, false, "目标资源")?;
+            let existing_bytes = fs::read(&target).map_err(|_| "读取目标资源失败".to_string())?;
             if existing_bytes != bytes {
-                return Err(format!("本地图片目标已存在且内容不同：{local_path}"));
+                return Err(format!("本地资源目标已存在且内容不同：{local_path}"));
             }
         } else {
             if let Some(parent) = target.parent() {
-                ensure_game_creator_private_directory_tree(parent, "本地图片导入目录")?;
-                prepare_game_creator_private_path_for_read(parent, true, "本地图片导入目录")?;
+                ensure_game_creator_private_directory_tree(parent, "本地资源导入目录")?;
+                prepare_game_creator_private_path_for_read(parent, true, "本地资源导入目录")?;
             }
             let mut options = fs::OpenOptions::new();
             options.write(true).create_new(true);
@@ -3543,8 +3758,8 @@ pub(crate) fn import_local_project_image_assets_for_agent(
             }
             let mut file = options
                 .open(&target)
-                .map_err(|error| format!("写入本地图片失败：{}: {error}", target.display()))?;
-            if let Err(error) = harden_new_game_creator_private_path(&target, false, "目标图片")
+                .map_err(|error| format!("写入本地资源失败：{}: {error}", target.display()))?;
+            if let Err(error) = harden_new_game_creator_private_path(&target, false, "目标资源")
             {
                 drop(file);
                 let _ = fs::remove_file(&target);
@@ -3552,13 +3767,13 @@ pub(crate) fn import_local_project_image_assets_for_agent(
             }
             file.write_all(&bytes)
                 .and_then(|_| file.sync_all())
-                .map_err(|error| format!("写入本地图片失败：{}: {error}", target.display()))?;
+                .map_err(|error| format!("写入本地资源失败：{}: {error}", target.display()))?;
             drop(file);
         }
         let registered = register_local_asset_entry(
             root,
             &local_path,
-            "ui",
+            &asset_kind,
             &media_type,
             "local",
             GameCreationAppAssetSource {
@@ -3577,10 +3792,10 @@ pub(crate) fn import_local_project_image_assets_for_agent(
         imported.push(ImportedAsset {
             id: registered.id,
             local_path: registered.local_path,
-            asset_kind: Some("ui".to_string()),
+            asset_kind: Some(asset_kind),
         });
         advance_agent_runtime_project_revision_locked(root).map_err(|error| {
-            format!("reconciliation-required: 本地图片已登记，但项目 revision 未能推进：{error}")
+            format!("reconciliation-required: 本地资源已登记，但项目 revision 未能推进：{error}")
         })?;
     }
     Ok(RemoteImportResult { assets: imported })
@@ -4008,7 +4223,7 @@ pub(crate) fn list_local_project_files(
     list_local_project_files_at(root)
 }
 
-/// 登记当前项目中已经存在、但尚未写入 manifest 的本地图片。
+/// 登记当前项目中已经存在、但尚未写入 manifest 的本地资源。
 ///
 /// 该入口只接受项目根相对路径；实际文件签名、大小、敏感路径、项目锁和
 /// manifest/revision 更新统一复用 Agent 的受控导入实现。未登记文件在调用前
@@ -4020,10 +4235,10 @@ pub(crate) async fn import_local_project_image_assets(
 ) -> Result<LocalImportResult, String> {
     let root = PathBuf::from(project_path.trim());
     tokio::task::spawn_blocking(move || {
-        import_local_project_image_assets_for_agent(&root, &relative_paths)
+        import_local_project_assets_for_agent(&root, &relative_paths)
     })
     .await
-    .map_err(|error| format!("项目内图片登记任务意外终止：{error}"))
+    .map_err(|error| format!("项目内资源登记任务意外终止：{error}"))
     .and_then(|result| result)
 }
 
diff --git a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
index 8211684b9..caa7f9134 100644
--- a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
+++ b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
@@ -10,7 +10,7 @@
 
 - 素材读取区分三类来源：`asset.list` / `agc_list_registered_assets` 是当前项目本地 manifest，`agc_list_project_files` / `file.list` 只发现项目目录中实际存在但可能未登记的文件，`asset.library.list` 是当前登录账号素材库，项目画布资源读取是当前网页项目/画布的完整图片清单；账户素材库不能替代项目画布清单。
 - Agent 只接收稳定素材 ID、类型、尺寸和项目相对路径等安全投影。客户端负责重新校验账号/项目归属、换签下载、媒体校验，以及 manifest/画布原子登记；不得向 Agent 暴露绝对路径、签名 URL、objectKey、token 或 Cookie。
-- `canvas.asset_import` 支持账户/画布资源 ID 和项目内本地相对路径。项目文件发现结果以 `assetImportable` 明确区分当前可登记的 PNG/JPEG/WEBP 与仅可发现的 GIF/SVG/其它媒体，Agent 只能提交前者。导入拒绝路径穿越、`.agent`、符号链接/reparse point 及敏感配置文件；外部宿主文件须由 UI 原生文件选择器授权后导入，不开放任意绝对路径。
+- `canvas.asset_import` 支持账户/画布资源 ID 和项目内本地相对路径。项目文件发现结果以 `assetImportable` 明确区分当前可登记的已识别图片、字体、音频、视频、文档和代码文件与其它文件；Agent 只能提交前者。导入拒绝路径穿越、`.agent`、符号链接/reparse point 及敏感配置文件；外部宿主文件须由 UI 原生文件选择器授权后导入，不开放任意绝对路径。
 - Runtime `asset.list` 与 `file.list` 的详情使用文件上下文上限，而不是普通工具短摘要上限，确保有界候选/目录清单不会因前部内容较长而整体丢失；`asset.list` 超出 48 项或 `file.list` 超出 40 项时仍显式返回剩余数量，Agent 再按候选父目录（例如 `assets`、`game/assets`）缩小范围查询。
 - 结果仅返回成功/跳过/失败数量、安全 ID、相对路径、来源、脱敏失败摘要和实际 `revisionAdvanceCount`；幂等跳过不得虚增 revision，部分失败仍须准确记录已发生的 revision 变化。
 - 普通 Prompt 上下文与错误诊断必须使用分离的脱敏边界：Prompt 继续对疑似凭据行整体隐藏；错误诊断保留 HTTP 状态以及 `code / field / message / reason / detail` 等安全字段，仅替换 Token、Cookie、私钥、配置名、URL 和宿主路径等敏感值。`agc_create_or_derive_resource.assetName` 是必填的人类可读资源显示名称，不接受项目路径、URL、objectKey、Token 或其它凭据。
diff --git a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
index 9e2ff473d..b536f0875 100644
--- a/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
+++ b/docs/【开发运维】本地开发验证与生产运维-2026-05-15.md
@@ -901,7 +901,9 @@ SELECT * FROM profile_recharge_product_config ORDER BY sort_order ASC;
 
 后台通用表查询已经处理 SpacetimeDB 无载荷枚举的 SATS 形态。新增后台表展示时，枚举列优先按表名和列名做业务映射，再落回通用解码。
 
-后台通用表查询的“每页条数”不是筛选前的 SQL 截断量。API Server 通过单次 `SELECT * ... LIMIT 50001` 读取哨兵行，最多保留前 50,000 条候选；关键词 / JSON 过滤、所选列的完整候选集稳定排序和 1-based `page` 分页都基于这一次 SQL 结果，`totalMatched` 不再依赖另一份 `COUNT(*)` 快照。请求页码超过实际总页数时钳制到末页，零结果固定返回第 1 页。存在第 50,001 条哨兵行时响应必须返回 `scanLimitReached=true`，后台固定分页栏上方明确提示匹配总数和分页结果可能不完整，不得把扫描范围外的数据误报为不存在。候选 SQL 响应体仍受 32 MiB 和 20 秒硬限制；宽表即使每页条数很小也可能整次拒绝，不会返回部分结果。实时写入仍可能改变相邻请求的候选快照，精确审计应使用对应业务表的专用查询而不是通用浏览页。
+后台通用表查询的“每页条数”不是筛选前的 SQL 截断量。API Server 通过单次 `SELECT * ... LIMIT 50001` 读取哨兵行，最多保留前 50,000 条候选；关键词 / 字段条件过滤、所选列的完整候选集稳定排序和 1-based `page` 分页都基于这一次 SQL 结果，`totalMatched` 不再依赖另一份 `COUNT(*)` 快照。`filters` 支持两种 JSON 形式：object（列名到等值，如 `{"user_id":"u1"}`，兼容旧入口）与条件数组（如 `[{"column":"points","op":"gt","value":"5"}]`，运算符覆盖 `eq`、`ne`、`gt`、`gte`、`lt`、`lte`、`contains`、`notContains`、`startsWith`、`endsWith`、`in`、`notIn`、`isEmpty`、`isNotEmpty`，允许同列多条件，条件间为 AND）；两种形式的用户输入都不进入 SQL，只在 API Server 内存中过滤。请求页码超过实际总页数时钳制到末页，零结果固定返回第 1 页。存在第 50,001 条哨兵行时响应必须返回 `scanLimitReached=true`，后台固定分页栏上方明确提示匹配总数和分页结果可能不完整，不得把扫描范围外的数据误报为不存在。候选 SQL 响应体仍受 32 MiB 和 20 秒硬限制；宽表即使每页条数很小也可能整次拒绝，不会返回部分结果。实时写入仍可能改变相邻请求的候选快照，精确审计应使用对应业务表的专用查询而不是通用浏览页。
+
+后台表查询页的结构化筛选条件支持逐条勾选启用或停用；停用条件不会进入请求，但会保留当前字段和值。表单和标题区的查询入口共用同一完整性校验，未完成的启用条件不会静默丢弃。`eq` / `ne` 和比较、文本运算符一样必须提供标量 `value`；显式空值判断使用 `isEmpty` / `isNotEmpty`。`in` / `notIn` 使用逐项值标签编辑，支持粘贴多行值，避免把字符串中的逗号误拆成多个条件。行内交互控件的键盘事件不会冒泡触发行详情，空字段详情复制会给出失败反馈。
 
 ## Issue 与交接
 
diff --git a/server-rs/crates/api-server/src/admin.rs b/server-rs/crates/api-server/src/admin.rs
index 6a9a69ffe..9b2f29de7 100644
--- a/server-rs/crates/api-server/src/admin.rs
+++ b/server-rs/crates/api-server/src/admin.rs
@@ -3259,34 +3259,312 @@ fn apply_admin_database_table_filters(
     }
 
     if let Some(filters) = normalized_non_empty(query.filters.as_deref()) {
-        let parsed = serde_json::from_str::<Value>(filters).map_err(|error| {
-            AppError::from_status(StatusCode::BAD_REQUEST)
-                .with_message(format!("筛选 JSON 解析失败：{error}"))
-        })?;
-        let object = parsed.as_object().ok_or_else(|| {
-            AppError::from_status(StatusCode::BAD_REQUEST)
-                .with_message("筛选条件必须是 JSON object")
-        })?;
-        rows.retain(|row| row_matches_admin_database_filters(row, object));
+        let conditions = parse_admin_database_filter_conditions(filters)?;
+        if !conditions.is_empty() {
+            rows.retain(|row| row_matches_admin_database_filter_conditions(row, &conditions));
+        }
     }
     Ok(())
 }
 
-fn row_matches_admin_database_filters(
+// 后台表查询字段筛选运算符，覆盖后台浏览常用的等值、区间、包含与空值判断。
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum AdminDatabaseFilterOperator {
+    Eq,
+    Ne,
+    Gt,
+    Gte,
+    Lt,
+    Lte,
+    Contains,
+    NotContains,
+    StartsWith,
+    EndsWith,
+    In,
+    NotIn,
+    IsEmpty,
+    IsNotEmpty,
+}
+
+impl AdminDatabaseFilterOperator {
+    fn parse(value: &str) -> Option<Self> {
+        match value {
+            "eq" => Some(Self::Eq),
+            "ne" => Some(Self::Ne),
+            "gt" => Some(Self::Gt),
+            "gte" => Some(Self::Gte),
+            "lt" => Some(Self::Lt),
+            "lte" => Some(Self::Lte),
+            "contains" => Some(Self::Contains),
+            "notContains" => Some(Self::NotContains),
+            "startsWith" => Some(Self::StartsWith),
+            "endsWith" => Some(Self::EndsWith),
+            "in" => Some(Self::In),
+            "notIn" => Some(Self::NotIn),
+            "isEmpty" => Some(Self::IsEmpty),
+            "isNotEmpty" => Some(Self::IsNotEmpty),
+            _ => None,
+        }
+    }
+
+    fn requires_list_value(self) -> bool {
+        matches!(self, Self::In | Self::NotIn)
+    }
+
+    fn requires_scalar_value(self) -> bool {
+        matches!(
+            self,
+            Self::Eq
+                | Self::Ne
+                | Self::Gt
+                | Self::Gte
+                | Self::Lt
+                | Self::Lte
+                | Self::Contains
+                | Self::NotContains
+                | Self::StartsWith
+                | Self::EndsWith
+        )
+    }
+}
+
+// 单列筛选条件：等值形式保持旧 JSON object 语义，运算符形式来自后台结构化筛选。
+#[derive(Clone, Debug)]
+enum AdminDatabaseFilterCondition {
+    Equals(Value),
+    Operator {
+        op: AdminDatabaseFilterOperator,
+        value: Option<Value>,
+    },
+}
+
+fn admin_database_filter_bad_request(message: impl Into<String>) -> AppError {
+    AppError::from_status(StatusCode::BAD_REQUEST).with_message(message)
+}
+
+// filters 支持两种形式：JSON object（列名到等值，兼容旧入口）与条件数组（column/op/value 运算符），数组形式允许同列多条件。
+fn parse_admin_database_filter_conditions(
+    filters: &str,
+) -> Result<Vec<(String, AdminDatabaseFilterCondition)>, AppError> {
+    let parsed = serde_json::from_str::<Value>(filters).map_err(|error| {
+        AppError::from_status(StatusCode::BAD_REQUEST)
+            .with_message(format!("筛选 JSON 解析失败：{error}"))
+    })?;
+    match &parsed {
+        Value::Object(object) => object
+            .iter()
+            .map(|(column, expected)| {
+                Ok((
+                    column.clone(),
+                    parse_admin_database_filter_condition(expected)?,
+                ))
+            })
+            .collect(),
+        Value::Array(items) => items
+            .iter()
+            .map(parse_admin_database_filter_array_entry)
+            .collect(),
+        _ => Err(admin_database_filter_bad_request(
+            "筛选条件必须是 JSON object 或条件数组",
+        )),
+    }
+}
+
+fn parse_admin_database_filter_condition(
+    expected: &Value,
+) -> Result<AdminDatabaseFilterCondition, AppError> {
+    if let Some(object) = expected.as_object() {
+        if let Some(op) = object.get("op").and_then(Value::as_str) {
+            let operator = AdminDatabaseFilterOperator::parse(op).ok_or_else(|| {
+                admin_database_filter_bad_request(format!("不支持的筛选运算符：{op}"))
+            })?;
+            let value = object.get("value");
+            validate_admin_database_filter_value(operator, value)?;
+            return Ok(AdminDatabaseFilterCondition::Operator {
+                op: operator,
+                value: value.cloned(),
+            });
+        }
+    }
+    Ok(AdminDatabaseFilterCondition::Equals(expected.clone()))
+}
+
+fn parse_admin_database_filter_array_entry(
+    entry: &Value,
+) -> Result<(String, AdminDatabaseFilterCondition), AppError> {
+    let object = entry
+        .as_object()
+        .ok_or_else(|| admin_database_filter_bad_request("条件数组中的每一项必须是 JSON object"))?;
+    let column = object
+        .get("column")
+        .and_then(Value::as_str)
+        .map(str::trim)
+        .filter(|column| !column.is_empty())
+        .ok_or_else(|| admin_database_filter_bad_request("筛选条件缺少 column 字段"))?;
+    if !object.contains_key("op") {
+        return Err(admin_database_filter_bad_request(
+            "条件数组中的每一项必须包含 op 字段",
+        ));
+    }
+    let condition = parse_admin_database_filter_condition(entry)?;
+    Ok((column.to_string(), condition))
+}
+
+fn validate_admin_database_filter_value(
+    op: AdminDatabaseFilterOperator,
+    value: Option<&Value>,
+) -> Result<(), AppError> {
+    if op.requires_list_value() {
+        if value.and_then(Value::as_array).is_none() {
+            return Err(admin_database_filter_bad_request(
+                "在列表中筛选的 value 必须是数组",
+            ));
+        }
+        return Ok(());
+    }
+    if op.requires_scalar_value() {
+        let is_scalar = value.is_some_and(|value| {
+            matches!(value, Value::Bool(_) | Value::Number(_) | Value::String(_))
+        });
+        if !is_scalar {
+            return Err(admin_database_filter_bad_request(
+                "该筛选运算符的 value 必须是字符串或数字",
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn row_matches_admin_database_filter_conditions(
     row: &AdminDatabaseTableRowPayload,
-    filters: &Map<String, Value>,
+    conditions: &[(String, AdminDatabaseFilterCondition)],
 ) -> bool {
-    let Some(cells) = row.cells.as_object() else {
-        return filters.is_empty();
-    };
-    filters.iter().all(|(key, expected)| {
-        cells
-            .get(key)
-            .map(|actual| admin_database_filter_value_matches(actual, expected))
-            .unwrap_or(false)
+    let cells = row.cells.as_object();
+    conditions.iter().all(|(column, condition)| {
+        let actual = cells.and_then(|cells| cells.get(column));
+        admin_database_filter_condition_matches(actual, condition)
     })
 }
 
+fn admin_database_filter_condition_matches(
+    actual: Option<&Value>,
+    condition: &AdminDatabaseFilterCondition,
+) -> bool {
+    match condition {
+        AdminDatabaseFilterCondition::Equals(expected) => actual
+            .map(|actual| admin_database_filter_value_matches(actual, expected))
+            .unwrap_or(false),
+        AdminDatabaseFilterCondition::Operator { op, value } => {
+            admin_database_filter_operator_matches(actual, *op, value.as_ref())
+        }
+    }
+}
+
+fn admin_database_filter_operator_matches(
+    actual: Option<&Value>,
+    op: AdminDatabaseFilterOperator,
+    value: Option<&Value>,
+) -> bool {
+    match op {
+        AdminDatabaseFilterOperator::Eq => actual
+            .map(|actual| {
+                admin_database_filter_value_matches(actual, value.unwrap_or(&Value::Null))
+            })
+            .unwrap_or(false),
+        AdminDatabaseFilterOperator::Ne => actual
+            .map(|actual| {
+                !admin_database_filter_value_matches(actual, value.unwrap_or(&Value::Null))
+            })
+            .unwrap_or(false),
+        AdminDatabaseFilterOperator::Gt
+        | AdminDatabaseFilterOperator::Gte
+        | AdminDatabaseFilterOperator::Lt
+        | AdminDatabaseFilterOperator::Lte => {
+            let (Some(actual), Some(expected)) = (actual, value) else {
+                return false;
+            };
+            match compare_admin_database_filter_values(actual, expected) {
+                Some(ordering) => match op {
+                    AdminDatabaseFilterOperator::Gt => ordering.is_gt(),
+                    AdminDatabaseFilterOperator::Gte => ordering.is_ge(),
+                    AdminDatabaseFilterOperator::Lt => ordering.is_lt(),
+                    AdminDatabaseFilterOperator::Lte => ordering.is_le(),
+                    _ => unreachable!(),
+                },
+                None => false,
+            }
+        }
+        AdminDatabaseFilterOperator::Contains
+        | AdminDatabaseFilterOperator::NotContains
+        | AdminDatabaseFilterOperator::StartsWith
+        | AdminDatabaseFilterOperator::EndsWith => {
+            let Some(actual_text) = actual.and_then(value_to_string) else {
+                return false;
+            };
+            let Some(expected_text) = value.and_then(value_to_string) else {
+                return false;
+            };
+            let haystack = actual_text.to_lowercase();
+            let needle = expected_text.to_lowercase();
+            match op {
+                AdminDatabaseFilterOperator::Contains => haystack.contains(&needle),
+                AdminDatabaseFilterOperator::NotContains => !haystack.contains(&needle),
+                AdminDatabaseFilterOperator::StartsWith => haystack.starts_with(&needle),
+                AdminDatabaseFilterOperator::EndsWith => haystack.ends_with(&needle),
+                _ => unreachable!(),
+            }
+        }
+        AdminDatabaseFilterOperator::In | AdminDatabaseFilterOperator::NotIn => {
+            let Some(expected_items) = value.and_then(Value::as_array) else {
+                return false;
+            };
+            let matched = actual
+                .map(|actual| {
+                    expected_items
+                        .iter()
+                        .any(|item| admin_database_filter_value_matches(actual, item))
+                })
+                .unwrap_or(false);
+            if op == AdminDatabaseFilterOperator::In {
+                matched
+            } else {
+                actual.is_some() && !matched
+            }
+        }
+        AdminDatabaseFilterOperator::IsEmpty => admin_database_value_is_empty(actual),
+        AdminDatabaseFilterOperator::IsNotEmpty => !admin_database_value_is_empty(actual),
+    }
+}
+
+// 数值优先、字符串兜底的比较，兼容后台单元格的字符串化值。
+fn compare_admin_database_filter_values(actual: &Value, expected: &Value) -> Option<Ordering> {
+    let actual_number = actual
+        .as_f64()
+        .or_else(|| actual.as_str().and_then(|value| value.trim().parse().ok()));
+    let expected_number = expected.as_f64().or_else(|| {
+        expected
+            .as_str()
+            .and_then(|value| value.trim().parse().ok())
+    });
+    if let (Some(actual_number), Some(expected_number)) = (actual_number, expected_number) {
+        if actual_number.is_finite() && expected_number.is_finite() {
+            return actual_number.partial_cmp(&expected_number);
+        }
+    }
+    let actual_text = value_to_string(actual)?;
+    let expected_text = value_to_string(expected)?;
+    Some(actual_text.cmp(&expected_text))
+}
+
+// 为空定义为 null、缺失或空字符串；不为空取反。
+fn admin_database_value_is_empty(actual: Option<&Value>) -> bool {
+    match actual {
+        None | Some(Value::Null) => true,
+        Some(Value::String(text)) => text.is_empty(),
+        _ => false,
+    }
+}
+
 fn admin_database_filter_value_matches(actual: &Value, expected: &Value) -> bool {
     if actual == expected {
         return true;
@@ -5361,7 +5639,7 @@ mod tests {
             &mut rows,
             &AdminDatabaseTableRowsQuery {
                 search: None,
-                filters: Some("[]".to_string()),
+                filters: Some("123".to_string()),
                 ..Default::default()
             },
         )
@@ -5370,6 +5648,213 @@ mod tests {
         assert_eq!(error.into_response().status(), StatusCode::BAD_REQUEST);
     }
 
+    #[test]
+    fn apply_admin_database_table_filters_supports_operator_conditions() {
+        let columns: Vec<String> = ["user_id", "name", "points", "deleted_at"]
+            .iter()
+            .map(|column| column.to_string())
+            .collect();
+        let mut rows = vec![
+            build_admin_database_table_row(&json!(["u1", "Alice", 12, null]), &columns),
+            build_admin_database_table_row(&json!(["u2", "bob", 8, null]), &columns),
+            build_admin_database_table_row(&json!(["u3", "alan", 8, null]), &columns),
+        ];
+
+        apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                search: None,
+                filters: Some(
+                    json!([
+                        {"column": "points", "op": "gt", "value": "5"},
+                        {"column": "points", "op": "lte", "value": 10},
+                        {"column": "name", "op": "contains", "value": "AL"},
+                        {"column": "deleted_at", "op": "isEmpty"},
+                    ])
+                    .to_string(),
+                ),
+                ..Default::default()
+            },
+        )
+        .expect("operator filters should apply");
+
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].cells["user_id"], json!("u3"));
+    }
+
+    #[test]
+    fn apply_admin_database_table_filters_compares_numeric_columns_against_string_inputs() {
+        let columns = vec!["user_id".to_string(), "points".to_string()];
+        let mut rows = vec![
+            build_admin_database_table_row(&json!(["u2", 2]), &columns),
+            build_admin_database_table_row(&json!(["u10", 10]), &columns),
+            build_admin_database_table_row(&json!(["u12", 12]), &columns),
+        ];
+
+        apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                filters: Some(json!([{"column": "points", "op": "gt", "value": "5"}]).to_string()),
+                ..Default::default()
+            },
+        )
+        .expect("numeric range filters should accept string inputs");
+
+        let user_ids = rows
+            .iter()
+            .filter_map(|row| row.cells.get("user_id").and_then(|value| value.as_str()))
+            .collect::<Vec<_>>();
+        assert_eq!(user_ids, vec!["u10", "u12"]);
+    }
+
+    #[test]
+    fn apply_admin_database_table_filters_compares_stringified_numeric_columns_numerically() {
+        let columns = vec!["user_id".to_string(), "points".to_string()];
+        let mut rows = vec![
+            build_admin_database_table_row(&json!(["u2", "2"]), &columns),
+            build_admin_database_table_row(&json!(["u10", "10"]), &columns),
+            build_admin_database_table_row(&json!(["u12", "12"]), &columns),
+        ];
+
+        apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                filters: Some(json!([{"column": "points", "op": "gt", "value": "5"}]).to_string()),
+                ..Default::default()
+            },
+        )
+        .expect("stringified numeric range filters should compare numerically");
+
+        let user_ids = rows
+            .iter()
+            .filter_map(|row| row.cells.get("user_id").and_then(|value| value.as_str()))
+            .collect::<Vec<_>>();
+        assert_eq!(user_ids, vec!["u10", "u12"]);
+    }
+
+    #[test]
+    fn apply_admin_database_table_filters_supports_list_and_negation_operators() {
+        let columns: Vec<String> = ["user_id", "name", "points", "deleted_at"]
+            .iter()
+            .map(|column| column.to_string())
+            .collect();
+        let mut rows = vec![
+            build_admin_database_table_row(&json!(["u1", "alice", 12, "2026-05-01"]), &columns),
+            build_admin_database_table_row(&json!(["u2", "bob", 8, null]), &columns),
+            build_admin_database_table_row(&json!(["u3", "alan", 5, "2026-05-02"]), &columns),
+        ];
+
+        apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                search: None,
+                filters: Some(
+                    json!([
+                        {"column": "user_id", "op": "notIn", "value": ["u1", "u9"]},
+                        {"column": "name", "op": "startsWith", "value": "a"},
+                        {"column": "name", "op": "notContains", "value": "ob"},
+                        {"column": "points", "op": "ne", "value": "8"},
+                        {"column": "deleted_at", "op": "isNotEmpty"},
+                    ])
+                    .to_string(),
+                ),
+                ..Default::default()
+            },
+        )
+        .expect("list and negation filters should apply");
+
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].cells["user_id"], json!("u3"));
+    }
+
+    #[test]
+    fn apply_admin_database_table_filters_supports_legacy_object_with_operators() {
+        let columns: Vec<String> = ["user_id", "name", "points"]
+            .iter()
+            .map(|column| column.to_string())
+            .collect();
+        let mut rows = vec![
+            build_admin_database_table_row(&json!(["u1", "alice", 12]), &columns),
+            build_admin_database_table_row(&json!(["u2", "bob", 8]), &columns),
+        ];
+
+        apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                search: None,
+                filters: Some(
+                    r#"{"name":{"op":"startsWith","value":"a"},"points":12}"#.to_string(),
+                ),
+                ..Default::default()
+            },
+        )
+        .expect("mixed legacy and operator filters should apply");
+
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].cells["user_id"], json!("u1"));
+
+        apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                search: None,
+                filters: Some("[]".to_string()),
+                ..Default::default()
+            },
+        )
+        .expect("empty condition array should be a no-op");
+
+        assert_eq!(rows.len(), 1);
+    }
+
+    #[test]
+    fn apply_admin_database_table_filters_rejects_invalid_operator_forms() {
+        let invalid_filters = [
+            json!([{"column": "points", "op": "eq"}]).to_string(),
+            json!([{"column": "points", "op": "ne", "value": null}]).to_string(),
+            json!([{"column": "points", "op": "between", "value": "1"}]).to_string(),
+            json!([{"column": "points", "op": "in", "value": "1"}]).to_string(),
+            json!([{"column": "points", "op": "contains"}]).to_string(),
+            json!([{"op": "eq", "value": "1"}]).to_string(),
+            json!([{"column": "points", "value": "1"}]).to_string(),
+            json!(["points"]).to_string(),
+        ];
+        for filters in invalid_filters {
+            let mut rows = vec![build_admin_database_table_row(
+                &json!(["u1"]),
+                &["user_id".to_string()],
+            )];
+            let error = apply_admin_database_table_filters(
+                &mut rows,
+                &AdminDatabaseTableRowsQuery {
+                    search: None,
+                    filters: Some(filters),
+                    ..Default::default()
+                },
+            )
+            .expect_err("invalid operator filter should fail");
+            assert_eq!(error.into_response().status(), StatusCode::BAD_REQUEST);
+        }
+    }
+
+    #[test]
+    fn apply_admin_database_table_filters_rejects_eq_without_required_value() {
+        let mut rows = vec![build_admin_database_table_row(
+            &json!(["u1"]),
+            &["user_id".to_string()],
+        )];
+
+        let error = apply_admin_database_table_filters(
+            &mut rows,
+            &AdminDatabaseTableRowsQuery {
+                filters: Some(json!([{"column": "user_id", "op": "eq"}]).to_string()),
+                ..Default::default()
+            },
+        )
+        .expect_err("eq without value should fail as a malformed request");
+
+        assert_eq!(error.into_response().status(), StatusCode::BAD_REQUEST);
+    }
+
     #[test]
     fn build_admin_tracking_events_sql_quotes_filters_and_clamps_limit() {
         let sql = build_admin_tracking_events_sql(&AdminTrackingEventListQuery {
diff --git a/server-rs/crates/shared-contracts/src/admin.rs b/server-rs/crates/shared-contracts/src/admin.rs
index ab8c690c9..52f0e9733 100644
--- a/server-rs/crates/shared-contracts/src/admin.rs
+++ b/server-rs/crates/shared-contracts/src/admin.rs
@@ -682,6 +682,10 @@ pub struct AdminDatabaseTableListResponse {
 }
 
 // 后台通用表查询参数，用户输入不进入 SQL，只在 API Server 内存中过滤。
+// filters 支持两种 JSON 形式：object（列名到等值，如 {"user_id":"u1"}，兼容旧入口）
+// 与条件数组（如 [{"column":"points","op":"gt","value":"5"}]）。条件数组运算符包含
+// eq、ne、gt、gte、lt、lte、contains、notContains、startsWith、endsWith、in、notIn、
+// isEmpty、isNotEmpty；允许同列多条件，全部条件之间为 AND。
 #[derive(Clone, Debug, Serialize, Deserialize, Default, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]
 pub struct AdminDatabaseTableRowsQuery {

From ae79d50b14af835b55d7244c1d3c3c9925dc34a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8E=8B=E5=BE=B7=E5=AE=87?= <kvtodev@outlook.com>
Date: Tue, 1 Sep 2026 14:35:45 +0800
Subject: [PATCH 8/8] =?UTF-8?q?Fix/=E4=BF=AE=E5=A4=8Dui-editor=E8=B0=83?=
 =?UTF-8?q?=E7=94=A8llm=E4=B8=8E=E5=AE=9E=E9=99=85=E9=85=8D=E7=BD=AE?=
 =?UTF-8?q?=E4=B8=8D=E4=B8=80=E8=87=B4=20(#235)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

复用统一的LLM调用, 原来的方法内部会默认不stream传输,
一些上游要求流式传输会出现问题

---------

Co-authored-by: 段舒康 <kdletters@qq.com>
Reviewed-on: http://192.168.35.82/git/GenarrativeAI/Genarrative/pulls/235
Co-authored-by: 王德宇 <kvtodev@outlook.com>
Co-committed-by: 王德宇 <kvtodev@outlook.com>
---
 .../src-tauri/src/agent.rs                    |  1 +
 .../src/ui_editor/commands/binding.rs         | 37 +++++++++++-----
 .../src-tauri/src/ui_editor/commands/merge.rs | 39 +++++++++++------
 .../src/ui_editor/commands/recognition.rs     | 38 ++++++++++------
 .../commands/ui_design_suggestion.rs          | 43 +++++++++++--------
 .../src-tauri/src/ui_editor/commands/utils.rs | 18 ++++++++
 ...�案】AI游戏创作智能体App实施计划-2026-06-24.md |  2 +-
 7 files changed, 124 insertions(+), 54 deletions(-)

diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent.rs b/apps/ai-game-creator-shell/src-tauri/src/agent.rs
index bc2bedb87..bb0f70aee 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/agent.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/agent.rs
@@ -73,6 +73,7 @@ pub(crate) async fn request_game_creator_ui_editor_llm_at(
         .with_api_kind(api_kind)
         .with_model(config.llm.model.clone())
         .with_request_timeout_ms(config.llm.request_timeout_ms);
+    let request = apply_game_creator_llm_reasoning_effort(request, &config.llm)?;
     let snapshot = {
         let _lock = acquire_game_creator_agent_runtime_project_write_lock_with_wait(
             root,
diff --git a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/binding.rs b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/binding.rs
index 29ba2ab80..8ede8b652 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/binding.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/binding.rs
@@ -1,6 +1,8 @@
-use crate::config::build_game_creator_llm_client_from_config;
+use crate::config::build_game_creator_llm_client_from_llm_config;
+use crate::config::load_game_creator_app_config;
 use crate::ui_editor::commands::utils::{
-    parse_limited_llm_tool_arguments, read_ui_reference_image_data_url, strict_json_schema,
+    parse_limited_llm_tool_arguments, read_ui_reference_image_data_url, request_ui_editor_llm,
+    strict_json_schema,
 };
 use crate::ui_editor::component::text::FontSource;
 use crate::ui_editor::component::Component;
@@ -343,10 +345,21 @@ pub(crate) async fn bind_components_impl_with_provider(
         });
         parts.push(LlmMessageContentPart::InputImage { image_url });
     }
-    let client = if provider_identity.is_none() {
-        Some(build_game_creator_llm_client_from_config()?)
+    let (llm, client) = if provider_identity.is_none() {
+        let llm = load_game_creator_app_config()
+            .map_err(|error| {
+                eprintln!("ui_binding.error stage=build_client error={error}");
+                error
+            })?
+            .llm;
+        let client =
+            build_game_creator_llm_client_from_llm_config(&llm, "llm").map_err(|error| {
+                eprintln!("ui_binding.error stage=build_client error={error}");
+                error
+            })?;
+        (Some(llm), Some(client))
     } else {
-        None
+        (None, None)
     };
     let tool = LlmFunctionTool::new(
         "bind_ui_components",
@@ -371,11 +384,15 @@ pub(crate) async fn bind_components_impl_with_provider(
         .await
         .map_err(platform_llm::LlmError::InvalidRequest)
     } else {
-        client
-            .as_ref()
-            .expect("provider client exists without runtime identity")
-            .run(request)
-            .await
+        request_ui_editor_llm(
+            client
+                .as_ref()
+                .expect("provider client exists without runtime identity"),
+            llm.as_ref()
+                .expect("LLM config exists without runtime identity"),
+            request,
+        )
+        .await
     }
     .map_err(|error| format!("组件绑定失败：{error}"))?;
     let call = response
diff --git a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/merge.rs b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/merge.rs
index aeaadfd1e..4b9852063 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/merge.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/merge.rs
@@ -1,5 +1,8 @@
-use crate::config::build_game_creator_llm_client_from_config;
-use crate::ui_editor::commands::utils::{parse_limited_llm_tool_arguments, strict_json_schema};
+use crate::config::build_game_creator_llm_client_from_llm_config;
+use crate::config::load_game_creator_app_config;
+use crate::ui_editor::commands::utils::{
+    parse_limited_llm_tool_arguments, request_ui_editor_llm, strict_json_schema,
+};
 use crate::ui_editor::state::{State, UITree};
 use platform_llm::{LlmFunctionTool, LlmMessage, LlmRunRequest, LlmToolChoice};
 use serde::{Deserialize, Serialize};
@@ -426,15 +429,21 @@ pub(crate) async fn merge_ui_impl_with_provider(
         );
         return Err(format!("UI 合并输入超过 {MAX_MERGE_INPUT_BYTES} 字节上限"));
     }
-    let client = if provider_identity.is_none() {
-        Some(
-            build_game_creator_llm_client_from_config().map_err(|error| {
+    let (llm, client) = if provider_identity.is_none() {
+        let llm = load_game_creator_app_config()
+            .map_err(|error| {
                 eprintln!("ui_merge.error stage=build_client error={error}");
                 error
-            })?,
-        )
+            })?
+            .llm;
+        let client =
+            build_game_creator_llm_client_from_llm_config(&llm, "llm").map_err(|error| {
+                eprintln!("ui_merge.error stage=build_client error={error}");
+                error
+            })?;
+        (Some(llm), Some(client))
     } else {
-        None
+        (None, None)
     };
     let schema = llm_contract::schema().map_err(|error| {
         eprintln!("ui_merge.error stage=build_schema error={error}");
@@ -463,11 +472,15 @@ pub(crate) async fn merge_ui_impl_with_provider(
         .await
         .map_err(platform_llm::LlmError::InvalidRequest)
     } else {
-        client
-            .as_ref()
-            .expect("provider client exists without runtime identity")
-            .run(request)
-            .await
+        request_ui_editor_llm(
+            client
+                .as_ref()
+                .expect("provider client exists without runtime identity"),
+            llm.as_ref()
+                .expect("LLM config exists without runtime identity"),
+            request,
+        )
+        .await
     }
     .map_err(|error| {
         eprintln!("ui_merge.error stage=llm_request error={error}");
diff --git a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/recognition.rs b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/recognition.rs
index ce6b8bdab..408b95e4e 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/recognition.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/recognition.rs
@@ -1,6 +1,8 @@
-use crate::config::build_game_creator_llm_client_from_config;
+use crate::config::build_game_creator_llm_client_from_llm_config;
+use crate::config::load_game_creator_app_config;
 use crate::ui_editor::commands::utils::{
-    parse_limited_llm_tool_arguments, read_ui_reference_image_data_url, strict_json_schema,
+    parse_limited_llm_tool_arguments, read_ui_reference_image_data_url, request_ui_editor_llm,
+    strict_json_schema,
 };
 use crate::ui_editor::layout::children_display_mode::ChildrenDisplayMode;
 use crate::ui_editor::layout::control_layout::ControlLayout;
@@ -608,15 +610,21 @@ pub(crate) async fn recognize_ui_impl_with_provider(
         eprintln!("ui_recognition.error stage=validate reason=no_root_image");
         return Err("至少需要一张可作为识别上下文根的界面图".to_string());
     }
-    let client = if provider_identity.is_none() {
-        Some(
-            build_game_creator_llm_client_from_config().map_err(|error| {
+    let (llm, client) = if provider_identity.is_none() {
+        let llm = load_game_creator_app_config()
+            .map_err(|error| {
                 eprintln!("ui_recognition.error stage=build_client error={error}");
                 error
-            })?,
-        )
+            })?
+            .llm;
+        let client =
+            build_game_creator_llm_client_from_llm_config(&llm, "llm").map_err(|error| {
+                eprintln!("ui_recognition.error stage=build_client error={error}");
+                error
+            })?;
+        (Some(llm), Some(client))
     } else {
-        None
+        (None, None)
     };
     let schema = recognition_json_schema().map_err(|error| {
         eprintln!("ui_recognition.error stage=build_schema error={error}");
@@ -687,11 +695,15 @@ pub(crate) async fn recognize_ui_impl_with_provider(
             .await
             .map_err(platform_llm::LlmError::InvalidRequest)
         } else {
-            client
-                .as_ref()
-                .expect("provider client exists without runtime identity")
-                .run(request)
-                .await
+            request_ui_editor_llm(
+                client
+                    .as_ref()
+                    .expect("provider client exists without runtime identity"),
+                llm.as_ref()
+                    .expect("LLM config exists without runtime identity"),
+                request,
+            )
+            .await
         }
         .map_err(|error| {
             eprintln!(
diff --git a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/ui_design_suggestion.rs b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/ui_design_suggestion.rs
index 296835e62..2bb51d67b 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/ui_design_suggestion.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/ui_design_suggestion.rs
@@ -1,6 +1,8 @@
-use crate::config::build_game_creator_llm_client_from_config;
+use crate::config::build_game_creator_llm_client_from_llm_config;
+use crate::config::load_game_creator_app_config;
 use crate::ui_editor::commands::utils::{
-    parse_limited_llm_tool_arguments, read_ui_reference_image_data_url, strict_json_schema,
+    parse_limited_llm_tool_arguments, read_ui_reference_image_data_url, request_ui_editor_llm,
+    strict_json_schema,
 };
 use crate::ui_editor::resource::ui_design_image::UIDesignImageRole;
 use crate::ui_editor::state::State;
@@ -172,7 +174,13 @@ pub(crate) async fn suggest_ui_design_semantic_impl(
         });
         parts.push(LlmMessageContentPart::InputImage { image_url });
     }
-    let client = build_game_creator_llm_client_from_config().map_err(|error| {
+    let llm = load_game_creator_app_config()
+        .map_err(|error| {
+            eprintln!("ui_design_suggestion.error stage=build_client error={error}");
+            error
+        })?
+        .llm;
+    let client = build_game_creator_llm_client_from_llm_config(&llm, "llm").map_err(|error| {
         eprintln!("ui_design_suggestion.error stage=build_client error={error}");
         error
     })?;
@@ -186,20 +194,21 @@ pub(crate) async fn suggest_ui_design_semantic_impl(
         schema,
     )
     .with_strict(true);
-    let response = client
-        .run(
-            LlmRunRequest::new(vec![
-                LlmMessage::system(SYSTEM_PROMPT),
-                LlmMessage::user_multimodal(parts),
-            ])
-            .with_function_tools(vec![tool])
-            .with_tool_choice(LlmToolChoice::Required),
-        )
-        .await
-        .map_err(|error| {
-            eprintln!("ui_design_suggestion.error stage=llm_request error={error}");
-            format!("UI 参考图语义识别失败：{error}")
-        })?;
+    let response = request_ui_editor_llm(
+        &client,
+        &llm,
+        LlmRunRequest::new(vec![
+            LlmMessage::system(SYSTEM_PROMPT),
+            LlmMessage::user_multimodal(parts),
+        ])
+        .with_function_tools(vec![tool])
+        .with_tool_choice(LlmToolChoice::Required),
+    )
+    .await
+    .map_err(|error| {
+        eprintln!("ui_design_suggestion.error stage=llm_request error={error}");
+        format!("UI 参考图语义识别失败：{error}")
+    })?;
     eprintln!(
         "ui_design_suggestion.llm_output text_present={} tool_call_count={}",
         !response.text.trim().is_empty(),
diff --git a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/utils.rs b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/utils.rs
index 5468f60a6..4faa40579 100644
--- a/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/utils.rs
+++ b/apps/ai-game-creator-shell/src-tauri/src/ui_editor/commands/utils.rs
@@ -1,4 +1,7 @@
+use crate::agent::request_game_creator_llm_text;
+use crate::config::{apply_game_creator_llm_reasoning_effort, parse_game_creator_llm_api_kind};
 use base64::Engine as _;
+use platform_llm::{LlmClient, LlmError, LlmRunRequest, LlmRunResponse};
 use schemars::JsonSchema;
 use std::fs::File;
 use std::io::Read;
@@ -7,6 +10,21 @@ use std::path::{Path, PathBuf};
 pub(crate) const LLM_TOOL_ARGUMENT_MAX_BYTES: usize = 1024 * 1024;
 pub(crate) const UI_REFERENCE_IMAGE_MAX_BYTES: usize = 5 * 1024 * 1024;
 
+/// Prepare a UI Editor request and reuse the caller-owned client. The transport
+/// selection remains centralized in `request_game_creator_llm_text`.
+pub(crate) async fn request_ui_editor_llm(
+    client: &LlmClient,
+    llm: &crate::GameCreatorLlmConfig,
+    request: LlmRunRequest,
+) -> Result<LlmRunResponse, LlmError> {
+    let request = request.with_api_kind(
+        parse_game_creator_llm_api_kind(&llm.api_kind).map_err(LlmError::InvalidConfig)?,
+    );
+    let request =
+        apply_game_creator_llm_reasoning_effort(request, llm).map_err(LlmError::InvalidConfig)?;
+    request_game_creator_llm_text(client, llm, request).await
+}
+
 pub(crate) fn parse_limited_llm_tool_arguments(
     arguments: &str,
 ) -> Result<serde_json::Value, String> {
diff --git a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
index caa7f9134..99637cb5f 100644
--- a/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
+++ b/docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md
@@ -1255,7 +1255,7 @@ game-project/
 DirectProject 使用 `approvalPolicy=never`，避免每次原生调用再经过泛化 ToolHost 包装；原生命令网络保持关闭，联网资料继续走受控 `agc_web_search`。多 Agent、Apps、插件、hooks、Goals、Workspace Dependencies、Tool Suggestion 和原生浏览器/电脑控制仍关闭，避免绕过 AGC durable delegation、浏览器证据和副作用审计；图片生成通过客户端审核的 `agc_tools.agc_generate_image` 暴露普通单图、角色图、视觉规范图和 UI 设计图，完整游戏美术包继续使用 `agc_tools.taonier_prepare_game_art`，两者都复用同一客户端登录态、幂等账本、下载校验和 manifest/revision 投影，不开放 Codex 原生 image tool。app-server 使用隔离 `CODEX_HOME`，明确清空外部 MCP 后只注入 `agc_tools`；配置了 AGC LLM Key 或可解析的 `OPENAI_API_KEY` 登录态时，真实 provider 凭据只由 AGC 本地 provider proxy 持有，Codex 仅使用连接级随机代理令牌；无法安全代理的 OAuth `auth.json` 继续关闭 native shell/unified exec。`agc_tools` 的平台授权由 AGC 客户端当前登录会话和受控后端完成，普通客户端不得把 DirectProject 请求改成外部 API Key 请求；401/403 只投影为客户端登录或权限异常，不向用户索要凭据或暴露内部 URL。shell 子进程采用 `shell_environment_policy` core 继承及 secret/proxy/bridge 排除，provider key 和桥接凭据不得进入命令环境。系统提示词不再预注入项目源码快照或 Skill 正文，Codex 按需读取当前 cwd 文件。
 ## 2026-08-24 AGC UI 原型桥接与自主 UI workflow
 
-- 2026-08-24 起，`ui-prototype` 与 UI 编辑器的 `UI` JSON 资源明确分离。设计图生成后必须由白名单 `ui.workflow.run` 按页面执行 `prepare → recognize → status → finalize`：为每个功能页面创建并关联 `UI` JSON，载入页面设计图和已登记图片/图标/字体，调用 UI Editor 的 provider-backed 结构识别、多树合并与分批组件绑定，持久化 State/revision，写入 `game/` 应用标记，并把 `reference-ready → structure-ready → merge-ready → binding-ready → application-ready → completed` 各阶段的 `generationKind` 和 manifest revision 投影给客户端。Provider 未配置、请求失败、工具调用缺失、结果不匹配、未知字体引用、未产出可渲染组件或仍有待审节点时保留最近真实阶段并返回 blocker，不得使用 deterministic seed 冒充完成。工作台点击 `ui-prototype` 时通过 `ensure_ui_design_resource_for_prototype` 幂等补齐关联资源；工作流完成后自动打开首个页面的 UI 编辑器 `visual-binding` 最终阶段，交给用户检查和手动调整。只生成图片、登记空 JSON 或进入普通图片画布均不构成 UI 工作流完成，详见 [`【技术方案】UI工作流资源桥接与Runtime执行-2026-08-24.md`](../【技术方案】UI工作流资源桥接与Runtime执行-2026-08-24.md)。
+- 2026-08-24 起，`ui-prototype` 与 UI 编辑器的 `UI` JSON 资源明确分离。设计图生成后必须由白名单 `ui.workflow.run` 按页面执行 `prepare → recognize → status → finalize`：为每个功能页面创建并关联 `UI` JSON，载入页面设计图和已登记图片/图标/字体，调用 UI Editor 的 provider-backed 结构识别、多树合并与分批组件绑定，持久化 State/revision，写入 `game/` 应用标记，并把 `reference-ready → structure-ready → merge-ready → binding-ready → application-ready → completed` 各阶段的 `generationKind` 和 manifest revision 投影给客户端。Provider 未配置、请求失败、工具调用缺失、结果不匹配、未知字体引用、未产出可渲染组件或仍有待审节点时保留最近真实阶段并返回 blocker，不得使用 deterministic seed 冒充完成。工作台点击 `ui-prototype` 时通过 `ensure_ui_design_resource_for_prototype` 幂等补齐关联资源；工作流完成后自动打开首个页面的 UI 编辑器 `visual-binding` 最终阶段，交给用户检查和手动调整。UI 编辑器独立的语义建议请求也必须复用统一 LLM 传输选择，`llm.stream=true` 时发送 `stream=true` 并聚合完整工具调用后再校验结果。只生成图片、登记空 JSON 或进入普通图片画布均不构成 UI 工作流完成，详见 [`【技术方案】UI工作流资源桥接与Runtime执行-2026-08-24.md`](../【技术方案】UI工作流资源桥接与Runtime执行-2026-08-24.md)。
 
 ## 2026-08-28 AGC 自主构建 relaxed 编排覆盖