diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/ResourceReferenceInput.tsx b/apps/ai-game-creator-shell/src/features/project-workspace/ResourceReferenceInput.tsx
index 28250a85c..bf205276a 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/ResourceReferenceInput.tsx
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/ResourceReferenceInput.tsx
@@ -759,8 +759,15 @@ function ResourceReferenceEditor({
   const reminderDisabledRef = useRef(reminderDisabled);
   reminderDisabledRef.current = reminderDisabled;
 
+  /**
+   * 我们自己回填进草稿的那一份文本，用于区分「润色回填」与「用户手改」：
+   * 只有后者该把上一轮往返留下的提示（截断 / 与原文相同）收掉，
+   * 否则刚显示出来的提示会被自己的回填立刻清掉。
+   */
+  const appliedPromptRef = useRef<string | null>(null);
   const applyPromptText = useCallback(
     (text: string) => {
+      appliedPromptRef.current = text;
       flushSync(() => {
         onChange({ text, references: liveDraftRef.current.references });
       });
@@ -782,13 +789,25 @@ function ResourceReferenceEditor({
   const {
     polishing,
     error: polishError,
+    notice: polishNotice,
     originalText: polishedOriginalText,
     polish: runPolish,
     restoreOriginal: restoreOriginalPrompt,
     clearError: clearPolishError,
+    clearNotice: clearPolishNotice,
     reset: resetPromptPolish,
   } = promptPolishState;
 
+  useEffect(() => {
+    if (
+      appliedPromptRef.current !== null &&
+      value === appliedPromptRef.current
+    ) {
+      return;
+    }
+    clearPolishNotice();
+  }, [clearPolishNotice, value]);
+
   const polishPrompt = useCallback(async () => {
     await runPolish();
   }, [runPolish]);
@@ -1083,13 +1102,16 @@ function ResourceReferenceEditor({
         ) : null}
       </div>
       {/* 提醒面板打开时错误提示只在面板里出现，输入区不重复显示。 */}
-      {showPolishAction && !reminderOpen && (polishing || polishError) ? (
+      {/* 「与原文相同 / 已截断」这类提示也要可见：只报失败会让「润色没变化」看起来像按钮坏了。 */}
+      {showPolishAction &&
+      !reminderOpen &&
+      (polishing || polishError || polishNotice) ? (
         <span
           className="resource-reference-input-status"
           role="status"
           aria-live="polite"
         >
-          {polishing ? '润色中…' : polishError}
+          {polishing ? '润色中…' : (polishError ?? polishNotice)}
         </span>
       ) : null}
       <LexicalTypeaheadMenuPlugin<ResourceMentionOption>
diff --git a/apps/ai-game-creator-shell/src/features/project-workspace/usePromptPolish.ts b/apps/ai-game-creator-shell/src/features/project-workspace/usePromptPolish.ts
index 76b02b421..e8506823b 100644
--- a/apps/ai-game-creator-shell/src/features/project-workspace/usePromptPolish.ts
+++ b/apps/ai-game-creator-shell/src/features/project-workspace/usePromptPolish.ts
@@ -2,6 +2,15 @@ import { useCallback, useRef, useState } from 'react';
 
 import { requestChatPromptPolish } from './chatPromptPolish';
 
+/**
+ * 回包与原文一字不差时的提示语。
+ *
+ * 平台侧有时会把同一句话原样还回来（AGC-004：快速编辑里点「AI 润色」后文案毫无变化，
+ * 用户以为按钮没反应或已经改过）。这种情况必须给一条说得清的提示，而且**不能**落下
+ * 原文快照——没有可回退的变化，就不该冒出「恢复原文」这种假入口。
+ */
+export const PROMPT_POLISH_UNCHANGED_NOTICE = 'AI 润色结果与原文相同，未做修改';
+
 /**
  * 润色回填前的规范化结果。
  *
@@ -41,14 +50,19 @@ export type UsePromptPolishOptions = {
 export type UsePromptPolishResult = {
   polishing: boolean;
   error: string | null;
-  /** 最近一次成功回填的截断提示；没有截断时为 null。 */
+  /** 最近一次成功回包的提示：截断说明，或「与原文相同，未做修改」；两者都没有时为 null。 */
   notice: string | null;
-  /** 首次成功润色时落下的原文快照；非空时宿主渲染「恢复原文」。 */
+  /**
+   * 首次**真的改动了文本**的润色时落下的原文快照；非空时宿主渲染「恢复原文」。
+   * 回包与原文相同的那些次不落快照（没什么可恢复的）。
+   */
   originalText: string | null;
   /** 润色并在成功时回填，返回回填后的文本；失败返回 null 并保留原文。 */
   polish: (options?: PromptPolishRunOptions) => Promise<string | null>;
   restoreOriginal: () => void;
   clearError: () => void;
+  /** 用户自己改了提示词：把上一轮往返留下的提示（截断 / 与原文相同）收掉。 */
+  clearNotice: () => void;
   /** 清掉往返状态（草稿清空、面板换资源时用）。 */
   reset: () => void;
 };
@@ -56,6 +70,10 @@ export type UsePromptPolishResult = {
 /**
  * 提示词润色的状态机：失败保留原文、首次成功落原文快照、反复润色只覆盖结果。
  *
+ * 成功但回包与原文逐字相同（规范化前后都没变）时不算「润色出了新东西」：不落原文快照、
+ * 不回填宿主状态，只给 {@link PROMPT_POLISH_UNCHANGED_NOTICE} 这条明确反馈，
+ * 免得用户把「按钮点了没反应」误当成功能坏了、或者以为文案已经被改过。
+ *
  * 聊天输入区与资源侧（生成素材 / 快速编辑）共用这一份；它与界面无关，也不碰共享组件，
  * 宿主自己决定文本存在哪里、怎么回填。Tauri 调用固定在 AGC 侧
  * （`requestChatPromptPolish`），共享 composer 只接一个可选的注入位。
@@ -108,6 +126,18 @@ export function usePromptPolish({
         const normalized = normalizeResult
           ? normalizeResult(polished)
           : { text: polished };
+        if (normalized.text === prompt) {
+          // 最终要写回宿主的文本与当前文本逐字相同：既没有新内容可回填，也没有可回退的
+          // 变化，因此不落原文快照、不写宿主状态——`applyPrompt` 在宿主侧还有「提示词变了
+          // 就重铸请求身份」这类副作用，回填一份没变的文本会平白作废一次请求身份。
+          //
+          // 判据必须是**规范化之后**的文本，不能只看回包：润色结果被按长度上限截回原文时
+          // （`truncateResourceEditPrompt` 是切片不是 trim），回包与原文不同、写回去却一字
+          // 未变，那会渲染出一枚点了等于没点的「恢复原文」，正是要消灭的那种假入口。
+          // 截断提示优先——它解释的是「这次为什么没变」。
+          setNotice(normalized.notice ?? PROMPT_POLISH_UNCHANGED_NOTICE);
+          return normalized.text;
+        }
         // 原文快照只在第一次成功润色时落下，因此「恢复原文」永远回到最初原文。
         setOriginalText((current) => current ?? prompt);
         setNotice(normalized.notice ?? null);
@@ -150,6 +180,10 @@ export function usePromptPolish({
     setError(null);
   }, []);
 
+  const clearNotice = useCallback(() => {
+    setNotice(null);
+  }, []);
+
   const reset = useCallback(() => {
     // 作废在飞请求：宿主清空草稿 / 换资源后，迟到的润色结果不许再回填。
     requestIdRef.current += 1;
@@ -166,6 +200,7 @@ export function usePromptPolish({
     polish,
     restoreOriginal,
     clearError,
+    clearNotice,
     reset,
   };
 }
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationPanelView.tsx b/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationPanelView.tsx
index 50b687831..68886de45 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationPanelView.tsx
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationPanelView.tsx
@@ -414,7 +414,13 @@ export function ResourceCanvasAssetGenerationPanelView({
             onChange={(event) => setAssetName(event.currentTarget.value)}
           />
         </label>
-        <label>
+        {/*
+          这一格**不能**用 `<label>` 包：`<label>` 会把点击转发给内部第一个可标注控件，而这一格里
+          第一个可标注控件是引用输入区的「插入素材引用」按钮——于是点输入框任意位置都会弹出素材
+          选择框（客户端验收现场那条）。两边的可访问名都由控件自身的 `aria-label` 提供（引用输入区
+          的 `ariaLabel` 与 `PlatformTextField` 的 `aria-label`），不依赖 label 关联。
+        */}
+        <div className="resource-canvas-asset-generation-prompt-field">
           <span>生成提示词</span>
           {referenceEnabled ? (
             /*
@@ -433,7 +439,7 @@ export function ResourceCanvasAssetGenerationPanelView({
                 versions={versions}
                 activeVersionId={activeVersionId}
                 multiline
-                rows={6}
+                rows={3}
                 placeholder={`${action.promptPlaceholder}（可用 @ 选择参考图）`}
                 showPolishAction={false}
               />
@@ -442,7 +448,7 @@ export function ResourceCanvasAssetGenerationPanelView({
             <PlatformTextField
               variant="textarea"
               aria-label="生成提示词"
-              rows={6}
+              rows={3}
               autoFocus
               maxLength={promptMaxLength}
               placeholder={action.promptPlaceholder}
@@ -450,7 +456,7 @@ export function ResourceCanvasAssetGenerationPanelView({
               onChange={(event) => setPrompt(event.currentTarget.value)}
             />
           )}
-        </label>
+        </div>
         {action.adjustableDimensions ? (
           <div className="resource-canvas-asset-generation-dimensions">
             <PlatformSegmentedTabs
@@ -488,22 +494,6 @@ export function ResourceCanvasAssetGenerationPanelView({
             {resolveEditorImageSizeLabel({ aspectRatio, imageSize })}
           </span>
         )}
-        <ResourcePromptPolishSlot
-          subject={`素材生成提示词（${action.label}）`}
-          editKind="image-reference"
-          prompt={prompt}
-          applyPrompt={setPrompt}
-        />
-        {referenceEnabled && referenceLimit > 0 ? (
-          <p
-            className="resource-canvas-asset-generation-reference-hint"
-            data-resource-canvas-generation-reference-count={
-              referenceAssetIds.length
-            }
-          >
-            {`参考图 ${referenceAssetIds.length}/${referenceLimit}`}
-          </p>
-        ) : null}
         {referenceProblemNotice ? (
           <p
             className="game-resource-generation-error"
@@ -525,18 +515,43 @@ export function ResourceCanvasAssetGenerationPanelView({
             {shownError}
           </p>
         ) : null}
+        {/*
+          动作行收口：润色入口、参考图计数与两个按钮挤在同一行。
+
+          原先「润色一行、参考图计数一行、按钮一行」把面板顶到必须滚动（验收现场截图里那条
+          滚动条），而这三块内容都没有独占一行的必要：润色作用在提示词上、计数是提示词的从属
+          信息、按钮是收尾动作。放一行之后面板高度回落到几何上界以内，滚动条物理上不再出现。
+        */}
         <div className="game-resource-generation-actions">
-          <PlatformActionButton
-            type="button"
-            tone="secondary"
-            onClick={closeWithDraft}
-          >
-            取消
-          </PlatformActionButton>
-          <PlatformActionButton type="submit" disabled={!canSubmit}>
-            <Sparkles size={15} aria-hidden="true" />
-            {action.label}
-          </PlatformActionButton>
+          <ResourcePromptPolishSlot
+            subject={`素材生成提示词（${action.label}）`}
+            editKind="image-reference"
+            prompt={prompt}
+            applyPrompt={setPrompt}
+          />
+          {referenceEnabled && referenceLimit > 0 ? (
+            <p
+              className="resource-canvas-asset-generation-reference-hint"
+              data-resource-canvas-generation-reference-count={
+                referenceAssetIds.length
+              }
+            >
+              {`参考图 ${referenceAssetIds.length}/${referenceLimit}`}
+            </p>
+          ) : null}
+          <div className="game-resource-generation-actions-buttons">
+            <PlatformActionButton
+              type="button"
+              tone="secondary"
+              onClick={closeWithDraft}
+            >
+              取消
+            </PlatformActionButton>
+            <PlatformActionButton type="submit" disabled={!canSubmit}>
+              <Sparkles size={15} aria-hidden="true" />
+              {action.label}
+            </PlatformActionButton>
+          </div>
         </div>
       </form>
     </>
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationTasksPanelView.tsx b/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationTasksPanelView.tsx
index ed1a33d0b..0a6cc43ff 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationTasksPanelView.tsx
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/ResourceCanvasAssetGenerationTasksPanelView.tsx
@@ -12,6 +12,12 @@ import {
   resourceCanvasAssetGenerationTaskTone,
   sortResourceCanvasAssetGenerationTasks,
 } from './resourceCanvasAssetGenerationTaskModel';
+import {
+  resourceCanvasResourceEditElapsedLabel,
+  type ResourceCanvasResourceEditTask,
+  resourceCanvasResourceEditTaskElapsedMillis,
+  resourceCanvasResourceEditTaskIsTerminal,
+} from './resourceCanvasResourceEditTaskModel';
 
 /** 「已完成」分栏的展示上限：触顶后只提示还有多少条，不无限拉长侧栏。 */
 export const RESOURCE_CANVAS_ASSET_GENERATION_DONE_SECTION_LIMIT = 20;
@@ -24,6 +30,14 @@ export const RESOURCE_CANVAS_ASSET_GENERATION_TASKS_LEAVE_MILLIS = 160;
 
 export type ResourceCanvasAssetGenerationTasksPanelViewProps = {
   tasks: readonly ResourceCanvasAssetGenerationTask[];
+  /**
+   * 派生/修改类任务（快速编辑、生成动画、抠图…）。
+   *
+   * 它们不在图片类生成任务的账本里（原生资源编辑账本按 `operationId` 记），但用户眼里都是
+   * 「我交出去、等着出结果的那件事」，所以进同一个侧栏、同一套分栏；状态与阶段文案各按自己的
+   * 账本渲染。缺省为空数组：老调用方不传就没有这一段。
+   */
+  resourceEditTasks?: readonly ResourceCanvasResourceEditTask[];
   /** 侧栏是否展开；折叠时只留贴边把手。 */
   open: boolean;
   onToggleOpen: () => void;
@@ -31,7 +45,53 @@ export type ResourceCanvasAssetGenerationTasksPanelViewProps = {
   onFocusTask: (task: ResourceCanvasAssetGenerationTask) => void;
 };
 
-function taskRow(
+/**
+ * 侧栏的一行。
+ *
+ * 两种来源合并成同一条列表：图片类生成任务按后端账本推进，派生/修改任务按原生资源编辑账本
+ * 推进；排序与分栏只认「提交时间」和「是否终态」，用户不需要知道它们来自两套账本。
+ */
+type ResourceCanvasGenerationTaskRow =
+  | {
+      readonly source: 'asset-generation';
+      readonly createdAtMillis: number;
+      readonly task: ResourceCanvasAssetGenerationTask;
+    }
+  | {
+      readonly source: 'resource-edit';
+      readonly createdAtMillis: number;
+      readonly task: ResourceCanvasResourceEditTask;
+    };
+
+function resourceCanvasGenerationTaskRowKey(
+  row: ResourceCanvasGenerationTaskRow,
+): string {
+  return row.source === 'asset-generation'
+    ? row.task.taskId
+    : row.task.operationId;
+}
+
+function resourceCanvasGenerationTaskRowIsTerminal(
+  row: ResourceCanvasGenerationTaskRow,
+): boolean {
+  return row.source === 'asset-generation'
+    ? resourceCanvasAssetGenerationTaskIsTerminal(row.task)
+    : resourceCanvasResourceEditTaskIsTerminal(row.task);
+}
+
+function sortResourceCanvasGenerationTaskRows(
+  rows: readonly ResourceCanvasGenerationTaskRow[],
+): ResourceCanvasGenerationTaskRow[] {
+  return [...rows].sort(
+    (left, right) =>
+      right.createdAtMillis - left.createdAtMillis ||
+      resourceCanvasGenerationTaskRowKey(left).localeCompare(
+        resourceCanvasGenerationTaskRowKey(right),
+      ),
+  );
+}
+
+function assetGenerationTaskRow(
   task: ResourceCanvasAssetGenerationTask,
   nowMillis: number,
   onFocusTask: (task: ResourceCanvasAssetGenerationTask) => void,
@@ -86,6 +146,79 @@ function taskRow(
   );
 }
 
+/**
+ * 派生/修改任务的一行。
+ *
+ * 与图片类生成的卡片同一套 class、同一套 tone，只有两点不同：① 没有「定位到素材」——原生账本
+ * 给的待办记录里没有产物 id，编一个指向不明的跳转不如不给；② 提示词单独一行，用户要能认出手上
+ * 这行是哪一次修改。
+ */
+function resourceEditTaskRow(
+  task: ResourceCanvasResourceEditTask,
+  nowMillis: number,
+) {
+  const elapsedMillis = resourceCanvasResourceEditTaskElapsedMillis(
+    task,
+    nowMillis,
+  );
+  return (
+    <li
+      key={task.operationId}
+      className="game-resource-generation-task-card"
+      data-task-status={task.status}
+      data-task-source="resource-edit"
+    >
+      <div className="game-resource-generation-task-card-title-row">
+        <strong className="game-resource-generation-task-card-name">
+          {task.assetName}
+        </strong>
+        <span className="game-resource-generation-task-card-action">
+          {task.actionLabel}
+        </span>
+      </div>
+      <div className="game-resource-generation-task-card-meta">
+        <span
+          className="game-resource-generation-task-badge"
+          data-tone={resourceCanvasAssetGenerationTaskTone(task.status)}
+        >
+          {RESOURCE_CANVAS_ASSET_GENERATION_STATUS_LABELS[task.status]}
+        </span>
+        <span className="game-resource-generation-task-card-phase">
+          {task.phaseDetail}
+        </span>
+        {elapsedMillis === null ? null : (
+          <span className="game-resource-generation-task-card-elapsed">
+            {`已耗时 ${resourceCanvasResourceEditElapsedLabel(elapsedMillis)}`}
+          </span>
+        )}
+      </div>
+      {task.error ? (
+        <p className="game-resource-generation-task-card-error" role="alert">
+          {task.error}
+        </p>
+      ) : null}
+      {task.prompt ? (
+        <p
+          className="game-resource-generation-task-card-prompt"
+          title={task.prompt}
+        >
+          {task.prompt}
+        </p>
+      ) : null}
+    </li>
+  );
+}
+
+function resourceCanvasGenerationTaskRowNode(
+  row: ResourceCanvasGenerationTaskRow,
+  nowMillis: number,
+  onFocusTask: (task: ResourceCanvasAssetGenerationTask) => void,
+) {
+  return row.source === 'asset-generation'
+    ? assetGenerationTaskRow(row.task, nowMillis, onFocusTask)
+    : resourceEditTaskRow(row.task, nowMillis);
+}
+
 /**
  * 画布上的「生成任务」侧栏（常驻、可折叠、非模态）。
  *
@@ -103,6 +236,7 @@ function taskRow(
  */
 export function ResourceCanvasAssetGenerationTasksPanelView({
   tasks,
+  resourceEditTasks = [],
   open,
   onToggleOpen,
   onFocusTask,
@@ -115,20 +249,33 @@ export function ResourceCanvasAssetGenerationTasksPanelView({
   const [phase, setPhase] = useState<'idle' | 'entering' | 'leaving'>(
     open ? 'entering' : 'idle',
   );
-  const inFlightCount = tasks.filter(
-    (task) => !resourceCanvasAssetGenerationTaskIsTerminal(task),
-  ).length;
-  const hasLiveTask = inFlightCount > 0;
-  const ordered = useMemo(
-    () => sortResourceCanvasAssetGenerationTasks(tasks),
-    [tasks],
+  /**
+   * 两套账本合成一条列表：图片类生成任务（后端生成账本）在前端本地队列里已按提交时间排序，
+   * 派生/修改任务（原生资源编辑账本）自带提交时间，这里统一按时间倒序，用户看到的就是
+   * 「我最近交出去的那几件事」。
+   */
+  const ordered = useMemo<ResourceCanvasGenerationTaskRow[]>(
+    () =>
+      sortResourceCanvasGenerationTaskRows([
+        ...sortResourceCanvasAssetGenerationTasks(tasks).map((task) => ({
+          source: 'asset-generation' as const,
+          createdAtMillis: task.createdAtMillis,
+          task,
+        })),
+        ...resourceEditTasks.map((task) => ({
+          source: 'resource-edit' as const,
+          createdAtMillis: task.createdAtMillis,
+          task,
+        })),
+      ]),
+    [resourceEditTasks, tasks],
   );
   const active = ordered.filter(
-    (task) => !resourceCanvasAssetGenerationTaskIsTerminal(task),
-  );
-  const done = ordered.filter((task) =>
-    resourceCanvasAssetGenerationTaskIsTerminal(task),
+    (row) => !resourceCanvasGenerationTaskRowIsTerminal(row),
   );
+  const done = ordered.filter(resourceCanvasGenerationTaskRowIsTerminal);
+  const inFlightCount = active.length;
+  const hasLiveTask = inFlightCount > 0;
   const visibleDone = done.slice(
     0,
     RESOURCE_CANVAS_ASSET_GENERATION_DONE_SECTION_LIMIT,
@@ -248,8 +395,12 @@ export function ResourceCanvasAssetGenerationTasksPanelView({
                 </p>
               ) : (
                 <ul className="game-resource-generation-tasks-list">
-                  {rendered.active.map((task) =>
-                    taskRow(task, nowMillis, onFocusTask),
+                  {rendered.active.map((row) =>
+                    resourceCanvasGenerationTaskRowNode(
+                      row,
+                      nowMillis,
+                      onFocusTask,
+                    ),
                   )}
                 </ul>
               )}
@@ -271,8 +422,12 @@ export function ResourceCanvasAssetGenerationTasksPanelView({
               ) : (
                 <>
                   <ul className="game-resource-generation-tasks-list">
-                    {rendered.visibleDone.map((task) =>
-                      taskRow(task, nowMillis, onFocusTask),
+                    {rendered.visibleDone.map((row) =>
+                      resourceCanvasGenerationTaskRowNode(
+                        row,
+                        nowMillis,
+                        onFocusTask,
+                      ),
                     )}
                   </ul>
                   {rendered.done.length > rendered.visibleDone.length ? (
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/ResourcePromptPolishSlot.tsx b/apps/ai-game-creator-shell/src/features/resource-canvas/ResourcePromptPolishSlot.tsx
index b7a6ed284..5625cfcc5 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/ResourcePromptPolishSlot.tsx
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/ResourcePromptPolishSlot.tsx
@@ -1,4 +1,5 @@
 import { Loader2, RotateCcw, Sparkles } from 'lucide-react';
+import { useCallback, useEffect, useRef } from 'react';
 
 import {
   type LocalProjectResourceEditKind,
@@ -30,14 +31,38 @@ export function ResourcePromptPolishSlot({
   disabled = false,
   applyPrompt,
 }: ResourcePromptPolishSlotProps) {
+  /**
+   * 我们自己写回去的那一份文本。用于区分「润色回填导致的 prop 变化」与「用户手改」：
+   * 只有后者该把上一轮往返留下的提示收掉，否则刚显示出来的提示会被自己的回填清掉。
+   */
+  const appliedPromptRef = useRef<string | null>(null);
+  // 宿主回调存 ref：包一层只为记账，不该让这份包装每次渲染都换身份、
+  // 进而把 `usePromptPolish` 的 `polish` 也跟着重造。
+  const applyPromptRef = useRef(applyPrompt);
+  applyPromptRef.current = applyPrompt;
+  const applyPromptAndTrack = useCallback((text: string) => {
+    appliedPromptRef.current = text;
+    applyPromptRef.current(text);
+  }, []);
   const polish = usePromptPolish({
     readPrompt: () => prompt,
-    applyPrompt,
+    applyPrompt: applyPromptAndTrack,
     canPolish: () => !disabled,
     resolveContext: () => resourceAssetPromptPolishContext(subject),
     normalizeResult: (polished) =>
       truncateResourceEditPrompt(polished, editKind),
   });
+  const { clearNotice } = polish;
+  useEffect(() => {
+    if (
+      appliedPromptRef.current !== null &&
+      prompt === appliedPromptRef.current
+    ) {
+      return;
+    }
+    // 手改过提示词：上一轮「与原文相同 / 已截断」的结论不再描述当前这段文本。
+    clearNotice();
+  }, [clearNotice, prompt]);
   const statusText = polish.polishing
     ? '润色中…'
     : (polish.error ?? polish.notice);
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasAssetGenerationTasksSidebar.css b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasAssetGenerationTasksSidebar.css
index 25b7d4e89..56abc9d1c 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasAssetGenerationTasksSidebar.css
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasAssetGenerationTasksSidebar.css
@@ -326,6 +326,17 @@
   white-space: normal;
 }
 
+/* 派生/修改任务多一行提示词：用户要能认出这行是哪一次修改（图片类生成任务没有这一行）。 */
+.game-resource-generation-task-card-prompt {
+  overflow: hidden;
+  color: var(--platform-text-muted);
+  font-size: 0.68rem;
+  font-style: italic;
+  line-height: 1.35;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
 .game-resource-generation-task-locate {
   justify-self: start;
   border: 0;
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasChrome.css b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasChrome.css
index 1b4255781..68071970e 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasChrome.css
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasChrome.css
@@ -1408,3 +1408,437 @@
   font-weight: 700;
   font-variant-numeric: tabular-nums;
 }
+
+/*
+ * 角色动画生成面板（共享 `ImageCanvasCharacterAnimationPanelView`）与它的素材缩略图。
+ *
+ * 同一处样式缺口：`image-canvas-editor__character-animation-*`、`__generation-close` 与
+ * `__reference-strip/__reference-slot/__reference-chip*` 在网页端由整站表 `src/index.css` 提供，
+ * 而 AGC 不引那张表、宿主 chrome 表又只照抄了 composer 的通用规则。结果是这个面板只剩通用
+ * composer 外观：素材缩略图、预设胶囊、提交按钮与右上角关闭键全部落回默认流布局，面板里出现
+ * 一大块空白、预设竖排、`生成80泥点` 悬在中间（客户端验收现场截图）。
+ *
+ * 下面逐条照抄 `src/index.css` 的同名规则（注释里给行号），不手写近似值；AGC 不会渲染的兄弟
+ * 选择器不搬（例如 `.image-canvas-editor__character-animation-head` 在这版组件里没有节点）。
+ */
+
+/* src/index.css:6776 */
+.image-canvas-editor__generation-composer--character-animation {
+  grid-template-columns: minmax(0, 1fr);
+  grid-template-rows: auto auto auto auto auto;
+  width: min(42rem, calc(100% - 1.5rem));
+}
+
+/* src/index.css:6874 */
+.image-canvas-editor__generation-close {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border: 0;
+  background: transparent;
+  color: #374151;
+  font-size: 0.82rem;
+  font-weight: 800;
+}
+
+/* src/index.css:6906 */
+.image-canvas-editor__reference-strip {
+  display: flex;
+  grid-column: 1 / -1;
+  min-width: 0;
+  align-items: center;
+  gap: 0.36rem;
+  overflow-x: auto;
+  padding: 0 2.2rem 0.02rem 0;
+  scrollbar-width: thin;
+}
+
+/* src/index.css:6917 */
+.image-canvas-editor__reference-slot {
+  position: relative;
+  display: inline-flex;
+  flex: 0 0 auto;
+  width: 3.95rem;
+  height: 3.95rem;
+}
+
+/* src/index.css:6925 */
+.image-canvas-editor__reference-chip {
+  position: relative;
+  display: inline-grid;
+  width: 3.95rem;
+  min-width: 3.95rem;
+  max-width: 3.95rem;
+  height: 3.95rem;
+  min-height: 3.95rem;
+  grid-template-rows: 1.42rem auto;
+  align-items: center;
+  justify-items: center;
+  gap: 0.28rem;
+  overflow: hidden;
+  border: 1px solid rgba(148, 163, 184, 0.16);
+  border-radius: 1rem;
+  background: #f2f3f5;
+  padding: 0.62rem 0.36rem 0.5rem;
+  color: #a3a8ae;
+  font-size: 0.68rem;
+  font-weight: 850;
+  line-height: 1.04;
+  text-align: center;
+  box-shadow: none;
+}
+
+/* src/index.css:6950 */
+button.image-canvas-editor__reference-chip {
+  cursor: pointer;
+}
+
+button.image-canvas-editor__reference-chip:hover:not(:disabled) {
+  transform: translateY(-1px);
+  border-color: rgba(148, 163, 184, 0.22);
+  background: #eef0f2;
+}
+
+button.image-canvas-editor__reference-chip:disabled {
+  cursor: not-allowed;
+  opacity: 0.62;
+  transform: none;
+}
+
+/* src/index.css:6966 */
+.image-canvas-editor__reference-chip-icon {
+  display: grid;
+  width: 1.42rem;
+  height: 1.42rem;
+  flex: 0 0 auto;
+  place-items: center;
+  overflow: hidden;
+  border-radius: 0.36rem;
+  background: transparent;
+  color: currentColor;
+}
+
+.image-canvas-editor__reference-chip-icon img {
+  width: 100%;
+  height: 100%;
+  border-radius: 0.36rem;
+  object-fit: cover;
+}
+
+/* src/index.css:6985 */
+.image-canvas-editor__reference-chip-label {
+  display: -webkit-box;
+  min-width: 0;
+  overflow: hidden;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 2;
+  text-overflow: ellipsis;
+  white-space: normal;
+  word-break: keep-all;
+}
+
+/* src/index.css:6996 */
+.image-canvas-editor__reference-chip-source-label {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  clip-path: inset(50%);
+}
+
+/* src/index.css:7006 */
+.image-canvas-editor__reference-chip-remove {
+  position: absolute;
+  top: 0.16rem;
+  right: 0.16rem;
+  z-index: 2;
+  display: grid;
+  width: 1.12rem;
+  height: 1.12rem;
+  place-items: center;
+  border: 1px solid rgba(15, 23, 42, 0.08);
+  border-radius: 999px;
+  background: rgba(15, 23, 42, 0.86);
+  color: #ffffff;
+  opacity: 0;
+  box-shadow: 0 8px 18px rgba(15, 23, 42, 0.18);
+  pointer-events: none;
+  transform: scale(0.88);
+  transition:
+    opacity 120ms ease,
+    transform 120ms ease;
+}
+
+.image-canvas-editor__reference-chip-remove--always-visible {
+  opacity: 1;
+  pointer-events: auto;
+  transform: scale(1);
+}
+
+.image-canvas-editor__reference-slot:hover
+  .image-canvas-editor__reference-chip-remove,
+.image-canvas-editor__reference-slot:focus-within
+  .image-canvas-editor__reference-chip-remove {
+  opacity: 1;
+  pointer-events: auto;
+  transform: scale(1);
+}
+
+@media (hover: none) {
+  .image-canvas-editor__reference-chip-remove {
+    opacity: 1;
+    pointer-events: auto;
+    transform: scale(1);
+  }
+}
+
+.image-canvas-editor__reference-chip-remove:disabled {
+  cursor: not-allowed;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.image-canvas-editor__reference-chip-remove:hover:not(:disabled) {
+  background: rgba(220, 38, 38, 0.95);
+}
+
+/* src/index.css:7061：带图缩略图的图标尺寸（角色动画的源图就是这一档） */
+.image-canvas-editor__reference-chip--has-image
+  .image-canvas-editor__reference-chip-icon {
+  width: 1.74rem;
+  height: 1.74rem;
+  border-radius: 0.48rem;
+}
+
+.image-canvas-editor__reference-chip--has-image
+  .image-canvas-editor__reference-chip-icon
+  img {
+  border-radius: 0.48rem;
+}
+
+/* src/index.css:7074–7112：tone 取色（AGC 目前渲染 quick-edit 与 character，其余一并有备） */
+.image-canvas-editor__reference-chip--spec
+  .image-canvas-editor__reference-chip-icon {
+  color: #8b5cf6;
+}
+
+.image-canvas-editor__reference-chip--icon
+  .image-canvas-editor__reference-chip-icon {
+  color: #059669;
+}
+
+.image-canvas-editor__reference-chip--ui
+  .image-canvas-editor__reference-chip-icon {
+  color: #d97706;
+}
+
+.image-canvas-editor__reference-chip--character
+  .image-canvas-editor__reference-chip-icon {
+  color: #0f172a;
+}
+
+.image-canvas-editor__reference-chip--quick-edit {
+  background: #f3f4f6;
+  color: #9ca3af;
+}
+
+.image-canvas-editor__reference-chip--quick-edit
+  .image-canvas-editor__reference-chip-icon {
+  color: #9ca3af;
+}
+
+.image-canvas-editor__reference-chip--video
+  .image-canvas-editor__reference-chip-icon {
+  color: #2563eb;
+}
+
+.image-canvas-editor__reference-chip--audio
+  .image-canvas-editor__reference-chip-icon {
+  color: #7c3aed;
+}
+
+/* src/index.css:8728 */
+.image-canvas-editor__character-animation-panel {
+  position: absolute;
+  z-index: 14;
+  display: grid;
+  width: min(42rem, calc(100vw - 1.5rem));
+  max-height: min(34rem, calc(100% - 1.5rem));
+  gap: 0.58rem;
+  overflow: auto;
+  border: 1px solid rgba(148, 163, 184, 0.36);
+  border-radius: 1.1rem;
+  background: rgba(255, 255, 255, 0.96);
+  padding: 0.76rem;
+  font-size: 0.82rem;
+  box-shadow: 0 22px 48px rgba(15, 23, 42, 0.22);
+}
+
+/* src/index.css:8753 */
+.image-canvas-editor__character-animation-textarea {
+  grid-column: 1 / -1;
+  --auto-grow-editor-min-height: 8rem;
+  --auto-grow-editor-max-height: 16rem;
+}
+
+/* src/index.css:8759 */
+.image-canvas-editor__character-animation-presets {
+  display: flex;
+  grid-column: 1 / -1;
+  flex-wrap: wrap;
+  gap: 0.38rem;
+}
+
+.image-canvas-editor__character-animation-preset {
+  border: 1px solid rgba(148, 163, 184, 0.28);
+  border-radius: 999px;
+  background: #f8fafc;
+  padding: 0.34rem 0.58rem;
+  color: #334155;
+  font-size: 0.78rem;
+}
+
+/* src/index.css:8775 */
+.image-canvas-editor__character-animation-footer {
+  display: grid;
+  grid-column: 1 / -1;
+  grid-template-columns: auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 0.46rem;
+}
+
+.image-canvas-editor__character-animation-submit {
+  grid-column: 3;
+  min-width: 5.45rem;
+  height: 2.25rem;
+  gap: 0.4rem;
+  border: 0;
+  background: var(--image-canvas-brand-fill);
+  color: var(--image-canvas-brand-text-on-fill);
+}
+
+/* src/index.css:6811：提示词输入区的聚焦态（快速编辑 / 动画面板共用这一档）。 */
+.image-canvas-editor__generation-prompt:focus-within,
+.image-canvas-editor__video-prompt:focus {
+  border-color: var(--image-canvas-brand-border-strong);
+  background: #ffffff;
+  box-shadow: 0 0 0 3px var(--image-canvas-brand-focus-ring);
+}
+
+/* src/index.css:6822 */
+.image-canvas-editor__generation-prompt:has(
+    .auto-grow-text-area__content[aria-invalid='true']
+  ) {
+  border-color: #e11d48;
+  background: #fff7f8;
+}
+
+/* src/index.css:6829 */
+.image-canvas-editor__generation-prompt:has(
+    .auto-grow-text-area__content[aria-invalid='true']
+  ):focus-within {
+  border-color: #e11d48;
+  box-shadow: 0 0 0 3px rgba(225, 29, 72, 0.14);
+}
+
+/*
+ * src/index.css:7630 —— 关闭键在浮层里的**落位**。
+ *
+ * 这一族在网页端有两条同名规则：6874 给基础外观，这条给「贴在浮层右上角」的绝对定位。
+ * 只搬前一条时按钮会掉进网格流、独自占一行并居中（客户端验收现场那张图里的 ×）。
+ */
+.image-canvas-editor__generation-close {
+  position: absolute;
+  right: 0.62rem;
+  top: 0.58rem;
+  width: 2rem;
+  height: 2rem;
+  color: #94a3b8;
+}
+
+/* src/index.css:16988：composer 里的参数簇去掉自身底色，hover / 展开时才浮起。 */
+.image-canvas-editor__generation-composer .image-canvas-editor__option-cluster {
+  min-height: 2.25rem;
+  background: transparent;
+  border-color: transparent;
+}
+
+/* src/index.css:16994 */
+.image-canvas-editor__generation-composer
+  .image-canvas-editor__option-cluster:hover:not(:disabled),
+.image-canvas-editor__generation-composer
+  .image-canvas-editor__option-cluster[aria-expanded='true'] {
+  border-color: rgba(15, 23, 42, 0.08);
+  background: #f8fafc;
+  box-shadow: 0 10px 24px rgba(15, 23, 42, 0.08);
+}
+
+/*
+ * 窄屏整档照抄（src/index.css:8981 的 `@media (max-width: 760px)`）：浮层落到底部整宽、
+ * 动作竖排、参数与提交整宽。选择器与断点都按网页端原样搬，避免"我拆一半、你拆一半"之后
+ * 两边再各自漂移。
+ */
+@media (max-width: 760px) {
+  /*
+   * src/index.css:9020 —— **只搬动画面板那一支**。
+   *
+   * 网页端这一条把快速编辑浮层与动画面板一起变成 `position: fixed` 的整宽底栏；AGC 的快速编辑
+   * 浮层是「居中贴资源卡」的绝对定位（`transform: translateX(-50%)` + 内联 left/top，见本文件
+   * 上面那一族），窄屏宽度已经由 `calc(100vw - 1.5rem)` 自己收好——跟网页端改成底栏会压住栏目
+   * 画布左下角工具栏与左侧「生成任务」侧栏。这条宿主差异在样式守卫里显式放行，不静默漂移。
+   */
+  .image-canvas-editor__character-animation-panel {
+    position: fixed;
+    left: 0.75rem !important;
+    right: 0.75rem;
+    top: auto !important;
+    bottom: 0.75rem;
+    width: auto;
+    max-height: min(72vh, 34rem);
+    transform: none;
+  }
+
+  /* src/index.css:9037 */
+  .image-canvas-editor__generation-composer {
+    position: fixed;
+    left: 0.75rem !important;
+    right: 0.75rem;
+    top: auto !important;
+    bottom: 3.85rem;
+    width: auto;
+    max-height: min(72vh, 31rem);
+    grid-template-columns: 3.55rem minmax(0, 1fr);
+    overflow: auto;
+    transform: none;
+  }
+
+  /* src/index.css:9050 */
+  .image-canvas-editor__generation-composer-footer,
+  .image-canvas-editor__character-animation-footer {
+    grid-template-columns: minmax(0, 1fr);
+    align-items: stretch;
+  }
+
+  /* src/index.css:9056 */
+  .image-canvas-editor__option-popover-anchor--dimensions,
+  .image-canvas-editor__option-popover-anchor--model {
+    grid-column: auto;
+    width: 100%;
+    justify-self: stretch;
+  }
+
+  /* src/index.css:9063 */
+  .image-canvas-editor__option-cluster--dimensions,
+  .image-canvas-editor__option-cluster--model,
+  .image-canvas-editor__image-style-toggle,
+  .image-canvas-editor__readonly-generation-option,
+  .image-canvas-editor__generation-submit,
+  .image-canvas-editor__character-animation-submit {
+    grid-column: auto;
+    width: 100%;
+    max-width: none;
+    justify-self: stretch;
+  }
+}
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasFocusModel.ts b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasFocusModel.ts
index b08cf7620..260e12164 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasFocusModel.ts
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasFocusModel.ts
@@ -48,9 +48,9 @@ export function isResourceCanvasPanTarget(
   if (!isResourceCanvasInteractionTarget(target)) return true;
   return Boolean(
     target.closest('.game-resource-card') &&
-    !target.closest(
-      'button:not(.game-resource-card-select), [role="button"], input, textarea, select, a, audio, video',
-    ),
+      !target.closest(
+        'button:not(.game-resource-card-select), [role="button"], input, textarea, select, a, audio, video',
+      ),
   );
 }
 
@@ -85,18 +85,6 @@ export function isResourceCanvasWheelOverlayTarget(
   );
 }
 
-/**
- * 画布浮层是否可以被清焦点顺手关掉。
- *
- * 对齐美术画布 `closeTransientEditorPanels()`：生成中的面板不关，否则用户看不到
- * 「修改中」状态，也拿不到失败后的重试入口。信息浮层是只读的，没有生成态。
- */
-export function canDismissResourceCanvasQuickEdit(
-  panel: { readonly status: string } | null | undefined,
-): boolean {
-  return panel?.status !== 'generating';
-}
-
 /** 资源画布上的 AGC 自有弹层：它们开着时画布浮层不参与「点外部关闭」。 */
 export type ResourceCanvasHostOverlayState = {
   readonly isResourcePanelOpen: boolean;
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasGenerationPanel.css b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasGenerationPanel.css
index 7d19a99ec..9983b191c 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasGenerationPanel.css
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasGenerationPanel.css
@@ -14,8 +14,9 @@
   align-content: center;
   gap: 4px;
   padding: 8px;
+  /* 差异只留「虚线 + 更深的描边」（表示还没落地）；圆角与浮层卡共用基类 token。 */
   border: 1px dashed #c9a493;
-  border-radius: 14px;
+  border-radius: var(--game-canvas-card-radius-inner, 14px);
   background: rgb(255 250 247 / 88%);
   color: #8a6a5c;
   text-align: center;
@@ -80,14 +81,70 @@
   /* 锚点给的是占位卡中心：不居中就会整体右偏半个面板宽（真实浏览器 x287 vs 卡中心 286 复现过）。 */
   transform: translateX(-50%);
   width: min(560px, calc(100% - 24px));
+  /* 外形走基类 token（= 网页端画布面板那一套），三块浮层因此长得一样。 */
+  border: 1px solid var(--game-canvas-card-border, #e4c8ba);
+  border-radius: var(--game-canvas-card-radius, 18px);
+  background: var(--game-canvas-card-fill, #fffaf7);
+  box-shadow: var(--game-canvas-card-shadow, 0 24px 64px rgb(62 37 27 / 24%));
+  padding: var(--game-canvas-card-padding, 18px);
   overflow-y: auto;
   overflow-x: hidden;
   overscroll-behavior: contain;
   pointer-events: auto;
-  /* 内联 `maxHeight` 按真实画布底边算；这条只是拿不到几何时的兜底上界。 */
+  /*
+   * 内联 `maxHeight` 按真实画布底边算；这条只是拿不到几何时的兜底上界。
+   *
+   * 面板内容已经压到「一行提示词 + 一行参数 + 一行动作」的紧凑版（见下面那组规则），正常几何下
+   * 根本到不了这里；`overflow` 与这条上界保留为极端窗口下的兜底，而不是日常出现的滚动条。
+   */
   max-height: min(560px, calc(100dvh - 160px));
 }
 
+/*
+ * 紧凑版：字段行两列（标签在左、控件在右）、比例与尺寸并排、动作用一行收口。
+ *
+ * 验收现场那张图里面板要滚动，是因为「标签各占一行 + 提示词 6 行 + 比例一行 + 尺寸一行 + 润色
+ * 一行 + 参考计数一行」把内容顶到几何上界之外。这里按信息层级重新排：从属信息（标签、计数、
+ * 润色）让位给主体（提示词、参数、动作），面板高度回落到上界以内，滚动条物理上不再出现。
+ */
+.game-resource-generation-form {
+  gap: 10px;
+}
+
+.game-resource-generation-form > label,
+.game-resource-generation-form
+  > .resource-canvas-asset-generation-prompt-field {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  align-items: center;
+  gap: 4px 10px;
+}
+
+.resource-canvas-asset-generation-prompt-field > span,
+.game-resource-generation-form > label > span {
+  white-space: nowrap;
+}
+
+/* 比例（5 项）与尺寸（3 项）并排：两组都很短，各占半行足够点。 */
+.resource-canvas-asset-generation-dimensions {
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: 8px;
+}
+
+/* 动作行：润色与参考计数贴左，两个按钮贴右，同一行收口。 */
+.game-approval-dialog.resource-canvas-generation-floating-panel
+  .game-resource-generation-actions {
+  align-items: center;
+  gap: 10px;
+  padding-top: 2px;
+}
+
+.game-resource-generation-actions-buttons {
+  display: flex;
+  margin-left: auto;
+  gap: 8px;
+}
+
 /*
  * 提交行固定在浮层底部。
  *
@@ -113,4 +170,5 @@
   margin: 0;
   color: #9a7d70;
   font-size: 11px;
+  white-space: nowrap;
 }
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasQuickEditModel.ts b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasQuickEditModel.ts
index 5d5535c5b..8c558ec75 100644
--- a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasQuickEditModel.ts
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasQuickEditModel.ts
@@ -1,6 +1,7 @@
 import type { CanvasLayer } from '../../../../../src/components/image-editor/ImageCanvasEditorTypes';
 import type { QuickEditPanelState } from '../../../../../src/components/image-editor/ImageCanvasEditorTypes';
 import { createQuickEditPanelDraft } from '../../../../../src/components/image-editor/ImageCanvasGenerationDialogModel';
+import type { ChatReference } from '../project-workspace/resourceReferences';
 
 /**
  * AGC 资源卡快速编辑面板的初始草稿。
@@ -13,3 +14,174 @@ export function createResourceQuickEditPanelDraft(
 ): QuickEditPanelState {
   return createQuickEditPanelDraft(sourceLayer, {});
 }
+
+/**
+ * 一份还没提交的快速编辑草稿。
+ *
+ * 这是**宿主会话内存**里的一笔记录，不是正式业务状态：不落盘、不进资源编辑账本、
+ * 不参与对账。它存在的唯一理由是面板被点外部 / Esc 收起、或用户切到另一张素材卡之后，
+ * 用户刚写的提示词与 `@` 引用还能原样回到面板里；正式的可恢复事实仍然只由原生
+ * `list_pending_local_project_resource_edits` / `resume_local_project_resource_edit`
+ * 那条既有账本链路负责。
+ */
+export type ResourceQuickEditDraft = {
+  /** 提示词原文（含 `@显示名` 字面量，与聊天同源）。 */
+  readonly prompt: string;
+  /** 与提示词配套的 `@` 引用，回填输入区 chip。 */
+  readonly references: readonly ChatReference[];
+  /** 最后一次改动时间（恢复列表按新→旧排序）。 */
+  readonly updatedAt: number;
+};
+
+/**
+ * 资源**路径** → 未提交草稿。
+ *
+ * 键必须是投影的稳定身份，也就是 `ProjectResource.path`：资源投影本来就按 `path` 去重
+ * （`resourceProjectionModel` 的 `uniqueByPath`），而资源 ID 会变——任务产物被正规化登记成
+ * 正式素材后，同一张卡会从 `task:<任务>:<路径>` 变成 `asset:<id>`。拿 ID 当键时，只要重投影
+ * 不是「打开中这一笔快速编辑」自己触发（换素材卡收起面板、Agent 或外部编辑器把同一路径登记成
+ * 资产），草稿就会挂在一个再也点不到的键上：恢复入口按 id 找不到而把它静默过滤，重开面板也按
+ * 新卡 id 查不到，用户刚写的提示词凭空消失。
+ */
+export type ResourceQuickEditDraftStore = ReadonlyMap<
+  string,
+  ResourceQuickEditDraft
+>;
+
+/**
+ * 空草稿表：只在项目身份变化时用它整体清空。
+ *
+ * 走工厂而不是导出一个共享常量：这个表会直接交给 `useState`，一旦哪天有人改成原地
+ * `set` / `delete`，模块级单例就会跨面板、跨项目串味。每次调用都拿到一张新表。
+ */
+export function createEmptyResourceQuickEditDraftStore(): ResourceQuickEditDraftStore {
+  return new Map();
+}
+
+/** 提示词与引用都空才算「没有草稿」，不留一条空记录去占用恢复入口。 */
+export function isResourceQuickEditDraftEmpty(draft: {
+  readonly prompt: string;
+  readonly references: readonly unknown[];
+}): boolean {
+  return draft.prompt.trim().length === 0 && draft.references.length === 0;
+}
+
+export function readResourceQuickEditDraft(
+  store: ResourceQuickEditDraftStore,
+  key: string | null | undefined,
+): ResourceQuickEditDraft | undefined {
+  return key ? store.get(key) : undefined;
+}
+
+/**
+ * 写入一笔草稿补丁。
+ *
+ * - 只给 `prompt` 或只给 `references` 时，另一头沿用该键下既有记录（输入区两条
+ *   状态各自上报，谁都不该把对方清掉）；
+ * - 合并结果为空就不留记录，避免恢复入口里堆一条点开空面板的条目。
+ *
+ * 没有「换键」这一步：键是资源路径，正规化把卡片换成 `asset:…` 也不改路径，草稿不需要
+ * 跟着投影搬家（换键逻辑本身正是「搬家搬丢了」的来源）。
+ */
+export function writeResourceQuickEditDraft(
+  store: ResourceQuickEditDraftStore,
+  input: {
+    readonly key: string;
+    readonly prompt?: string;
+    readonly references?: readonly ChatReference[];
+    readonly updatedAt: number;
+  },
+): ResourceQuickEditDraftStore {
+  const current = store.get(input.key);
+  const next: ResourceQuickEditDraft = {
+    prompt: input.prompt ?? current?.prompt ?? '',
+    references: input.references ?? current?.references ?? [],
+    updatedAt: input.updatedAt,
+  };
+  const result = new Map(store);
+  if (isResourceQuickEditDraftEmpty(next)) {
+    result.delete(input.key);
+    return result;
+  }
+  result.set(input.key, next);
+  return result;
+}
+
+/** 恢复入口里的一行未提交草稿。 */
+export type ResourceQuickEditDraftEntry = {
+  /** 资源路径——`writeResourceQuickEditDraft` 的键，也是回填 / 丢弃时要用的键。 */
+  readonly key: string;
+  readonly label: string;
+  readonly prompt: string;
+  readonly updatedAt: number;
+};
+
+/**
+ * 恢复入口里的未提交草稿：只列**此刻还在当前投影里**的素材（按路径匹配，与卡片 id 无关），
+ * 按最后改动时间从新到旧。
+ *
+ * 资源已经不在项目里的草稿没有可继续的落点，不该继续占着入口；但表里那份记录不在这里删，
+ * 删了就分不清「资源暂时不可见」和「用户已经不要这笔草稿」——由「继续编辑」与用户显式
+ * 丢弃两处负责清理。
+ */
+export function listResourceQuickEditDraftEntries(
+  store: ResourceQuickEditDraftStore,
+  resources: readonly {
+    readonly path: string;
+    readonly label: string;
+  }[],
+): ResourceQuickEditDraftEntry[] {
+  const labelByPath = new Map(
+    resources.map((resource) => [resource.path, resource.label] as const),
+  );
+  const entries: ResourceQuickEditDraftEntry[] = [];
+  for (const [key, draft] of store) {
+    const label = labelByPath.get(key);
+    if (label === undefined) {
+      continue;
+    }
+    entries.push({
+      key,
+      label,
+      prompt: draft.prompt,
+      updatedAt: draft.updatedAt,
+    });
+  }
+  return entries.sort((left, right) => right.updatedAt - left.updatedAt);
+}
+
+/** 成功提交 / 用户显式丢弃后抹掉这笔草稿。 */
+export function dropResourceQuickEditDraft(
+  store: ResourceQuickEditDraftStore,
+  key: string | null | undefined,
+): ResourceQuickEditDraftStore {
+  if (!key || !store.has(key)) {
+    return store;
+  }
+  const result = new Map(store);
+  result.delete(key);
+  return result;
+}
+
+/**
+ * 把记录下来的草稿盖回刚造出来的面板草稿：模型 / 比例 / 尺寸等仍取当下的默认值，
+ * 只有用户真正改过的提示词与引用回填，避免用一份过期面板把当前默认档位也一起还原。
+ */
+export function restoreResourceQuickEditPanelDraft(
+  panelDraft: QuickEditPanelState,
+  draft: ResourceQuickEditDraft | undefined,
+): QuickEditPanelState {
+  return draft ? { ...panelDraft, prompt: draft.prompt } : panelDraft;
+}
+
+/** 恢复入口里的提示词摘要：只做一行展示，不改变原草稿内容。 */
+export function resourceQuickEditDraftPromptExcerpt(
+  prompt: string,
+  limit = 48,
+): string {
+  const text = prompt.trim().replace(/\s+/gu, ' ');
+  if (!text) {
+    return '（尚未填写提示词）';
+  }
+  return text.length > limit ? `${text.slice(0, limit)}…` : text;
+}
diff --git a/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasResourceEditTaskModel.ts b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasResourceEditTaskModel.ts
new file mode 100644
index 000000000..cf29486ef
--- /dev/null
+++ b/apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasResourceEditTaskModel.ts
@@ -0,0 +1,371 @@
+import { formatElapsedDuration } from '../../../../../packages/shared/src/lib/formatElapsedDuration';
+import type { ResourceCanvasAssetGenerationTaskStatus } from './resourceCanvasAssetGenerationTaskModel';
+
+/**
+ * 原生资源编辑账本里的一条**未收口**操作（Rust `list_pending_local_project_resource_edits`）。
+ *
+ * `phase` 由 Rust 的 `ResourceEditLedgerPhase` 拥有：前端只做「阶段 → 面板状态」的映射与文案渲染，
+ * 不自己发明阶段，也不从别的字段反推进度。
+ */
+export type PendingLocalProjectResourceEdit = {
+  operationId: string;
+  editKind: string;
+  sourceResourceId: string;
+  assetName: string;
+  backgroundMode?: string | null;
+  screenColor?: string | null;
+  phase: string;
+  createdAt: number;
+};
+
+/**
+ * 本会话内**由本进程发起**的一次派生/修改提交。
+ *
+ * 原生账本要等 Rust 建好 ledger 才读得到，而「点了生成」到那一刻之间界面上一片空白；这份
+ * 本地记录就是补那一段的：提交当帧就进「生成任务」侧栏，收口时按终态改写。它与原生待办
+ * 列表按 `operationId` 合并，同一条不会出现两遍。
+ */
+export type ResourceCanvasResourceEditSubmission = {
+  operationId: string;
+  /** 输入区里那句需求，收进侧栏当副标题（与聊天 `@` 同源的原文）。 */
+  prompt: string;
+  assetName: string;
+  /** 入口文案：快速编辑 / 生成动画 / 图片抠图…，由 `pendingResourceEditKindLabel` 出。 */
+  actionLabel: string;
+  /**
+   * 这笔提交属于哪张资源（资源路径，见 `ProjectResource.path`）；无源入口（视频 / 音效 /
+   * 背景音乐）为 `null`。
+   *
+   * 两个用途：① 快速编辑提交期间，这张资源的未提交草稿不再算「未完成编辑」——用户已经交出去了，
+   * 恢复入口里不该再多一条点开就重复提交的条目（见 `resourceCanvasQuickEditModel`）；② 同一张
+   * 资源还有在途提交时，快速编辑与生成动画都不允许再铸一次身份（见
+   * `resourceCanvasResourceEditSubmissionBlocksResource`）。
+   */
+  resourcePath: string | null;
+  createdAtMillis: number;
+  status: 'running' | 'completed' | 'failed';
+  error: string | null;
+  assetId: string | null;
+  finishedAtMillis: number | null;
+};
+
+/** 「生成任务」侧栏里的一条派生/修改任务：原生阶段 + 本地提交记录合并后的呈现单元。 */
+export type ResourceCanvasResourceEditTask = {
+  operationId: string;
+  assetName: string;
+  actionLabel: string;
+  prompt: string;
+  status: ResourceCanvasAssetGenerationTaskStatus;
+  phaseDetail: string;
+  createdAtMillis: number;
+  finishedAtMillis: number | null;
+  error: string | null;
+  assetId: string | null;
+  /** 从原生账本恢复、本地没有对应提交记录的那一条：耗时不可知，面板不编时间。 */
+  restored: boolean;
+};
+
+/**
+ * 原生阶段 → 面板文案。
+ *
+ * 键逐字对应 Rust `ResourceEditLedgerPhase::as_str()`；措辞沿用恢复入口（「管理未完成编辑」）里
+ * 已经在用的那一套——同一条操作在两处必须叫同一个名字，否则用户会以为是两件事。未知阶段原样
+ * 透出阶段名，排障时能一眼看出前端还没跟上的新档，而不是显示一句编造的进度。
+ */
+export const RESOURCE_CANVAS_RESOURCE_EDIT_PHASE_LABELS: Record<
+  string,
+  string
+> = {
+  prepared: '原请求已冻结',
+  accepted: '远程已受理',
+  'remote-completed': '远程已完成',
+  'media-downloaded': '结果已下载',
+  'remote-failed': '远程明确失败',
+  'reconciliation-required': '需要人工对账',
+  committed: '已写入项目',
+  archived: '已归档',
+};
+
+/** 本会话内刚提交、原生账本还没读回来的那一段自述文案。 */
+export const RESOURCE_CANVAS_RESOURCE_EDIT_SUBMITTED_PHASE =
+  '已提交，等待远端受理';
+/** 提交成功、本地已经拿到结果的收口文案。 */
+export const RESOURCE_CANVAS_RESOURCE_EDIT_COMPLETED_PHASE = '已产出新素材';
+
+/**
+ * `editKind` → 入口文案。
+ *
+ * 与恢复入口（`list_pending_local_project_resource_edits` 那张列表）共用同一个映射：同一条操作
+ * 在两处显示的入口名必须一致，否则用户会以为它们是两件事。
+ */
+export function pendingResourceEditKindLabel({
+  editKind,
+  backgroundMode,
+  screenColor,
+}: Pick<
+  PendingLocalProjectResourceEdit,
+  'editKind' | 'backgroundMode' | 'screenColor'
+>) {
+  if (editKind === 'image') return '图片编辑';
+  if (editKind === 'background-removal') {
+    if (backgroundMode === 'complex') return '图片抠图 · 复杂背景';
+    if (backgroundMode === 'flat') {
+      const color = screenColor === 'auto' ? '自动背景色' : screenColor;
+      return `图片抠图 · 平面背景${color ? ` · ${color}` : ''}`;
+    }
+    return '图片抠图';
+  }
+  if (editKind === 'text') return '文本编辑';
+  if (editKind === 'agent-result') return '智能体结果编辑';
+  if (editKind === 'image-reference') return '快速编辑';
+  if (editKind === 'character-animation') return '生成动画';
+  if (editKind === 'sound-effect') return '生成音效';
+  if (editKind === 'background-music') return '生成背景音乐';
+  if (editKind === 'video') return '生成视频';
+  return '资源编辑';
+}
+
+/**
+ * 原生阶段 → 面板状态。
+ *
+ * `prepared` 是「账本已建、远端请求还没发出」的本地排队档，映射成 `queued` 让面板把它和
+ * `running` 一起放进「排队/生成中」分栏；两个真失败档（远端失败、需要人工对账）映射成
+ * `failed`，用户才有可点的定位与可见的失败原因。
+ */
+export function resourceCanvasResourceEditTaskStatusFromPhase(
+  phase: string,
+): ResourceCanvasAssetGenerationTaskStatus {
+  switch (phase) {
+    case 'prepared':
+      return 'queued';
+    case 'remote-failed':
+    case 'reconciliation-required':
+      return 'failed';
+    case 'committed':
+    case 'archived':
+      return 'completed';
+    default:
+      return 'running';
+  }
+}
+
+/** 未知阶段不编文案：原样显示阶段名，排障时能一眼看出前端还没跟上的档。 */
+export function resourceCanvasResourceEditPhaseLabel(phase: string): string {
+  return RESOURCE_CANVAS_RESOURCE_EDIT_PHASE_LABELS[phase] ?? phase;
+}
+
+export function resourceCanvasResourceEditTaskIsTerminal(
+  task: Pick<ResourceCanvasResourceEditTask, 'status'>,
+): boolean {
+  return task.status === 'completed' || task.status === 'failed';
+}
+
+export function resourceCanvasResourceEditSubmissionIsLive(
+  submission: Pick<ResourceCanvasResourceEditSubmission, 'status'>,
+): boolean {
+  return submission.status === 'running';
+}
+
+/**
+ * 「这张资源上还有一笔没结束的提交」。
+ *
+ * 快速编辑（顺带把该资源的草稿从「未完成编辑」里让位）与生成动画共用同一条判据：提交即关面板
+ * 之后，「重开面板再提交」是唯一的重试路径，不拦就会出现两条并发提交——提示词没变时第二次会卡在
+ * 原生 per-operation 锁上、最后以阶段不可恢复报错；改了提示词则直接多出一笔付费生成。
+ */
+export function resourceCanvasResourceEditSubmissionBlocksResource(
+  submissions: readonly ResourceCanvasResourceEditSubmission[],
+  resourcePath: string,
+): boolean {
+  return submissions.some(
+    (submission) =>
+      submission.resourcePath === resourcePath &&
+      resourceCanvasResourceEditSubmissionIsLive(submission),
+  );
+}
+
+/**
+ * 记一笔刚发生的提交。
+ *
+ * 按 `operationId` 覆盖写入：同一笔重试（身份复用）不该在侧栏里堆出第二条；换了身份则是新的一笔，
+ * 两条并存本来就是用户看到的真相。
+ */
+export function beginResourceCanvasResourceEditSubmission(
+  submissions: readonly ResourceCanvasResourceEditSubmission[],
+  input: Omit<
+    ResourceCanvasResourceEditSubmission,
+    'status' | 'error' | 'assetId' | 'finishedAtMillis'
+  >,
+): ResourceCanvasResourceEditSubmission[] {
+  const next: ResourceCanvasResourceEditSubmission = {
+    ...input,
+    status: 'running',
+    error: null,
+    assetId: null,
+    finishedAtMillis: null,
+  };
+  return [
+    ...submissions.filter(
+      (submission) => submission.operationId !== input.operationId,
+    ),
+    next,
+  ];
+}
+
+/** 收口一笔提交：成功给产物 id，失败给原因；两者都写结束时间，侧栏据此停表。 */
+export function settleResourceCanvasResourceEditSubmission(
+  submissions: readonly ResourceCanvasResourceEditSubmission[],
+  operationId: string,
+  result:
+    | { status: 'completed'; assetId: string | null; finishedAtMillis: number }
+    | { status: 'failed'; error: string; finishedAtMillis: number },
+): ResourceCanvasResourceEditSubmission[] {
+  return submissions.map((submission) =>
+    submission.operationId === operationId
+      ? result.status === 'completed'
+        ? {
+            ...submission,
+            status: 'completed',
+            assetId: result.assetId,
+            error: null,
+            finishedAtMillis: result.finishedAtMillis,
+          }
+        : {
+            ...submission,
+            status: 'failed',
+            assetId: null,
+            error: result.error,
+            finishedAtMillis: result.finishedAtMillis,
+          }
+      : submission,
+  );
+}
+
+function resourceCanvasResourceEditTaskFromPendingEdit(
+  edit: PendingLocalProjectResourceEdit,
+): ResourceCanvasResourceEditTask {
+  const status = resourceCanvasResourceEditTaskStatusFromPhase(edit.phase);
+  return {
+    operationId: edit.operationId,
+    assetName: edit.assetName,
+    actionLabel: pendingResourceEditKindLabel(edit),
+    prompt: '',
+    status,
+    phaseDetail: resourceCanvasResourceEditPhaseLabel(edit.phase),
+    createdAtMillis: edit.createdAt,
+    finishedAtMillis: null,
+    error:
+      status === 'failed'
+        ? `原生账本停留在「${resourceCanvasResourceEditPhaseLabel(edit.phase)}」阶段`
+        : null,
+    assetId: null,
+    restored: true,
+  };
+}
+
+function resourceCanvasResourceEditTaskFromSubmission(
+  submission: ResourceCanvasResourceEditSubmission,
+  pending: PendingLocalProjectResourceEdit | undefined,
+): ResourceCanvasResourceEditTask {
+  const live = resourceCanvasResourceEditSubmissionIsLive(submission);
+  return {
+    operationId: submission.operationId,
+    assetName: submission.assetName,
+    actionLabel: submission.actionLabel,
+    prompt: submission.prompt,
+    status: live
+      ? pending
+        ? resourceCanvasResourceEditTaskStatusFromPhase(pending.phase)
+        : 'running'
+      : submission.status,
+    // 在途期间以原生阶段为准（它才知道远端走到了哪一步）；收口后由本地说结果。
+    phaseDetail: live
+      ? pending
+        ? resourceCanvasResourceEditPhaseLabel(pending.phase)
+        : RESOURCE_CANVAS_RESOURCE_EDIT_SUBMITTED_PHASE
+      : submission.status === 'failed'
+        ? submission.error || '资源修改失败'
+        : RESOURCE_CANVAS_RESOURCE_EDIT_COMPLETED_PHASE,
+    createdAtMillis: submission.createdAtMillis,
+    finishedAtMillis: submission.finishedAtMillis,
+    error: live ? null : submission.error,
+    assetId: submission.assetId,
+    restored: false,
+  };
+}
+
+/**
+ * 原生待办账本 + 本地提交记录 → 侧栏里的派生/修改任务。
+ *
+ * 两个方向都要覆盖，与图片类生成任务的合并口径一致：本地提交按 `operationId` 用原生阶段刷新，
+ * 原生有、本地没有的记录（重开项目、别处提交、本会话已剪掉的历史）恢复成一条；本地已收口、
+ * 原生已经查不到的那几笔仍留在列表里——用户刚看到的结果不该因为账本收口而从面板上消失。
+ */
+export function resourceCanvasResourceEditTasks({
+  submissions,
+  pendingEdits,
+}: {
+  submissions: readonly ResourceCanvasResourceEditSubmission[];
+  pendingEdits: readonly PendingLocalProjectResourceEdit[] | null | undefined;
+}): ResourceCanvasResourceEditTask[] {
+  const safePending = Array.isArray(pendingEdits) ? pendingEdits : [];
+  const pendingByOperationId = new Map(
+    safePending.map((edit) => [edit.operationId, edit]),
+  );
+  const local = submissions.map((submission) =>
+    resourceCanvasResourceEditTaskFromSubmission(
+      submission,
+      pendingByOperationId.get(submission.operationId),
+    ),
+  );
+  const knownOperationIds = new Set(
+    submissions.map((submission) => submission.operationId),
+  );
+  const restored = safePending
+    .filter((edit) => !knownOperationIds.has(edit.operationId))
+    .map(resourceCanvasResourceEditTaskFromPendingEdit);
+  return sortResourceCanvasResourceEditTasks([...local, ...restored]);
+}
+
+/** 面板展示顺序：新提交的在上。 */
+export function sortResourceCanvasResourceEditTasks(
+  tasks: readonly ResourceCanvasResourceEditTask[],
+): ResourceCanvasResourceEditTask[] {
+  return [...tasks].sort(
+    (left, right) =>
+      right.createdAtMillis - left.createdAtMillis ||
+      left.operationId.localeCompare(right.operationId),
+  );
+}
+
+/**
+ * 派生/修改任务的已耗时。
+ *
+ * 从原生账本恢复的收口记录没有结束时间（Rust 只给 `createdAt`），这里返回 `null`，由面板整格
+ * 不渲染——宁可不显示，也不拿创建时间冒充耗时。
+ */
+export function resourceCanvasResourceEditTaskElapsedMillis(
+  task: Pick<
+    ResourceCanvasResourceEditTask,
+    'createdAtMillis' | 'finishedAtMillis' | 'restored'
+  >,
+  nowMillis: number,
+): number | null {
+  if (task.restored && task.finishedAtMillis === null) {
+    return null;
+  }
+  return Math.max(
+    0,
+    (task.finishedAtMillis ?? nowMillis) - task.createdAtMillis,
+  );
+}
+
+/** 与图片类生成任务共用一套耗时文案（`formatElapsedDuration` 的唯一入口）。 */
+export function resourceCanvasResourceEditElapsedLabel(
+  elapsedMillis: number | null,
+): string {
+  if (elapsedMillis === null) {
+    return '—';
+  }
+  return formatElapsedDuration(elapsedMillis) ?? '—';
+}
diff --git a/apps/ai-game-creator-shell/src/styles.css b/apps/ai-game-creator-shell/src/styles.css
index f76ef6046..6833fd921 100644
--- a/apps/ai-game-creator-shell/src/styles.css
+++ b/apps/ai-game-creator-shell/src/styles.css
@@ -9546,6 +9546,26 @@ iframe.preview-frame {
   box-shadow: 0 24px 64px rgb(62 37 27 / 24%);
 }
 
+/*
+ * 画布卡片基类 token。
+ *
+ * 取值**照抄网页端美术画布的面板**（`src/index.css` 的 `.image-canvas-editor__generation-composer`
+ * 一族）：占位卡、生成浮层 / 弹窗、资源信息浮层从此共用同一组圆角 / 描边 / 底色 / 投影，各卡
+ * 自己的规则只表达差异（占位卡虚线描边、浮层的定位与宽度、信息浮层的窄宽…）。
+ *
+ * 两块从网页端整站表逐条照抄下来的浮层（快速编辑 / 生成动画）本身不在这里改——它们的取值由
+ * `tests/resourceCanvasCharacterAnimationPanelStyle.test.tsx` 逐条比对，改了会直接把守卫打红；
+ * 它们本来就是这套取值的来源。
+ */
+.game-project-workbench {
+  --game-canvas-card-radius: 1.1rem;
+  --game-canvas-card-radius-inner: 0.85rem;
+  --game-canvas-card-border: rgba(148, 163, 184, 0.36);
+  --game-canvas-card-fill: rgba(255, 255, 255, 0.96);
+  --game-canvas-card-shadow: 0 22px 48px rgba(15, 23, 42, 0.22);
+  --game-canvas-card-padding: 0.76rem;
+}
+
 .game-approval-dialog > header {
   display: flex;
   align-items: flex-start;
@@ -9590,7 +9610,7 @@ iframe.preview-frame {
   background: #fff;
 }
 
-.game-resource-recovery-item > div {
+.game-resource-recovery-item > div:first-child {
   display: grid;
   min-width: 0;
   gap: 4px;
@@ -9606,7 +9626,18 @@ iframe.preview-frame {
   color: #9a7d70;
 }
 
+/*
+ * 一行里的多枚动作收在一个容器里：条目是 `space-between` 的 flex，动作不收拢就会被
+ * 摊到中间，和原生条目右对齐的单枚动作对不齐（移动端尤其明显）。
+ */
+.game-resource-recovery-actions {
+  display: flex;
+  flex: 0 0 auto;
+  gap: 8px;
+}
+
 .game-resource-recovery-item > button,
+.game-resource-recovery-actions > button,
 .game-resource-recovery-error > button {
   min-height: 34px;
   padding: 0 13px;
@@ -9618,6 +9649,7 @@ iframe.preview-frame {
 }
 
 .game-resource-recovery-item > button:disabled,
+.game-resource-recovery-actions > button:disabled,
 .game-resource-recovery-error > button:disabled {
   cursor: wait;
   opacity: 0.56;
@@ -9652,9 +9684,14 @@ iframe.preview-frame {
   }
 
   .game-resource-recovery-item > button,
+  .game-resource-recovery-actions,
   .game-resource-recovery-error > button {
     width: 100%;
   }
+
+  .game-resource-recovery-actions {
+    flex-direction: column;
+  }
 }
 
 .game-approval-dialog > header button {
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 e5a900738..f0895eaf7 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
@@ -167,7 +167,6 @@ import {
 } from '../../features/resource-canvas/resourceCanvasBottomToolbarModel';
 import { ResourceCanvasBottomToolbarView } from '../../features/resource-canvas/ResourceCanvasBottomToolbarView';
 import {
-  canDismissResourceCanvasQuickEdit,
   isResourceCanvasInteractionTarget,
   isResourceCanvasPanTarget,
   isResourceCanvasWheelOverlayTarget,
@@ -204,7 +203,28 @@ import {
   undoResourceCanvasHistory,
 } from '../../features/resource-canvas/resourceCanvasHistoryModel';
 import { ResourceCanvasPanelView } from '../../features/resource-canvas/ResourceCanvasPanelView';
-import { createResourceQuickEditPanelDraft } from '../../features/resource-canvas/resourceCanvasQuickEditModel';
+import {
+  createEmptyResourceQuickEditDraftStore,
+  createResourceQuickEditPanelDraft,
+  dropResourceQuickEditDraft,
+  listResourceQuickEditDraftEntries,
+  readResourceQuickEditDraft,
+  resourceQuickEditDraftPromptExcerpt,
+  type ResourceQuickEditDraftStore,
+  restoreResourceQuickEditPanelDraft,
+  writeResourceQuickEditDraft,
+} from '../../features/resource-canvas/resourceCanvasQuickEditModel';
+import {
+  beginResourceCanvasResourceEditSubmission,
+  type PendingLocalProjectResourceEdit,
+  pendingResourceEditKindLabel,
+  RESOURCE_CANVAS_RESOURCE_EDIT_PHASE_LABELS,
+  type ResourceCanvasResourceEditSubmission,
+  resourceCanvasResourceEditSubmissionBlocksResource,
+  resourceCanvasResourceEditTaskIsTerminal,
+  resourceCanvasResourceEditTasks,
+  settleResourceCanvasResourceEditSubmission,
+} from '../../features/resource-canvas/resourceCanvasResourceEditTaskModel';
 import {
   canNormalizeResourceIntoManifestAsset,
   projectResourceToCanvasLayer,
@@ -341,10 +361,10 @@ import { ResourceDocumentPreviewDialog } from './ResourceDocumentPreviewDialog';
 import {
   canonicalProjectedResourceMediaType,
   createResourceEditRequestIdentity,
-  defaultCharacterAnimationResourceName,
-  defaultDerivedResourceName,
+  resolveDerivedResourceNameCheck,
   resolveProjectCharacterAnimationCapability,
   resolveResourceEditRequestIdentity,
+  type ResourceEditNameCheck,
   type ResourceEditRequestIdentity,
 } from './resourceEditModel';
 import { ResourceFilterPanel } from './ResourceFilterPanel';
@@ -502,17 +522,6 @@ type DeriveLocalProjectResourceResult = {
   manifest: GameCreationAppManifest;
 };
 
-type PendingLocalProjectResourceEdit = {
-  operationId: string;
-  editKind: string;
-  sourceResourceId: string;
-  assetName: string;
-  backgroundMode?: string | null;
-  screenColor?: string | null;
-  phase: string;
-  createdAt: number;
-};
-
 /**
  * 一次资源派生的请求身份，外加源解析过程中要缓存的两条事实。
  *
@@ -549,33 +558,29 @@ type ResourceEditServiceIdentityConfirmation = {
   expiresAt: number;
 };
 
-function pendingResourceEditKindLabel({
-  editKind,
-  backgroundMode,
-  screenColor,
-}: PendingLocalProjectResourceEdit) {
-  if (editKind === 'image') return '图片编辑';
-  if (editKind === 'background-removal') {
-    if (backgroundMode === 'complex') return '图片抠图 · 复杂背景';
-    if (backgroundMode === 'flat') {
-      const color = screenColor === 'auto' ? '自动背景色' : screenColor;
-      return `图片抠图 · 平面背景${color ? ` · ${color}` : ''}`;
-    }
-    return '图片抠图';
-  }
-  if (editKind === 'text') return '文本编辑';
-  if (editKind === 'agent-result') return '智能体结果编辑';
-  return '资源编辑';
+/**
+ * 恢复入口里的阶段文案。
+ *
+ * 取值与「生成任务」侧栏共用同一张表（`RESOURCE_CANVAS_RESOURCE_EDIT_PHASE_LABELS`），只在这里
+ * 换掉未知档的兜底：恢复入口对用户表达的是「这件事还能不能接着做」，所以未知阶段落地成
+ * 「等待恢复」，而不是把生阶段名摆给用户看。
+ */
+function pendingResourceEditPhaseLabel(phase: string) {
+  return RESOURCE_CANVAS_RESOURCE_EDIT_PHASE_LABELS[phase] ?? '等待恢复';
 }
 
-function pendingResourceEditPhaseLabel(phase: string) {
-  if (phase === 'prepared') return '原请求已冻结';
-  if (phase === 'accepted') return '远程已受理';
-  if (phase === 'remote-completed') return '远程已完成';
-  if (phase === 'media-downloaded') return '结果已下载';
-  if (phase === 'remote-failed') return '远程明确失败';
-  if (phase === 'reconciliation-required') return '需要人工对账';
-  return '等待恢复';
+/**
+ * 卡片浮层的派生请求身份表键：**入口 + 资源路径**。
+ *
+ * 两块浮层都是「提交即关」，重试的唯一路径是重开面板再提交；身份不跟着资源走的话，重试会变成
+ * 一条全新的 operation（原生账本认不出同一件事，还可能重复计费）。同一张素材上的两种入口
+ * （快速编辑 / 生成动画）是两条不同的派生请求，所以键里带上入口。
+ */
+function resourceEditRequestKey(
+  kind: 'quick-edit' | 'character-animation',
+  resourcePath: string,
+): string {
+  return `${kind}:${resourcePath}`;
 }
 
 function pendingResourceEditCreatedAtLabel(createdAt: number) {
@@ -588,6 +593,37 @@ function pendingResourceEditCreatedAtLabel(createdAt: number) {
   }).format(new Date(createdAt * 1000));
 }
 
+/**
+ * 未提交草稿的「最后改动时间」标签。
+ *
+ * 账本里的 `createdAt` 是**秒**（Rust 侧口径），宿主内存里的草稿时间戳是 `Date.now()` 的
+ * **毫秒**；直接丢给上面那个格式化器会再乘 1000，显示成某年 03/25 02:35 这种完全无关的
+ * 日期。换算收在这一处。
+ */
+function resourceQuickEditDraftUpdatedAtLabel(updatedAt: number) {
+  return pendingResourceEditCreatedAtLabel(Math.floor(updatedAt / 1000));
+}
+
+/**
+ * 「管理未完成编辑」入口的按钮文案。
+ *
+ * 原生账本读取失败时也把本会话草稿的条数说出来：两边来源不同（一个在 Rust 账本里、
+ * 一个只在这次打开客户端期间存在），账本读不出来不代表手头的草稿也没有，用户不该
+ * 因为一次读取失败就以为「没有未完成的编辑」。
+ */
+function resourceRecoveryTriggerLabel(input: {
+  readonly loadFailed: boolean;
+  readonly pendingCount: number;
+  readonly draftCount: number;
+}) {
+  if (input.loadFailed) {
+    return input.draftCount > 0
+      ? `恢复队列读取失败（另有本会话草稿 ${input.draftCount} 条）`
+      : '恢复队列读取失败';
+  }
+  return `管理未完成编辑 (${input.pendingCount + input.draftCount})`;
+}
+
 export type ProjectAgentRuntimeSummary = {
   group: GameCreationAppAgentGroup;
   label: string;
@@ -2143,10 +2179,36 @@ export default function ProjectDevelopmentView({
   const [pendingResourceEdits, setPendingResourceEdits] = useState<
     PendingLocalProjectResourceEdit[]
   >([]);
+  /**
+   * 本会话**由本进程发起**的派生/修改提交（快速编辑、生成动画、抠图…）。
+   *
+   * 原生账本要等 Rust 建好 ledger 才读得到，而「点了生成」到那一刻之间界面上一片空白——
+   * 这正是验收现场那半条「点了生成，生成任务里什么都没有」。这份本地记录补那一段：提交当帧
+   * 就进「生成任务」侧栏，收口时按结果改写；与原生待办按 `operationId` 合并，同一条不会重复。
+   */
+  const [resourceEditSubmissions, setResourceEditSubmissions] = useState<
+    ResourceCanvasResourceEditSubmission[]
+  >([]);
+  const resourceEditSubmissionsRef = useRef<
+    ResourceCanvasResourceEditSubmission[]
+  >([]);
+  resourceEditSubmissionsRef.current = resourceEditSubmissions;
   const [pendingResourceEditsLoadState, setPendingResourceEditsLoadState] =
     useState<PendingResourceEditsLoadState>('idle');
   const [pendingResourceEditsError, setPendingResourceEditsError] =
     useState('');
+  /**
+   * 快速编辑里**还没提交**的草稿：宿主会话内存态，不落盘、不进资源编辑账本，也不参与
+   * 对账（正式的可恢复事实只有原生 `list_pending_local_project_resource_edits` /
+   * `resume_local_project_resource_edit` 那条既有链路）。点外部 / Esc 收起面板、或用户
+   * 切到另一张素材卡，都不再无条件丢掉刚写的提示词；重开面板原样回填，也能从「管理未完成
+   * 编辑」里继续。键是资源**路径**（投影的稳定身份，见 `resourceCanvasQuickEditModel`
+   * 的类型注释），正规化把卡片换成 `asset:…` 不影响它。
+   */
+  const [resourceQuickEditDrafts, setResourceQuickEditDrafts] =
+    useState<ResourceQuickEditDraftStore>(
+      createEmptyResourceQuickEditDraftStore,
+    );
   const [platformSessionGeneration, setPlatformSessionGeneration] = useState(
     currentPlatformSessionGeneration,
   );
@@ -2341,15 +2403,28 @@ export default function ProjectDevelopmentView({
   /** 「生成动画」的请求身份，与快速编辑同一套复用/重铸口径。 */
   const resourceCharacterAnimationRequestRef =
     useRef<ResourceDeriveRequest | null>(null);
-  /** 快速编辑面板的最新状态：清焦点回调只在事件里读，不随面板状态反复重建。 */
-  const quickEditPanelRef = useRef<QuickEditPanelState | null>(null);
-  quickEditPanelRef.current = quickEditPanel;
-  /** 「生成动画」面板的最新状态，读法同上。 */
-  const characterAnimationPanelRef =
-    useRef<CharacterAnimationPanelState | null>(null);
-  characterAnimationPanelRef.current = characterAnimationPanel;
+  /**
+   * 资源路径 → 这块资源上最后一次派生请求的身份（按入口分键，见 `resourceEditRequestKey`）。
+   *
+   * 卡片浮层提交即关，用户重试只能「重开面板再提交」；身份不跟着资源走的话，那次重试就成了
+   * 一条全新的 operation。派生成成功即清掉：下一次编辑本来就该是新的一笔。
+   */
+  const resourceEditLastRequestsRef = useRef(
+    new Map<string, ResourceDeriveRequest>(),
+  );
+  /**
+   * 打开中的快速编辑面板，这一笔草稿挂在哪个资源路径下。
+   *
+   * 收起面板或换素材卡时清空。键取路径而不是投影 id：正规化（`task:…` → `asset:…`）
+   * 换掉的是 id，路径不变，所以这里不需要任何「跟着重投影搬家」的纠偏。
+   */
+  const resourceQuickEditDraftPathRef = useRef<string | null>(null);
+  /** 未提交草稿表的最新值：只在事件与回调里读，不随每次按键重建回调。 */
+  const resourceQuickEditDraftsRef = useRef(resourceQuickEditDrafts);
+  resourceQuickEditDraftsRef.current = resourceQuickEditDrafts;
 
   const closeResourceQuickEditPanel = useCallback(() => {
+    resourceQuickEditDraftPathRef.current = null;
     setQuickEditPanel(null);
     setQuickEditSourceLayer(null);
     resourceQuickEditRequestRef.current = null;
@@ -2383,23 +2458,16 @@ export default function ProjectDevelopmentView({
    * 清资源画布焦点：对齐美术画布 `clearCanvasFocus()`。
    *
    * 美术画布在画布空白 pointerdown 与 Escape 两处都会走这一步——清空选中让选中工具条
-   * 收起，并关掉画布浮层（快速编辑与信息）。资源画布保持同一套时机：点在资源卡或浮层里
-   * 不清，点画布空白、按 Esc 才清。生成中的快速编辑面板不关，与美术画布
-   * `closeTransientEditorPanels()` 的 `status === 'generating'` 判断一致；信息浮层只读，
-   * 没有生成态，随焦点一起收起。
+   * 收起，并关掉画布浮层（快速编辑 / 生成动画 / 信息）。资源画布保持同一套时机：点在资源卡
+   * 或浮层里不清，点画布空白、按 Esc 才清。
+   *
+   * 这里的浮层一律可收：卡片浮层只负责**提交任务**，提交当帧自己就关了（任务进「生成任务」
+   * 侧栏跟踪），所以不存在「生成中必须留在画布上」的那一档。
    */
   const clearResourceCanvasFocus = useCallback(() => {
     setSelectedResourceIds([]);
     setResourceInfoResourceId(null);
-    if (!canDismissResourceCanvasQuickEdit(quickEditPanelRef.current)) {
-      return;
-    }
     closeResourceQuickEditPanel();
-    // 「生成动画」与快速编辑同样是挂在资源卡旁的浮层，走同一套「点外部 / Esc 关闭」
-    // 时机与「生成中不关」判据，否则按下 Esc 会只收起一个浮层。
-    if (characterAnimationPanelRef.current?.status === 'generating') {
-      return;
-    }
     closeResourceCharacterAnimationPanel();
   }, [closeResourceCharacterAnimationPanel, closeResourceQuickEditPanel]);
 
@@ -4744,6 +4812,10 @@ export default function ProjectDevelopmentView({
     setPendingResourceEditActionIds(new Set());
     pendingResourceEditsReadEpochRef.current += 1;
     setSelectedResourceIds([]);
+    // 未提交草稿是会话内存态、按资源路径归属：换项目后这些路径一个都不再成立，
+    // 整体清空，不能让上一个项目的草稿在新项目里冒出来。
+    resourceQuickEditDraftPathRef.current = null;
+    setResourceQuickEditDrafts(createEmptyResourceQuickEditDraftStore());
     setQuickEditPanel(null);
     setQuickEditSourceLayer(null);
     setResourceCanvasHistory(clearResourceCanvasHistory);
@@ -4847,6 +4919,57 @@ export default function ProjectDevelopmentView({
     };
   }, [refreshPendingResourceEdits]);
 
+  /**
+   * 记一笔派生/修改提交：提交当帧进「生成任务」侧栏。
+   *
+   * 侧栏的计数与列表都读这份记录，所以它是「用户按下生成」到「原生账本可读」之间唯一的事实。
+   */
+  const beginResourceEditSubmission = useCallback(
+    (input: {
+      operationId: string;
+      assetName: string;
+      actionLabel: string;
+      prompt: string;
+      resourcePath: string | null;
+    }) => {
+      setResourceEditSubmissions((current) =>
+        beginResourceCanvasResourceEditSubmission(current, {
+          ...input,
+          createdAtMillis: Date.now(),
+        }),
+      );
+    },
+    [],
+  );
+
+  /**
+   * 收口一笔派生/修改提交，并顺手重读原生待办列表。
+   *
+   * 重读是必须的：这一笔要么已经进账本（在途），要么已经收口（查不到），恢复入口据此决定还
+   * 要不要把它列成「未完成」。只改本地状态不重读，恢复入口会停在提交前的那份快照上。
+   */
+  const settleResourceEditSubmission = useCallback(
+    (
+      operationId: string,
+      result:
+        | { status: 'completed'; assetId: string | null }
+        | { status: 'failed'; error: string },
+    ) => {
+      const finishedAtMillis = Date.now();
+      setResourceEditSubmissions((current) =>
+        settleResourceCanvasResourceEditSubmission(
+          current,
+          operationId,
+          result.status === 'completed'
+            ? { status: 'completed', assetId: result.assetId, finishedAtMillis }
+            : { status: 'failed', error: result.error, finishedAtMillis },
+        ),
+      );
+      void refreshPendingResourceEdits();
+    },
+    [refreshPendingResourceEdits],
+  );
+
   const openResourceRecoveryPanel = useCallback(() => {
     resourceRecoveryPanelEpochRef.current += 1;
     setResourceRecoveryPanelOpen(true);
@@ -7233,6 +7356,40 @@ export default function ProjectDevelopmentView({
   );
   marqueeHitTestLayersRef.current = marqueeHitTestLayers;
 
+  /**
+   * 当前子画布里那张卡的图层：与 `selectedResourceCard` 同一份判据（子画布 + 可见）。
+   *
+   * 「继续编辑」用它把面板**当场**开到卡旁边，不必等选中态、也不用先切栏目再等一帧：
+   * 卡片已经在当前画布里时，这一刻就有一张可锚定的图层。卡片不在当前画布（别的栏目、
+   * 总览态或被搜索挡住）时返回 null，由调用处走既有的定位链。
+   */
+  const resolveVisibleResourceLayer = useCallback(
+    (resourceId: string): CanvasLayer | null => {
+      if (resourceBookView === 'main') {
+        return null;
+      }
+      const card = resourceBookScenePlan
+        .flatMap((group) => group.cards)
+        .find(
+          (entry) =>
+            entry.resource.id === resourceId &&
+            entry.presentation === 'child' &&
+            visibleResourceIds.has(entry.resource.id),
+        );
+      if (!card) {
+        return null;
+      }
+      return projectResourceToCanvasLayer({
+        resource: card.resource,
+        x: card.layout.x,
+        y: card.layout.y,
+        width: card.layout.width,
+        height: card.layout.height,
+      });
+    },
+    [resourceBookScenePlan, resourceBookView, visibleResourceIds],
+  );
+
   const selectedResourcePreviewIdentity = selectedResourceId
     ? (resourceCardPreviews.identityByResourceId.get(selectedResourceId) ??
       null)
@@ -7357,6 +7514,33 @@ export default function ProjectDevelopmentView({
     [manifest, onManifestChange, projectPath],
   );
 
+  /**
+   * 记一笔未提交草稿。
+   *
+   * 输入区两条状态各自上报（提示词、`@` 引用），这里只做合并写：给谁就更新谁，另一头
+   * 沿用该键下既有记录，谁都不会把对方抹掉；两头都空时不留记录，恢复入口里不会出现
+   * 一条点开空面板的条目。
+   */
+  const rememberResourceQuickEditDraft = useCallback(
+    (patch: {
+      readonly prompt?: string;
+      readonly references?: readonly ChatReference[];
+    }) => {
+      const key = resourceQuickEditDraftPathRef.current;
+      if (!key) {
+        return;
+      }
+      setResourceQuickEditDrafts((current) =>
+        writeResourceQuickEditDraft(current, {
+          ...patch,
+          key,
+          updatedAt: Date.now(),
+        }),
+      );
+    },
+    [],
+  );
+
   const openResourceQuickEditPanel = useCallback(
     (layer: CanvasLayer) => {
       const resource = canvasResources.find((item) => item.id === layer.id);
@@ -7367,38 +7551,138 @@ export default function ProjectDevelopmentView({
       applyResourceCardFloatingPanelOpen('quick-edit');
       setQuickEditSourceLayer(layer);
       const panelDraft = createResourceQuickEditPanelDraft(layer);
-      setQuickEditPanel(panelDraft);
-      setQuickEditReferences([]);
-      resourceQuickEditRequestRef.current = {
-        ...createResourceEditRequestIdentity(panelDraft.prompt),
-        sourceLayerId: layer.id,
-        normalizedAssetId: null,
-        expectedProjectRevision: null,
-      };
+      // 这张素材还有没提交的草稿就原样回填：点外部 / Esc 收起面板、或换过素材卡再回来，
+      // 用户刚写的提示词与 `@` 引用都还在。模型 / 比例 / 尺寸仍取当下默认值，不用一份
+      // 过期面板把默认档位也一起还原。查的是**路径**：卡片正规化后 id 会变，路径不会。
+      const remembered = readResourceQuickEditDraft(
+        resourceQuickEditDraftsRef.current,
+        resource.path,
+      );
+      const restoredPanelDraft = restoreResourceQuickEditPanelDraft(
+        panelDraft,
+        remembered,
+      );
+      resourceQuickEditDraftPathRef.current = resource.path;
+      setQuickEditPanel(restoredPanelDraft);
+      setQuickEditReferences(remembered ? [...remembered.references] : []);
+      /*
+        身份跟着**资源**走：上一次尝试失败后重开面板，提示词没变就沿用同一 operationId / 幂等键，
+        重试命中同一 operation 账本（提交时由 `resolveResourceEditRequestIdentity` 再判一次）。
+      */
+      const rememberedRequest = resourceEditLastRequestsRef.current.get(
+        resourceEditRequestKey('quick-edit', resource.path),
+      );
+      resourceQuickEditRequestRef.current = rememberedRequest
+        ? { ...rememberedRequest, sourceLayerId: layer.id }
+        : {
+            ...createResourceEditRequestIdentity(restoredPanelDraft.prompt),
+            sourceLayerId: layer.id,
+            normalizedAssetId: null,
+            expectedProjectRevision: null,
+          };
       setResourceWorkbenchNotice('');
     },
     [applyResourceCardFloatingPanelOpen, canvasResources],
   );
 
+  /**
+   * 恢复入口里的未提交草稿：按**路径**与当前投影对上号，再按最后改动时间从新到旧。
+   * 与卡片 id 无关，所以正规化换掉 id 之后这笔草稿照样在入口里、照样能继续。
+   *
+   * **正在提交的那一笔不算未完成**：它已经交出去了，只是结果还没回来（验收现场看到的
+   * 「面板显示生成中，恢复入口里还挂着同一条」就是这个口径缺失）。提交失败后它自动回来，
+   * 因为那时这份本地记录已经收口成 failed、不再拦这条草稿。
+   */
+  const resourceQuickEditDraftEntries = useMemo(
+    () =>
+      listResourceQuickEditDraftEntries(
+        resourceQuickEditDrafts,
+        canvasResources,
+      ).filter(
+        (entry) =>
+          !resourceCanvasResourceEditSubmissionBlocksResource(
+            resourceEditSubmissions,
+            entry.key,
+          ),
+      ),
+    [canvasResources, resourceEditSubmissions, resourceQuickEditDrafts],
+  );
+
+  /**
+   * 「继续编辑」一笔未提交草稿。
+   *
+   * 卡片就在当前子画布里时当场重开面板（提示词与 `@` 引用由 `openResourceQuickEditPanel`
+   * 回填）；不在当前画布（别的栏目、总览态或被搜索挡住）时先按既有栏目导航把它切到眼前并
+   * 选中，草稿留在原位，从工具栏重开快速编辑即可继续。
+   *
+   * 开面板走一个 0ms 定时器而不是当帧直开：这次点击发生在恢复弹窗（画布边界之外）里，
+   * 「点外部 / Esc 关闭」的 document 监听若在同一帧挂上，会把这次点击当成点外部，刚开的
+   * 面板会被自己人立刻收掉。等这一轮事件派发彻底结束再开，时序上就没有这个窗口。
+   */
+  const resumeResourceQuickEditDraft = useCallback(
+    (draftPath: string) => {
+      const resource = canvasResources.find((item) => item.path === draftPath);
+      if (!resource) {
+        setResourceQuickEditDrafts((current) =>
+          dropResourceQuickEditDraft(current, draftPath),
+        );
+        return;
+      }
+      closeResourceRecoveryPanel();
+      handleResourceSelect(resource.id);
+      const layer = resolveVisibleResourceLayer(resource.id);
+      if (layer) {
+        window.setTimeout(() => openResourceQuickEditPanel(layer), 0);
+        return;
+      }
+      if (resource.category !== activePageCategory) {
+        selectResourceCanvasPage(resource.category);
+      }
+      setResourceWorkbenchNotice(
+        `已定位到「${resource.label}」，打开快速编辑即可继续未完成的编辑`,
+      );
+    },
+    [
+      activePageCategory,
+      canvasResources,
+      closeResourceRecoveryPanel,
+      handleResourceSelect,
+      openResourceQuickEditPanel,
+      resolveVisibleResourceLayer,
+      selectResourceCanvasPage,
+    ],
+  );
+
+  /** 用户在恢复入口里显式丢弃一笔本地草稿。 */
+  const discardResourceQuickEditDraft = useCallback((key: string) => {
+    setResourceQuickEditDrafts((current) =>
+      dropResourceQuickEditDraft(current, key),
+    );
+  }, []);
+
   /**
    * 润色回填（或用户改写）快速编辑提示词。
    *
    * 与共享 composer 的 `resetFailedDialogStatus` 同口径：提示词变了就不再是上一次
    * 失败的那份请求，状态回到 idle、错误清空——同时提交侧会按新提示词重铸请求身份。
    */
-  const applyResourceQuickEditPrompt = useCallback((text: string) => {
-    setQuickEditPanel((current) =>
-      current
-        ? {
-            ...current,
-            prompt: text,
-            status: current.status === 'failed' ? 'idle' : current.status,
-            errorMessage:
-              current.status === 'failed' ? undefined : current.errorMessage,
-          }
-        : current,
-    );
-  }, []);
+  const applyResourceQuickEditPrompt = useCallback(
+    (text: string) => {
+      rememberResourceQuickEditDraft({ prompt: text });
+      setQuickEditPanel((current) =>
+        current
+          ? {
+              ...current,
+              prompt: text,
+              status: current.status === 'failed' ? 'idle' : current.status,
+              errorMessage:
+                current.status === 'failed' ? undefined : current.errorMessage,
+            }
+          : current,
+      );
+    },
+    [rememberResourceQuickEditDraft],
+  );
 
   /**
    * 快速编辑提示词输入区的整体草稿（文本 + `@` 引用）。
@@ -7409,9 +7693,11 @@ export default function ProjectDevelopmentView({
   const applyResourceQuickEditDraft = useCallback(
     (draft: ChatComposerDraft) => {
       setQuickEditReferences(draft.references);
+      // 提示词那一半由 `applyResourceQuickEditPrompt` 顺带记账，这里只补 `@` 引用。
+      rememberResourceQuickEditDraft({ references: draft.references });
       applyResourceQuickEditPrompt(draft.text);
     },
-    [applyResourceQuickEditPrompt],
+    [applyResourceQuickEditPrompt, rememberResourceQuickEditDraft],
   );
 
   /**
@@ -7480,33 +7766,112 @@ export default function ProjectDevelopmentView({
       }
       return;
     }
+    /*
+      同一张素材上已经有一笔修改在跑：**不再铸一次身份**。
+
+      验收现场的重复产物（22:05:16 与 22:05:34 两份一模一样的「编辑版」）就是这条缺失的后果：
+      面板收起再打开会重铸 operationId / 幂等键，原生账本认不出这是同一件事，于是又派生一次。
+      在跑的这笔结束时（成功或失败）这道门自动放行——失败回落成未完成草稿，用户接着改。
+    */
+    if (
+      resourceCanvasResourceEditSubmissionBlocksResource(
+        resourceEditSubmissionsRef.current,
+        resource.path,
+      )
+    ) {
+      setQuickEditPanel((current) =>
+        current
+          ? {
+              ...current,
+              status: 'failed',
+              errorMessage: '这张素材正在修改中，请等它出结果后再提交',
+            }
+          : current,
+      );
+      return;
+    }
+    /*
+      派生资源名必须在**发请求之前**按 Rust 的同一条门禁校验：Rust
+      `normalize_resource_edit_name`（`resource_editor.rs:802-808`）对「trim 后为空 / 超过 120
+      码点 / 含控制字符」的名字整条拒绝，而这个名字是前端用源资源 label 拼出来的（Agent 回执
+      的 label 直接取任务标题，可能很长或带换行）。
+
+      放在这里而不是拼 payload 时：`resolveResourceDeriveSource` 会先做
+      `normalize_local_project_raster_resource` 正规化写盘，等拼 `assetName` 才发现名字不合法，
+      项目里已经多出一条素材了。不截断也是同一条口径——截到 120 会让同前缀的两个长源名塌成
+      同一个名字，宁可先拦住让用户改名。
+    */
+    // 这一步包在 try 里：预检是纯函数，但源 label 形状异常时它同样会抛。抛出去这个
+    // onSubmit 的 promise 就成了未处理拒绝，面板停在原状、按钮表现为「点了没反应」，
+    // 与下面 `resolveResourceDeriveSource` 的失败口径不一致。
+    let nameCheck: ResourceEditNameCheck;
+    try {
+      nameCheck = resolveDerivedResourceNameCheck(resource, 'edit');
+    } catch (error) {
+      setQuickEditPanel((current) =>
+        current
+          ? {
+              ...current,
+              status: 'failed',
+              errorMessage:
+                error instanceof Error ? error.message : String(error),
+            }
+          : current,
+      );
+      return;
+    }
+    // 解构出局部常量：`error` 在 setState 回调里要能保持收窄（对象属性收窄不跨闭包）。
+    const { name: derivedName, error: nameError } = nameCheck;
+    if (nameError) {
+      setQuickEditPanel((current) =>
+        current
+          ? { ...current, status: 'failed', errorMessage: nameError }
+          : current,
+      );
+      return;
+    }
     const actionProject = { projectPath, projectId: manifest.projectId };
     const flowId = crypto.randomUUID();
     const sourceLayerId = layer.id;
-    const previousRequest = resourceQuickEditRequestRef.current;
+    const requestStoreKey = resourceEditRequestKey('quick-edit', resource.path);
+    const previousRequest =
+      resourceEditLastRequestsRef.current.get(requestStoreKey) ?? null;
     // 请求身份只对它铸造时的那句提示词有效：Rust 的 request_fingerprint 含 prompt
     // （resource_editor.rs:807-827），改了提示词还拿旧 operationId 重试会被判
     // 「operationId 或幂等键已绑定到不同资源编辑请求」（同文件 :5216-5225）。
     // 提示词没变时仍复用，失败重试照旧命中同一 operation 账本；
     // 正规化结果与 revision 是别的事实，换身份时原样保留。
-    const request =
-      previousRequest?.sourceLayerId === sourceLayerId
-        ? {
-            ...previousRequest,
-            ...resolveResourceEditRequestIdentity(previousRequest, prompt),
-          }
-        : {
-            ...createResourceEditRequestIdentity(prompt),
-            sourceLayerId,
-            normalizedAssetId: null,
-            expectedProjectRevision: null,
-          };
+    const request = previousRequest
+      ? {
+          ...previousRequest,
+          ...resolveResourceEditRequestIdentity(previousRequest, prompt),
+        }
+      : {
+          ...createResourceEditRequestIdentity(prompt),
+          sourceLayerId,
+          normalizedAssetId: null,
+          expectedProjectRevision: null,
+        };
     resourceQuickEditRequestRef.current = request;
-    setQuickEditPanel((current) =>
-      current
-        ? { ...current, status: 'generating', errorMessage: undefined }
-        : current,
-    );
+    resourceEditLastRequestsRef.current.set(requestStoreKey, request);
+    /*
+      提交即关面板：这块浮层只负责「把这次修改交出去」，交出去之后它的生命周期就结束了——
+      进度、阶段与结果都在「生成任务」侧栏里跟，画布上不再挂一块等结果的板子。失败也不把面板
+      拉回来：异步失败会回落成未完成草稿（恢复入口）＋ 侧栏一条失败 ＋ 提示条；只有**点击瞬间**
+      就能判定的失败（名称预检、源素材不在画布上、没有客户端）才留在面板里。
+    */
+    setQuickEditPanel(null);
+    setQuickEditSourceLayer(null);
+    resourceQuickEditDraftPathRef.current = null;
+    // 提交当帧就上「生成任务」侧栏：原生账本要等 Rust 建好 ledger 才读得到，中间那段空白
+    // 正是验收现场看到的「点了生成，生成任务里什么都没有」。
+    beginResourceEditSubmission({
+      operationId: request.operationId,
+      assetName: derivedName,
+      actionLabel: '快速编辑',
+      prompt,
+      resourcePath: resource.path,
+    });
     try {
       const { sourceResourceId, sourceAssetId, expectedProjectRevision } =
         await resolveResourceDeriveSource({
@@ -7534,7 +7899,7 @@ export default function ProjectDevelopmentView({
               producerTaskId: null,
               sourceVersionId: null,
               prompt,
-              assetName: defaultDerivedResourceName(resource),
+              assetName: derivedName,
             },
           },
         ),
@@ -7564,23 +7929,30 @@ export default function ProjectDevelopmentView({
         resourceId: `asset:${result.asset.id}`,
         completed: false,
       };
-      setQuickEditPanel(null);
-      setQuickEditSourceLayer(null);
+      // 正式的可恢复事实已经由原 operation 账本接管，本地草稿再留着只会在恢复入口里
+      // 多出一条重复条目。键是源素材路径，正规化换掉卡片 id 也不影响这一笔的归属。
+      discardResourceQuickEditDraft(resource.path);
+      // 这一笔已经落定：下一次编辑该是新的一笔，不再复用它的身份。
+      resourceEditLastRequestsRef.current.delete(requestStoreKey);
+      settleResourceEditSubmission(request.operationId, {
+        status: 'completed',
+        assetId: result.asset.id,
+      });
       resourceQuickEditRequestRef.current = null;
       setResourceWorkbenchNotice('快速编辑已产出新素材，正在同步资源与布局…');
     } catch (error) {
-      setQuickEditPanel((current) =>
-        current
-          ? {
-              ...current,
-              status: 'failed',
-              errorMessage:
-                error instanceof Error ? error.message : String(error),
-            }
-          : current,
-      );
+      const message = error instanceof Error ? error.message : String(error);
+      settleResourceEditSubmission(request.operationId, {
+        status: 'failed',
+        error: message,
+      });
+      resourceQuickEditRequestRef.current = null;
+      // 面板已经关了：失败只能落在提示条与「生成任务」侧栏上，草稿留在原处等重开。
+      setResourceWorkbenchNotice(`快速编辑失败：${message}`);
     }
   }, [
+    beginResourceEditSubmission,
+    discardResourceQuickEditDraft,
     manifest,
     onManifestChange,
     projectPath,
@@ -7588,6 +7960,7 @@ export default function ProjectDevelopmentView({
     quickEditSourceLayer,
     resolveQuickEditSourceResource,
     resolveResourceDeriveSource,
+    settleResourceEditSubmission,
   ]);
 
   /**
@@ -7621,12 +7994,18 @@ export default function ProjectDevelopmentView({
         ...panelDraft,
         resolution: RESOURCE_CHARACTER_ANIMATION_RESOLUTION,
       });
-      resourceCharacterAnimationRequestRef.current = {
-        ...createResourceEditRequestIdentity(''),
-        sourceLayerId: layer.id,
-        normalizedAssetId: null,
-        expectedProjectRevision: null,
-      };
+      // 与快速编辑同口径：失败后重开面板，提示词没变就沿用同一 operation 身份。
+      const rememberedRequest = resourceEditLastRequestsRef.current.get(
+        resourceEditRequestKey('character-animation', resource.path),
+      );
+      resourceCharacterAnimationRequestRef.current = rememberedRequest
+        ? { ...rememberedRequest, sourceLayerId: layer.id }
+        : {
+            ...createResourceEditRequestIdentity(''),
+            sourceLayerId: layer.id,
+            normalizedAssetId: null,
+            expectedProjectRevision: null,
+          };
       setResourceWorkbenchNotice('');
     },
     [applyResourceCardFloatingPanelOpen, canvasResources],
@@ -7687,30 +8066,94 @@ export default function ProjectDevelopmentView({
       }
       return;
     }
+    /*
+      与快速编辑同一条口径：角色动画的派生名是「源名 + -角色动画」，同样由 Rust
+      `normalize_resource_edit_name`（`resource_editor.rs:802-808`）把关。校验放在
+      `resolveResourceDeriveSource` 之前，避免先正规化写盘再发现名字不合法；不合法时只回写
+      面板失败态，不发派生请求、不扣费。
+    */
+    // 与快速编辑同样包一层：预检自己抛错时也要有可见失败，不能变成未处理拒绝。
+    let nameCheck: ResourceEditNameCheck;
+    try {
+      nameCheck = resolveDerivedResourceNameCheck(
+        resource,
+        'character-animation',
+      );
+    } catch (error) {
+      setCharacterAnimationPanel((current) =>
+        current
+          ? {
+              ...current,
+              status: 'failed',
+              errorMessage:
+                error instanceof Error ? error.message : String(error),
+            }
+          : current,
+      );
+      return;
+    }
+    const { name: derivedName, error: nameError } = nameCheck;
+    if (nameError) {
+      setCharacterAnimationPanel((current) =>
+        current
+          ? { ...current, status: 'failed', errorMessage: nameError }
+          : current,
+      );
+      return;
+    }
     const actionProject = { projectPath, projectId: manifest.projectId };
     const flowId = crypto.randomUUID();
     const sourceLayerId = layer.id;
-    const previousRequest = resourceCharacterAnimationRequestRef.current;
+    // 与快速编辑共用同一条在途判据：这张素材上还有没结束的提交就不再铸一次身份。
+    if (
+      resourceCanvasResourceEditSubmissionBlocksResource(
+        resourceEditSubmissionsRef.current,
+        resource.path,
+      )
+    ) {
+      setCharacterAnimationPanel((current) =>
+        current
+          ? {
+              ...current,
+              status: 'failed',
+              errorMessage: '这张素材正在生成动画，请等它出结果后再提交',
+            }
+          : current,
+      );
+      return;
+    }
+    const requestStoreKey = resourceEditRequestKey(
+      'character-animation',
+      resource.path,
+    );
+    const previousRequest =
+      resourceEditLastRequestsRef.current.get(requestStoreKey) ?? null;
     // 与快速编辑同一套口径：提示词没变就复用 operationId / 幂等键，失败重试命中同一
     // operation 账本；改了提示词必须重铸，否则 Rust 的 request_fingerprint 会判不一致。
-    const request =
-      previousRequest?.sourceLayerId === sourceLayerId
-        ? {
-            ...previousRequest,
-            ...resolveResourceEditRequestIdentity(previousRequest, prompt),
-          }
-        : {
-            ...createResourceEditRequestIdentity(prompt),
-            sourceLayerId,
-            normalizedAssetId: null,
-            expectedProjectRevision: null,
-          };
+    const request = previousRequest
+      ? {
+          ...previousRequest,
+          ...resolveResourceEditRequestIdentity(previousRequest, prompt),
+        }
+      : {
+          ...createResourceEditRequestIdentity(prompt),
+          sourceLayerId,
+          normalizedAssetId: null,
+          expectedProjectRevision: null,
+        };
     resourceCharacterAnimationRequestRef.current = request;
-    setCharacterAnimationPanel((current) =>
-      current
-        ? { ...current, status: 'generating', errorMessage: undefined }
-        : current,
-    );
+    resourceEditLastRequestsRef.current.set(requestStoreKey, request);
+    // 与快速编辑同口径：提交即关面板，进度与结果都在「生成任务」侧栏里跟。
+    setCharacterAnimationPanel(null);
+    setCharacterAnimationSourceLayer(null);
+    // 与快速编辑同口径：这一笔从按下按钮那一刻就进「生成任务」侧栏。
+    beginResourceEditSubmission({
+      operationId: request.operationId,
+      assetName: derivedName,
+      actionLabel: '生成动画',
+      prompt,
+      resourcePath: resource.path,
+    });
     try {
       const { sourceResourceId, sourceAssetId, expectedProjectRevision } =
         await resolveResourceDeriveSource({
@@ -7738,7 +8181,7 @@ export default function ProjectDevelopmentView({
               producerTaskId: null,
               sourceVersionId: null,
               prompt,
-              assetName: defaultCharacterAnimationResourceName(resource),
+              assetName: derivedName,
             },
           },
         ),
@@ -7771,20 +8214,25 @@ export default function ProjectDevelopmentView({
       setCharacterAnimationPanel(null);
       setCharacterAnimationSourceLayer(null);
       resourceCharacterAnimationRequestRef.current = null;
+      // 落定后不再复用这笔身份：下一次编辑是新的一笔。
+      resourceEditLastRequestsRef.current.delete(requestStoreKey);
+      settleResourceEditSubmission(request.operationId, {
+        status: 'completed',
+        assetId: result.asset.id,
+      });
       setResourceWorkbenchNotice('生成动画已产出新素材，正在同步资源与布局…');
     } catch (error) {
-      setCharacterAnimationPanel((current) =>
-        current
-          ? {
-              ...current,
-              status: 'failed',
-              errorMessage:
-                error instanceof Error ? error.message : String(error),
-            }
-          : current,
-      );
+      const message = error instanceof Error ? error.message : String(error);
+      settleResourceEditSubmission(request.operationId, {
+        status: 'failed',
+        error: message,
+      });
+      resourceCharacterAnimationRequestRef.current = null;
+      // 面板已经关了：失败落在提示条与「生成任务」侧栏上，重开面板再试命中同一 operation。
+      setResourceWorkbenchNotice(`生成动画失败：${message}`);
     }
   }, [
+    beginResourceEditSubmission,
     canvasResources,
     characterAnimationPanel,
     characterAnimationSourceLayer,
@@ -7792,6 +8240,7 @@ export default function ProjectDevelopmentView({
     onManifestChange,
     projectPath,
     resolveResourceDeriveSource,
+    settleResourceEditSubmission,
   ]);
 
   /**
@@ -7933,12 +8382,29 @@ export default function ProjectDevelopmentView({
     activePageCategory,
   };
   resourceWorkbenchNoticeRef.current = resourceWorkbenchNotice;
-  /** 入口按钮与折叠把手上显示的在途数量：只数当前项目的未终态任务。 */
+  /**
+   * 「生成任务」侧栏里的派生/修改任务：本地提交记录 + 原生待办账本。
+   *
+   * 两条来源缺一不可——本地那份负责「按下按钮就当帧可见」，原生那份负责「重开项目/别处提交也
+   * 看得见、阶段以后端为准」。用户眼里它们和图片类生成任务是同一件事，所以进同一个侧栏。
+   */
+  const resourceCanvasResourceEdits = useMemo(
+    () =>
+      resourceCanvasResourceEditTasks({
+        submissions: resourceEditSubmissions,
+        pendingEdits: pendingResourceEdits,
+      }),
+    [pendingResourceEdits, resourceEditSubmissions],
+  );
+  /** 入口按钮与折叠把手上显示的在途数量：只数当前项目的未终态任务（两套账本都算）。 */
   const resourceAssetGenerationInFlightCount =
     resourceAssetGenerationTasks.filter(
       (task) =>
         task.projectId === manifest.projectId &&
         !resourceCanvasAssetGenerationTaskIsTerminal(task),
+    ).length +
+    resourceCanvasResourceEdits.filter(
+      (task) => !resourceCanvasResourceEditTaskIsTerminal(task),
     ).length;
 
   const replaceResourceAssetGenerationTask = useCallback(
@@ -9084,7 +9550,13 @@ export default function ProjectDevelopmentView({
                     <LayoutGrid size={15} aria-hidden="true" />
                     整理画布
                   </button>
+                  {/*
+                    未提交草稿与原生恢复队列共用这一枚入口：两者都是「没做完的资源编辑」，
+                    多开一枚按钮只会让用户分不清该点哪个。计数是两者之和，本地草稿也在
+                    弹窗里逐条列出、可继续或丢弃。
+                  */}
                   {pendingResourceEdits.length > 0 ||
+                  resourceQuickEditDraftEntries.length > 0 ||
                   pendingResourceEditsLoadState === 'failed' ? (
                     <button
                       ref={resourceRecoveryTriggerRef}
@@ -9093,9 +9565,11 @@ export default function ProjectDevelopmentView({
                       aria-expanded={resourceRecoveryPanelOpen}
                     >
                       <Sparkles size={15} aria-hidden="true" />
-                      {pendingResourceEditsLoadState === 'failed'
-                        ? '恢复队列读取失败'
-                        : `管理未完成编辑 (${pendingResourceEdits.length})`}
+                      {resourceRecoveryTriggerLabel({
+                        loadFailed: pendingResourceEditsLoadState === 'failed',
+                        pendingCount: pendingResourceEdits.length,
+                        draftCount: resourceQuickEditDraftEntries.length,
+                      })}
                     </button>
                   ) : null}
                   {/*
@@ -9560,9 +10034,6 @@ export default function ProjectDevelopmentView({
                                         multiline
                                         rows={3}
                                         placeholder="你希望素材如何修改？"
-                                        disabled={
-                                          quickEditPanel.status === 'generating'
-                                        }
                                         // 润色由下面的 ResourcePromptPolishSlot 承担
                                         // （带资源编辑场景上下文与长度上限），
                                         // 不在这里再渲染第二个润色入口。
@@ -9575,9 +10046,6 @@ export default function ProjectDevelopmentView({
                                       subject="图片素材的快速编辑提示词"
                                       editKind="image-reference"
                                       prompt={quickEditPanel.prompt}
-                                      disabled={
-                                        quickEditPanel.status === 'generating'
-                                      }
                                       applyPrompt={applyResourceQuickEditPrompt}
                                     />
                                   }
@@ -10344,6 +10812,10 @@ export default function ProjectDevelopmentView({
         tasks={resourceAssetGenerationTasks.filter(
           (task) => task.projectId === manifest.projectId,
         )}
+        resourceEditTasks={resourceCanvasResourceEdits.filter(
+          (task) =>
+            !task.restored || !resourceCanvasResourceEditTaskIsTerminal(task),
+        )}
         open={resourceAssetGenerationTasksPanelOpen}
         onToggleOpen={() =>
           setResourceAssetGenerationTasksPanelOpen((current) => !current)
@@ -10569,7 +11041,7 @@ export default function ProjectDevelopmentView({
             <header>
               <div>
                 <h2 id="game-resource-recovery-title">未完成的资源编辑</h2>
-                <p>选择任意原 operation 继续或处置</p>
+                <p>选择任意条目继续、处置或丢弃</p>
               </div>
               <button
                 ref={resourceRecoveryCloseRef}
@@ -10607,10 +11079,51 @@ export default function ProjectDevelopmentView({
             ) : null}
 
             {pendingResourceEditsLoadState === 'ready' &&
-            pendingResourceEdits.length === 0 ? (
+            pendingResourceEdits.length === 0 &&
+            resourceQuickEditDraftEntries.length === 0 ? (
               <p role="status">当前没有未完成的资源编辑</p>
             ) : null}
 
+            {/*
+              未提交的快速编辑草稿排在最前：它们还没有 operation，最接近「刚刚在写的那一段」，
+              继续就是原地把面板连同提示词一起打开；处置是显式丢弃。
+            */}
+            {resourceQuickEditDraftEntries.length > 0 ? (
+              <div className="game-resource-recovery-list">
+                {resourceQuickEditDraftEntries.map((entry) => (
+                  <article
+                    className="game-resource-recovery-item"
+                    key={entry.key}
+                  >
+                    <div>
+                      <strong>{entry.label}</strong>
+                      <small>
+                        快速编辑草稿 · 本会话未提交，关闭客户端不保留 ·{' '}
+                        {resourceQuickEditDraftUpdatedAtLabel(entry.updatedAt)}
+                      </small>
+                      <span>
+                        {resourceQuickEditDraftPromptExcerpt(entry.prompt)}
+                      </span>
+                    </div>
+                    <div className="game-resource-recovery-actions">
+                      <button
+                        type="button"
+                        onClick={() => resumeResourceQuickEditDraft(entry.key)}
+                      >
+                        继续编辑
+                      </button>
+                      <button
+                        type="button"
+                        onClick={() => discardResourceQuickEditDraft(entry.key)}
+                      >
+                        丢弃草稿
+                      </button>
+                    </div>
+                  </article>
+                ))}
+              </div>
+            ) : null}
+
             {pendingResourceEdits.length > 0 ? (
               <div className="game-resource-recovery-list">
                 {pendingResourceEdits.map((pending) => {
diff --git a/apps/ai-game-creator-shell/src/view/project-development/resourceEditModel.ts b/apps/ai-game-creator-shell/src/view/project-development/resourceEditModel.ts
index 4d739bec6..012d18452 100644
--- a/apps/ai-game-creator-shell/src/view/project-development/resourceEditModel.ts
+++ b/apps/ai-game-creator-shell/src/view/project-development/resourceEditModel.ts
@@ -208,8 +208,122 @@ export function resourceBaseName(
   return resource.label.replace(/\.[^.]+$/u, '').trim();
 }
 
+/**
+ * 派生资源名上限：与 Rust `normalize_resource_edit_name`
+ * （`src-tauri/src/project/resource_editor.rs:802-808`）逐值同口径。
+ */
+export const RESOURCE_EDIT_NAME_MAX_LENGTH = 120;
+
+/**
+ * 名称不合法时给用户看的那一句：与 Rust 的返回文案逐字一致（同文件 :805）。
+ *
+ * 前端只做镜像、不另造一套中文语义：提交前拦住和提交后失败看到的是同一句话，
+ * 用户不必靠比对两边措辞去猜这是不是同一个问题。
+ */
+export const RESOURCE_EDIT_NAME_INVALID_NOTICE =
+  '派生资源名称必须在 1..=120 字符内且不能包含控制字符';
+
+/**
+ * 名称检查结果：只有 `error === null` 才允许进入生成请求。
+ *
+ * 不合法时 `name` 原样保留（已 trim），**绝不返回截断名**：超长名截到 120 会让两个不同的
+ * 长源名塌成同一个名字（同前缀的两张图就是这种情况），那是把一次可见失败换成一次静默重名。
+ */
+export type ResourceEditNameCheck = {
+  name: string;
+  error: string | null;
+};
+
+/**
+ * 按 Unicode 码点算长度：Rust 侧是 `value.chars().count()`（同文件 :804），
+ * 不是 JS 的 UTF-16 `.length`——`'😀'.repeat(120)` 的 `.length` 是 240，码点数才是 120。
+ * 用 `.length` 会把 Rust 明确接受的名字在前端误判成非法。
+ */
+function resourceNameLength(value: string) {
+  return [...value].length;
+}
+
+/**
+ * Rust `char::is_control()` 的口径：Unicode 通用类别 `Cc`，即 C0（U+0000–U+001F）、
+ * DEL（U+007F）与 C1（U+0080–U+009F）。
+ *
+ * 用码点比较而不是控制字符正则：`Cc` 之外（例如 `Cf` 格式符）Rust 是放行的，前端也不额外
+ * 收窄——这份实现的职责是镜像，不是借机加一条客户端自有规则。
+ */
+function isResourceNameControlCodePoint(codePoint: number) {
+  return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+}
+
+function resourceNameHasControlCharacter(value: string) {
+  for (const character of value) {
+    if (isResourceNameControlCodePoint(character.codePointAt(0) ?? 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * 提交前按 Rust 的同一条规则检查派生资源名：先 `trim`，再要求非空、码点数 1..=120，
+ * 且不含控制字符。首尾的换行 / 制表符会被 `trim` 掉，因此不算违规——与 Rust 逐条一致。
+ *
+ * 调用方拿到 `error` 非空时必须在发请求**之前**停下并把它显示给用户（不合法时 `name`
+ * 只是 trim 后的原样名，不能拿它去提交）。
+ */
+export function resolveResourceEditNameCheck(
+  name: string,
+): ResourceEditNameCheck {
+  const trimmed = name.trim();
+  if (
+    trimmed.length === 0 ||
+    resourceNameLength(trimmed) > RESOURCE_EDIT_NAME_MAX_LENGTH ||
+    resourceNameHasControlCharacter(trimmed)
+  ) {
+    return { name: trimmed, error: RESOURCE_EDIT_NAME_INVALID_NOTICE };
+  }
+  return { name: trimmed, error: null };
+}
+
+/**
+ * 现役两种派生资源名后缀：快速编辑产出「-编辑版」，角色动画产出「-角色动画」。
+ *
+ * 后缀表是唯一来源，默认名与提交前检查共用它，避免「-编辑版」与「-角色动画」两条路径
+ * 再次各自演化出不同的拼接口径。
+ */
+export const DERIVED_RESOURCE_NAME_SUFFIXES = {
+  edit: '-编辑版',
+  'character-animation': '-角色动画',
+} as const;
+
+export type DerivedResourceNameKind =
+  keyof typeof DERIVED_RESOURCE_NAME_SUFFIXES;
+
+/**
+ * 派生资源名的默认值 + 校验：去扩展名的基名（空则兜底「资源」）拼上对应后缀再检查。
+ *
+ * 后缀本身只有 4~5 字，所以超限几乎总是源名太长（例如 Agent 回执的 label 直接取任务标题）
+ * 或源名里带控制字符（任务标题里的换行就是）。
+ */
+export function resolveDerivedResourceNameCheck(
+  resource: ProjectResource,
+  kind: DerivedResourceNameKind,
+): ResourceEditNameCheck {
+  const base = resourceBaseName(resource) || '资源';
+  return resolveResourceEditNameCheck(
+    `${base}${DERIVED_RESOURCE_NAME_SUFFIXES[kind]}`,
+  );
+}
+
+/**
+ * 快速编辑派生资源的默认名称。
+ *
+ * 只负责拼名字，不校验也不截断：名字是否能在 Rust 侧通过由
+ * `resolveDerivedResourceNameCheck(resource, 'edit')` 回答，调用方必须在提交前用它拦下
+ * 不可用的名字。这里保持返回不合法原名（而不是悄悄截到 120），是为了让上层的检查
+ * 拿到真实长度并给出提示。
+ */
 export function defaultDerivedResourceName(resource: ProjectResource) {
-  return `${resourceBaseName(resource) || '资源'}-编辑版`;
+  return resolveDerivedResourceNameCheck(resource, 'edit').name;
 }
 
 /**
@@ -217,11 +331,14 @@ export function defaultDerivedResourceName(resource: ProjectResource) {
  *
  * 与 `defaultDerivedResourceName` 同一条口径（去扩展名 + 兜底名），只换后缀：动作序列帧
  * 不是"编辑版"，用「-角色动画」让新素材在资源卡上一眼认出来源与产出类型。
+ *
+ * 同样只是默认名，提交前必须走
+ * `resolveDerivedResourceNameCheck(resource, 'character-animation')`。
  */
 export function defaultCharacterAnimationResourceName(
   resource: ProjectResource,
 ) {
-  return `${resourceBaseName(resource) || '资源'}-角色动画`;
+  return resolveDerivedResourceNameCheck(resource, 'character-animation').name;
 }
 
 /**
diff --git a/apps/ai-game-creator-shell/tests/AgentMessageContent.test.tsx b/apps/ai-game-creator-shell/tests/AgentMessageContent.test.tsx
index 2b32c26e5..604775b68 100644
--- a/apps/ai-game-creator-shell/tests/AgentMessageContent.test.tsx
+++ b/apps/ai-game-creator-shell/tests/AgentMessageContent.test.tsx
@@ -1,13 +1,12 @@
 // @vitest-environment jsdom
-
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { render } from '@testing-library/react';
 import { describe, expect, it } from 'vitest';
 
 import { AgentMessageContent } from '../../../packages/shared/src/components/AgentMessageContent';
 import { ChatMarkdownMessage } from '../src/components/ChatMarkdownMessage';
+import { repoPath } from './repoPath';
 import {
   declaration,
   parseStyleSheet,
@@ -15,14 +14,11 @@ import {
 } from './styleCascade';
 
 const sharedCss = readFileSync(
-  resolve(
-    process.cwd(),
-    'packages/shared/src/components/AgentMessageContent.css',
-  ),
+  repoPath('packages/shared/src/components/AgentMessageContent.css'),
   'utf8',
 );
 const appCss = readFileSync(
-  resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+  repoPath('apps/ai-game-creator-shell/src/styles.css'),
   'utf8',
 );
 const base = '.agent-message-content[data-agent-content]';
diff --git a/apps/ai-game-creator-shell/tests/ResourceDependencyOverlay.test.ts b/apps/ai-game-creator-shell/tests/ResourceDependencyOverlay.test.ts
index 58a3edffe..bc73e068c 100644
--- a/apps/ai-game-creator-shell/tests/ResourceDependencyOverlay.test.ts
+++ b/apps/ai-game-creator-shell/tests/ResourceDependencyOverlay.test.ts
@@ -1,6 +1,5 @@
 /** @vitest-environment jsdom */
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import {
   act,
@@ -28,6 +27,7 @@ import {
   ResourceDependencyOverlay,
   type ResourceDependencyOverlayHandle,
 } from '../src/view/project-development/ResourceDependencyOverlay';
+import { repoPath } from './repoPath';
 
 function position(
   resourceId: string,
@@ -1030,7 +1030,7 @@ describe('ResourceDependencyOverlay', () => {
 
   it('uses a persistent orange with at least 3:1 canvas contrast', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     expect(styles).toMatch(
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 f70dd5566..ed2ba1494 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
@@ -25,6 +25,7 @@ import { normalizeProjectResourceGraph } from '../../src/view/project-developmen
 import { ResourceDependencyOverlay } from '../../src/view/project-development/ResourceDependencyOverlay';
 import type { ProjectAgentResultSummary } from '../../src/view/project-development/resourceProjectionModel';
 import { projectResourcesFromReadModels } from '../../src/view/project-development/resourceProjectionModel';
+import { repoPath } from '../repoPath';
 import {
   generationPromptText,
   typeGenerationPrompt,
@@ -60,7 +61,6 @@ import {
   render,
   renderAppAt,
   renderLauncherProjectsAt,
-  resolve,
   screen,
   setComposerText,
   submitChat,
@@ -1455,12 +1455,11 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the resource filter panel above the titlebar band and anchored to the dock', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const tsxSource = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/view/project-development/index.tsx',
       ),
       'utf8',
@@ -1538,7 +1537,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the resource overview grid off fit-content so its columns stay responsive', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     // 先剥掉 CSS 注释再取声明体：这条修复的注释里就写着 `width: 100%` 等字样，
@@ -1668,7 +1667,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the shared selection overlay colours resolvable from the scene root', () => {
     const sharedStyles = readFileSync(
-      resolve(process.cwd(), 'packages/image-canvas-react/src/styles.css'),
+      repoPath('packages/image-canvas-react/src/styles.css'),
       'utf8',
     );
     // 消费端 `border/background: var(...)` 没有 fallback：token 缺失或被写透明，框选就没有颜色。
@@ -1896,12 +1895,11 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the overview-return button out of the floating notice layer hit region', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const tsxSource = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/view/project-development/index.tsx',
       ),
       'utf8',
@@ -3479,7 +3477,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('资源卡 chrome 只保留选中按钮与当前版本边框', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     /*
@@ -3573,7 +3571,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('资源卡的 @ 引用入口只留在选中工具条里', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     // 卡片右上角那个圆钮连同它撑出来的 44×44 热区一起退役：卡片本体只剩
@@ -3581,8 +3579,7 @@ export function registerProjectWorkbenchFoundationTests() {
     expect(styles).not.toContain('.game-resource-card-reference');
 
     const source = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/view/project-development/index.tsx',
       ),
       'utf8',
@@ -5837,7 +5834,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the landscape workbench edge-to-edge with internal chat scrolling', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
 
@@ -5993,12 +5990,11 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the wallet entry available when the workbench opens the UI editor', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const projectDevelopmentSource = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/view/project-development/index.tsx',
       ),
       'utf8',
@@ -6307,7 +6303,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps resource sort tab keyboard focus inside the clipped segmented control', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
 
@@ -6318,7 +6314,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps the chat composer an inset block inside the conversation dialog', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     // 对话框就是消息列表那只铺满会话区的盒子；输入区是它内部的一块，不再是贴在它下边、
@@ -6367,7 +6363,7 @@ export function registerProjectWorkbenchFoundationTests() {
 
   it('keeps workbench chat bubbles aligned without shrinking process cards', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const messageListRule =
@@ -7079,7 +7075,7 @@ export function registerProjectSupervisorSurfaceTests() {
 
   it('anchors the model dropdown to its own trigger instead of the composer box', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
 
@@ -7139,7 +7135,7 @@ export function registerProjectSupervisorSurfaceTests() {
 
   it('bounds the model dropdown height so a long catalog cannot cover the composer', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const menu = styleRuleBody(styles, '\\.conversation-model-menu');
@@ -11639,7 +11635,7 @@ export function registerProjectAgentStatusTests() {
     ).not.toBeNull();
     // 宿主几何与栏目卡共用同一条规则，视觉上不是另写一套。
     const previewStyles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const previewHostRule = styleRuleBody(
@@ -11747,7 +11743,7 @@ export function registerProjectAgentStatusTests() {
     // 视觉不是另写一套：那一页没有任何专属选择器，卡与宿主都只用共享规则
     // （声明级断言——它验的是"没有平行样式"，验不到布局本身）。
     const allPageStyles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     expect(allPageStyles).not.toMatch(/\.game-resource-all-/);
@@ -13396,12 +13392,11 @@ export function registerProjectAgentStatusTests() {
 
   it('keeps the bottom toolbar clear of the zoom dock and above the book scene', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const chromeStyles = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasChrome.css',
       ),
       'utf8',
diff --git a/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts b/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts
index 59084103f..00fa9fe5e 100644
--- a/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts
+++ b/apps/ai-game-creator-shell/tests/appSurface/runtime-settings.suite.ts
@@ -1,7 +1,7 @@
 import fs from 'node:fs';
-import path from 'node:path';
 
 import { APP_VERSION } from '../../src/app/appMetadata';
+import { repoPath } from '../repoPath';
 import {
   act,
   createGameCreationAppManifest,
@@ -23,7 +23,7 @@ import {
 export function registerAgentStatusDerivationTests() {
   it('keeps fixed overlays below the in-page window title bar', () => {
     const styles = fs.readFileSync(
-      path.join(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     expect(styles).toContain('--window-chrome-height: 50px;');
diff --git a/apps/ai-game-creator-shell/tests/chatDialogFrameLayout.test.ts b/apps/ai-game-creator-shell/tests/chatDialogFrameLayout.test.ts
index 7ead17c07..81963f43c 100644
--- a/apps/ai-game-creator-shell/tests/chatDialogFrameLayout.test.ts
+++ b/apps/ai-game-creator-shell/tests/chatDialogFrameLayout.test.ts
@@ -1,22 +1,17 @@
 // @vitest-environment jsdom
-
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { describe, expect, it } from 'vitest';
 
+import { repoPath } from './repoPath';
 import {
   declaration,
   parseStyleSheet,
   resolveDeclarations,
 } from './styleCascade';
 
-const STYLES_PATH = resolve(
-  process.cwd(),
-  'apps/ai-game-creator-shell/src/styles.css',
-);
-const VIEW_PATH = resolve(
-  process.cwd(),
+const STYLES_PATH = repoPath('apps/ai-game-creator-shell/src/styles.css');
+const VIEW_PATH = repoPath(
   'apps/ai-game-creator-shell/src/features/project-workspace/ProjectSupervisorView.tsx',
 );
 
diff --git a/apps/ai-game-creator-shell/tests/chatPromptPolish.test.tsx b/apps/ai-game-creator-shell/tests/chatPromptPolish.test.tsx
index 696fccadb..a391d6ed2 100644
--- a/apps/ai-game-creator-shell/tests/chatPromptPolish.test.tsx
+++ b/apps/ai-game-creator-shell/tests/chatPromptPolish.test.tsx
@@ -291,6 +291,22 @@ describe('聊天输入区 AI 润色与发送前提醒', () => {
     expect(screen.queryByRole('button', { name: '恢复原文' })).toBeNull();
   });
 
+  test('回包与原文相同时聊天输入区也给提示，且不冒出「恢复原文」', async () => {
+    const user = userEvent.setup();
+    installPolishingInvoke('原本的需求');
+    renderComposer({ initialText: '原本的需求' });
+
+    await user.click(screen.getByRole('button', { name: 'AI 润色' }));
+
+    // 聊天输入区与资源侧共用 `usePromptPolish`：修好状态机还不够，共享输入区必须把
+    // notice 渲染出来，否则这三个宿主里「点了没反应」看起来还是按钮坏了。
+    expect(
+      await screen.findByText('AI 润色结果与原文相同，未做修改'),
+    ).not.toBeNull();
+    expect(await composerText()).toBe('原本的需求');
+    expect(screen.queryByRole('button', { name: '恢复原文' })).toBeNull();
+  });
+
   test('holds a long prompt behind the reminder panel and sends the original on demand', async () => {
     const onSubmitDraft = renderComposer({ initialText: LONG_PROMPT });
 
diff --git a/apps/ai-game-creator-shell/tests/projectAssetPickerDialogShellStyle.test.tsx b/apps/ai-game-creator-shell/tests/projectAssetPickerDialogShellStyle.test.tsx
index 6c37ac024..821c2b3c1 100644
--- a/apps/ai-game-creator-shell/tests/projectAssetPickerDialogShellStyle.test.tsx
+++ b/apps/ai-game-creator-shell/tests/projectAssetPickerDialogShellStyle.test.tsx
@@ -7,6 +7,7 @@ import { cleanup, render, screen } from '@testing-library/react';
 import { afterEach, describe, expect, it } from 'vitest';
 
 import { ImageCanvasProjectAssetPickerDialog } from '../../../src/components/image-editor/ImageCanvasProjectAssetPickerDialog';
+import { REPO_ROOT } from './repoPath';
 
 /**
  * 「选择替换素材」弹窗在 AGC 的面板底色契约。
@@ -25,7 +26,6 @@ import { ImageCanvasProjectAssetPickerDialog } from '../../../src/components/ima
  * 这是**弱验证**（声明级，不是真机观感）。真机判据见文件末尾注释。
  */
 
-const REPO_ROOT = process.cwd();
 const AGC_ROOT = resolve(REPO_ROOT, 'apps/ai-game-creator-shell');
 
 const PLATFORM_MODAL_SHELL = '.platform-modal-shell';
@@ -336,9 +336,14 @@ describe('「选择替换素材」弹窗在 AGC 的面板底色', () => {
   });
 
   it('没有平行拷贝：外壳三条规则只在共享表里定义一次', () => {
-    const hostRules = HOST_STYLE_SHEETS.filter(existsSync).flatMap((sheet) =>
-      readRules(absoluteSheetPath(sheet)),
-    );
+    /*
+      这里必须**先转绝对路径再判断存在**：`filter(existsSync)` 拿到的是仓库相对路径，`existsSync`
+      按 `process.cwd()` 解析——从 `apps/ai-game-creator-shell` 跑时四张表全被判成不存在，
+      断言退化成「谁都没定义」的假绿/假红（本次就是从这条假红里揪出来的）。
+    */
+    const hostRules = HOST_STYLE_SHEETS.filter((sheet) =>
+      existsSync(absoluteSheetPath(sheet)),
+    ).flatMap((sheet) => readRules(absoluteSheetPath(sheet)));
     for (const className of [
       PLATFORM_MODAL_SHELL,
       PLATFORM_MODAL_BACKDROP,
diff --git a/apps/ai-game-creator-shell/tests/projectResourceLiveIntegration.test.tsx b/apps/ai-game-creator-shell/tests/projectResourceLiveIntegration.test.tsx
index 61914473c..920ae1b9c 100644
--- a/apps/ai-game-creator-shell/tests/projectResourceLiveIntegration.test.tsx
+++ b/apps/ai-game-creator-shell/tests/projectResourceLiveIntegration.test.tsx
@@ -15,6 +15,7 @@ import {
 } from '../../../src/components/image-editor/ImageCanvasGenerationModel';
 import { resourceReferenceFromAsset } from '../src/features/project-workspace/resourceReferences';
 import ProjectDevelopmentView from '../src/view/project-development';
+import { RESOURCE_EDIT_NAME_INVALID_NOTICE } from '../src/view/project-development/resourceEditModel';
 import {
   act,
   createGameCreationAppManifest,
@@ -259,9 +260,17 @@ function ClassificationWorkbench() {
 function DerivedWorkbench({
   includeArt = false,
   includeCharacter = false,
+  artName = 'source-art.png',
+  characterName = 'hero.png',
 }: {
   includeArt?: boolean;
   includeCharacter?: boolean;
+  /**
+   * 源文件名可替换：派生资源名按源资源 label 拼出，用长名夹具复现
+   * `normalize_resource_edit_name` 的 120 码点门禁（AGC-025）。
+   */
+  artName?: string;
+  characterName?: string;
 }) {
   const initial = createGameCreationAppManifest(
     'live-canvas-project',
@@ -281,7 +290,7 @@ function DerivedWorkbench({
             id: 'source-art',
             kind: 'art-image',
             mediaType: 'image/png',
-            localPath: 'assets/source-art.png',
+            localPath: `assets/${artName}`,
             source: { kind: 'generated', resourceId: 'art-resource' },
           },
         ]
@@ -293,7 +302,7 @@ function DerivedWorkbench({
             kind: 'character',
             category: 'character' as const,
             mediaType: 'image/png',
-            localPath: 'assets/hero.png',
+            localPath: `assets/${characterName}`,
             source: { kind: 'generated', resourceId: 'hero-resource' },
           },
         ]
@@ -832,14 +841,33 @@ describe('project resource live canvas integration', () => {
       '把角色头发设定改为红色',
     );
     fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
-    expect(await screen.findByRole('alert')).not.toBeNull();
-    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+    // 提交即关面板：失败也不把面板拉回来，重试只能重开面板（任务与失败都在「生成任务」侧栏里）。
+    await waitFor(() =>
+      expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+    );
+    fireEvent.click(await findResourceSelectButton('source-art.png'));
+    const retryToolbar = await screen.findByRole('toolbar', {
+      name: '图片工具栏',
+    });
+    fireEvent.click(
+      within(retryToolbar).getByRole('button', { name: '快速编辑' }),
+    );
+    const retryPanel = await screen.findByRole('dialog', {
+      name: '快速编辑图片',
+    });
+    // 草稿回填，提示词没变 → 沿用上一次那笔 operation 身份。
+    expect(
+      within(retryPanel).getByLabelText('快速编辑提示词').textContent,
+    ).toContain('把角色头发设定改为红色');
+    fireEvent.click(within(retryPanel).getByRole('button', { name: '修改' }));
 
     await waitFor(() => expect(deriveCalls).toHaveLength(2));
     expect(deriveCalls[0]?.operationId).toBe(deriveCalls[1]?.operationId);
     expect(deriveCalls[0]?.idempotencyKey).toBe(deriveCalls[1]?.idempotencyKey);
     expect(deriveCalls[0]?.editKind).toBe('image-reference');
     expect(deriveCalls[0]?.generationMode).toBe('derive');
+    // 名字合法时出站 assetName 就是提交前校验过的那个名字（默认名，逐字未改）。
+    expect(deriveCalls[0]?.assetName).toBe('source-art-编辑版');
     expect(deriveCalls[0]).not.toHaveProperty('accessToken');
     expect(deriveCalls[0]).not.toHaveProperty('apiKey');
     expect(deriveCalls[1]).not.toHaveProperty('accessToken');
@@ -891,6 +919,71 @@ describe('project resource live canvas integration', () => {
     expect(deriveCalls[0]).not.toHaveProperty('apiKey');
   });
 
+  /**
+   * AGC-025：派生资源名由源资源 label 拼出，Rust `normalize_resource_edit_name`
+   * （`resource_editor.rs:802-808`）对「超 120 码点 / 含控制字符 / trim 后为空」的名字整条
+   * 拒绝。前端必须在**任何正规化写盘与派生请求之前**用同一句中文回写面板失败态，否则用户得
+   * 提交一次才知道名字不合法，项目里还可能先多出一条正规化素材。
+   */
+  it('快速编辑：源名超 120 码点时在派生请求之前拦下，并回写面板错误态', async () => {
+    const longName = `${'生成角色正面半身战斗姿态设定稿'.repeat(8)}.png`;
+    const { invoke, deriveCalls } = installTauri();
+    render(<DerivedWorkbench includeArt artName={longName} />);
+
+    fireEvent.click(screen.getByRole('button', { name: '打开待归类' }));
+    fireEvent.click(await findResourceSelectButton(longName));
+    const toolbar = await screen.findByRole('toolbar', { name: '图片工具栏' });
+    fireEvent.click(within(toolbar).getByRole('button', { name: '快速编辑' }));
+    const panel = await screen.findByRole('dialog', { name: '快速编辑图片' });
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把角色头发设定改为红色',
+    );
+    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+
+    expect((await screen.findByRole('alert')).textContent).toBe(
+      RESOURCE_EDIT_NAME_INVALID_NOTICE,
+    );
+    // 零写盘、零远程请求：派生请求一次没发，正规化也没有被调用。
+    expect(deriveCalls).toHaveLength(0);
+    expect(
+      invoke.mock.calls.some(
+        ([command]) => command === 'normalize_local_project_raster_resource',
+      ),
+    ).toBe(false);
+  });
+
+  it('角色动画：源名超 120 码点时同样在派生请求之前拦下', async () => {
+    const longName = `${'生成角色正面半身战斗姿态设定稿'.repeat(8)}.png`;
+    const { invoke, deriveCalls } = installTauri();
+    render(<DerivedWorkbench includeCharacter characterName={longName} />);
+
+    fireEvent.click(screen.getByRole('button', { name: '打开角色与对象' }));
+    fireEvent.click(await findResourceSelectButton(longName));
+    const toolbar = await screen.findByRole('toolbar', { name: '图片工具栏' });
+    fireEvent.click(within(toolbar).getByRole('button', { name: '生成动画' }));
+    const panel = await screen.findByRole('dialog', {
+      name: '角色动画生成面板',
+    });
+    await setComposerText(
+      within(panel).getByLabelText('动画描述'),
+      '角色挥手打招呼',
+    );
+    fireEvent.click(
+      within(panel).getByRole('button', { name: /生成[\d.]+泥点/ }),
+    );
+
+    expect((await screen.findByRole('alert')).textContent).toBe(
+      RESOURCE_EDIT_NAME_INVALID_NOTICE,
+    );
+    expect(deriveCalls).toHaveLength(0);
+    expect(
+      invoke.mock.calls.some(
+        ([command]) => command === 'normalize_local_project_raster_resource',
+      ),
+    ).toBe(false);
+  });
+
   it('快速编辑里润色提示词：带场景约束回填，提示词变了就换请求身份', async () => {
     const { deriveCalls, polishCalls } = installTauri({
       failFirstDerive: true,
@@ -912,13 +1005,28 @@ describe('project resource live canvas integration', () => {
       '把角色头发改成红色',
     );
     fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
-    expect(await screen.findByRole('alert')).not.toBeNull();
+    // 提交即关面板，重开面板继续改：草稿回填的是原文。
+    await waitFor(() =>
+      expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+    );
+    fireEvent.click(await findResourceSelectButton('source-art.png'));
+    const retryToolbar = await screen.findByRole('toolbar', {
+      name: '图片工具栏',
+    });
+    fireEvent.click(
+      within(retryToolbar).getByRole('button', { name: '快速编辑' }),
+    );
+    const retryPanel = await screen.findByRole('dialog', {
+      name: '快速编辑图片',
+    });
 
     // 失败后提示词仍可改：润色一次，回填的是润色结果，而不是原文。
-    fireEvent.click(within(panel).getByRole('button', { name: 'AI 润色' }));
+    fireEvent.click(
+      within(retryPanel).getByRole('button', { name: 'AI 润色' }),
+    );
     await waitFor(() => {
       expect(
-        within(panel).getByLabelText('快速编辑提示词').textContent,
+        within(retryPanel).getByLabelText('快速编辑提示词').textContent,
       ).toContain('亮红色');
     });
     expect(polishCalls[0]).toMatchObject({ prompt: '把角色头发改成红色' });
@@ -926,7 +1034,7 @@ describe('project resource live canvas integration', () => {
       '图片素材的快速编辑提示词',
     );
 
-    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+    fireEvent.click(within(retryPanel).getByRole('button', { name: '修改' }));
     await waitFor(() => expect(deriveCalls).toHaveLength(2));
     // Rust 的 request_fingerprint 含 prompt：提示词换过就必须换 operationId / 幂等键，
     // 否则后端会判「已绑定到不同资源编辑请求」。
@@ -955,17 +1063,32 @@ describe('project resource live canvas integration', () => {
       '把角色头发改成红色',
     );
     fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
-    expect(await screen.findByRole('alert')).not.toBeNull();
+    // 提交即关面板：重开面板后提示词仍是原文（草稿回填），再改再润色都在这一份草稿上。
+    await waitFor(() =>
+      expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+    );
+    fireEvent.click(await findResourceSelectButton('source-art.png'));
+    const retryToolbar = await screen.findByRole('toolbar', {
+      name: '图片工具栏',
+    });
+    fireEvent.click(
+      within(retryToolbar).getByRole('button', { name: '快速编辑' }),
+    );
+    const retryPanel = await screen.findByRole('dialog', {
+      name: '快速编辑图片',
+    });
 
-    fireEvent.click(within(panel).getByRole('button', { name: 'AI 润色' }));
+    fireEvent.click(
+      within(retryPanel).getByRole('button', { name: 'AI 润色' }),
+    );
     expect(
-      await within(panel).findByText('AI 润色失败，可重试'),
+      await within(retryPanel).findByText('AI 润色失败，可重试'),
     ).not.toBeNull();
     expect(
-      within(panel).getByLabelText('快速编辑提示词').textContent,
+      within(retryPanel).getByLabelText('快速编辑提示词').textContent,
     ).toContain('把角色头发改成红色');
 
-    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+    fireEvent.click(within(retryPanel).getByRole('button', { name: '修改' }));
     await waitFor(() => expect(deriveCalls).toHaveLength(2));
     // 提示词没变，身份也不该变：重试仍然命中同一 operation 账本。
     expect(deriveCalls[1]?.operationId).toBe(deriveCalls[0]?.operationId);
diff --git a/apps/ai-game-creator-shell/tests/repoPath.ts b/apps/ai-game-creator-shell/tests/repoPath.ts
new file mode 100644
index 000000000..98b017eaf
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/repoPath.ts
@@ -0,0 +1,23 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * 仓库根与"按仓库相对路径取文件"的唯一入口。
+ *
+ * 读样式表 / 脚本 / 文档的用例原先一律写 `resolve(process.cwd(), 'apps/ai-game-creator-shell/…')`：
+ * 从仓库根跑（CI 的 `npm run test`、根 `vitest.config.ts`）没问题，但只要从
+ * `apps/ai-game-creator-shell` 目录跑一次，路径就会翻成
+ * `…/apps/ai-game-creator-shell/apps/ai-game-creator-shell/…` 并整片 ENOENT——看起来像"这些用例本来
+ * 就红"，实际是路径解析跟着 cwd 漂。这里按 `import.meta.url` 反推仓库根，两种跑法结论一致。
+ */
+export const REPO_ROOT = resolve(
+  dirname(fileURLToPath(import.meta.url)),
+  '..',
+  '..',
+  '..',
+);
+
+/** 传仓库相对路径（如 `apps/ai-game-creator-shell/src/styles.css`）。 */
+export function repoPath(...segments: readonly string[]): string {
+  return resolve(REPO_ROOT, ...segments);
+}
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationReferences.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationReferences.test.tsx
index 08fb245ee..a8001ff90 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationReferences.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationReferences.test.tsx
@@ -300,6 +300,94 @@ describe('生成面板的参考接线', () => {
     });
   });
 
+  test('点提示词输入区不该自己弹出素材选择框', async () => {
+    const user = userEvent.setup();
+    const imageAsset = asset('asset-a', 'image/png', 'assets/素材-a.png');
+    render(
+      <ResourceCanvasAssetGenerationPanelView
+        action={imageAction}
+        assets={[imageAsset]}
+        projectPath="/tmp/project"
+        draft={{
+          prompt: '',
+          assetName: '猫',
+          aspectRatio: '1:1',
+          imageSize: '1K',
+          references: [],
+        }}
+        onSubmit={vi.fn()}
+        onClose={() => undefined}
+      />,
+    );
+
+    await user.click(screen.getByLabelText('生成提示词'));
+    expect(screen.queryByRole('dialog', { name: '选择素材' })).toBeNull();
+
+    // 只有「插入素材引用」这一枚按钮才打开选择器。
+    await user.click(screen.getByRole('button', { name: '插入素材引用' }));
+    expect(
+      await screen.findByRole('dialog', { name: '选择素材' }),
+    ).not.toBeNull();
+  });
+
+  test('紧凑版排布：动作行同时装下润色 / 参考计数 / 两个动作，参数与提示词各占一行', () => {
+    const imageAsset = asset('asset-a', 'image/png', 'assets/素材-a.png');
+    render(
+      <ResourceCanvasAssetGenerationPanelView
+        action={imageAction}
+        assets={[imageAsset]}
+        projectPath="/tmp/project"
+        draft={{
+          prompt: '',
+          assetName: '猫',
+          aspectRatio: '1:1',
+          imageSize: '1K',
+          references: [],
+        }}
+        onSubmit={vi.fn()}
+        onClose={() => undefined}
+      />,
+    );
+
+    const panel = screen.getByRole('dialog', { name: '生成图片' });
+    /*
+      验收现场那张图里面板要滚动：标签各占一行、提示词 6 行、比例与尺寸各占一行、润色与参考
+      计数又各占一行。这里钉住重排后的形状——动作行一行收口、参数两栏并排、提示词三行，
+      面板高度因此回落到几何上界以内（滚动条不该再出现）。
+    */
+    const actions = panel.querySelector('.game-resource-generation-actions');
+    expect(actions).not.toBeNull();
+    expect(
+      within(actions as HTMLElement).getByRole('button', { name: 'AI 润色' }),
+    ).not.toBeNull();
+    expect(
+      within(actions as HTMLElement).getByText('参考图 0/5'),
+    ).not.toBeNull();
+    expect(
+      within(actions as HTMLElement).getByRole('button', { name: '取消' }),
+    ).not.toBeNull();
+    expect(
+      within(actions as HTMLElement).getByRole('button', { name: '生成图片' }),
+    ).not.toBeNull();
+
+    // 比例与尺寸同处一格（CSS 里排成两栏），不再各占一行。
+    const dimensions = panel.querySelectorAll(
+      '.resource-canvas-asset-generation-dimensions',
+    );
+    expect(dimensions).toHaveLength(1);
+    // 两组选择器（比例 5 项、尺寸 3 项）同处这一格，CSS 里排成两栏。
+    expect(
+      within(dimensions[0] as HTMLElement).getByRole('button', {
+        name: '生成图片比例 1:1',
+      }),
+    ).not.toBeNull();
+    expect(
+      within(dimensions[0] as HTMLElement).getByRole('button', {
+        name: '生成图片尺寸 1K',
+      }),
+    ).not.toBeNull();
+  });
+
   test('超限时提交被挡住并给出原因', async () => {
     const user = userEvent.setup();
     const onSubmit =
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationTasksSidebarStyle.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationTasksSidebarStyle.test.ts
index 87c7f7f4d..d2b3f8b71 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationTasksSidebarStyle.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasAssetGenerationTasksSidebarStyle.test.ts
@@ -1,9 +1,9 @@
 // @vitest-environment jsdom
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { describe, expect, test } from 'vitest';
 
+import { repoPath } from './repoPath';
 import {
   declaration,
   parseStyleSheet,
@@ -17,8 +17,7 @@ import {
  * jsdom 不加载这个 CSS 文件，所以这里按仓库既有做法（`styleCascade`）直接解析**真实生效的声明**：
  * 「状态 tone 映射」「等宽数字」「圆角 / 悬停」「过渡」「reduced-motion 关动效」都用声明钉住。
  */
-const SIDEBAR_CSS_PATH = resolve(
-  process.cwd(),
+const SIDEBAR_CSS_PATH = repoPath(
   'apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasAssetGenerationTasksSidebar.css',
 );
 const rules = parseStyleSheet(readFileSync(SIDEBAR_CSS_PATH, 'utf8'));
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasCardName.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasCardName.test.tsx
index a11503f21..dad22664f 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasCardName.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasCardName.test.tsx
@@ -1,6 +1,5 @@
 /** @vitest-environment jsdom */
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
@@ -17,6 +16,7 @@ import {
   waitFor,
   within,
 } from './appSurface/harness';
+import { repoPath } from './repoPath';
 
 vi.mock('@tauri-apps/api/core', async () => ({
   ...(await vi.importActual<typeof import('@tauri-apps/api/core')>(
@@ -237,7 +237,7 @@ function renderWorkbench(manifest: GameCreationAppManifest) {
 
 function stylesSource() {
   return readFileSync(
-    resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+    repoPath('apps/ai-game-creator-shell/src/styles.css'),
     'utf8',
   );
 }
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasCharacterAnimationPanelStyle.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasCharacterAnimationPanelStyle.test.tsx
new file mode 100644
index 000000000..2e043fe8c
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasCharacterAnimationPanelStyle.test.tsx
@@ -0,0 +1,420 @@
+// @vitest-environment jsdom
+
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { cleanup, render } from '@testing-library/react';
+import { useState } from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { ImageCanvasCharacterAnimationPanelView } from '../../../src/components/image-editor/ImageCanvasCharacterAnimationPanelView';
+import type {
+  CanvasLayer,
+  CharacterAnimationPanelState,
+  QuickEditPanelState,
+} from '../../../src/components/image-editor/ImageCanvasEditorTypes';
+import { ImageCanvasQuickEditPanelView } from '../../../src/components/image-editor/ImageCanvasQuickEditPanelView';
+import { createResourceQuickEditPanelDraft } from '../src/features/resource-canvas/resourceCanvasQuickEditModel';
+
+/**
+ * 共享画布面板在 AGC 的样式覆盖契约（动画面板 / 快速编辑面板 / 生图面板）。
+ *
+ * 现象（客户端验收现场，两次）：①「生成动画」面板只剩通用 composer 外观——素材缩略图、动作预设、
+ * `生成NN泥点` 按钮与关闭键全部落回默认流布局，关闭键还跑到面板正中；② 快速编辑 composer 的同族
+ * 样式也缺过。根因是这套 `image-canvas-editor__*` 规则只写在网页端整站表 `src/index.css` 里，
+ * 而 AGC 是独立宿主，宿主的 `resourceCanvasChrome.css` 只能逐条照抄。
+ *
+ * jsdom 不计算外部 CSS，所以这里不做"渲染出来看观感"，而是把两半分别钉死：
+ *   1) DOM 契约：真渲染出这三块面板（含 `reference-chip--${tone}` 这种运行时拼出来的类）；
+ *   2) 样式表契约：从 AGC 入口 `src/main.tsx` 按真实 import 关系解析出"AGC 到底加载了哪些样式表"，
+ *      逐条比对**网页端命中这份 DOM 的规则（选择器分支 + 声明）AGC 是否都有一条**。
+ *
+ * 比对必须按「选择器分支 + 声明」而不是类名或整串选择器：同名规则在网页端会出现两次
+ * （`__generation-close` 先给基础外观、再给浮层内的绝对定位），只搬第一条照样"类名有规则"却跑偏；
+ * 而 `A, B { … }` 里只命中 A 的那一支，也不该逼宿主连 B 一起搬。
+ *
+ * 这是**弱验证**（声明级，不是真机观感）。真机判据：资源卡 → 生成动画 → 缩略图、动作预设一排、
+ * 按钮落在面板右下角、右上角有关闭键；窄屏动画面板落到底部整宽、按钮整宽。
+ */
+
+/**
+ * 显式放行的宿主差异（每条都写明原因，避免"守卫红了就加白名单"式的静默漂移）：
+ *
+ * 1. 快速编辑浮层**窄屏**：网页端在 `@media (max-width: 760px)` 把它与动画面板一起变成
+ *    `position: fixed` 的整宽底栏（下一条是配套的 bottom 计算）。AGC 的快速编辑浮层是
+ *    「居中贴资源卡」的绝对定位（`transform: translateX(-50%)` + 内联 left/top），窄屏宽度由
+ *    `calc(100vw - 1.5rem)` 自己收；改成底栏会压住栏目画布左下角工具栏与左侧「生成任务」侧栏。
+ * 2. 快速编辑浮层**桌面档**：网页端 `overflow: auto`，AGC 必须 `overflow: visible`——AGC 没有
+ *    portal，共享组件的下拉弹层就地渲染，面板一旦滚动就会把弹层裁掉（见 `resourceCanvasChrome.css`
+ *    快速编辑面板那段注释）。
+ */
+const ACCEPTED_AGENT_HOST_DIVERGENCES = new Set([
+  '.image-canvas-editor__quick-edit-panel { position: fixed; left: 0.75rem !important; right: 0.75rem; top: auto !important; bottom: 0.75rem; width: auto; max-height: min(72vh, 34rem); transform: none; }',
+  '.image-canvas-editor__quick-edit-panel.image-canvas-editor__generation-composer { width: auto; bottom: calc(9rem + env(safe-area-inset-bottom, 0px)); }',
+  '.image-canvas-editor__quick-edit-panel { position: absolute; z-index: 14; display: grid; width: min(24rem, calc(100vw - 1.5rem)); max-height: min(32rem, calc(100% - 1.5rem)); gap: 0.58rem; overflow: auto; border: 1px solid rgba(148, 163, 184, 0.36); border-radius: 1.1rem; background: rgba(255, 255, 255, 0.96); padding: 0.72rem; color: #1f2937; box-shadow: 0 22px 48px rgba(15, 23, 42, 0.22); transform: translateX(-50%); }',
+]);
+
+const TEST_DIR = dirname(fileURLToPath(import.meta.url));
+const AGC_ROOT = resolve(TEST_DIR, '..');
+const REPO_ROOT = resolve(AGC_ROOT, '..', '..');
+
+const PANEL_CLASS = 'image-canvas-editor__character-animation-panel';
+
+type CssRule = { selector: string; body: string };
+
+/** `@genarrative/<pkg>/<subpath>` → `packages/<pkg>/package.json` 的 exports 指向的真实文件。 */
+function resolveStyleSpecifier(specifier: string, fromFile: string): string {
+  if (specifier.startsWith('.')) {
+    return resolve(dirname(fromFile), specifier);
+  }
+  const match = /^(@[^/]+\/[^/]+|[^@/][^/]*)(\/.*)?$/u.exec(specifier);
+  expect(match, `样式入口无法解析：${specifier}`).not.toBeNull();
+  const packageName = match![1]!
+    .replace(/^@genarrative\//u, '')
+    .replace(/\//gu, '-');
+  const packageDir = resolve(REPO_ROOT, 'packages', packageName);
+  const manifestPath = resolve(packageDir, 'package.json');
+  if (!existsSync(manifestPath)) {
+    throw new Error(
+      `AGC 新增了未知样式入口「${specifier}」：请把它的解析方式补进本用例的清单。`,
+    );
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as {
+    exports?: Record<string, string>;
+  };
+  const subpath = match![2] ? `.${match![2]}` : '.';
+  const target = manifest.exports?.[subpath];
+  if (!target) {
+    throw new Error(
+      `样式入口「${specifier}」在 packages/${packageName}/package.json 的 exports 里没有对应项。`,
+    );
+  }
+  return resolve(packageDir, target);
+}
+
+/** 从 AGC 入口出发按 import / @import 关系收集它加载的样式表，不手写清单。 */
+function collectAgcLoadedStyleSheets(): string[] {
+  const entryFile = resolve(AGC_ROOT, 'src/main.tsx');
+  const pending = [
+    ...readFileSync(entryFile, 'utf8').matchAll(
+      /import\s+'(?<specifier>[^']+\.css)'/gu,
+    ),
+  ].map((match) => resolveStyleSpecifier(match.groups!.specifier!, entryFile));
+
+  const loaded: string[] = [];
+  while (pending.length > 0) {
+    const sheet = pending.pop()!;
+    if (loaded.includes(sheet)) {
+      continue;
+    }
+    loaded.push(sheet);
+    const source = readFileSync(sheet, 'utf8');
+    for (const match of source.matchAll(/@import\s+'(?<specifier>[^']+)'/gu)) {
+      const specifier = match.groups!.specifier!;
+      // 由 Vite / Tailwind 插件接管的入口没有实体文件。
+      if (specifier === 'tailwindcss') {
+        continue;
+      }
+      pending.push(resolveStyleSpecifier(specifier, sheet));
+    }
+  }
+  return loaded.sort();
+}
+
+/** 够用的规则读取：取每一段 `选择器 { 声明 }`，跳过 `@media` 这类容器本身。 */
+function readRules(file: string): CssRule[] {
+  const source = readFileSync(file, 'utf8').replace(/\/\*[\s\S]*?\*\//gu, '');
+  const rules: CssRule[] = [];
+  for (const match of source.matchAll(/([^{}]+)\{([^{}]*)\}/gu)) {
+    const selector = match[1]!.trim().replace(/\s+/gu, ' ');
+    if (!selector || selector.startsWith('@')) {
+      continue;
+    }
+    rules.push({ selector, body: match[2]!.trim().replace(/\s+/gu, ' ') });
+  }
+  return rules;
+}
+
+/**
+ * 选择器能不能命中这一份 DOM：逐条 `matches()` 试。
+ *
+ * 只做「元素是否可能匹配」这一层，所以把状态类伪类（`:hover` / `:focus-within` / `:disabled`…）
+ * 与伪元素摘掉再试；`::before` / `::after` 这类由真实浏览器生成的内容不参与判断。
+ */
+function ruleMatchesPanel(selector: string, elements: readonly Element[]) {
+  const stripped = selector
+    .replace(/::[a-z-]+/gu, '')
+    .replace(/:[a-z-]+(\([^)]*\))?/gu, '')
+    .trim();
+  if (!stripped) {
+    return false;
+  }
+  return elements.some((element) => {
+    try {
+      return element.matches(stripped);
+    } catch {
+      return false;
+    }
+  });
+}
+
+function declarationOf(
+  rules: readonly CssRule[],
+  className: string,
+  property: string,
+): string | null {
+  const dot = `.${className}`;
+  for (const rule of rules) {
+    const selectors = rule.selector.split(',').map((item) => item.trim());
+    // 只认「这个类自己那一档」的声明：`.cls` 精确出现，或 `.cls 后代`。
+    const owns = selectors.some(
+      (selector) =>
+        selector === dot ||
+        selector.startsWith(`${dot} `) ||
+        selector.startsWith(`${dot}:`) ||
+        selector.startsWith(`${dot}[`) ||
+        selector.endsWith(` ${dot}`),
+    );
+    if (!owns) {
+      continue;
+    }
+    for (const chunk of rule.body.split(';')) {
+      const separator = chunk.indexOf(':');
+      if (separator < 0) {
+        continue;
+      }
+      if (chunk.slice(0, separator).trim() === property) {
+        return chunk
+          .slice(separator + 1)
+          .trim()
+          .replace(/\s+/gu, ' ');
+      }
+    }
+  }
+  return null;
+}
+
+function animationPanel() {
+  const sourceLayer: CanvasLayer = {
+    id: 'layer-a',
+    resourceId: 'resource-a',
+    title: 'char_hero_back.png',
+    src: 'data:image/png;base64,Y2hhcmFjdGVy',
+    x: 0,
+    y: 0,
+    width: 128,
+    height: 128,
+    originalWidth: 128,
+    originalHeight: 128,
+    zIndex: 1,
+    sourceType: 'uploaded',
+  };
+  const initialPanel: CharacterAnimationPanelState = {
+    sourceLayerId: 'layer-a',
+    promptText: '待机动作',
+    resolution: '480p',
+    ratio: 'same',
+    frameCount: 32,
+    durationSeconds: 4,
+    status: 'idle',
+  };
+  function Harness() {
+    const [panel, setPanel] = useState<CharacterAnimationPanelState | null>(
+      initialPanel,
+    );
+    return panel ? (
+      <ImageCanvasCharacterAnimationPanelView
+        panel={panel}
+        sourceLayer={sourceLayer}
+        style={{ left: 12, top: 24 }}
+        price={80}
+        setCharacterAnimationPanel={setPanel}
+        onUpdateDuration={vi.fn()}
+        onSubmit={vi.fn()}
+      />
+    ) : null;
+  }
+  const { container } = render(<Harness />);
+  return container;
+}
+
+function quickEditPanel() {
+  const sourceLayer: CanvasLayer = {
+    id: 'layer-q',
+    resourceId: 'resource-q',
+    title: 'source-art.png',
+    src: 'data:image/png;base64,c291cmNl',
+    x: 0,
+    y: 0,
+    width: 128,
+    height: 128,
+    originalWidth: 128,
+    originalHeight: 128,
+    zIndex: 1,
+    sourceType: 'uploaded',
+  };
+  function Harness() {
+    const [panel, setPanel] = useState<QuickEditPanelState | null>(() =>
+      createResourceQuickEditPanelDraft(sourceLayer),
+    );
+    return panel ? (
+      <ImageCanvasQuickEditPanelView
+        panel={panel}
+        style={{ left: 12, top: 24 }}
+        setQuickEditPanel={setPanel}
+        onSubmit={vi.fn()}
+      />
+    ) : null;
+  }
+  const { container } = render(<Harness />);
+  return container;
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+/**
+ * 网页端命中这份 DOM、但 AGC 一条都没有的（选择器分支 + 声明）。
+ *
+ * 比对键是**分支 + 声明**而不是类名或整串选择器：同名规则在网页端会出现两次，只搬第一条也
+ * "类名有规则"却跑偏；`A, B { … }` 里只命中 A 的那一支，也不该逼宿主连 B 一起搬。
+ */
+function missingWebRulesFor(container: HTMLElement): {
+  missing: string[];
+  matchedCount: number;
+} {
+  const elements = [container, ...Array.from(container.querySelectorAll('*'))];
+  const matched = readRules(resolve(REPO_ROOT, 'src/index.css')).flatMap(
+    (rule) =>
+      rule.selector
+        .split(',')
+        .map((selector) => selector.trim().replace(/\s+/gu, ' '))
+        .filter(
+          (selector) =>
+            selector.includes('image-canvas-editor__') &&
+            ruleMatchesPanel(selector, elements),
+        )
+        .map((selector) => `${selector} { ${rule.body} }`),
+  );
+  const agcRuleKeys = new Set(
+    collectAgcLoadedStyleSheets()
+      .flatMap(readRules)
+      .flatMap((rule) =>
+        rule.selector
+          .split(',')
+          .map(
+            (selector) =>
+              `${selector.trim().replace(/\s+/gu, ' ')} { ${rule.body} }`,
+          ),
+      ),
+  );
+  return {
+    missing: [
+      ...new Set(
+        matched.filter(
+          (key) =>
+            !agcRuleKeys.has(key) && !ACCEPTED_AGENT_HOST_DIVERGENCES.has(key),
+        ),
+      ),
+    ],
+    matchedCount: matched.length,
+  };
+}
+
+describe('共享画布面板的 AGC 样式覆盖', () => {
+  /*
+    只探**消费共享 `ImageCanvas*` 组件**的两块面板（动画 / 快速编辑）——它们的类名来自网页端整站表，
+    宿主必须逐条照抄。生图（资源生成）面板走的是 AGC 自有类名（`game-resource-generation-*` 与
+    `resource-canvas-asset-generation-*`），不属于这条守卫的对象；它的排布由
+    `resourceCanvasAssetGenerationReferences.test.tsx` 的结构用例与基类 token 覆盖。
+  */
+  for (const probe of [
+    { name: '「生成动画」面板', render: animationPanel },
+    { name: '快速编辑面板', render: quickEditPanel },
+  ]) {
+    it(`${probe.name}：网页端命中它的每条规则，AGC 都有同名同声明的一条`, () => {
+      const { missing, matchedCount } = missingWebRulesFor(probe.render());
+      expect(
+        matchedCount,
+        `${probe.name}一条网页端规则都没匹配上：判据退化成空集，守卫失效`,
+      ).toBeGreaterThan(0);
+      expect(
+        missing,
+        `${probe.name}缺这些规则（网页端有、AGC 没有）：\n${missing.join('\n')}`,
+      ).toEqual([]);
+    });
+  }
+
+  it('撑开面板布局的关键声明逐条在位', () => {
+    const rules = collectAgcLoadedStyleSheets().flatMap(readRules);
+
+    expect(declarationOf(rules, PANEL_CLASS, 'position')).toBe('absolute');
+    expect(declarationOf(rules, PANEL_CLASS, 'width')).toContain('42rem');
+    expect(
+      declarationOf(
+        rules,
+        'image-canvas-editor__generation-composer--character-animation',
+        'grid-template-columns',
+      ),
+    ).toBe('minmax(0, 1fr)');
+    expect(
+      declarationOf(
+        rules,
+        'image-canvas-editor__character-animation-presets',
+        'display',
+      ),
+    ).toBe('flex');
+    expect(
+      declarationOf(
+        rules,
+        'image-canvas-editor__character-animation-preset',
+        'border-radius',
+      ),
+    ).toBe('999px');
+    expect(
+      declarationOf(
+        rules,
+        'image-canvas-editor__character-animation-footer',
+        'grid-template-columns',
+      ),
+    ).toBe('auto minmax(0, 1fr) auto');
+    expect(
+      declarationOf(
+        rules,
+        'image-canvas-editor__character-animation-submit',
+        'grid-column',
+      ),
+    ).toBe('3');
+    expect(
+      declarationOf(rules, 'image-canvas-editor__generation-close', 'display'),
+    ).toBe('inline-flex');
+    expect(
+      declarationOf(
+        rules,
+        'image-canvas-editor__reference-strip',
+        'grid-column',
+      ),
+    ).toBe('1 / -1');
+    expect(
+      declarationOf(rules, 'image-canvas-editor__reference-chip', 'width'),
+    ).toBe('3.95rem');
+  });
+
+  it('判据本身可信：动画面板至少要匹配上十几条网页端规则', () => {
+    const container = animationPanel();
+    const elements = [
+      container,
+      ...Array.from(container.querySelectorAll('*')),
+    ];
+    const matched = readRules(resolve(REPO_ROOT, 'src/index.css')).filter(
+      (rule) =>
+        rule.selector.includes('image-canvas-editor__') &&
+        rule.selector
+          .split(',')
+          .some((selector) => ruleMatchesPanel(selector, elements)),
+    );
+    expect(matched.length).toBeGreaterThan(10);
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasFloatingDismiss.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasFloatingDismiss.test.tsx
index 98ee615bc..ce3da42c4 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasFloatingDismiss.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasFloatingDismiss.test.tsx
@@ -2,6 +2,7 @@
 import type { CanvasLayer } from '@genarrative/image-canvas-core';
 import { cleanup, fireEvent, render, screen } from '@testing-library/react';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
 import { afterEach, describe, expect, test, vi } from 'vitest';
 
 import type { QuickEditPanelState } from '../../../src/components/image-editor/ImageCanvasEditorTypes';
@@ -11,7 +12,6 @@ import {
   useImageCanvasFloatingOptionDismiss,
 } from '../../../src/components/image-editor/useImageCanvasFloatingOptionDismiss';
 import {
-  canDismissResourceCanvasQuickEdit,
   isResourceCanvasHostOverlayOpen,
   isResourceCanvasInteractionTarget,
   isResourceCanvasPanTarget,
@@ -133,15 +133,6 @@ describe('resourceCanvasFocusModel', () => {
     document.body.innerHTML = '';
   });
 
-  test('快速编辑生成中不参与清焦点', () => {
-    expect(canDismissResourceCanvasQuickEdit(null)).toBe(true);
-    expect(canDismissResourceCanvasQuickEdit({ status: 'idle' })).toBe(true);
-    expect(canDismissResourceCanvasQuickEdit({ status: 'failed' })).toBe(true);
-    expect(canDismissResourceCanvasQuickEdit({ status: 'generating' })).toBe(
-      false,
-    );
-  });
-
   test('AGC 自有弹层开着时画布浮层不接管点外部关闭', () => {
     const closed = {
       isResourcePanelOpen: false,
@@ -407,6 +398,211 @@ describe('资源画布浮层关闭时机', () => {
   });
 });
 
+/**
+ * 「恢复原文」的形状：浮层里的按钮在**这一次点击**里把自己卸掉
+ * （原文快照被消费 ⇒ 按钮不再渲染）。AGC-005 的验收视频里，这一下把整个快速编辑面板
+ * 连同画布选中一起收掉了。
+ *
+ * 这里用 React 的 `onClick`（应用里的真实形状）复现。
+ */
+function SelfUnmountingOverlayHarness({
+  onDismiss,
+}: {
+  onDismiss: () => void;
+}) {
+  const canvasRef = useRef<HTMLDivElement | null>(null);
+  const [restoreVisible, setRestoreVisible] = useState(true);
+  const [panelOpen, setPanelOpen] = useState(true);
+
+  useImageCanvasFloatingOptionDismiss({
+    isOpen: panelOpen,
+    boundaryRefs: [canvasRef],
+    onDismiss: () => {
+      onDismiss();
+      setPanelOpen(false);
+    },
+  });
+
+  return (
+    <div ref={canvasRef} data-testid="self-unmount-canvas">
+      {panelOpen ? (
+        <div role="dialog" aria-label="快速编辑浮层面板">
+          {restoreVisible ? (
+            <button type="button" onClick={() => setRestoreVisible(false)}>
+              恢复原文
+            </button>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+/**
+ * 同一种形状的**同步**版本：目标节点在自己的原生 click 监听里被 `remove()`。
+ *
+ * 边界判定必须在事件派发最早期完成——等冒泡到 `document` 再拿 `event.target` 现算，
+ * 节点已经脱离 DOM，`element.contains(target)` 恒为 false，「点浮层内部」就被误判成
+ * 「点外部」，面板被自己的按钮关掉。这条用例是 AGC-005 的回归判据：
+ * 冻结判定接上之前它是红的。
+ */
+function NativeSelfRemovingOverlayHarness({
+  onDismiss,
+}: {
+  onDismiss: () => void;
+}) {
+  const canvasRef = useRef<HTMLDivElement | null>(null);
+  const buttonRef = useRef<HTMLButtonElement | null>(null);
+  const [panelOpen, setPanelOpen] = useState(true);
+
+  useImageCanvasFloatingOptionDismiss({
+    isOpen: panelOpen,
+    boundaryRefs: [canvasRef],
+    onDismiss: () => {
+      onDismiss();
+      setPanelOpen(false);
+    },
+  });
+
+  useEffect(() => {
+    const button = buttonRef.current;
+    if (!button) {
+      return undefined;
+    }
+    const handleClick = () => {
+      button.remove();
+    };
+    button.addEventListener('click', handleClick);
+    return () => button.removeEventListener('click', handleClick);
+  }, [panelOpen]);
+
+  return (
+    <div ref={canvasRef} data-testid="native-self-unmount-canvas">
+      {panelOpen ? (
+        <div role="dialog" aria-label="快速编辑浮层面板">
+          <button ref={buttonRef} type="button">
+            恢复原文
+          </button>
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+/**
+ * 宿主自己 portal 到 `body` 的浮层（`@` 资源选择器 / 候选菜单）由 `isInsideExtraOverlay`
+ * 登记；菜单项点完即卸载时同样不能被判成点外部——portal 语义必须与边界 DOM 一视同仁。
+ */
+function ExtraOverlaySelfRemovalHarness({
+  onDismiss,
+}: {
+  onDismiss: () => void;
+}) {
+  const canvasRef = useRef<HTMLDivElement | null>(null);
+  const itemRef = useRef<HTMLButtonElement | null>(null);
+  const [panelOpen, setPanelOpen] = useState(true);
+
+  useImageCanvasFloatingOptionDismiss({
+    isOpen: panelOpen,
+    boundaryRefs: [canvasRef],
+    onDismiss: () => {
+      onDismiss();
+      setPanelOpen(false);
+    },
+    isInsideExtraOverlay: (target) =>
+      target instanceof Element &&
+      target.closest('.resource-reference-picker') !== null,
+  });
+
+  useEffect(() => {
+    const item = itemRef.current;
+    if (!item) {
+      return undefined;
+    }
+    const handleClick = () => {
+      item.remove();
+    };
+    item.addEventListener('click', handleClick);
+    return () => item.removeEventListener('click', handleClick);
+  }, [panelOpen]);
+
+  if (!panelOpen) {
+    return null;
+  }
+
+  return (
+    <>
+      <div ref={canvasRef} data-testid="registered-overlay-canvas">
+        <div role="dialog" aria-label="快速编辑浮层面板" />
+      </div>
+      {createPortal(
+        <div className="resource-reference-picker">
+          <button ref={itemRef} type="button">
+            引用素材
+          </button>
+        </div>,
+        document.body,
+      )}
+    </>
+  );
+}
+
+describe('点外部关闭的边界判据', () => {
+  test('点会自卸载的按钮不算点外部，面板不退出', () => {
+    const onDismiss = vi.fn();
+    render(<SelfUnmountingOverlayHarness onDismiss={onDismiss} />);
+
+    fireEvent.click(screen.getByRole('button', { name: '恢复原文' }));
+
+    expect(screen.queryByRole('button', { name: '恢复原文' })).toBeNull();
+    expect(onDismiss).not.toHaveBeenCalled();
+    expect(
+      screen.getByRole('dialog', { name: '快速编辑浮层面板' }),
+    ).toBeTruthy();
+  });
+
+  test('按钮在自己这次点击里被同步卸载，也仍算点在浮层内部', () => {
+    const onDismiss = vi.fn();
+    render(<NativeSelfRemovingOverlayHarness onDismiss={onDismiss} />);
+
+    const button = screen.getByRole('button', { name: '恢复原文' });
+    fireEvent.click(button);
+
+    // 目标确实是在这次点击里卸载的——判定不能因此翻成「点外部」。
+    expect(button.isConnected).toBe(false);
+    expect(onDismiss).not.toHaveBeenCalled();
+    expect(
+      screen.getByRole('dialog', { name: '快速编辑浮层面板' }),
+    ).toBeTruthy();
+  });
+
+  test('登记的 portal 浮层项自己卸载也算内部，宿主面板不被误关', () => {
+    const onDismiss = vi.fn();
+    render(<ExtraOverlaySelfRemovalHarness onDismiss={onDismiss} />);
+
+    const item = screen.getByRole('button', { name: '引用素材' });
+    fireEvent.click(item);
+
+    expect(item.isConnected).toBe(false);
+    expect(onDismiss).not.toHaveBeenCalled();
+    expect(
+      screen.getByRole('dialog', { name: '快速编辑浮层面板' }),
+    ).toBeTruthy();
+  });
+
+  test('点边界外照旧立即关闭（对照）', () => {
+    const onDismiss = vi.fn();
+    render(<NativeSelfRemovingOverlayHarness onDismiss={onDismiss} />);
+
+    fireEvent.click(document.body);
+
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+    expect(
+      screen.queryByRole('dialog', { name: '快速编辑浮层面板' }),
+    ).toBeNull();
+  });
+});
+
 describe('画布滚轮归属判据', () => {
   /**
    * 与「点外部关闭」同一份口径：portal 出去的东西 DOM 上不在边界里，但 React 的事件会沿
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasGenerationFloatingPanelChrome.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasGenerationFloatingPanelChrome.test.tsx
index 5b1dd62e4..6d3a686d3 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasGenerationFloatingPanelChrome.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasGenerationFloatingPanelChrome.test.tsx
@@ -1,6 +1,5 @@
 // @vitest-environment jsdom
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { cleanup, render, screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
@@ -9,6 +8,7 @@ import { afterEach, describe, expect, test, vi } from 'vitest';
 import { ResourceCanvasAssetGenerationPanelView } from '../src/features/resource-canvas/ResourceCanvasAssetGenerationPanelView';
 import type { ResourceCanvasAssetToolAction } from '../src/features/resource-canvas/resourceCanvasBottomToolbarModel';
 import { ResourceCanvasGenerationPanelView } from '../src/features/resource-canvas/ResourceCanvasGenerationPanelView';
+import { repoPath } from './repoPath';
 
 afterEach(cleanup);
 
@@ -112,8 +112,7 @@ describe('生成浮层的面板外观与高度合同', () => {
 describe('生成浮层样式结构', () => {
   const panelCss = () =>
     readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasGenerationPanel.css',
       ),
       'utf8',
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx
index 5e94acb39..e4eccc910 100644
--- a/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasGenerationTasksSidebarDismiss.test.tsx
@@ -1,7 +1,6 @@
 /** @vitest-environment jsdom */
 
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
@@ -14,6 +13,7 @@ import {
   screen,
   waitFor,
 } from './appSurface/harness';
+import { repoPath } from './repoPath';
 
 /**
  * 「生成任务」侧栏与工具条入口的三条口径：
@@ -144,7 +144,7 @@ describe('「生成任务」侧栏的开合与入口位置', () => {
 
   it('「依赖 / 类型」与前一按钮之间的间距跟行内其他按钮一致', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     // 这一行是 gap: 7px 的 flex 容器；分段控件曾靠自带 padding: 3px 与前一按钮只隔 10px，
@@ -157,7 +157,7 @@ describe('「生成任务」侧栏的开合与入口位置', () => {
 
   it('布局状态提示不参与动作行排版，不会按文案宽度顶开按钮', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     // 它是随保存过程变长的文案（空 →「保存中」→「布局已保存」→ 失败原因）。作为 flex 子项
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasQuickEditDraft.test.tsx b/apps/ai-game-creator-shell/tests/resourceCanvasQuickEditDraft.test.tsx
new file mode 100644
index 000000000..b9383a561
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasQuickEditDraft.test.tsx
@@ -0,0 +1,829 @@
+/** @vitest-environment jsdom */
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { GameCreationAppManifest } from '../../../packages/shared/src/contracts/gameCreationApp';
+import {
+  createGameCreationAppManifest,
+  findResourceSelectButton,
+  fireEvent,
+  installResizeObserverStub,
+  ProjectDevelopmentView,
+  React,
+  render,
+  screen,
+  setComposerText,
+  waitFor,
+  within,
+} from './appSurface/harness';
+
+vi.mock('@tauri-apps/api/core', async () => ({
+  ...(await vi.importActual<typeof import('@tauri-apps/api/core')>(
+    '@tauri-apps/api/core',
+  )),
+  invoke: (command: string, args?: Record<string, unknown>) =>
+    window.__TAURI__!.core.invoke(command, args),
+}));
+
+const PROJECT_PATH = '/tmp/quick-edit-draft';
+const PROJECT_ID = 'quick-edit-draft-project';
+const CANVAS_TASK_ART_PATH = 'assets/generated/task-art.png';
+
+/**
+ * 两张同栏目图片 + 一份文档素材。
+ *
+ * 两张图片落在同一个「待归类」栏目里，才测得出**换素材卡**时草稿各归各的；文档素材
+ * 供快速编辑的 `@` 引用选择器取用——引用的回填与提示词一样属于这份草稿。
+ */
+function createDraftManifest(): GameCreationAppManifest {
+  const manifest = createGameCreationAppManifest(
+    PROJECT_ID,
+    '快速编辑草稿测试',
+  );
+  manifest.assets = [
+    {
+      id: 'source-art',
+      kind: 'art-image',
+      mediaType: 'image/png',
+      localPath: 'assets/source-art.png',
+      source: { kind: 'generated', resourceId: 'art-resource' },
+    },
+    {
+      id: 'source-art-2',
+      kind: 'art-image',
+      mediaType: 'image/png',
+      localPath: 'assets/source-art-2.png',
+      source: { kind: 'generated', resourceId: 'art-resource-2' },
+    },
+    {
+      id: 'source-rules',
+      kind: 'game-rules',
+      mediaType: 'text/markdown',
+      localPath: 'docs/rules.md',
+      source: { kind: 'generated', resourceId: 'rules-resource' },
+    },
+  ];
+  return manifest;
+}
+
+/**
+ * 画布产物（还没登记成正式素材的任务产物）那一份清单。
+ *
+ * 卡片 id 是 `task:canvas-task:assets/generated/task-art.png`，提交快速编辑时先走
+ * `normalize_local_project_raster_resource` 正规化成 `asset:<id>`——卡片被重投影走、
+ * 面板的 `sourceLayerId` 仍停在旧 id 上，这正是草稿键必须跟着投影走的那条路。
+ */
+function createCanvasTaskArtManifest(): GameCreationAppManifest {
+  const manifest = createGameCreationAppManifest(
+    PROJECT_ID,
+    '快速编辑草稿测试',
+  );
+  manifest.assets = [
+    {
+      id: 'source-rules',
+      kind: 'game-rules',
+      mediaType: 'text/markdown',
+      localPath: 'docs/rules.md',
+      source: { kind: 'generated', resourceId: 'rules-resource' },
+    },
+  ];
+  manifest.tasks = [
+    ...manifest.tasks,
+    {
+      id: 'canvas-task',
+      title: '画布生成',
+      group: 'art',
+      role: 'Artisan',
+      status: 'completed',
+      dependencies: [],
+      artifacts: [CANVAS_TASK_ART_PATH],
+      acceptanceCriteria: ['画布产物落在画布上'],
+    },
+  ];
+  return manifest;
+}
+
+type PendingResourceEditFixture = {
+  operationId: string;
+  editKind: string;
+  sourceResourceId: string;
+  assetName: string;
+  phase: string;
+  createdAt: number;
+};
+
+/**
+ * 工作台跑真实链路所需的最小原生桩：资源图、画布布局、预览读取与恢复队列读取。
+ * 派生走成功分支，用于验证「提交成功后这一笔草稿作废」。
+ */
+function installInvoke(
+  options: {
+    pendingResourceEdits?: PendingResourceEditFixture[];
+    /** 与工作台同一份清单工厂：两边必须是同一份初始 manifest。 */
+    createManifest?: () => GameCreationAppManifest;
+    /** 派生一律失败：用于把面板留在失败态、只验证草稿的去向。 */
+    failDerive?: boolean;
+    /**
+     * 派生挂起门：测试拿住它就能停在「已经提交、结果还没回来」那一段，验证提交期间的界面。
+     * 不传时派生立即返回，行为与从前一致。
+     */
+    deriveGate?: Promise<void>;
+  } = {},
+) {
+  const createManifest = options.createManifest ?? createDraftManifest;
+  let revision = 0;
+  let manifest = createManifest();
+  const deriveCalls: Array<Record<string, unknown>> = [];
+  const normalizeCalls: Array<Record<string, unknown>> = [];
+  const invoke = vi.fn(
+    async (command: string, args?: Record<string, unknown>) => {
+      if (command === 'get_local_game_project_revision') {
+        return { revision };
+      }
+      if (command === 'read_local_project_resource_graph') {
+        const resourceIds = (
+          args?.resources as Array<{ resourceId: string }>
+        ).map((item) => item.resourceId);
+        return {
+          resourceIds,
+          referenceEdges: [],
+          taskFlows: [],
+          producerAssignments: [],
+          dependencyDepths: resourceIds.map((resourceId) => ({
+            resourceId,
+            dependencyDepth: 0,
+          })),
+          connectionIndex: resourceIds.map((resourceId) => ({
+            resourceId,
+            upstreamReferenceResourceIds: [],
+            downstreamReferenceResourceIds: [],
+            referenceEdgeIds: [],
+            taskFlowIds: [],
+          })),
+          unresolvedReferenceResourceIds: [],
+          cyclicResourceIds: [],
+          cyclicTaskIds: [],
+          producerMappingTruncated: false,
+        };
+      }
+      if (
+        command === 'read_local_project_resource_canvas_layout' ||
+        command === 'update_local_project_resource_canvas_layout'
+      ) {
+        const layout = {
+          schemaVersion: 'game-creator-resource-layout.v1',
+          projectId: PROJECT_ID,
+          mode: args?.mode,
+          revision: Number(args?.expectedRevision ?? 0) + 1,
+          positions: args?.positions ?? [],
+          updatedAt: 1,
+        };
+        return command.startsWith('update_')
+          ? { status: 'updated', layout }
+          : layout;
+      }
+      if (command === 'read_local_project_image_preview') {
+        return {
+          path: String(args?.relativePath ?? ''),
+          mediaType: 'image/png',
+          byteLen: 12,
+          dataUrl: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB',
+        };
+      }
+      if (command === 'read_local_project_text_preview') {
+        return {
+          path: String(args?.relativePath ?? ''),
+          mediaType: 'text/markdown',
+          byteLen: 5,
+          content: '# 规则',
+        };
+      }
+      if (command === 'list_pending_local_project_resource_edits') {
+        return structuredClone(options.pendingResourceEdits ?? []);
+      }
+      if (command === 'list_local_project_asset_generations') {
+        return [];
+      }
+      if (command === 'get_local_game_manifest') {
+        return manifest;
+      }
+      if (command === 'normalize_local_project_raster_resource') {
+        const input = structuredClone(
+          (args?.input ?? {}) as Record<string, unknown>,
+        );
+        normalizeCalls.push(input);
+        const asset = {
+          id: 'normalized-task-art',
+          kind: 'art-image',
+          mediaType: 'image/png',
+          localPath: CANVAS_TASK_ART_PATH,
+          source: {
+            kind: 'canvas' as const,
+            resourceId: String(input.sourceResourceId),
+            taskId: 'canvas-task',
+          },
+        };
+        revision += 1;
+        manifest = { ...manifest, assets: [...manifest.assets, asset] };
+        return {
+          committedProjectRevision: revision,
+          asset,
+          manifest,
+        };
+      }
+      if (command === 'derive_local_project_resource') {
+        const input = structuredClone(
+          (args?.input ?? {}) as Record<string, unknown>,
+        );
+        deriveCalls.push(input);
+        if (options.failDerive) {
+          throw new Error('result-unknown: 测试网络中断');
+        }
+        if (options.deriveGate) {
+          await options.deriveGate;
+        }
+        const operationId = String(input.operationId);
+        const assetId = `edit-${operationId}`;
+        const asset = {
+          id: assetId,
+          kind: 'art-image',
+          mediaType: 'image/png',
+          localPath: `assets/edits/${operationId}-art.png`,
+          source: {
+            kind: 'generated' as const,
+            resourceId: `local-asset:${assetId}`,
+            referenceResourceIds: ['art-resource'],
+          },
+        };
+        revision += 1;
+        manifest = { ...manifest, assets: [...manifest.assets, asset] };
+        return {
+          operationId,
+          editKind: input.editKind,
+          sourceResourceId: 'art-resource',
+          committedProjectRevision: revision,
+          asset,
+          version: null,
+          manifest,
+        };
+      }
+      throw new Error(`unexpected command: ${command}`);
+    },
+  );
+  (
+    window as unknown as {
+      __TAURI__?: { core?: { invoke?: typeof invoke } };
+    }
+  ).__TAURI__ = { core: { invoke } };
+  return { invoke, deriveCalls, normalizeCalls };
+}
+
+/** 宿主由状态持有 manifest，派生结果才能真的回写并重投影（不是断言桩）。 */
+function DraftWorkbench({
+  createManifest = createDraftManifest,
+  externalAssetPath = null,
+}: {
+  createManifest?: () => GameCreationAppManifest;
+  /**
+   * 打开一枚测试用的「外部登记素材」按钮：模拟 Agent / 外部编辑器把某个路径登记成
+   * 正式素材。走的是同一条投影链路（manifest 变更 → 卡片重投影），与快速编辑自己
+   * 触发的正规化无关——这正是「别的流程换了卡片 id」的那条旁路。
+   */
+  externalAssetPath?: string | null;
+} = {}) {
+  const [manifest, setManifest] = React.useState(createManifest);
+  return React.createElement(
+    React.Fragment,
+    null,
+    externalAssetPath
+      ? React.createElement(
+          'button',
+          {
+            type: 'button',
+            onClick: () =>
+              setManifest((current) => ({
+                ...current,
+                assets: [
+                  ...current.assets,
+                  {
+                    id: 'external-art',
+                    kind: 'art-image',
+                    mediaType: 'image/png',
+                    localPath: externalAssetPath,
+                    source: {
+                      kind: 'generated' as const,
+                      resourceId: 'external-art-resource',
+                    },
+                  },
+                ],
+              })),
+          },
+          '外部登记素材',
+        )
+      : null,
+    React.createElement(ProjectDevelopmentView, {
+      projectName: manifest.name,
+      projectPath: PROJECT_PATH,
+      manifest,
+      attachments: [],
+      recentRunStatus: null,
+      recentRunStopReason: null,
+      supervisor: React.createElement('div', null, '项目总控'),
+      onHomeOpen: vi.fn(),
+      onProjectsOpen: vi.fn(),
+      onManifestChange: (
+        _path: string,
+        nextManifest: GameCreationAppManifest,
+      ) => setManifest(nextManifest),
+    }),
+  );
+}
+
+/** 切栏目：左侧大纲导航已删除，一律走「资源总览」的栏目缩略卡片。 */
+async function openResourceBookCategory(label: string) {
+  if (document.querySelector('[data-resource-book-view="child"]')) {
+    fireEvent.click(await screen.findByRole('button', { name: '收起资源' }));
+    await waitFor(() =>
+      expect(
+        document.querySelector('[data-resource-book-view="main"]'),
+      ).not.toBeNull(),
+    );
+  }
+  fireEvent.click(await screen.findByRole('button', { name: `打开${label}` }));
+  await waitFor(() =>
+    expect(
+      document.querySelector('[data-resource-book-view="child"]'),
+    ).not.toBeNull(),
+  );
+}
+
+async function openQuickEditPanel(fileName: string) {
+  fireEvent.click(await findResourceSelectButton(fileName));
+  const toolbar = await screen.findByRole('toolbar', { name: '图片工具栏' });
+  fireEvent.click(within(toolbar).getByRole('button', { name: '快速编辑' }));
+  return await screen.findByRole('dialog', { name: '快速编辑图片' });
+}
+
+/** 面板里的提示词文本（`@` 引用只活在 chip 里，不重复出现在文本里）。 */
+function panelPromptText(panel: HTMLElement) {
+  return within(panel).getByLabelText('快速编辑提示词').textContent ?? '';
+}
+
+/** 关掉画布浮层：Esc 与点外部同一条既有链路（`clearResourceCanvasFocus`）。 */
+async function dismissPanel() {
+  fireEvent.keyDown(document, { key: 'Escape' });
+  await waitFor(() =>
+    expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+  );
+}
+
+afterEach(() => {
+  delete (window as unknown as { __TAURI__?: unknown }).__TAURI__;
+});
+
+describe('快速编辑草稿的保留与恢复', () => {
+  it('Esc 收起面板后重开：提示词与 @ 引用都回到输入区', async () => {
+    installResizeObserverStub();
+    installInvoke();
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把夜色改成星空',
+    );
+    // `@` 引用也是这一笔草稿的一部分：插入一枚再收起面板。
+    fireEvent.click(
+      within(panel).getByRole('button', { name: '插入素材引用' }),
+    );
+    const picker = await screen.findByRole('dialog', { name: '选择素材' });
+    fireEvent.click(within(picker).getByRole('option', { name: /^rules/u }));
+    fireEvent.click(within(picker).getByRole('button', { name: '插入引用' }));
+    await waitFor(() =>
+      expect(
+        document.querySelector('[data-resource-reference-id="source-rules"]'),
+      ).not.toBeNull(),
+    );
+
+    await dismissPanel();
+
+    const reopened = await openQuickEditPanel('source-art.png');
+    expect(panelPromptText(reopened)).toContain('把夜色改成星空');
+    expect(
+      document.querySelector('[data-resource-reference-id="source-rules"]'),
+    ).not.toBeNull();
+  });
+
+  it('换素材卡时两笔草稿各归各的，切回来不串也不丢', async () => {
+    installResizeObserverStub();
+    installInvoke();
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const firstPanel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(firstPanel).getByLabelText('快速编辑提示词'),
+      '第一张的草稿',
+    );
+
+    // 面板开着直接换卡：宿主换选中时收起面板，草稿必须留在第一张名下。
+    const secondPanel = await openQuickEditPanel('source-art-2.png');
+    expect(secondPanel).not.toBe(firstPanel);
+    await waitFor(() =>
+      expect(panelPromptText(secondPanel)).not.toContain('第一张的草稿'),
+    );
+    await setComposerText(
+      within(secondPanel).getByLabelText('快速编辑提示词'),
+      '第二张的草稿',
+    );
+
+    await dismissPanel();
+    expect(
+      panelPromptText(await openQuickEditPanel('source-art.png')),
+    ).toContain('第一张的草稿');
+    await dismissPanel();
+    expect(
+      panelPromptText(await openQuickEditPanel('source-art-2.png')),
+    ).toContain('第二张的草稿');
+  });
+
+  it('恢复入口按草稿计数，「继续编辑」重开面板并回填，丢弃后入口消失', async () => {
+    installResizeObserverStub();
+    installInvoke();
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把角色头发改成红色',
+    );
+    await dismissPanel();
+
+    // 未提交草稿同样要有继续入口：入口计数把本地草稿算进去。
+    fireEvent.click(
+      await screen.findByRole('button', { name: '管理未完成编辑 (1)' }),
+    );
+    const recovery = await screen.findByRole('dialog', {
+      name: '未完成的资源编辑',
+    });
+    expect(within(recovery).getByText('source-art.png')).not.toBeNull();
+    // 语义标注：草稿只在这次打开客户端期间存在，不能和账本里正式的可恢复事实看起来一样。
+    expect(within(recovery).getByText(/^快速编辑草稿/u).textContent).toContain(
+      '快速编辑草稿 · 本会话未提交，关闭客户端不保留 · ',
+    );
+    // 时间戳口径：草稿存的是 `Date.now()` 毫秒，标签复用账本那条秒级格式化器，
+    // 少一次换算就会把毫秒当成秒、显示成完全无关的日期——这里按「就是今天」钉住。
+    expect(within(recovery).getByText(/^快速编辑草稿/u).textContent).toContain(
+      new Intl.DateTimeFormat('zh-CN', {
+        month: '2-digit',
+        day: '2-digit',
+      }).format(new Date()),
+    );
+    expect(within(recovery).getByText('把角色头发改成红色')).not.toBeNull();
+
+    fireEvent.click(within(recovery).getByRole('button', { name: '继续编辑' }));
+    const resumed = await screen.findByRole('dialog', {
+      name: '快速编辑图片',
+    });
+    expect(panelPromptText(resumed)).toContain('把角色头发改成红色');
+    await dismissPanel();
+
+    fireEvent.click(
+      await screen.findByRole('button', { name: '管理未完成编辑 (1)' }),
+    );
+    fireEvent.click(
+      within(
+        await screen.findByRole('dialog', { name: '未完成的资源编辑' }),
+      ).getByRole('button', { name: '丢弃草稿' }),
+    );
+    await waitFor(() =>
+      expect(
+        screen.queryByRole('button', { name: /管理未完成编辑/u }),
+      ).toBeNull(),
+    );
+  });
+
+  it('草稿所在的素材不在当前栏目时：先切栏目定位，再从工具栏重开继续', async () => {
+    installResizeObserverStub();
+    installInvoke();
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把夜色改成星空',
+    );
+    await dismissPanel();
+
+    // 人在别的栏目：草稿条目仍在入口里，点「继续编辑」先把栏目切回去。
+    await openResourceBookCategory('文档');
+    fireEvent.click(
+      await screen.findByRole('button', { name: '管理未完成编辑 (1)' }),
+    );
+    fireEvent.click(
+      within(
+        await screen.findByRole('dialog', { name: '未完成的资源编辑' }),
+      ).getByRole('button', { name: '继续编辑' }),
+    );
+    await waitFor(() =>
+      expect(
+        document.querySelector(
+          '[data-resource-book-view="child"] .game-resource-book-scene-titlebar.is-active[data-resource-book-category="unclassified"]',
+        ),
+      ).not.toBeNull(),
+    );
+    expect(
+      await screen.findByText(/已定位到「source-art\.png」/u),
+    ).not.toBeNull();
+
+    const resumed = await openQuickEditPanel('source-art.png');
+    expect(panelPromptText(resumed)).toContain('把夜色改成星空');
+  });
+
+  it('正规化换掉卡片投影后，草稿跟着资源走、重开在正式素材上继续', async () => {
+    installResizeObserverStub();
+    const { deriveCalls, normalizeCalls } = installInvoke({
+      createManifest: createCanvasTaskArtManifest,
+      failDerive: true,
+    });
+    render(
+      React.createElement(DraftWorkbench, {
+        createManifest: createCanvasTaskArtManifest,
+      }),
+    );
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('task-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把夜色改成星空',
+    );
+    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+    // 提交即关面板：面板只负责把任务交出去，失败也不再把它拉回来（回落成草稿 + 提示条）。
+    await waitFor(() =>
+      expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+    );
+    // 先正规化成正式素材、再派生失败：卡片已经重投影。
+    await waitFor(() => expect(normalizeCalls).toHaveLength(1));
+    await waitFor(() => expect(deriveCalls).toHaveLength(1));
+    await waitFor(() =>
+      expect(
+        document.querySelector(
+          '[data-resource-card-id="asset:normalized-task-art"]',
+        ),
+      ).not.toBeNull(),
+    );
+    expect(
+      document.querySelector(
+        '[data-resource-card-id="task:canvas-task:assets/generated/task-art.png"]',
+      ),
+    ).toBeNull();
+    // 失败可见：这一笔在「生成任务」侧栏里收口为失败并带上原因（面板已经关了，结果只在这里）。
+    fireEvent.click(await screen.findByRole('button', { name: '生成任务' }));
+    const taskSidebar = await screen.findByRole('region', { name: '生成任务' });
+    expect(within(taskSidebar).getByText('失败')).not.toBeNull();
+    expect(
+      within(taskSidebar).getAllByText(/result-unknown: 测试网络中断/u).length,
+    ).toBeGreaterThan(0);
+    // 草稿回到「未完成编辑」等重开。
+    fireEvent.click(
+      await screen.findByRole('button', { name: '管理未完成编辑 (1)' }),
+    );
+    expect(
+      within(
+        await screen.findByRole('dialog', { name: '未完成的资源编辑' }),
+      ).getByRole('button', { name: '继续编辑' }),
+    ).not.toBeNull();
+    fireEvent.click(
+      within(
+        screen.getByRole('dialog', { name: '未完成的资源编辑' }),
+      ).getByRole('button', { name: '关闭资源编辑恢复面板' }),
+    );
+
+    // 旧卡片已经不在画布上：草稿按**路径**归属，新投影的正式素材卡照样命中，否则这一笔
+    // 就再也点不到。
+    const reopened = await openQuickEditPanel('task-art.png');
+    expect(panelPromptText(reopened)).toContain('把夜色改成星空');
+  });
+
+  /**
+   * 旁路重投影：换卡片 id 的不是「打开中这一笔快速编辑」自己，而是 Agent / 外部编辑器把
+   * 同一路径登记成正式素材。草稿是会话内存态、面板已经收起，没有任何「跟着投影搬家」的机会，
+   * 只有键本身就是稳定身份（路径）时才不会变成查不到的孤儿草稿。
+   */
+  it('面板收起后卡片被旁路重投影：草稿仍在入口里，重开照样回填', async () => {
+    installResizeObserverStub();
+    installInvoke({
+      createManifest: createCanvasTaskArtManifest,
+      failDerive: true,
+    });
+    render(
+      React.createElement(DraftWorkbench, {
+        createManifest: createCanvasTaskArtManifest,
+        externalAssetPath: CANVAS_TASK_ART_PATH,
+      }),
+    );
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('task-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把夜色改成星空',
+    );
+    // 收起面板：这一笔草稿只留在宿主内存里，没有任何打开中的面板替它盯投影。
+    await dismissPanel();
+
+    fireEvent.click(
+      await screen.findByRole('button', { name: '外部登记素材' }),
+    );
+    await waitFor(() =>
+      expect(
+        document.querySelector(
+          '[data-resource-card-id="task:canvas-task:' +
+            CANVAS_TASK_ART_PATH +
+            '"]',
+        ),
+      ).toBeNull(),
+    );
+    expect(
+      document.querySelector('[data-resource-card-id="asset:external-art"]'),
+    ).not.toBeNull();
+
+    // 入口里那一笔还在（旧实现按投影 id 过滤，这里会整条消失）。
+    fireEvent.click(
+      await screen.findByRole('button', { name: '管理未完成编辑 (1)' }),
+    );
+    const recovery = await screen.findByRole('dialog', {
+      name: '未完成的资源编辑',
+    });
+    expect(within(recovery).getByText('task-art.png')).not.toBeNull();
+    fireEvent.click(
+      within(recovery).getByRole('button', { name: '关闭资源编辑恢复面板' }),
+    );
+
+    const reopened = await openQuickEditPanel('task-art.png');
+    expect(panelPromptText(reopened)).toContain('把夜色改成星空');
+  });
+
+  it('原生恢复队列与本地草稿共用同一枚入口，两边都能继续', async () => {
+    installResizeObserverStub();
+    installInvoke({
+      pendingResourceEdits: [
+        {
+          operationId: '99999999-9999-4999-8999-999999999999',
+          editKind: 'image',
+          sourceResourceId: 'art-resource',
+          assetName: '未完成的派生图.png',
+          phase: 'media-downloaded',
+          createdAt: 1,
+        },
+      ],
+    });
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把夜色改成星空',
+    );
+    await dismissPanel();
+
+    fireEvent.click(
+      await screen.findByRole('button', { name: '管理未完成编辑 (2)' }),
+    );
+    const recovery = await screen.findByRole('dialog', {
+      name: '未完成的资源编辑',
+    });
+    // 两边语义不同：本地草稿是「继续编辑」，原生账本是「继续原编辑」。
+    expect(
+      within(recovery).getByRole('button', { name: '继续编辑' }),
+    ).not.toBeNull();
+    expect(
+      within(recovery).getByRole('button', { name: '继续原编辑' }),
+    ).not.toBeNull();
+  });
+
+  it('提交成功后这一笔草稿作废，重开是空面板', async () => {
+    installResizeObserverStub();
+    const { deriveCalls } = installInvoke();
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把夜色改成星空',
+    );
+    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+    await waitFor(() => expect(deriveCalls).toHaveLength(1));
+    // 先证明这条草稿真的写进了出站请求，下面的「重开是空面板」才不是空断言。
+    expect(deriveCalls[0]?.prompt).toBe('把夜色改成星空');
+    await waitFor(() =>
+      expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+    );
+    // 正式的可恢复事实已经由原 operation 账本接管，本地草稿不再占着恢复入口。
+    await waitFor(() =>
+      expect(
+        screen.queryByRole('button', { name: /管理未完成编辑/u }),
+      ).toBeNull(),
+    );
+
+    const reopened = await openQuickEditPanel('source-art.png');
+    expect(panelPromptText(reopened)).not.toContain('把夜色改成星空');
+  });
+});
+
+/**
+ * 验收现场那条「点了生成，生成任务里什么都没有」：派生链路既没进生成任务侧栏，又让恢复入口
+ * 继续列着同一条草稿，用户据此判断「这次没提交」。这里钉住三件事——提交当帧就进侧栏、提交
+ * 期间那笔草稿让位、有结果之后收口为已完成。
+ */
+describe('提交中的快速编辑进「生成任务」侧栏', () => {
+  it('提交当帧进侧栏并显示阶段与提示词，结果回来后收口为已完成', async () => {
+    installResizeObserverStub();
+    let releaseDerive = () => {};
+    const deriveGate = new Promise<void>((resolve) => {
+      releaseDerive = resolve;
+    });
+    const { deriveCalls } = installInvoke({ deriveGate });
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const panel = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(panel).getByLabelText('快速编辑提示词'),
+      '把嘴改小一点',
+    );
+    fireEvent.click(within(panel).getByRole('button', { name: '修改' }));
+    await waitFor(() => expect(deriveCalls).toHaveLength(1));
+
+    // 在途计数把这一笔算进来：入口按钮带上数量，侧栏里能看到素材名、入口文案与提示词。
+    const entry = await screen.findByRole('button', { name: '生成任务' });
+    await waitFor(() =>
+      expect(entry.getAttribute('data-resource-generation-task-count')).toBe(
+        '1',
+      ),
+    );
+    fireEvent.click(entry);
+    const sidebar = await screen.findByRole('region', { name: '生成任务' });
+    expect(within(sidebar).getByText('source-art-编辑版')).not.toBeNull();
+    expect(within(sidebar).getByText('快速编辑')).not.toBeNull();
+    expect(within(sidebar).getByText('把嘴改小一点')).not.toBeNull();
+    expect(within(sidebar).getByText('生成中')).not.toBeNull();
+    expect(within(sidebar).queryByText('还没有生成任务')).toBeNull();
+
+    releaseDerive();
+    await waitFor(() =>
+      expect(within(sidebar).getByText('已完成')).not.toBeNull(),
+    );
+    expect(within(sidebar).getByText('已产出新素材')).not.toBeNull();
+  });
+
+  it('同一张素材还在提交中时换卡再回来提交：拦下且不重复派生', async () => {
+    installResizeObserverStub();
+    let releaseDerive = () => {};
+    const deriveGate = new Promise<void>((resolve) => {
+      releaseDerive = resolve;
+    });
+    const { deriveCalls } = installInvoke({ deriveGate });
+    render(React.createElement(DraftWorkbench));
+
+    await openResourceBookCategory('待归类');
+    const first = await openQuickEditPanel('source-art.png');
+    await setComposerText(
+      within(first).getByLabelText('快速编辑提示词'),
+      '把嘴改小一点',
+    );
+    fireEvent.click(within(first).getByRole('button', { name: '修改' }));
+    await waitFor(() => expect(deriveCalls).toHaveLength(1));
+
+    // 换到另一张卡：浮层互斥把第一张的面板收起来，而第一笔提交仍在后台跑。工具条这时才露出来，
+    // 所以「已经交出去的那一笔不再算未完成编辑」这条判据只能在这里验（面板开着时工具条被盖住，
+    // 在那个位置断言会变成永远为真的空断言）。
+    fireEvent.click(await findResourceSelectButton('source-art-2.png'));
+    await waitFor(() =>
+      expect(screen.queryByRole('dialog', { name: '快速编辑图片' })).toBeNull(),
+    );
+    await waitFor(() =>
+      expect(
+        screen.queryByRole('button', { name: /管理未完成编辑/u }),
+      ).toBeNull(),
+    );
+
+    // 回到第一张：草稿照旧回填，但这一笔已经在跑——再点提交必须被拦下。
+    const reopened = await openQuickEditPanel('source-art.png');
+    expect(panelPromptText(reopened)).toContain('把嘴改小一点');
+    fireEvent.click(within(reopened).getByRole('button', { name: '修改' }));
+    expect(
+      await within(reopened).findByText(
+        '这张素材正在修改中，请等它出结果后再提交',
+      ),
+    ).not.toBeNull();
+    expect(deriveCalls).toHaveLength(1);
+
+    releaseDerive();
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasQuickEditModel.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasQuickEditModel.test.ts
new file mode 100644
index 000000000..4f9c6caf8
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasQuickEditModel.test.ts
@@ -0,0 +1,207 @@
+import { describe, expect, it } from 'vitest';
+
+import type { CanvasLayer } from '../../../src/components/image-editor/ImageCanvasEditorTypes';
+import type { ChatReference } from '../src/features/project-workspace/resourceReferences';
+import {
+  createEmptyResourceQuickEditDraftStore,
+  createResourceQuickEditPanelDraft,
+  dropResourceQuickEditDraft,
+  isResourceQuickEditDraftEmpty,
+  listResourceQuickEditDraftEntries,
+  readResourceQuickEditDraft,
+  resourceQuickEditDraftPromptExcerpt,
+  restoreResourceQuickEditPanelDraft,
+  writeResourceQuickEditDraft,
+} from '../src/features/resource-canvas/resourceCanvasQuickEditModel';
+
+const SOURCE_LAYER: CanvasLayer = {
+  id: 'asset:source-art',
+  resourceId: 'asset:source-art',
+  title: 'source-art.png',
+  src: '/source-art.png',
+  x: 0,
+  y: 0,
+  width: 512,
+  height: 512,
+  originalWidth: 1024,
+  originalHeight: 1024,
+  zIndex: 1,
+  sourceType: 'upload',
+};
+
+const RULES_REFERENCE: ChatReference = {
+  type: 'resource',
+  resourceId: 'rules-resource',
+  kind: 'game-rules',
+  mediaType: 'text/markdown',
+  label: 'rules',
+  category: 'document',
+  tags: [],
+  source: 'asset-picker',
+};
+
+describe('快速编辑草稿表', () => {
+  it('提示词与引用各自上报时互相补齐，不改动原表', () => {
+    const withPrompt = writeResourceQuickEditDraft(
+      createEmptyResourceQuickEditDraftStore(),
+      { key: 'asset:source-art', prompt: '把夜色改成星空', updatedAt: 10 },
+    );
+    const withReferences = writeResourceQuickEditDraft(withPrompt, {
+      key: 'asset:source-art',
+      references: [RULES_REFERENCE],
+      updatedAt: 20,
+    });
+
+    // 只补引用那一次不能把提示词清掉，反之亦然：输入区两条状态是分别上报的。
+    expect(
+      readResourceQuickEditDraft(withReferences, 'asset:source-art'),
+    ).toEqual({
+      prompt: '把夜色改成星空',
+      references: [RULES_REFERENCE],
+      updatedAt: 20,
+    });
+    expect(readResourceQuickEditDraft(withPrompt, 'asset:source-art')).toEqual({
+      prompt: '把夜色改成星空',
+      references: [],
+      updatedAt: 10,
+    });
+    // 只读语义：写操作返回新表、源表不动；空表走工厂，每次都是独立的一张。
+    expect(withPrompt.size).toBe(1);
+    expect(createEmptyResourceQuickEditDraftStore().size).toBe(0);
+    expect(createEmptyResourceQuickEditDraftStore()).not.toBe(
+      createEmptyResourceQuickEditDraftStore(),
+    );
+  });
+
+  /**
+   * 键是资源**路径**，不是投影 id：正规化把卡片从 `task:…` 换成 `asset:…` 之后，
+   * 同一张卡的草稿必须在恢复入口里照样对得上号，否则用户刚写的提示词会静默消失。
+   */
+  it('草稿按路径归属，卡片换成 asset 投影后仍在入口里', () => {
+    const store = writeResourceQuickEditDraft(
+      createEmptyResourceQuickEditDraftStore(),
+      {
+        key: 'assets/generated/hero.png',
+        prompt: '改成红色头发',
+        references: [RULES_REFERENCE],
+        updatedAt: 10,
+      },
+    );
+    // 正规化前后是同一路径的两张卡；入口只认路径，落在哪一张上都该列出来。
+    expect(
+      listResourceQuickEditDraftEntries(store, [
+        { path: 'assets/generated/hero.png', label: 'hero.png（正式素材）' },
+      ]),
+    ).toEqual([
+      {
+        key: 'assets/generated/hero.png',
+        label: 'hero.png（正式素材）',
+        prompt: '改成红色头发',
+        updatedAt: 10,
+      },
+    ]);
+    // 资源真的不在项目里时（删掉了）才不入列表，记录本身不在这一步删。
+    expect(listResourceQuickEditDraftEntries(store, [])).toEqual([]);
+    expect(store.size).toBe(1);
+  });
+
+  it('恢复入口按最后改动时间从新到旧', () => {
+    const store = writeResourceQuickEditDraft(
+      writeResourceQuickEditDraft(createEmptyResourceQuickEditDraftStore(), {
+        key: 'assets/older.png',
+        prompt: '早写的',
+        updatedAt: 10,
+      }),
+      { key: 'assets/newer.png', prompt: '后写的', updatedAt: 30 },
+    );
+
+    expect(
+      listResourceQuickEditDraftEntries(store, [
+        { path: 'assets/older.png', label: 'older.png' },
+        { path: 'assets/newer.png', label: 'newer.png' },
+      ]).map((entry) => entry.key),
+    ).toEqual(['assets/newer.png', 'assets/older.png']);
+  });
+
+  it('提示词与引用都清空后不留条目', () => {
+    const store = writeResourceQuickEditDraft(
+      createEmptyResourceQuickEditDraftStore(),
+      {
+        key: 'asset:source-art',
+        prompt: '把夜色改成星空',
+        updatedAt: 10,
+      },
+    );
+    const cleared = writeResourceQuickEditDraft(store, {
+      key: 'asset:source-art',
+      prompt: '',
+      updatedAt: 20,
+    });
+
+    expect(
+      isResourceQuickEditDraftEmpty({ prompt: '   ', references: [] }),
+    ).toBe(true);
+    expect(
+      readResourceQuickEditDraft(cleared, 'asset:source-art'),
+    ).toBeUndefined();
+    expect(cleared.size).toBe(0);
+  });
+
+  it('丢弃只删目标键，未记录过时原样返回', () => {
+    const store = writeResourceQuickEditDraft(
+      createEmptyResourceQuickEditDraftStore(),
+      {
+        key: 'asset:a',
+        prompt: 'A 的草稿',
+        updatedAt: 10,
+      },
+    );
+    const withTwo = writeResourceQuickEditDraft(store, {
+      key: 'asset:b',
+      prompt: 'B 的草稿',
+      updatedAt: 20,
+    });
+    const dropped = dropResourceQuickEditDraft(withTwo, 'asset:a');
+
+    expect(readResourceQuickEditDraft(dropped, 'asset:a')).toBeUndefined();
+    expect(readResourceQuickEditDraft(dropped, 'asset:b')?.prompt).toBe(
+      'B 的草稿',
+    );
+    expect(dropResourceQuickEditDraft(dropped, 'asset:missing')).toBe(dropped);
+    expect(dropResourceQuickEditDraft(dropped, null)).toBe(dropped);
+    expect(readResourceQuickEditDraft(dropped, null)).toBeUndefined();
+  });
+
+  it('回填只覆盖提示词，模型与比例仍取当下默认值', () => {
+    const panelDraft = createResourceQuickEditPanelDraft(SOURCE_LAYER);
+    const restored = restoreResourceQuickEditPanelDraft(panelDraft, {
+      prompt: '把夜色改成星空',
+      references: [],
+      updatedAt: 10,
+    });
+
+    expect(restored.prompt).toBe('把夜色改成星空');
+    expect(restored.model).toBe(panelDraft.model);
+    expect(restored.aspectRatio).toBe(panelDraft.aspectRatio);
+    expect(restored.size).toBe(panelDraft.size);
+    expect(restored.status).toBe('idle');
+    // 没有草稿时面板原样返回：默认面板不该被这一步改写。
+    expect(restoreResourceQuickEditPanelDraft(panelDraft, undefined)).toBe(
+      panelDraft,
+    );
+  });
+
+  it('摘要压缩空白并按上限截断', () => {
+    expect(resourceQuickEditDraftPromptExcerpt('')).toBe('（尚未填写提示词）');
+    expect(resourceQuickEditDraftPromptExcerpt('   \n  ')).toBe(
+      '（尚未填写提示词）',
+    );
+    expect(resourceQuickEditDraftPromptExcerpt('把夜色\n改成  星空')).toBe(
+      '把夜色 改成 星空',
+    );
+    expect(resourceQuickEditDraftPromptExcerpt('一二三四五', 3)).toBe(
+      '一二三…',
+    );
+    expect(resourceQuickEditDraftPromptExcerpt('一二三', 3)).toBe('一二三');
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/resourceCanvasResourceEditTasks.test.ts b/apps/ai-game-creator-shell/tests/resourceCanvasResourceEditTasks.test.ts
new file mode 100644
index 000000000..fbd252a11
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/resourceCanvasResourceEditTasks.test.ts
@@ -0,0 +1,272 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  beginResourceCanvasResourceEditSubmission,
+  type PendingLocalProjectResourceEdit,
+  pendingResourceEditKindLabel,
+  resourceCanvasResourceEditPhaseLabel,
+  type ResourceCanvasResourceEditSubmission,
+  resourceCanvasResourceEditSubmissionBlocksResource,
+  resourceCanvasResourceEditTaskElapsedMillis,
+  resourceCanvasResourceEditTaskIsTerminal,
+  resourceCanvasResourceEditTasks,
+  resourceCanvasResourceEditTaskStatusFromPhase,
+  settleResourceCanvasResourceEditSubmission,
+} from '../src/features/resource-canvas/resourceCanvasResourceEditTaskModel';
+
+function pendingEdit(
+  overrides: Partial<PendingLocalProjectResourceEdit> = {},
+): PendingLocalProjectResourceEdit {
+  return {
+    operationId: 'op-1',
+    editKind: 'image-reference',
+    sourceResourceId: 'asset:source-art',
+    assetName: 'source-art-编辑版',
+    backgroundMode: null,
+    screenColor: null,
+    phase: 'accepted',
+    createdAt: 1_700_000_000_000,
+    ...overrides,
+  };
+}
+
+function liveSubmission(
+  overrides: Partial<ResourceCanvasResourceEditSubmission> = {},
+): ResourceCanvasResourceEditSubmission {
+  return {
+    operationId: 'op-1',
+    prompt: '把嘴改小一点',
+    assetName: 'source-art-编辑版',
+    actionLabel: '快速编辑',
+    resourcePath: 'assets/source-art.png',
+    createdAtMillis: 1_700_000_000_000,
+    status: 'running',
+    error: null,
+    assetId: null,
+    finishedAtMillis: null,
+    ...overrides,
+  };
+}
+
+describe('资源派生任务：阶段映射', () => {
+  it('按原生账本阶段给出面板状态', () => {
+    expect(resourceCanvasResourceEditTaskStatusFromPhase('prepared')).toBe(
+      'queued',
+    );
+    expect(resourceCanvasResourceEditTaskStatusFromPhase('accepted')).toBe(
+      'running',
+    );
+    expect(
+      resourceCanvasResourceEditTaskStatusFromPhase('remote-completed'),
+    ).toBe('running');
+    expect(
+      resourceCanvasResourceEditTaskStatusFromPhase('media-downloaded'),
+    ).toBe('running');
+    expect(resourceCanvasResourceEditTaskStatusFromPhase('committed')).toBe(
+      'completed',
+    );
+    expect(resourceCanvasResourceEditTaskStatusFromPhase('archived')).toBe(
+      'completed',
+    );
+    expect(resourceCanvasResourceEditTaskStatusFromPhase('remote-failed')).toBe(
+      'failed',
+    );
+    expect(
+      resourceCanvasResourceEditTaskStatusFromPhase('reconciliation-required'),
+    ).toBe('failed');
+  });
+
+  it('阶段文案与恢复入口同源，未知阶段原样透出', () => {
+    expect(resourceCanvasResourceEditPhaseLabel('remote-completed')).toBe(
+      '远程已完成',
+    );
+    expect(resourceCanvasResourceEditPhaseLabel('committed')).toBe(
+      '已写入项目',
+    );
+    // 前端还没跟上的新档：给出阶段名，便于排障时一眼认出。
+    expect(resourceCanvasResourceEditPhaseLabel('pending-review')).toBe(
+      'pending-review',
+    );
+  });
+
+  it('入口文案覆盖派生链路的几种 kind', () => {
+    expect(pendingResourceEditKindLabel(pendingEdit())).toBe('快速编辑');
+    expect(
+      pendingResourceEditKindLabel(
+        pendingEdit({ editKind: 'character-animation' }),
+      ),
+    ).toBe('生成动画');
+    expect(
+      pendingResourceEditKindLabel(
+        pendingEdit({ editKind: 'background-music' }),
+      ),
+    ).toBe('生成背景音乐');
+    expect(
+      pendingResourceEditKindLabel(
+        pendingEdit({
+          editKind: 'background-removal',
+          backgroundMode: 'flat',
+          screenColor: 'auto',
+        }),
+      ),
+    ).toBe('图片抠图 · 平面背景 · 自动背景色');
+  });
+});
+
+describe('资源派生任务：本地提交记录', () => {
+  it('同一 operationId 只留一条，收口后按结果改写', () => {
+    const begun = beginResourceCanvasResourceEditSubmission([], {
+      operationId: 'op-1',
+      assetName: 'source-art-编辑版',
+      actionLabel: '快速编辑',
+      prompt: '把嘴改小一点',
+      resourcePath: 'assets/source-art.png',
+      createdAtMillis: 1_700_000_000_000,
+    });
+    expect(begun).toHaveLength(1);
+    expect(begun[0]?.status).toBe('running');
+
+    const rebegun = beginResourceCanvasResourceEditSubmission(begun, {
+      operationId: 'op-1',
+      assetName: 'source-art-编辑版',
+      actionLabel: '快速编辑',
+      prompt: '把嘴改小一点',
+      resourcePath: 'assets/source-art.png',
+      createdAtMillis: 1_700_000_001_000,
+    });
+    expect(rebegun).toHaveLength(1);
+
+    const settled = settleResourceCanvasResourceEditSubmission(
+      rebegun,
+      'op-1',
+      {
+        status: 'completed',
+        assetId: 'edit-1',
+        finishedAtMillis: 1_700_000_120_000,
+      },
+    );
+    expect(settled[0]).toMatchObject({
+      status: 'completed',
+      assetId: 'edit-1',
+      error: null,
+    });
+  });
+
+  it('失败收口带原因，未完成草稿的提交门随之放行', () => {
+    const live = beginResourceCanvasResourceEditSubmission([], {
+      operationId: 'op-1',
+      assetName: 'source-art-编辑版',
+      actionLabel: '快速编辑',
+      prompt: '把嘴改小一点',
+      resourcePath: 'assets/source-art.png',
+      createdAtMillis: 1_700_000_000_000,
+    });
+    expect(
+      resourceCanvasResourceEditSubmissionBlocksResource(
+        live,
+        'assets/source-art.png',
+      ),
+    ).toBe(true);
+    // 别的素材不受影响，其它入口（没有草稿键）也不受这条判据牵制。
+    expect(
+      resourceCanvasResourceEditSubmissionBlocksResource(
+        live,
+        'assets/other.png',
+      ),
+    ).toBe(false);
+
+    const failed = settleResourceCanvasResourceEditSubmission(live, 'op-1', {
+      status: 'failed',
+      error: '登录已失效，请重新登录',
+      finishedAtMillis: 1_700_000_090_000,
+    });
+    expect(
+      resourceCanvasResourceEditSubmissionBlocksResource(
+        failed,
+        'assets/source-art.png',
+      ),
+    ).toBe(false);
+  });
+});
+
+describe('资源派生任务：两套账本合并', () => {
+  it('在途期间以后端阶段为准，收口后以本地结果为准', () => {
+    const submissions = [liveSubmission()];
+    const inFlight = resourceCanvasResourceEditTasks({
+      submissions,
+      pendingEdits: [pendingEdit({ phase: 'media-downloaded' })],
+    });
+    expect(inFlight).toHaveLength(1);
+    expect(inFlight[0]).toMatchObject({
+      operationId: 'op-1',
+      status: 'running',
+      phaseDetail: '结果已下载',
+      prompt: '把嘴改小一点',
+      restored: false,
+    });
+
+    const settled = resourceCanvasResourceEditTasks({
+      submissions: settleResourceCanvasResourceEditSubmission(
+        submissions,
+        'op-1',
+        {
+          status: 'completed',
+          assetId: 'edit-1',
+          finishedAtMillis: 1_700_000_120_000,
+        },
+      ),
+      pendingEdits: [],
+    });
+    expect(settled[0]).toMatchObject({
+      status: 'completed',
+      phaseDetail: '已产出新素材',
+      assetId: 'edit-1',
+    });
+    expect(resourceCanvasResourceEditTaskIsTerminal(settled[0]!)).toBe(true);
+  });
+
+  it('原生有、本地没有的记录恢复成一条待办，但不占用已完成分栏', () => {
+    const tasks = resourceCanvasResourceEditTasks({
+      submissions: [],
+      pendingEdits: [
+        pendingEdit({ operationId: 'op-9', phase: 'remote-failed' }),
+      ],
+    });
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0]).toMatchObject({
+      operationId: 'op-9',
+      status: 'failed',
+      restored: true,
+      actionLabel: '快速编辑',
+    });
+    expect(tasks[0]?.error).toContain('远程明确失败');
+    // 恢复记录没有结束时间：不拿创建时间冒充耗时。
+    expect(
+      resourceCanvasResourceEditTaskElapsedMillis(tasks[0]!, 1_700_000_500_000),
+    ).toBeNull();
+  });
+
+  it('后端读回非数组时不炸，只按本地提交记录渲染', () => {
+    const tasks = resourceCanvasResourceEditTasks({
+      submissions: [liveSubmission()],
+      pendingEdits: undefined,
+    });
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0]?.phaseDetail).toBe('已提交，等待远端受理');
+  });
+
+  it('新提交的排在前面', () => {
+    const tasks = resourceCanvasResourceEditTasks({
+      submissions: [
+        liveSubmission({
+          operationId: 'op-new',
+          createdAtMillis: 1_700_000_200_000,
+        }),
+      ],
+      pendingEdits: [
+        pendingEdit({ operationId: 'op-old', createdAt: 1_700_000_000_000 }),
+      ],
+    });
+    expect(tasks.map((task) => task.operationId)).toEqual(['op-new', 'op-old']);
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/resourceCardCurrentVersionStyle.test.ts b/apps/ai-game-creator-shell/tests/resourceCardCurrentVersionStyle.test.ts
index 892b390ce..1bc8f037d 100644
--- a/apps/ai-game-creator-shell/tests/resourceCardCurrentVersionStyle.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceCardCurrentVersionStyle.test.ts
@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { describe, expect, it } from 'vitest';
 
+import { repoPath } from './repoPath';
+
 /**
  * 「当前使用」资源卡的发光档案：声明级断言。
  *
@@ -12,7 +13,7 @@ import { describe, expect, it } from 'vitest';
  */
 function stylesSource() {
   return readFileSync(
-    resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+    repoPath('apps/ai-game-creator-shell/src/styles.css'),
     'utf8',
   );
 }
diff --git a/apps/ai-game-creator-shell/tests/resourceCardPreviewAlphaBackground.test.tsx b/apps/ai-game-creator-shell/tests/resourceCardPreviewAlphaBackground.test.tsx
index b611522f5..6a2f1122d 100644
--- a/apps/ai-game-creator-shell/tests/resourceCardPreviewAlphaBackground.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceCardPreviewAlphaBackground.test.tsx
@@ -32,11 +32,11 @@ import {
   React,
   readFileSync,
   render,
-  resolve,
   screen,
   vi,
   waitFor,
 } from './appSurface/harness';
+import { repoPath } from './repoPath';
 import {
   declaration,
   parseStyleSheet,
@@ -294,10 +294,7 @@ function cardFor(label: string) {
  */
 function visualDeclarationsForCard(card: HTMLElement) {
   const rules = parseStyleSheet(
-    readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
-      'utf8',
-    ),
+    readFileSync(repoPath('apps/ai-game-creator-shell/src/styles.css'), 'utf8'),
   );
   const kind = card.getAttribute('data-preview-kind');
   const hasAlpha = card.getAttribute('data-preview-has-alpha');
@@ -381,7 +378,7 @@ describe('资源卡棋盘格底按真实 alpha 决定', () => {
   it('透明图自身不被填底色：没有任何规则给 .game-resource-card-visual > img 声明背景', () => {
     const rules = parseStyleSheet(
       readFileSync(
-        resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+        repoPath('apps/ai-game-creator-shell/src/styles.css'),
         'utf8',
       ),
     );
@@ -409,7 +406,7 @@ describe('资源卡棋盘格底按真实 alpha 决定', () => {
     // 这条用例必须同步改成「有判据才铺」。
     const rules = parseStyleSheet(
       readFileSync(
-        resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+        repoPath('apps/ai-game-creator-shell/src/styles.css'),
         'utf8',
       ),
     );
diff --git a/apps/ai-game-creator-shell/tests/resourceClassificationPanel.test.tsx b/apps/ai-game-creator-shell/tests/resourceClassificationPanel.test.tsx
index eb8aa048c..6a1786ec8 100644
--- a/apps/ai-game-creator-shell/tests/resourceClassificationPanel.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceClassificationPanel.test.tsx
@@ -1,6 +1,5 @@
 // @vitest-environment jsdom
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import {
   cleanup,
@@ -15,6 +14,7 @@ import { afterEach, describe, expect, test, vi } from 'vitest';
 
 import type { GameCreationAppAssetManifestEntry } from '../../../packages/shared/src/contracts/gameCreationApp';
 import { ResourceClassificationPanel } from '../src/view/project-development/ResourceClassificationPanel';
+import { repoPath } from './repoPath';
 import {
   declaration,
   parseStyleSheet,
@@ -431,8 +431,7 @@ describe('ResourceClassificationPanel 编辑素材标签', () => {
 
   test('资源卡工具条入口 label 与面板标题一致，不再是「分类与标签」', () => {
     const viewSource = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/view/project-development/index.tsx',
       ),
       'utf8',
@@ -452,8 +451,7 @@ describe('ResourceClassificationPanel 编辑素材标签', () => {
 
   test('标签 pill 的删除按钮热区不小于 32px', () => {
     const panelStyles = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/features/project-workspace/resourceClassificationTagPanel.css',
       ),
       'utf8',
@@ -606,7 +604,7 @@ describe('ResourceClassificationPanel 不再承载删除素材', () => {
    */
   test('底部只有一个「添加」并靠右下角', () => {
     const styles = readFileSync(
-      resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+      repoPath('apps/ai-game-creator-shell/src/styles.css'),
       'utf8',
     );
     const rule = styles.match(
@@ -641,7 +639,7 @@ describe('ResourceClassificationPanel 不再承载删除素材', () => {
  */
 describe('ResourceClassificationPanel 标签区可滚动', () => {
   const styles = readFileSync(
-    resolve(process.cwd(), 'apps/ai-game-creator-shell/src/styles.css'),
+    repoPath('apps/ai-game-creator-shell/src/styles.css'),
     'utf8',
   );
   const rules = parseStyleSheet(styles);
diff --git a/apps/ai-game-creator-shell/tests/resourceEditModel.test.ts b/apps/ai-game-creator-shell/tests/resourceEditModel.test.ts
index 6dc8bfb85..bffdf31a9 100644
--- a/apps/ai-game-creator-shell/tests/resourceEditModel.test.ts
+++ b/apps/ai-game-creator-shell/tests/resourceEditModel.test.ts
@@ -1,10 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
 import { describe, expect, it } from 'vitest';
 
 import {
   canonicalProjectedResourceMediaType,
+  defaultCharacterAnimationResourceName,
+  defaultDerivedResourceName,
+  DERIVED_RESOURCE_NAME_SUFFIXES,
+  resolveDerivedResourceNameCheck,
   resolveProjectCharacterAnimationCapability,
   resolveProjectResourceEditCapability,
+  resolveResourceEditNameCheck,
   resolveResourceEditRequestIdentity,
+  RESOURCE_EDIT_NAME_INVALID_NOTICE,
+  RESOURCE_EDIT_NAME_MAX_LENGTH,
   RESOURCE_EDIT_PROMPT_TRUNCATED_NOTICE,
   resourceEditPromptMaxLength,
   truncateResourceEditPrompt,
@@ -280,3 +290,217 @@ describe('全类型资源编辑能力模型', () => {
     ).toBeNull();
   });
 });
+
+/**
+ * Rust 源码路径按**本文件位置**解析，不按仓库根 cwd 解析：这个用例是跨语言对表，
+ * 从别的工作目录单跑这一个文件时 `ENOENT` 会把「两边分叉」误报成一次环境问题。
+ */
+const RUST_RESOURCE_EDITOR_PATH = fileURLToPath(
+  new URL('../src-tauri/src/project/resource_editor.rs', import.meta.url),
+);
+
+/**
+ * Rust `normalize_resource_edit_name` 的函数体原文。
+ *
+ * 派生资源名的门禁在 Rust 侧，前端这份只是镜像；一旦两边数字或文案分叉，用户就会先看到
+ * 一句「提交前拦下」的话、再被后端换成另一句话，所以这里直接拿源码对表。
+ */
+function rustResourceEditNameNormalizer() {
+  const source = readFileSync(RUST_RESOURCE_EDITOR_PATH, 'utf8');
+  const start = source.indexOf('fn normalize_resource_edit_name(');
+  expect(start).toBeGreaterThan(-1);
+  const body = source.slice(start, source.indexOf('\n}\n', start));
+  expect(body.length).toBeGreaterThan(0);
+  return body;
+}
+
+/** 只换 label 的 Agent 回执资源：AGC 侧 label 直接取任务标题，是最容易触发名称门禁的一类。 */
+function labelResource(label: string) {
+  return resource({
+    id: 'agent-result:design:message-1',
+    category: 'document',
+    path: '专业 Agent 文本回执',
+    subtype: 'agent-result',
+    producerTaskId: null,
+    content: '回执',
+    label,
+  });
+}
+
+/** 默认名函数与 kind 的对应关系，供「默认名 == 检查名」的断言复用。 */
+function defaultDerivedNameFor(
+  target: ProjectResource,
+  kind: 'edit' | 'character-animation',
+) {
+  return kind === 'edit'
+    ? defaultDerivedResourceName(target)
+    : defaultCharacterAnimationResourceName(target);
+}
+
+describe('派生资源名称：提交前镜像 Rust 的 1..=120 与禁止控制字符', () => {
+  /**
+   * Rust 是权威：`value.trim()` → 非空 → `chars().count() > 120` → `char::is_control`，
+   * 任一不满足就 `Err`，并且**不截断**（没有 `truncate` / `chars().take(...)`）。
+   * 前端镜像必须逐条对齐，包括「宁可按原话拒绝、也不截成可能重名的名字」这条口径。
+   */
+  it('上限与提示文案逐字取自 Rust 的 normalize_resource_edit_name', () => {
+    const body = rustResourceEditNameNormalizer();
+
+    expect(body).toMatch(/\bvalue\.trim\(\)/u);
+    expect(body).toMatch(/value\.is_empty\(\)/u);
+    expect(body).toMatch(/char::is_control/u);
+    expect(body).toMatch(/return Err\(/u);
+    expect(body).not.toMatch(/truncate|\.take\(/u);
+
+    const limit = /chars\(\)\.count\(\)\s*>\s*(\d+)/u.exec(body);
+    expect(limit?.[1]).toBe(String(RESOURCE_EDIT_NAME_MAX_LENGTH));
+
+    const notice = /"([^"]*派生资源名称[^"]*)"/u.exec(body);
+    expect(notice?.[1]).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+  });
+
+  it('恰好 120 码点放行，多一个字就按 Rust 原话拦住且不截断', () => {
+    const exactlyLimit = '字'.repeat(RESOURCE_EDIT_NAME_MAX_LENGTH);
+    expect(resolveResourceEditNameCheck(exactlyLimit)).toEqual({
+      name: exactlyLimit,
+      error: null,
+    });
+
+    const overLimit = `${exactlyLimit}多`;
+    const overCheck = resolveResourceEditNameCheck(overLimit);
+    expect(overCheck.error).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+    // 提示里报的长度上限必须是拦下它的那个数字，且原样返回（不返回截断名）。
+    expect(RESOURCE_EDIT_NAME_INVALID_NOTICE).toContain(
+      `1..=${RESOURCE_EDIT_NAME_MAX_LENGTH}`,
+    );
+    expect(overCheck.name).toBe(overLimit);
+  });
+
+  it('先 trim 再判空：首尾空白不算违规，只有空白则拦下', () => {
+    expect(resolveResourceEditNameCheck('  小猫咪-编辑版  ')).toEqual({
+      name: '小猫咪-编辑版',
+      error: null,
+    });
+    expect(resolveResourceEditNameCheck('').error).toBe(
+      RESOURCE_EDIT_NAME_INVALID_NOTICE,
+    );
+    expect(resolveResourceEditNameCheck('   ').error).toBe(
+      RESOURCE_EDIT_NAME_INVALID_NOTICE,
+    );
+    expect(resolveResourceEditNameCheck('\n\t').error).toBe(
+      RESOURCE_EDIT_NAME_INVALID_NOTICE,
+    );
+  });
+
+  it('拒绝 Cc 控制字符（含内嵌换行 / 制表符），但放行 Rust 也放行的 Cf 格式符', () => {
+    for (const control of ['\u0000', '\u0007', '\u001f', '\u007f', '\u009f']) {
+      expect(
+        resolveResourceEditNameCheck(`角色${control}形象-编辑版`).error,
+        `U+${control.codePointAt(0)!.toString(16)}`,
+      ).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+    }
+    // 任务标题里的换行是真实成因：label 直接取任务标题，内嵌换行原样传下来。
+    for (const embedded of ['\n', '\r', '\t']) {
+      expect(
+        resolveResourceEditNameCheck(`生成角色${embedded}正面形象-编辑版`)
+          .error,
+      ).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+    }
+    // 首尾换行被 trim 掉，Rust 同样放行——不能在这里多收窄一条客户端自有规则。
+    expect(
+      resolveResourceEditNameCheck('\n角色形象-编辑版\n').error,
+    ).toBeNull();
+    expect(
+      resolveResourceEditNameCheck('角色形象\u200b-编辑版').error,
+    ).toBeNull();
+  });
+
+  it('按码点计长（chars().count() 口径），不按 UTF-16 长度误判', () => {
+    const emojiLimit = '😀'.repeat(RESOURCE_EDIT_NAME_MAX_LENGTH);
+    // UTF-16 长度是 240，码点数是 120：Rust 接受，前端不许拦。
+    expect(emojiLimit.length).toBe(RESOURCE_EDIT_NAME_MAX_LENGTH * 2);
+    expect(resolveResourceEditNameCheck(emojiLimit).error).toBeNull();
+    expect(
+      resolveResourceEditNameCheck(
+        `${'字'.repeat(RESOURCE_EDIT_NAME_MAX_LENGTH - 5)}${'😀'.repeat(5)}`,
+      ).error,
+    ).toBeNull();
+    expect(resolveResourceEditNameCheck(`${emojiLimit}😀`).error).toBe(
+      RESOURCE_EDIT_NAME_INVALID_NOTICE,
+    );
+  });
+
+  it('编辑版与角色动画共用同一张后缀表，默认名与检查名逐个相等', () => {
+    expect(DERIVED_RESOURCE_NAME_SUFFIXES).toEqual({
+      edit: '-编辑版',
+      'character-animation': '-角色动画',
+    });
+    const hero = resource({
+      id: 'asset:hero',
+      category: 'unclassified',
+      path: 'assets/hero.png',
+      label: 'hero.png',
+      mediaType: 'image/png',
+      manifestAssetId: 'hero',
+    });
+    expect(resolveDerivedResourceNameCheck(hero, 'edit')).toEqual({
+      name: 'hero-编辑版',
+      error: null,
+    });
+    expect(
+      resolveDerivedResourceNameCheck(hero, 'character-animation'),
+    ).toEqual({ name: 'hero-角色动画', error: null });
+    // 默认名与检查名是同一份拼接结果，调用方不必各自拼一遍。
+    expect(defaultDerivedResourceName(hero)).toBe('hero-编辑版');
+    expect(defaultCharacterAnimationResourceName(hero)).toBe('hero-角色动画');
+    // 去扩展名 + 空基名兜底的口径不变。
+    expect(defaultDerivedResourceName(labelResource('.png'))).toBe(
+      '资源-编辑版',
+    );
+    expect(defaultDerivedResourceName(labelResource('theme.mp3'))).toBe(
+      'theme-编辑版',
+    );
+  });
+
+  /**
+   * 两个后缀都要处理：快速编辑的「-编辑版」和角色动画的「-角色动画」是同一个源名的两种
+   * 派生。后缀只多 4~5 个字，所以超限的源名在两条路径上都必须被拦下，而不是只拦一条。
+   */
+  it('超长源名在编辑版与角色动画两条路径上都被拦下，不截成可能重名的名字', () => {
+    const base = '生成角色正面半身战斗姿态设定稿'.repeat(8);
+    const first = labelResource(`${base}A.png`);
+    const second = labelResource(`${base}B.png`);
+
+    for (const kind of ['edit', 'character-animation'] as const) {
+      const firstCheck = resolveDerivedResourceNameCheck(first, kind);
+      const secondCheck = resolveDerivedResourceNameCheck(second, kind);
+      expect(firstCheck.error).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+      expect(secondCheck.error).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+      // 不截断：检查结果仍是原样的长名（否则两个同前缀的长名会被截成同一个可用名字）。
+      expect([...firstCheck.name].length).toBeGreaterThan(
+        RESOURCE_EDIT_NAME_MAX_LENGTH,
+      );
+      expect(firstCheck.name).not.toBe(secondCheck.name);
+      expect(firstCheck.name).toBe(defaultDerivedNameFor(first, kind));
+    }
+  });
+
+  /**
+   * 真实成因：`agent-result` 资源的 label 直接取任务标题（`resourceProjectionModel`），
+   * 用户写的长标题或带换行的标题会原样进入派生名。
+   */
+  it('任务标题型源名（超长 / 带换行）在派生前就给出同一句中文提示', () => {
+    const longTitle = `${'把主角改成夜行侠并加上战斗姿态'.repeat(9)}.png`;
+    expect(
+      resolveDerivedResourceNameCheck(labelResource(longTitle), 'edit').error,
+    ).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+
+    const multilineTitle = '生成角色\n正面形象.png';
+    expect(
+      resolveDerivedResourceNameCheck(
+        labelResource(multilineTitle),
+        'character-animation',
+      ).error,
+    ).toBe(RESOURCE_EDIT_NAME_INVALID_NOTICE);
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/resourcePromptPolishSlot.test.tsx b/apps/ai-game-creator-shell/tests/resourcePromptPolishSlot.test.tsx
new file mode 100644
index 000000000..099703bc2
--- /dev/null
+++ b/apps/ai-game-creator-shell/tests/resourcePromptPolishSlot.test.tsx
@@ -0,0 +1,130 @@
+// @vitest-environment jsdom
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from '@testing-library/react';
+import { useState } from 'react';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+
+import { ResourcePromptPolishSlot } from '../src/features/resource-canvas/ResourcePromptPolishSlot';
+
+type TauriInvoke = (
+  command: string,
+  args?: Record<string, unknown>,
+) => Promise<unknown>;
+
+/**
+ * 平台侧润色的桩：`ResourcePromptPolishSlot` 走 `usePromptPolish` 的默认实现
+ * （`polish_local_project_prompt`），所以这里和生成素材面板的既有用例一样，
+ * 用 `window.__TAURI__` 打桩，不碰真实 Provider。
+ */
+function installPolishInvoke(result: string) {
+  const invoke = vi.fn(async (command: string) => {
+    if (command !== 'polish_local_project_prompt') {
+      throw new Error(`unexpected invoke ${command}`);
+    }
+    return result;
+  });
+  (
+    window as unknown as { __TAURI__?: { core?: { invoke: TauriInvoke } } }
+  ).__TAURI__ = { core: { invoke } };
+  return invoke;
+}
+
+afterEach(() => {
+  cleanup();
+  delete (window as unknown as { __TAURI__?: unknown }).__TAURI__;
+});
+
+/**
+ * 宿主侧的最小接线：slot 本身是受控的，提示词文本存在宿主里
+ * （与 AGC 快速编辑面板 / 生成素材弹窗同一形状），`output` 只是把宿主状态显示出来。
+ */
+function PolishSlotHarness({ prompt }: { prompt: string }) {
+  const [text, setText] = useState(prompt);
+  return (
+    <>
+      <ResourcePromptPolishSlot
+        subject="图片素材的快速编辑提示词"
+        editKind="image-reference"
+        prompt={text}
+        applyPrompt={setText}
+      />
+      {/* 刻意用 span：`<output>` 自带 status 角色，会和 slot 的状态行撞名。 */}
+      <span aria-label="宿主提示词">{text}</span>
+      {/* 宿主输入框里的手改：与 AGC 面板里改提示词同一条路径（改的是宿主状态）。 */}
+      <button type="button" onClick={() => setText('把角色头发改成蓝色')}>
+        模拟用户手改
+      </button>
+    </>
+  );
+}
+
+describe('ResourcePromptPolishSlot', () => {
+  test('回包与原文相同：状态行说清「未做修改」，也不给「恢复原文」假入口', async () => {
+    const invoke = installPolishInvoke('把角色头发改成红色');
+    render(<PolishSlotHarness prompt="把角色头发改成红色" />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'AI 润色' }));
+
+    // 验收项 AGC-004 的用户可见面：必须有一条说得清的反馈，而不是静默什么都不发生。
+    await waitFor(() =>
+      expect(screen.getByRole('status').textContent).toBe(
+        'AI 润色结果与原文相同，未做修改',
+      ),
+    );
+    expect(invoke).toHaveBeenCalledWith('polish_local_project_prompt', {
+      prompt: '把角色头发改成红色',
+      context: expect.stringContaining('图片素材的快速编辑提示词'),
+    });
+    // 文本没变，也就没有可回退的变化：不渲染「恢复原文」。
+    expect(screen.getByLabelText('宿主提示词').textContent).toBe(
+      '把角色头发改成红色',
+    );
+    expect(screen.queryByRole('button', { name: '恢复原文' })).toBeNull();
+  });
+
+  test('用户接着手改提示词：上一轮的提示收起，宿主文本就是用户写的那份', async () => {
+    installPolishInvoke('把角色头发改成红色');
+    render(<PolishSlotHarness prompt="把角色头发改成红色" />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'AI 润色' }));
+    await waitFor(() =>
+      expect(screen.getByRole('status').textContent).toBe(
+        'AI 润色结果与原文相同，未做修改',
+      ),
+    );
+
+    // 宿主文本被用户改写：上一轮「与原文相同」的结论不再描述当前这段话，提示收起，
+    // 免得用户把上一轮的结论当成对现在这段文本的判断。
+    fireEvent.click(screen.getByRole('button', { name: '模拟用户手改' }));
+
+    await waitFor(() => expect(screen.queryByRole('status')).toBeNull());
+    expect(screen.getByLabelText('宿主提示词').textContent).toBe(
+      '把角色头发改成蓝色',
+    );
+  });
+
+  test('回包不同：「恢复原文」把原输入回填给宿主，并收起自己与提示', async () => {
+    installPolishInvoke('把角色头发设定改为亮红色');
+    render(<PolishSlotHarness prompt="把角色头发改成红色" />);
+
+    fireEvent.click(screen.getByRole('button', { name: 'AI 润色' }));
+    const restore = await screen.findByRole('button', { name: '恢复原文' });
+    expect(screen.getByLabelText('宿主提示词').textContent).toBe(
+      '把角色头发设定改为亮红色',
+    );
+
+    fireEvent.click(restore);
+
+    // 验收项 AGC-005 的动作面：恢复原文 = 回填最初原文，快照被消费掉，按钮与提示一起收干净。
+    expect(screen.getByLabelText('宿主提示词').textContent).toBe(
+      '把角色头发改成红色',
+    );
+    expect(screen.queryByRole('button', { name: '恢复原文' })).toBeNull();
+    expect(screen.queryByRole('status')).toBeNull();
+  });
+});
diff --git a/apps/ai-game-creator-shell/tests/resourceTypePanel.test.tsx b/apps/ai-game-creator-shell/tests/resourceTypePanel.test.tsx
index 434cbedde..bcaf34569 100644
--- a/apps/ai-game-creator-shell/tests/resourceTypePanel.test.tsx
+++ b/apps/ai-game-creator-shell/tests/resourceTypePanel.test.tsx
@@ -1,6 +1,5 @@
 // @vitest-environment jsdom
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import {
   cleanup,
@@ -14,6 +13,7 @@ import { afterEach, describe, expect, test, vi } from 'vitest';
 
 import type { GameCreationAppAssetManifestEntry } from '../../../packages/shared/src/contracts/gameCreationApp';
 import { ResourceTypePanel } from '../src/view/project-development/ResourceTypePanel';
+import { repoPath } from './repoPath';
 import {
   declaration,
   parseStyleSheet,
@@ -106,8 +106,7 @@ function optionsList() {
 function panelStyleSheet() {
   return parseStyleSheet(
     readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/features/project-workspace/resourceTypePanel.css',
       ),
       'utf8',
@@ -279,8 +278,7 @@ describe('ResourceTypePanel 设置素材类型', () => {
     expect(declaration(idle, 'background')).toBe('rgb(255 255 255 / 62%)');
 
     const source = readFileSync(
-      resolve(
-        process.cwd(),
+      repoPath(
         'apps/ai-game-creator-shell/src/features/project-workspace/resourceTypePanel.css',
       ),
       'utf8',
diff --git a/apps/ai-game-creator-shell/tests/sessionPreview.test.ts b/apps/ai-game-creator-shell/tests/sessionPreview.test.ts
index 0f7fc58a0..872fb48d1 100644
--- a/apps/ai-game-creator-shell/tests/sessionPreview.test.ts
+++ b/apps/ai-game-creator-shell/tests/sessionPreview.test.ts
@@ -1,10 +1,10 @@
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { describe, expect, it, vi } from 'vitest';
 
 import type { GameCreationAppPreviewState } from '../../../packages/shared/src/contracts/gameCreationApp';
 import { resolveSessionPreviewOnProjectOpen } from '../src/features/app-shell/sessionPreview';
+import { repoPath } from './repoPath';
 
 const projectPath = '/tmp/session-preview-project';
 
@@ -172,14 +172,11 @@ describe('进入项目时的预览活体核验', () => {
 
 describe('本地预览记录的生命周期（Rust 侧结构性守卫）', () => {
   const mainSource = readFileSync(
-    resolve(process.cwd(), 'apps/ai-game-creator-shell/src-tauri/src/main.rs'),
+    repoPath('apps/ai-game-creator-shell/src-tauri/src/main.rs'),
     'utf8',
   );
   const previewSource = readFileSync(
-    resolve(
-      process.cwd(),
-      'apps/ai-game-creator-shell/src-tauri/src/preview.rs',
-    ),
+    repoPath('apps/ai-game-creator-shell/src-tauri/src/preview.rs'),
     'utf8',
   );
 
diff --git a/apps/ai-game-creator-shell/tests/usePromptPolish.test.tsx b/apps/ai-game-creator-shell/tests/usePromptPolish.test.tsx
index b95439f51..e0c97e61f 100644
--- a/apps/ai-game-creator-shell/tests/usePromptPolish.test.tsx
+++ b/apps/ai-game-creator-shell/tests/usePromptPolish.test.tsx
@@ -2,7 +2,10 @@
 import { act, cleanup, renderHook } from '@testing-library/react';
 import { afterEach, describe, expect, test, vi } from 'vitest';
 
-import { usePromptPolish } from '../src/features/project-workspace/usePromptPolish';
+import {
+  PROMPT_POLISH_UNCHANGED_NOTICE,
+  usePromptPolish,
+} from '../src/features/project-workspace/usePromptPolish';
 
 afterEach(cleanup);
 
@@ -10,6 +13,7 @@ function renderPolish({
   requestPolish,
   applyPrompt = vi.fn(),
   normalizeResult,
+  readPrompt = () => '原始需求',
 }: {
   requestPolish: (
     prompt: string,
@@ -20,10 +24,11 @@ function renderPolish({
     text: string;
     notice?: string | null;
   };
+  readPrompt?: () => string;
 }) {
   return renderHook(() =>
     usePromptPolish({
-      readPrompt: () => '原始需求',
+      readPrompt,
       applyPrompt,
       requestPolish,
       normalizeResult,
@@ -126,4 +131,120 @@ describe('usePromptPolish', () => {
     expect(applyPrompt).toHaveBeenCalledWith('润色后的需求');
     expect(result.current.originalText).toBe('原始需求');
   });
+
+  test('成功回包与当前 prompt 逐字相同：给「未做修改」提示，不落快照也不回填', async () => {
+    const applyPrompt = vi.fn();
+    const { result } = renderPolish({
+      requestPolish: async () => '原始需求',
+      applyPrompt,
+    });
+
+    let returned: string | null = null;
+    await act(async () => {
+      returned = await result.current.polish();
+    });
+
+    // 验收项 AGC-004：润色结果就是原文时必须说得清，不能让用户以为按钮没反应、
+    // 或者以为文案已经被改过。
+    expect(returned).toBe('原始需求');
+    expect(result.current.notice).toBe(PROMPT_POLISH_UNCHANGED_NOTICE);
+    expect(result.current.notice).toBe('AI 润色结果与原文相同，未做修改');
+    expect(result.current.error).toBeNull();
+    expect(result.current.polishing).toBe(false);
+    // 没有可回退的变化 ⇒ 不落原文快照，宿主也就不会渲染「恢复原文」这个假入口。
+    expect(result.current.originalText).toBeNull();
+    // 不回填：宿主侧的回填还牵着「提示词变了就重铸请求身份」这类副作用，这次什么都没变。
+    expect(applyPrompt).not.toHaveBeenCalled();
+  });
+
+  test('回包被上限截回原文：算「与原文相同」，提示改说截断原因', async () => {
+    const applyPrompt = vi.fn();
+    const { result } = renderPolish({
+      // 原文正好顶到长度上限、模型又在原文后面追加了内容：切片后与原文逐字相同。
+      requestPolish: async () => '原始需求加上很长很长的尾巴',
+      applyPrompt,
+      normalizeResult: () => ({ text: '原始需求', notice: '已按长度上限截断' }),
+    });
+
+    await act(async () => {
+      await result.current.polish();
+    });
+
+    // 判据是「最终要写回宿主的文本」而不是回包字符串：写回去一字未变，就没有可回退的变化，
+    // 不该为它落快照、渲染一枚点了等于没点的「恢复原文」；截断提示优先，说清这次为什么没变。
+    expect(result.current.notice).toBe('已按长度上限截断');
+    expect(result.current.notice).not.toBe(PROMPT_POLISH_UNCHANGED_NOTICE);
+    expect(applyPrompt).not.toHaveBeenCalled();
+    expect(result.current.originalText).toBeNull();
+  });
+
+  test('规范化确实改动了内容：照旧回填并给规范化提示（对照）', async () => {
+    const applyPrompt = vi.fn();
+    const { result } = renderPolish({
+      requestPolish: async () => '润色后的需求加上要被截掉的尾巴',
+      applyPrompt,
+      normalizeResult: () => ({
+        text: '润色后的需求',
+        notice: '已按长度上限截断',
+      }),
+    });
+
+    await act(async () => {
+      await result.current.polish();
+    });
+
+    expect(result.current.notice).toBe('已按长度上限截断');
+    expect(applyPrompt).toHaveBeenCalledWith('润色后的需求');
+    expect(result.current.originalText).toBe('原始需求');
+  });
+
+  test('clearNotice 收掉上一轮提示，快照与错误不受影响', async () => {
+    const { result } = renderPolish({
+      requestPolish: async () => '润色后的需求',
+    });
+
+    await act(async () => {
+      await result.current.polish();
+    });
+    expect(result.current.originalText).toBe('原始需求');
+
+    await act(async () => {
+      result.current.clearNotice();
+    });
+
+    // 用户手改提示词只作废「上一轮的结论」，不该顺手把「恢复原文」也取消掉。
+    expect(result.current.notice).toBeNull();
+    expect(result.current.originalText).toBe('原始需求');
+  });
+
+  test('先真润色再遇到「回包等于原文」：提示互不覆盖，快照与恢复入口都留着', async () => {
+    let current = '原始需求';
+    const applied: string[] = [];
+    // 第二次回包等于第一次回填后的当前文本。
+    const results = ['润色后的需求', '润色后的需求'];
+    const { result } = renderHook(() =>
+      usePromptPolish({
+        readPrompt: () => current,
+        applyPrompt: (text) => {
+          current = text;
+          applied.push(text);
+        },
+        requestPolish: async () => results.shift() ?? null,
+      }),
+    );
+
+    await act(async () => {
+      await result.current.polish();
+    });
+    expect(applied).toEqual(['润色后的需求']);
+    expect(result.current.originalText).toBe('原始需求');
+
+    // 第二次回包就是当前文本：只换提示，宿主状态与原文快照都不动。
+    await act(async () => {
+      await result.current.polish();
+    });
+    expect(result.current.notice).toBe('AI 润色结果与原文相同，未做修改');
+    expect(result.current.originalText).toBe('原始需求');
+    expect(applied).toEqual(['润色后的需求']);
+  });
 });
diff --git a/apps/ai-game-creator-shell/tests/workbenchThemeContrast.test.ts b/apps/ai-game-creator-shell/tests/workbenchThemeContrast.test.ts
index 8968364ec..c54b50f16 100644
--- a/apps/ai-game-creator-shell/tests/workbenchThemeContrast.test.ts
+++ b/apps/ai-game-creator-shell/tests/workbenchThemeContrast.test.ts
@@ -1,11 +1,12 @@
 import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
 
 import { describe, expect, it } from 'vitest';
 
+import { repoPath } from './repoPath';
+
 type Rgba = readonly [number, number, number, number];
 
-const themePath = resolve(process.cwd(), 'packages/shared/src/theme.css');
+const themePath = repoPath('packages/shared/src/theme.css');
 
 function getCssBlock(source: string, selector: string) {
   const selectorIndex = source.indexOf(selector);
diff --git a/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md b/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
index b1b20981e..d23c50d12 100644
--- a/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
+++ b/docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md
@@ -1,6 +1,6 @@
 # AI 游戏创作项目开发工作台 PRD
 
-更新时间：`2026-09-20`（同步功能画布图片类生成后台化的当前事实，以及 2026-09-20 音频生成并入同一条后台任务账本：入口 IPC 为 `start_local_project_asset_generation` + 项目内任务账本 + 本地排队 + 非模态「生成任务」面板，见 §3.10 / §7.9；2026-09-13 新增的功能画布底部工具栏入口矩阵 §3.10 / §7.9，以及右侧 Supervisor 对话气泡、可访问对比度与过程卡布局收口，资源卡预览、分区布局、非破坏性资源编辑、资源替换与 Godot 双根合同保持不变）
+更新时间：`2026-09-21`（2026-09-20 音频生成并入图片类那份后台任务账本、派生/修改类任务并入同一「生成任务」侧栏，2026-09-21 卡片浮层改为「提交即关」，见 §3.10 / §7.9；2026-09-14 图片类生成后台化：入口 IPC 为 `start_local_project_asset_generation` + 项目内任务账本 + 本地排队 + 非模态「生成任务」面板；2026-09-13 新增的功能画布底部工具栏入口矩阵 §3.10 / §7.9，以及右侧 Supervisor 对话气泡、可访问对比度与过程卡布局收口，资源卡预览、分区布局、非破坏性资源编辑、资源替换与 Godot 双根合同保持不变）
 
 ## 1. 产品定位
 
@@ -153,13 +153,13 @@
 
 实现状态（2026-09-13；2026-09-14 图片类生成后台化：提交即返回 + 项目内任务账本 + 本地排队 + 非模态「生成任务」面板；2026-09-20 音频生成并入同一条后台任务账本）：功能画布 = 资源栏目页（`resourceBookState.view === 'child'`）。栏目页左下角的底部工具栏按 manifest 资产的**功能分类** `category` 分流，矩阵由用户 2026-09-13 拍板，工具项顺序即下表顺序（最右一项为「上传」）。
 
-| 栏目 | 工具栏里的生成入口 |
-| --- | --- |
-| UI 与交互 `ui-interaction` | 生成图片 ｜ 生成规范（二级：图标规范 / 自定义规范）｜ 生成图标素材 ｜ 生成 UI 设计图 ｜ 上传 |
-| 角色与对象 `character` | 生成图片 ｜ 生成规范（二级：角色规范 / 自定义规范）｜ 生成角色形象 ｜ 上传 |
-| 场景与环境 `scene` | 生成图片 ｜ 生成规范（二级：自定义规范）｜ 上传 |
-| 音频 `audio` | 生成背景音乐 ｜ 生成音效 ｜ 上传 |
-| 文档 `document`、待归类 `unclassified`、项目版本 `version`、「所有资源」展开态、资源总览 | **不渲染工具栏** |
+| 栏目                                                                                     | 工具栏里的生成入口                                                                           |
+| ---------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| UI 与交互 `ui-interaction`                                                               | 生成图片 ｜ 生成规范（二级：图标规范 / 自定义规范）｜ 生成图标素材 ｜ 生成 UI 设计图 ｜ 上传 |
+| 角色与对象 `character`                                                                   | 生成图片 ｜ 生成规范（二级：角色规范 / 自定义规范）｜ 生成角色形象 ｜ 上传                   |
+| 场景与环境 `scene`                                                                       | 生成图片 ｜ 生成规范（二级：自定义规范）｜ 上传                                              |
+| 音频 `audio`                                                                             | 生成背景音乐 ｜ 生成音效 ｜ 上传                                                             |
+| 文档 `document`、待归类 `unclassified`、项目版本 `version`、「所有资源」展开态、资源总览 | **不渲染工具栏**                                                                             |
 
 - 位置与层级：画布左下角（`left: 14px; bottom: 14px; z-index: 40`）。右下角是既有的缩放 / 撤销 Dock（`right: 14px; bottom: 14px`），左下角是画布上唯一两者都不占的稳定空位。工具栏是管理区 `.game-resource-book-manager` 的**直接子节点**、与画本场景并列，不进带 `scale()` 的场景层；二级菜单与「入口不可用原因」都贴着工具栏上沿弹出，不做内嵌内容。
 - 外壳用共享 chrome（`packages/image-canvas-react` 的 `CanvasToolbar / CanvasToolbarGroup / CanvasChromeButton`），样式落在 AGC 的 `resourceCanvasChrome.css`；共享包只承接通用表现，不含业务规则。
@@ -171,6 +171,8 @@
 - 前置规范图：`start_local_project_asset_generation` 的 `ui-prototype` 与 `art-spritesheet` 要求项目里已有登记并绑定当前账号的 `assets/art-spec.png`（`kind: icon-spec`、图片媒体类型、来源为画布）。**后台化没有改这条前置判据**：Rust 侧仍是同一口径，前端 `projectHasIconSpecReference` 仍与它逐字对齐，缺前置时对应入口**保持可点击**并给出可执行的原因与指路（仓库口径：视觉不可用但可点击说明原因，不用原生 `disabled`），原因文案包含 `assets/art-spec.png` 与「生成规范 → 图标规范」。
 - 权威规范图由工具栏自身可满足：「图标规范」入口在项目尚无权威规范图时按 `assets/art-spec.png` 落盘；已有权威规范图时**不再传 `outputPath`**（Rust 侧 `replace_existing` 固定为 `false`，指向已存在文件会被硬拒绝「outputPath 已存在，禁止静默覆盖」），改为生成一张新的普通图标规范资产。这条前端策略不扩接口。
 - 音频入口收敛：音频画布的「生成背景音乐 / 生成音效」由工具栏承载，既有「生成素材」浮层入口**只保留生成视频**（视频能力不删，只是不出现在工具栏里）。
+- 派生/修改类任务并入同一侧栏（2026-09-20）：快速编辑、生成动画、视频 / 音效 / 背景音乐与抠图这类走**资源编辑链路**的任务也进「生成任务」侧栏。数据源 = 原生资源编辑账本 `list_pending_local_project_resource_edits` + **本会话的本地提交记录**，按 `operationId` 合并去重：本地那份负责「按下提交当帧可见」，原生那份负责「重开项目、别处提交也看得见，阶段文案以后端为首」。这类任务不写图片类生成账本（`.agent/runtime/asset-generation-tasks/tasks.json`），也不改原生资源编辑账本 schema。
+- 卡片浮层同一条「提交即关」（2026-09-21）：快速编辑 / 生成动画这类挂在资源卡上的浮层只负责**把任务交出去**，点提交当帧即关面板（不等 IPC），进度、阶段与结果都在「生成任务」侧栏里跟；面板内不出现「修改中 / 生成中」这类等待态。只有**点击瞬间就失败**（名称预检、源素材不在画布上、没有客户端）留在面板里可见；**受理之后才失败**只把侧栏那条收口为失败 + 提示条，不重开面板，草稿回落成「未完成编辑」等用户重开。因此原有的「生成中的卡片浮层不参与清焦点」判据一并退役（浮层不会带着进行中的任务留在画布上）。身份跟着资源走：按「入口 + 资源路径」记住最后一次派生请求，重开面板再提交时提示词没变就沿用同一 `operationId` / 幂等键，命中同一 operation 账本；派生成成功即清掉。同一张素材仍有在途提交时，再提交会被拦下并给出原因。
 - 本轮明确不做：生成视频（保留在既有浮层入口）、宣发素材、生成游戏场景、画布级「选择工具 / 抓手工具」（AGC 现无画布级工具模式）。这五类都**不得**出现在工具栏里。
 - 本地 IPC 边界（前端只做本地收窄，不改接口）：提示词上限 `32000` 字符、素材名上限 `120` 字符、比例白名单 `1:1 / 2:3 / 3:2 / 9:16 / 16:9`、尺寸白名单 `0.5K / 1K / 2K`。
 
@@ -364,7 +366,7 @@ type UpdateProjectResourceCanvasLayoutResult =
   1. **查找素材**：关键词，就是画布搜索本身，与筛选条件共用同一份状态，只有一个入口读写它，不得各存一份；判据沿用搜索既有的名称、路径、媒体类型、任务名四字段与大小写不敏感口径。
   2. **所在区域**：取值为「全部区域」加上现行分区栏目（`PROJECT_RESOURCE_CANVAS_SECTIONS` 的 6 类资产分类与末尾独立的「项目版本」栏），显示名沿用 `@` 面板资源筛选那份唯一中文口径，不另建译名表。
   3. **自定义标签**：从 manifest `assets[].tags` 派生的标签库，多选且为 AND 语义（已选标签必须全部命中，空选择不过滤），复用共享判据 `assetTagsMatchSelection`。
-  不提供「状态」字段：manifest 资产与资源投影都没有状态事实源，候选的任务状态与附件导入状态在资源投影里已被上游过滤，任何取值都恒为同一结果，因此不渲染该字段，也不保留占位下拉。
+     不提供「状态」字段：manifest 资产与资源投影都没有状态事实源，候选的任务状态与附件导入状态在资源投影里已被上游过滤，任何取值都恒为同一结果，因此不渲染该字段，也不保留占位下拉。
 - 「所在区域」**既是筛选维度也是画布当前栏目**，两者必须是同一份状态：区域取值由画布栏目状态派生，切换区域走与栏目切换完全相同的那一条路径，因此用户用滚轮、总览卡片或下一页切换栏目时区域显示随之变化，不需要双向同步逻辑，也不会出现两处状态互相漂移。
 - 区域取值与其它维度叠加时，筛选只作用于当前区域内的资源；「全部区域」作用于全部资源。两种语义共用同一份过滤实现，不为「只筛当前区域」另写一套裁集合逻辑。
 - 筛选浮层是画布唯一的搜索与筛选入口：Dock 上的放大镜按钮与 `Ctrl/Cmd+F` 叫出的是同一个浮层，不存在第二个浮层，因此也不存在「两个浮层互斥」这一说。
diff --git a/docs/project-memory/shared-memory/decision-log.md b/docs/project-memory/shared-memory/decision-log.md
index 31316e6ef..79204b43b 100644
--- a/docs/project-memory/shared-memory/decision-log.md
+++ b/docs/project-memory/shared-memory/decision-log.md
@@ -41,7 +41,6 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 决策（无写副作用）：只在生成本轮 prompt 时展开该上下文；历史 item 回读走 `direct_codex_user_item_to_response_item` 的纯投影，不得触发 UI 代码导出或任何项目写入。
 - 验证：`agent::direct_codex_user_item` 定向 16 条通过，覆盖成功注入、生成失败保留引用摘要、非 UI 文档不触发与历史回读不产生 `ui/generated-*.js`。
 
-
 ## 2026-09-19 AGC Direct 删除每回合四项媒体资源请求上限
 
 - 背景：2026-08-24 引入的单回合四项上限以「整个 agent run（一条用户消息到回合结束）」为窗口，计数只增不减、请求完成不释放额度；autonomous 游戏构建要求 agent 不停下跑完整局，额度耗尽后的报错实际是终态，与技能的三次重试纪律冲突，现场表现为长时间无效重试。2026-09-18 先将不计费的抠图豁免，但付费 create/derive 仍受同一窗口问题影响。
@@ -55,6 +54,24 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 决策：`agc_remove_background` 不再经过 `resource_request_ids` 计数，直接按回合身份与请求指纹确定性派生 operation/idempotency id（与 map 复用结果一致），同指纹重试与 pending 对账语义不变。付费的 create/derive（含 `agc_edit_image` 委托）维持四项上限与原有报错文案，且抠图请求不再挤占其额度。
 - 验证方式：`cargo check`（ai-game-creator-shell src-tauri）与 `git diff --check` 通过；未新增测试。
 
+## 2026-09-18 AGC 未提交快速编辑草稿按资源路径归属，正式恢复账本不动
+
+- 背景：画布验收项 AGC-006/023 要求「点外部 / Esc 收起面板、或换素材卡」不再无条件丢弃用户刚写的提示词与 `@` 引用，于是宿主内存里多了一份未提交草稿表（`resourceCanvasQuickEditModel.ts` 的 `ResourceQuickEditDraftStore`），与原生 `list_pending_local_project_resource_edits` / `resume_local_project_resource_edit` 那条正式可恢复账本**并存**。
+- 决策：草稿键是投影的稳定身份 `ProjectResource.path`，不是投影 id。资源投影本来就按 path 去重（`resourceProjectionModel` 的 `uniqueByPath`），而 id 会变——任务产物经 `normalize_local_project_raster_resource` 登记成正式素材后，同一张卡从 `task:<任务>:<路径>` 变成 `asset:<id>`。用 id 当键时，任何**不是打开中这一笔快速编辑自身触发**的重投影（换素材卡收起面板、Agent 或外部编辑器把同一路径登记成资产）都会让草稿落到再也点不到的键上：恢复入口按 id 过滤后静默丢弃、重开面板按新 id 查不到。按路径归属后不需要任何「跟着投影搬家」的换键逻辑，那条逻辑本身就是搬丢的来源。
+- 决策：本地草稿是**会话内存态**——不落盘、不进账本、不参与对账；共享入口「管理未完成编辑」同时列出来源不同的两种条目，草稿条目显式标注「本会话未提交，关闭客户端不保留」，账本读取失败时仍报出本会话草稿条数，避免用户把两者当成同一种持久事实。
+- 决策：`ResourcePromptPolishSlot` 与共享聊天输入区（`ResourceReferenceInput`）共用 `usePromptPolish`；「与原文相同」以**规范化之后要写回宿主的文本**为准（回包被长度上限截回原文同样算没变化），此时不落原文快照、不回填宿主，只给提示，避免出现点了等于没点的「恢复原文」假入口。
+- 边界：发送前提醒面板里「AI 润色并发送」遇到原样回包仍按用户意图直接提交，本轮按产品取舍保留（记录在 `docs/project-memory/todos/【待办】画布验收后续修复-2026-09-18.md`）。
+- 落地：`apps/ai-game-creator-shell/src/features/resource-canvas/resourceCanvasQuickEditModel.ts`（工厂空表 / 按路径写入读取丢弃 / `listResourceQuickEditDraftEntries`）、`apps/ai-game-creator-shell/src/view/project-development/index.tsx`（草稿接线与恢复入口）、`apps/ai-game-creator-shell/src/features/resource-canvas/ResourcePromptPolishSlot.tsx`、`apps/ai-game-creator-shell/src/features/project-workspace/{usePromptPolish.ts,ResourceReferenceInput.tsx}`；回归见 `tests/resourceCanvasQuickEditModel.test.ts`、`tests/resourceCanvasQuickEditDraft.test.tsx`（含「面板收起后旁路重投影」用例，改回 id 作键即红灯）、`tests/usePromptPolish.test.tsx`、`tests/resourcePromptPolishSlot.test.tsx`、`tests/chatPromptPolish.test.tsx`。
+
+## 2026-09-18 派生资源名称在前端镜像 Rust 门禁，宁可按原话拦下也不截断
+
+- 背景：快速编辑（`-编辑版`）与角色动画（`-角色动画`）的派生资源名由前端按源资源 label 拼出，直接进 `derive_local_project_resource` 的 `input.assetName`；Rust `normalize_resource_edit_name`（`resource_editor.rs:802-808`）要求 `trim` 后非空、码点数 1..=120 且不含控制字符，任一不满足即整条请求失败。源 label 取任务标题（Agent 回执）或长生成文件名时，用户必须提交一次才看到「派生资源名称必须在 1..=120 字符内且不能包含控制字符」。这是画布验收遗留项 AGC-025 的成因之一。
+- 决策：前端只做镜像，不另造中文语义——上限 120、`Cc` 控制字符判定（C0 / DEL / C1，`Cf` 继续放行）、`trim` 后判空、按 Unicode 码点计长（Rust `chars().count()`，不是 JS UTF-16 `.length`）四条与 Rust 逐条对齐，提示文案与 Rust 返回串逐字相同；两份判定由跨语言测试直接读 Rust 源码对表。
+- 决策：名称不合法时**阻止并提示**，不截断。截到 120 会让同前缀的两个长源名塌成同一个名字，把一次可见失败换成一次静默重名；默认名函数因此保持返回不合法原名，由检查结果里的 `error` 让调用方先停下。
+- 落地：`apps/ai-game-creator-shell/src/view/project-development/resourceEditModel.ts` 的 `RESOURCE_EDIT_NAME_MAX_LENGTH` / `RESOURCE_EDIT_NAME_INVALID_NOTICE` / `resolveResourceEditNameCheck` / `resolveDerivedResourceNameCheck(resource, 'edit' | 'character-animation')`，纯函数与跨语言对表见 `tests/resourceEditModel.test.ts`；两种后缀共用同一张后缀表，避免「-编辑版」与「-角色动画」再次分叉。
+- 接线：`index.tsx` 的 `submitResourceQuickEdit` 与 `submitResourceCharacterAnimation` 都在**调 `resolveResourceDeriveSource` 之前**做检查（正规化写盘发生在那一步之后），不合法时只把 `status: 'failed'` 与 Rust 原话写进各自的浮层面板并 return，不发派生请求；`assetName` 用检查结果里的 `name`。回归见 `tests/projectResourceLiveIntegration.test.tsx` 的两条「源名超 120 码点」用例与既有的合法名校验 `source-art-编辑版` / `hero-角色动画`。
+- 边界：资源画布的图片类生成走另一条门禁（`commands.rs` 的 `LOCAL_PROJECT_ASSET_MAX_ASSET_NAME_CHARS`，文案「素材名称超出安全边界」），不在本条口径内；提示词上限仍是 `resourceEditPromptMaxLength` 那一份，本决策不动它。
+
 ## 2026-09-18 Provider 瞬态重试次数严格按设置执行（游戏开发 Agent 与策划 Agent 不再被档位收进区间）
 
 - 背景：AGC 客户端此前把 `agentLlm.<agent>.maxRetries` 按运行档位重新收进固定区间——`autonomous-game-build` 档位（自主构建的游戏开发 Agent 及其继承档位的专业子 Agent）被抬到 12~16，`standard` 档位（含立项策划入口的策划 Agent 与普通 Agent 对话）被压到最多 3；瞬态分类里的上游 400 还在同一预算上再收窄到 2 次。现场把 `maxRetries` 设成 5 时，游戏开发与策划两条链路都不按设置执行。
@@ -68,6 +85,7 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 背景：AGC 已通过本地项目 ID 建立并持久化本地项目到主站远端画布项目的绑定，但 `agc_remove_background` 提交请求仍把本地 `manifest.project_id` 放入 `projectId`；`assetFolderId` 已使用远端素材目录 ID。主站因此按项目不存在或不属于当前账号返回 404，主站抠图和 BgFilter 本身均正常。
 - 决策：抠图请求及工具回执统一使用 `prepare_external_canvas_generation_context` 返回的远端 `context.project_id`；本地 manifest 项目 ID 只用于绑定键和本地状态，不得作为主站业务请求的 `projectId`。
 - 验证：客户端定向 Rust 测试、格式、编码和 diff 检查通过；未修改主站路由或 BgFilter。
+
 ## 2026-09-17 图集切分模式改为显式声明
 
 ## 2026-09-17 DirectProject 首屏历史锚点只认订阅回执的 lastCompletedItemId
@@ -89,6 +107,7 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 标准美术包：客户端显式声明 `sliceMode=connected-components` + `sliceCount=4`，本地按用途位置写四张 canonical 切片前再次校验数量正好为四，数量不符时失败关闭，禁止截断或补位。
 - 测试环境：在提权 shell 的 Windows 主机上，`%TEMP%` 下新建目录的默认所有者是 `BUILTIN\Administrators` 而不是当前 TokenUser，AGC 的所有者校验会拒绝测试自己创建的项目根；测试构建对该情形（仅限 `%TEMP%` 内、且失败原因为所有者不匹配）先按“本调用创建的对象”初始化所有者后重试，临时目录之外的越权所有者继续失败关闭。
 - 权威合同：[画板图标素材生成入口设计](../../【编辑器】画板图标素材生成入口设计-2026-06-15.md)。
+
 ## 2026-09-17 `agc_tools` 媒体资源提示词上限收敛为单一口径，并按 kind 暴露给模型
 
 - 背景：有人反馈「客户端没法由 agent 调用图片快速编辑功能以及背景音乐生成功能」。核查后工具本身都在（`agc_edit_image` / `agc_create_or_derive_resource`），图片快速编辑在 2026-09-14 的真实项目日志里也有成功记录；但存在三类真实缺陷：① `agc_create_or_derive_resource` 的 `prompt` 在 schema 里只声明 4000，真实上限却是按 kind 分的（背景音乐 140、音效 1900、视频/角色动画 4000、图片 32000），MCP 层还额外写死了一条 140 判断，模型从 schema 与 skill 都看不出 140/1900，写一句正常长度的背景音乐描述就当场被拒；② 客户端 UI 用同一口径但会截断并提示，agent 侧却只有硬拒，形成「UI 能做、agent 调不动」的观感；③ `sourceLocalAssetId` 不是已登记资源时只报「不属于当前项目已登记资源」，模型会原地重试而不会先登记。
@@ -207,6 +226,7 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 决策：图片类生成接线改为 `start_local_project_asset_generation` + `list_local_project_asset_generations` 后，同步命令 `generate_local_project_asset` **已无生产调用方**，只剩 `src-tauri/src/tests/project.rs` 的三条集成用例与 `commands.rs` 的自身单测在调它；因此登记进 `scripts/check-config.mjs` 的 native-only 白名单（该门禁有「App invoke 与白名单互斥」断言，谁重新给它接调用方就必须同时删掉这条白名单项）。
 - 待办：它是**注册中的可调用 IPC**，一旦被将来代码调用就是一条绕过任务账本、单次阻塞最长 35 分钟的并行生成路径。下一批次应删除它，或改为转调 `start_local_project_asset_generation`（连带迁移那三条集成用例）。
 - 关联文档：[栏目画布底部工具栏入口矩阵](../../technical/【AGC】栏目画布底部工具栏入口矩阵-2026-09-13.md)。
+
 ## 2026-09-14 AGC 壳 Rust 套件按「一片一 job」拆分，客户端 Rust 关键路径压到 7 分钟以内
 
 - 背景：`AI game creator shell Rust tests` 是客户端 CI 的关键路径（run 2097 实测 15 分 27 秒）。拆开来看：前置 5 分 30 秒（checkout 10s + `npm ci` 2m45s + Cargo fetch 2m35s）、编译 1m39s、**AGC 壳 bin target 的 2466 条单测串行 507s**、`agent-run` smoke 51s。这 2466 条全在 `apps/ai-game-creator-shell/src-tauri` 的 bin target 里，一条 `cargo test … -- --test-threads=1` 跑完。
@@ -219,6 +239,7 @@ Godot 编辑器操控复用既有 AGC 插件宿主、EditorAdapter、Runner 和
 - 影响范围：`.gitea/workflows/project-ci.yml`（十一个 job）、`scripts/check-native-shells.mjs`（分组由五个到十个：新增 `agc-rust-crates`、`agc-rust-shard-1..4`、`agc-rust-smoke`，移除 `agc-rust` 与随后的 `agc-rust-shell`）、根 `package.json`、`scripts/project-ci-workflow.test.ts`（新增纯 cargo job 免 `npm ci`、分片运行器覆盖校验、crate 级 job 预热顺序断言）、开发运维文档与共享记忆。本仓库不把 Project CI 的 context 配成 `master` 分支保护的合并必需检查（2026-09-14 复核），合并前由人工确认结果，因此 job 拆分/改名不需要同步分支保护设置。
 - 验证方式：`npx vitest run scripts/project-ci-workflow.test.ts`；分片运行器本地以 `agent-runtime-core`（7 条 → 2/2/2/1）与 `platform-llm`（146 条 → 49/49/48）验证分片、`--exact` 与片 TMPDIR 隔离，负例 `--shard-index=5` 立即失败；`node scripts/check-native-shells.mjs --groups=contract` 回归。预期每个分片 job 收敛到 5 分钟以内（前置约 1 分 30 秒 + 编译约 1 分 39 秒 + 约 617 条用例）。
 - 关联文档：[开发运维](../../【开发运维】本地开发验证与生产运维-2026-05-15.md)、[踩坑记录](pitfalls.md)。
+
 ## 2026-09-14 AGC 资源画布改为「手动整理」：新素材不再自动重排，整张重排只由「整理画布」发起
 
 - 背景：生成一张新素材会让整张资源画布重排。两个 layout hook 都把 `rederiveAutomaticPositions` 打开（type 侧无条件 `true`，dependency 侧长期等于 `resourceGraphReady`），而该开关的语义是「每次资源协调签名变化就丢掉全部 `manuallyPlaced=false` 坐标、按当前资源与拓扑整体重算」；新增一张素材必然改签名，于是既有自动卡全部跟着挪位，用户刚记住的位置就没了。画布上也没有任何显式整理入口（`复位资源视图` 只复位视口）。
@@ -8906,7 +8927,6 @@ CI 上 `background_agent_runtime_recovers_stale_running_before_pending_task` 在
 - 影响范围：新增 `apps/ai-game-creator-shell/src-tauri/src/asset_generation_tasks.rs`（+ `main.rs` 注册）、`src/features/resource-canvas/{resourceCanvasAssetGenerationTaskModel.ts,resourceCanvasAssetGenerationQueue.ts,ResourceCanvasAssetGenerationTasksPanelView.tsx}`；改动 `ResourceCanvasAssetGenerationPanelView.tsx` / `ResourceCanvasGenerationPanelView.tsx` / `src/view/project-development/index.tsx`；测试改动 `tests/{resourceCanvasAssetGenerationBackgroundClose.test.tsx,resourceCanvasAssetGenerationQueue.test.ts,resourceCanvasAssetGenerationTasksPanel.test.tsx}`（新增）与 `tests/appSurface/project-development.suite.ts`（把「每个入口一次 `generate_local_project_asset`」改成 `start_local_project_asset_generation` + `list_...` 轮询桩，载荷断言逐字不变）。**未动**：external v1 / OpenAPI、`packages/`、SpacetimeDB、音频入口的 pending-edit 账本语义、生成参数与 IPC 载荷字段名。
 - 关联文档：`docs/technical/【AGC】栏目画布底部工具栏入口矩阵-2026-09-13.md`（§4 / §4a / §8）、`docs/technical/【测试用例】AGC资源工作台V3端到端验收-2026-09-11.md`（S11a / §7.3）。
 
-
 ## 2026-09-15 非 Suno 的 VectorEngine 能力切换到 Tiantoken
 
 - 决策：新增本地私密环境变量 `TIANTOKEN_BASE_URL` / `TIANTOKEN_API_KEY`（图片 timeout 可独立配置），承载原 VectorEngine 的文本和图片；`VECTOR_ENGINE_BASE_URL` / `VECTOR_ENGINE_API_KEY` 仅保留给 Suno 背景音乐与 Suno 音效。编辑器 SFX V2 继续走 ElevenLabs。
@@ -8931,6 +8951,7 @@ CI 上 `background_agent_runtime_recovers_stale_running_before_pending_task` 在
 - 决策：平台会话拆成身份（`userId + api origin + identity generation`）与凭据（当前 access token）。identity generation 只在登录、切号、登出或新的 GUI authority epoch 推进；同账号续期只更新凭据并推进只用于拒绝迟到写入的 revision。冻结会话校验、MCP 会话身份与 Runner attach 统一按身份判定，换号 / 退出仍然失败关闭。刷新失败只在服务端明确 401/403 且一次收敛重试后仍失败时清会话；`/api/auth/refresh` 的轮换失败不再下发清空 refresh cookie 的响应。
 - 关联规范：`docs/technical/【技术方案】AI游戏创作智能体App实施计划-2026-06-24.md` 的“2026-09-16 平台会话身份与凭据分离”；开发期计划见 `docs/project-memory/plans/【里程碑】平台会话身份与凭据分离-2026-09-16.md` 与对应实施计划。
 - 验证：AGC `platform_session::tests`、`runner::tests`、`assets::tests` 定向通过；AGC `appSurface` 前端套件 468 项通过；网站 `src/services/apiClient.test.ts` 33 项通过；`cargo test -p api-server refresh_session` 通过。项目夹具类 Rust 用例受本机临时目录属主为 `BUILTIN\Administrators` 的环境限制，未计入本次证据。
+
 ## 2026-09-15 Direct 回合跨页面继续运行与活动项目面板
 
 - 决策：采用后台继续运行语义。Direct 回合由进程内项目身份锁持有，页面离开不取消；重进项目通过活动回合只读快照与 Thread Manager bootstrap/consume 恢复忙碌态和进度。左上角面板复用同一快照列出正在运行的 Direct 项目并支持进入。
@@ -9032,3 +9053,23 @@ CI 上 `background_agent_runtime_recovers_stale_running_before_pending_task` 在
 - 不变口径：平台侧 `/api/editor/audios/*/generations` 路由、请求体、计费与 `/api/external/v1`、OpenAPI、共享 DTO、SpacetimeDB schema 一律未动；音频仍复用既有资源编辑派生实现，不复制生成逻辑。
 - 关联规范：`docs/prd/【AI游戏创作】项目开发工作台PRD-2026-07-20.md`（§3.10 / §7.9）、`docs/technical/【AGC】栏目画布底部工具栏入口矩阵-2026-09-13.md`、`docs/project-memory/plans/【里程碑】AGC音频生成进入后台任务账本-2026-09-20.md`。
 - 验证：9 个定向 vitest 文件 73 项、`appSurface.test.ts` 552 项（17 跳过）、`cargo test asset_generation_task` 14 项、`npm run agc:typecheck`、`npm run check:encoding`、`npm run check:doc-index`、`git diff --check` 全部通过；未跑真实付费生成。
+
+## 2026-09-20 派生/修改类任务并入「生成任务」侧栏（AGC-039 / AGC-040）
+
+- 背景：客户端验收现场，快速编辑提交后画布右上角「生成任务」全程是「还没有生成任务」，同一条草稿又还挂在「管理未完成编辑」里，用户据此判断「点了没生成」；随后同一次修改被重复提交，同一张源图派生了两份一模一样的「-编辑版」。
+- 决策（取数）：派生/修改类任务（快速编辑、生成动画、视频 / 音效 / 背景音乐、抠图）进图片类生成任务**同一个**「生成任务」侧栏，数据源 = 原生资源编辑账本 `list_pending_local_project_resource_edits`（重开项目、别处提交、阶段文案以后端为首）+ 本会话**本地提交记录**（按下提交当帧即可见），两边按 `operationId` 合并去重。**不改**原生资源编辑账本 schema，也**不**把派生任务写进图片类生成账本 `.agent/runtime/asset-generation-tasks/tasks.json`——两套账本各管各的事实，只在视图层合并。
+- 决策（草稿口径）：提交进行中的那一笔不再列进「管理未完成编辑」；失败回落自动把它还回未完成列表，提示词与 `@` 引用不丢。
+- 决策（重复提交）：同一张素材存在在途提交时，重新打开面板再提交会被拦下（可见原因），不重铸 operation 身份。**未做**「同提示词成功后再提交」的去重——那是用户显式重复的付费动作，本批只消除误触来源。
+- 理由：用户对「生成」的心智是「交出去就得能看见它在跑」，而不是必须区分两条账本；而防重复必须在**身份重铸之前**拦，等到原生账本判重时已经派生过一次。
+- 验证：新增模型用例 9 条、快速编辑两组宿主用例（提交当帧进侧栏并收口 / 在途重复提交被拦），两处新判据做过变异验证；定向 7 个文件 97 条全绿。
+- 口径更正（2026-09-21）：当时记的「`appSurface` 16 条既有失败」是**从 `apps/ai-game-creator-shell` 目录跑**造成的 cwd 假红（`resolve(process.cwd(), 'apps/…')` 路径翻倍 → ENOENT），不是用例本身红。规范跑法是仓库根 `npm test`；现已用 `tests/repoPath.ts`（按 `import.meta.url` 反推仓库根）修掉 19 个文件的同类写法，从仓库根跑 `appSurface` 为 0 失败。远程 CI 与真实客户端验收仍未跑。
+
+## 2026-09-21 卡片浮层改为「提交即关」：快速编辑 / 生成动画只负责交任务
+
+- 背景：客户端验收反馈——「生成动画」这类卡片浮层在失焦时不会收起，而且这块的关闭判据一直是东一处西一处拼的（点画布空白、换选中卡、Esc、点画布以外各有一条）；动画面板在生成中还会被「生成中不关」判据锁在画布上。产品口径澄清：生成都归「生成任务」侧栏，**卡片浮层只用于提交任务，提交完生命周期就结束**。
+- 决策（提交即关）：快速编辑 / 生成动画点提交当帧即关面板，不等 IPC、不留等待态；阶段与结果只由「生成任务」侧栏承载（本地提交记录 + 原生待办按 `operationId` 合并，见 2026-09-20 那条）。只有**点击瞬间就失败**留在面板里；**受理之后才失败**把侧栏收口为失败 + 提示条并回落草稿，不重开面板。
+- 决策（身份跟着资源走）：按「入口 + 资源路径」记最后一次派生请求（`resourceEditRequestKey`）。重开面板再提交时提示词没变就沿用同一 `operationId` / 幂等键，重试仍命中同一 operation 账本；派生成成功即清掉，下一次编辑是新的一笔。原「按上次打开的 sourceLayerId 复用」在提交即关之后不再成立（面板重开时层 id 可能已被重投影换掉）。
+- 清理：`canDismissResourceCanvasQuickEdit`（生成中的浮层不参与清焦点）与宿主里两个只为它服务的面板状态 ref 一并删除；`clearResourceCanvasFocus` 恢复成「清选中 + 关两块浮层」的直线逻辑。
+- 影响面：`apps/ai-game-creator-shell/src/view/project-development/index.tsx`、`.../features/resource-canvas/resourceCanvasFocusModel.ts`、`tests/{projectResourceLiveIntegration,resourceCanvasQuickEditDraft,resourceCanvasFloatingDismiss}.test.tsx`、PRD §3.10。
+- 验证：定向 `projectResourceLiveIntegration`（32 条，三条断言面板留在失败态的用例按新口径改写为「重开面板再重试，身份不变」）、`resourceCanvasQuickEditDraft`（10 条）、`resourceCanvasFloatingDismiss`（18 条）全绿；`npm --prefix apps/ai-game-creator-shell run typecheck` 通过。
+- 合并前复核（2026-09-21）：合并 master 后按**仓库根**跑全量 `npx vitest run`，**373 个测试文件全过、4512 通过 / 34 跳过 / 0 失败**；PR #419 显示 `No Conflicts`。真实客户端观感与远程 CI 未复验（后者按用户要求不追，runner/镜像问题见 Issue #431）。
diff --git a/docs/project-memory/todos/【待办】画布验收后续修复-2026-09-18.md b/docs/project-memory/todos/【待办】画布验收后续修复-2026-09-18.md
new file mode 100644
index 000000000..4d6a3033a
--- /dev/null
+++ b/docs/project-memory/todos/【待办】画布验收后续修复-2026-09-18.md
@@ -0,0 +1,68 @@
+# 画布验收后续修复
+
+状态：待排查与方案确认。承接 Issue #411；首批修复已由 PR #412 合入，基准为 master `9a21690fe`。本提交仅登记后续范围，不代表以下问题已经修复。
+
+## 优先排查
+
+- 动画生成持续失败：读取具体操作错误及原请求状态后再定位，不盲目重复付费生成。
+- AI 润色无变化；恢复原文退出编辑面板、再次打开丢稿。
+- 文档全文预览入口不可用或不可发现，需在当前版本复验。
+- 标签面板无法查看更多标签；资源面板多选后卡死。
+- 未完成编辑缺少继续入口；快速编辑的素材名称校验报错。
+
+## 进展
+
+### 2026-09-20 第一批（已提交到本分支，待客户端验收）
+
+已完成并在本机跑通：AI 润色原样回包提示与「恢复原文」不再丢稿（AGC-004/005）、快速编辑未提交草稿的保留与继续入口（AGC-006/023）、派生资源名称的前端镜像校验与提交前拦截（AGC-025）。
+
+- 本机执行过：`npx vitest run` 定向 9 个文件（138 用例全绿）、`npm --prefix apps/ai-game-creator-shell run typecheck`、`npm run check:encoding`、`git diff --check`、改动文件的 prettier / eslint，以及 `appSurface` 等 20 个渲染工作台的用例文件。仅本地；远程 CI 与真实客户端验收都还没跑。
+- 本轮独立 review 的 4 条 P2 已处理：草稿身份改为资源路径（原先按投影 id，旁路重投影后草稿会静默消失）、润色判据改为「规范化后要写回的文本」、共享聊天输入区显示润色提示、本会话草稿与账本条目在入口上区分来源；P3 处理了名称预检的抛错兜底、恢复入口按钮对齐、提示随编辑失效、空表改工厂、跨语言用例按 `import.meta.url` 解析路径。
+- 明确保留未改：发送前提醒面板里「AI 润色并发送」遇到原样回包仍直接提交（按用户意图发出去，不做二次拦截）。
+- 仍未做：动画生成失败的真实复现与定位、文档全文入口、标签面板查看更多标签、多选卡死，以及卡片全类型重设计、画布内任务浮层、替换交互与聊天引用这批后续需求。
+
+### 2026-09-20 第二批（AGC-039 / AGC-040，待客户端验收）
+
+现场（项目 `gameagent-6e53c9e8`）：快速编辑提交后画布右上角「生成任务」全程是「还没有生成任务」，而「管理未完成编辑」里仍挂着同一条草稿——用户据此判断"点了没生成"；同一次修改在 22:05:16 与 22:05:34 各派生一次，manifest 多出两份重复的「-编辑版」。
+
+- 交付三条口径（本批一起改）：① 派生/修改类任务进「生成任务」侧栏——本地提交记录负责"按下按钮当帧可见"，原生 `list_pending_local_project_resource_edits` 负责"重开项目 / 别处提交也看得见、阶段以后端为准"，两边按 `operationId` 合并去重；② 提交期间那一笔不再算「未完成编辑」（失败后自动回落，草稿不丢）；③ 同一张素材还有在途提交时，重开面板再提交会被拦下并给出原因，避免重复派生。
+- 已知未做：成功之后**再次提交**仍会再派生一次（按用户显式重复计费），前端没有做"同提示词去重"；原生账本 schema、Rust 门禁与请求载荷都没有改动。
+- 本机执行过：新增模型用例 9 条与快速编辑两套新用例（提交当帧进侧栏 / 收口为已完成、在途重复提交被拦），两处新判据都做过变异验证（改回旧实现即红灯）；定向 7 个文件 97 条全绿；`tests/appSurface.test.ts` 与本批基线逐条一致（16 失败均为本分支既有，未新增）；`npm --prefix apps/ai-game-creator-shell run typecheck` 通过。远程 CI 与真实客户端验收仍未跑。
+
+### 2026-09-21 第三批（卡片浮层生命周期与画布样式，待客户端验收）
+
+验收现场又报三条：①「生成动画」面板样式与美术画布不一致（缩略图、预设、提交按钮落回默认流）；② 该浮层失焦不收起；③ 生图弹窗里**点提示词输入框任意位置**都会弹出「选择素材」。
+
+- 产品口径澄清后按「**卡片浮层只用于提交任务，提交完生命周期就结束**」改：快速编辑 / 生成动画点提交当帧即关面板（不等 IPC、不留等待态），进度与结果全在「生成任务」侧栏；受理后的失败不再重开面板（侧栏收口为失败 + 提示条、草稿回落到「未完成编辑」），只有点击瞬间就失败留在面板里。原「生成中不关」判据与此一并退役。
+- 派生请求身份改为按「入口 + 资源路径」记忆：重开面板再提交、提示词没变就沿用同一 `operationId` / 幂等键，重试仍命中同一 operation 账本。
+- 动画面板样式改为**按网页端整档照抄**：补上第二条同名规则（`.image-canvas-editor__generation-close` 的浮层内绝对定位——只搬第一条时关闭键会掉进网格流、跑到面板正中）、提示词聚焦 / `aria-invalid` 两档、composer 内参数簇底色，以及 `@media (max-width: 760px)` 整档；同时删掉面板里重复回显提示词的「动画描述」行。
+- 新增样式缺口守卫 `tests/resourceCanvasCharacterAnimationPanelStyle.test.tsx`：按 `src/main.tsx` 的真实 import 关系解析 AGC 加载的样式表，逐条比对「网页端命中该面板的规则（选择器 + 声明）AGC 是否都有一条」。第一版守卫只比选择器，漏掉了同名覆盖，已按现口径收紧。
+- 生图弹窗那个是 `<label>` 转发点击：`<label>` 会把点击交给内部第一个可标注控件，而这一格里第一个正是引用输入区的「插入素材引用」按钮。输入区改为 `<div>` 包裹（可访问名仍由控件自身 `aria-label` 提供），并补一条「点输入区不该自己弹出选择框、只有 @ 按钮才开」的用例——先用旧代码复现出红灯再修。
+- 本机执行过：定向 `projectResourceLiveIntegration` 32 条、`resourceCanvasQuickEditDraft` 10 条、`resourceCanvasFloatingDismiss` 18 条、样式守卫 3 条、`resourceCanvasAssetGenerationReferences` 10 条（含新增复现用例）等全绿；网页端 `ImageCanvasEditorGenerationIntegration` 44 条 + 面板 6 条全绿；`typecheck`、`check:encoding`、`git diff --check`、prettier、eslint 通过；`tests/appSurface.test.ts` 与基线逐条一致（16 失败均为本分支既有）。远程 CI 与真实客户端观感仍需复看。
+
+### 2026-09-21 复核收口（review 修复 + 生图浮层美化）
+
+- 在途拦截补齐**生成动画**：提交记录里「这笔属于哪张资源」从 `draftKey` 拆成 `resourcePath`，快速编辑与生成动画共用同一条 `…BlocksResource` 判据。此前动画这条键对不上拦不住——重开面板再提交会复用同一 `operationId` 卡在原生 per-operation 锁上，或（改了提示词）直接多出一笔付费生成。
+- 样式缺口守卫**扩到三块面板**（动画面板 / 快速编辑面板 / 生图面板），判据改为按「选择器分支 + 声明」逐条比对：只比类名会漏同名覆盖，只比整串选择器会逼宿主连不相干的兄弟支一起搬。实测把快速编辑面板的两条缺口一并照抄补上（其中两条按宿主差异显式登记：窄屏底栏与 `overflow: auto`）。
+- 网页端 `@media (max-width: 760px)` 只搬**动画面板**那一支：AGC 的快速编辑浮层是「居中贴资源卡」的绝对定位，跟随网页端改成整宽底栏会压住栏目工具栏与左侧「生成任务」侧栏。
+- **生图浮层紧凑化**（验收现场那条滚动条）：字段行改两列、比例与尺寸并排、提示词 6 行降到 3 行、润色 / 参考计数 / 两个动作收进同一行——面板高度回落到几何上界以内，滚动条物理上不再出现（`overflow` 只作极端窗口兜底）。相关卡片外形收敛到 `.game-project-workbench` 上的 `--game-canvas-card-*` 基类 token（取值照抄网页端画布面板），占位卡与生成浮层/弹窗共用一套圆角 / 描边 / 底色 / 投影。
+- **口径更正**：此前记的「`appSurface` 16 条既有失败」是**从 `apps/ai-game-creator-shell` 目录跑**造成的 cwd 假红（`resolve(process.cwd(), 'apps/…')` 路径翻倍 → ENOENT），不是用例本身红。规范跑法是仓库根 `npm test`；本次新增 `apps/ai-game-creator-shell/tests/repoPath.ts`（按 `import.meta.url` 反推仓库根）并把 19 个用例文件改成用它，另修掉 `HOST_STYLE_SHEETS.filter(existsSync)` 把仓库相对路径交给 cwd 解析的同类假红。改完从仓库根跑 `appSurface`：**538 通过 / 17 跳过 / 0 失败**。
+- 本机执行过（均在合并 master 之后）：`typecheck`、`check:encoding`、`git diff --check`、prettier、eslint 通过；AGC 定向 `projectResourceLiveIntegration` 32 + `resourceCanvasQuickEditDraft` 10 + `resourceCanvasFloatingDismiss` 18 + 样式守卫 5 + `resourceCanvasAssetGenerationReferences` 11 + 派生任务模型 9 等全绿；网页端 50 条全绿；`appSurface` 从仓库根 0 失败。真实客户端观感与远程 CI 仍需复看（CI 目前按用户要求不追）。
+
+### 合并前复核（2026-09-21，PR #419）
+
+- 合并 master（`cd98e0603`）后按**仓库根**跑全量 `npx vitest run`：**373 个测试文件全过，4512 通过 / 34 跳过 / 0 失败**；PR 显示 `No Conflicts`，分支与远端一致、工作区干净。
+- 范围核对：48 个改动文件全部落在 AGC 前端、3 个共享画布组件与 3 份文档；`server-rs` / `spacetime` / `docs/openapi` / `src-tauri` **零改动**（后端与契约无红线涉及），无 `.env`、密钥、构建产物或日志进入改动。
+- 合并后仍**未复验**的只有两类，且都不阻塞合并：① 真实客户端观感（本批动了动画面板样式、生图浮层紧凑排布与卡片基类 token——声明级与结构级都有守卫，真机要客户端验收确认）；② 远程 CI（runner/镜像问题仍在处理，见 Issue #431；按用户要求本批不追）。
+
+## 后续需求
+
+- 资源卡顶部独立名称区与全类型统一样式，确认 assetName/用户素材名的正式来源。
+- 生成任务列表移到画布右上角，进行中/已完成分组、失败可见、限高滚动及自动开合。
+- 素材替换关系与画布点选替换；聊天拖拽批量引用、复制对话保留有效引用。
+
+## 边界与验收
+
+先核对测试包/提交，避免旧包反馈与已合入修复混淆。每个问题先复现、明确原因与最小修复，再补回归和独立 review；复杂需求按现有规范驱动流程推进。首批本地通过不等于远程 CI 或真实 Provider 验收通过，遗留 Rust shard 2 失败仍需跟踪实际 SHA。不得为验证擅自提交付费生成、部署或修改他人项目。
+
+完成条件：逐项记录修复提交、实际执行的检查和客户端验收；长期规则回归主规范，全部关闭后删除本待办。
diff --git a/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.tsx b/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.tsx
index a9bd8d13d..505ef46c6 100644
--- a/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.tsx
+++ b/src/components/image-editor/ImageCanvasCharacterAnimationPanelView.tsx
@@ -259,13 +259,6 @@ export function ImageCanvasCharacterAnimationPanelView({
             {isGenerating ? '生成中' : `生成${price}泥点`}
           </PlatformActionButton>
         </div>
-        <span
-          className="image-canvas-editor__character-animation-summary-text"
-          title={panel.promptText.trim() || undefined}
-          aria-label={`生成文本：${panel.promptText.trim() || '动画描述'}`}
-        >
-          {panel.promptText.trim() ? panel.promptText.trim() : '动画描述'}
-        </span>
         {panel.status === 'completed' && panel.result ? (
           <PlatformStatusMessage
             tone="success"
diff --git a/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx b/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
index 1c3c42bf5..f778bfa5c 100644
--- a/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
+++ b/src/components/image-editor/ImageCanvasEditorGenerationIntegration.test.tsx
@@ -3522,9 +3522,13 @@ describe('ImageCanvasEditorView generation integration', () => {
       within(panel).getByLabelText('动画描述'),
       precisePrompt,
     );
+    // 面板里原本还有一行只读的「生成文本」回显（与上面的输入区重复）；它已删除，这里钉住不再渲染。
     expect(
-      within(panel).getByLabelText(`生成文本：${precisePrompt}`),
-    ).toBeTruthy();
+      within(panel).queryByLabelText(`生成文本：${precisePrompt}`),
+    ).toBeNull();
+    expect(within(panel).getByLabelText('动画描述').textContent).toContain(
+      precisePrompt,
+    );
     fireEvent.click(
       within(panel).getByRole('button', {
         name: '动画参数 同图尺寸 · 4秒 · 480p',
diff --git a/src/components/image-editor/useImageCanvasFloatingOptionDismiss.ts b/src/components/image-editor/useImageCanvasFloatingOptionDismiss.ts
index 25e13d409..356e9fbcc 100644
--- a/src/components/image-editor/useImageCanvasFloatingOptionDismiss.ts
+++ b/src/components/image-editor/useImageCanvasFloatingOptionDismiss.ts
@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
 
 type FloatingOptionBoundaryRef = {
   readonly current: HTMLElement | null;
@@ -107,19 +107,48 @@ export function useImageCanvasFloatingOptionDismiss({
   restoreFocusRef,
   isInsideExtraOverlay,
 }: UseImageCanvasFloatingOptionDismissOptions) {
+  /**
+   * 本次点击「算不算点在浮层里」的冻结判定。
+   *
+   * 判定必须在事件派发的最早期做，不能在冒泡到 `document` 时才拿 `event.target` 现算：
+   * 浮层里的按钮可能在**这一次点击**里把自己卸载掉（AGC 画布验收 AGC-005：快速编辑的
+   * 「恢复原文」被点后原文快照清空、按钮不再渲染，验收视频里表现为整个编辑面板连同选中
+   * 一起被收掉）。目标节点一旦脱离 DOM，`element.contains(target)` 一律为 false，
+   * 「点浮层内部」就被误判成「点外部」，面板被自己的按钮关掉。
+   *
+   * 捕获阶段挂在 `document` 上是最早的一站（React 的委托监听在 root 容器上，位置更靠内），
+   * 此刻 DOM 还是用户看到的那一份；判定口径本身不变，仍是
+   * {@link isEventInsideFloatingOverlay}（边界 DOM + portal 到 body 的浮层登记）。
+   * 真正触发关闭仍然留在冒泡阶段，宿主其它处理器看到的事件顺序与既有行为逐字一致。
+   */
+  const clickVerdictRef = useRef<{
+    event: MouseEvent;
+    inside: boolean;
+  } | null>(null);
+
   useEffect(() => {
     if (!isOpen || typeof document === 'undefined') {
       return undefined;
     }
 
+    const resolveInside = (event: MouseEvent) =>
+      isEventInsideFloatingOverlay(event.target, {
+        boundaryRefs,
+        isInsideExtraOverlay,
+      });
+
+    const handleClickCapture = (event: MouseEvent) => {
+      clickVerdictRef.current = { event, inside: resolveInside(event) };
+    };
+
     const handleClick = (event: MouseEvent) => {
       // 中文注释：选项项点击后要保留浮层；父级面板其它区域点击才收起。
-      if (
-        isEventInsideFloatingOverlay(event.target, {
-          boundaryRefs,
-          isInsideExtraOverlay,
-        })
-      ) {
+      const frozen = clickVerdictRef.current;
+      clickVerdictRef.current = null;
+      // 捕获阶段没跑到（例如事件不是这条派发路径派出来的）时退回现算，行为与改动前一致。
+      const isInside =
+        frozen && frozen.event === event ? frozen.inside : resolveInside(event);
+      if (isInside) {
         return;
       }
       onDismiss();
@@ -144,9 +173,11 @@ export function useImageCanvasFloatingOptionDismiss({
       }
     };
 
+    document.addEventListener('click', handleClickCapture, true);
     document.addEventListener('click', handleClick);
     document.addEventListener('keydown', handleKeyDown);
     return () => {
+      document.removeEventListener('click', handleClickCapture, true);
       document.removeEventListener('click', handleClick);
       document.removeEventListener('keydown', handleKeyDown);
     };