AGC 输入区三处观感修复：AI 润色归位、@ 面板筛选条单行、引用 chip 原子化

- styles.css：把 direct-codex composer 下广播式的 `.project-supervisor-composer button` 规则收窄到 `.project-supervisor-submit-button`（含 svg 那条与 media query 里那条），并给 `.resource-reference-input-actions` 补 `grid-column: 1 / -1` 让输入区操作排独占一行 - styles.css：`.resource-reference-input-actions` / `.resource-reference-input-at` 撤掉绝对定位，操作排回到网格文档流，与输入框右下角对齐，不再浮在文本区中间 - styles.css：`.resource-reference-input-polish` 与 `.resource-reference-input-restore` 并入 `@` 按钮同一条尺寸规则（28px 方钮、8px 圆角、同 hover/disabled 观感） - styles.css：输入区状态行（润色中/润色失败）改为与应用排同一行，不再单独占一行顶高 22.8px - styles.css：direct-codex 输入框 padding 收为 `12px 15px 6px`，窄屏 `10px 12px 6px` - styles.css：`.resource-reference-chip` 的 `×` 删除按钮不再被 broadcast 规则摘出 chip - PlatformSegmentedTabs.tsx：分段页签 item 加 `whitespace-nowrap`，中文不再逐字竖排 - packages/shared/styles.css：补 `.scrollbar-hide` 实现（该类名一直被 `layout="scroll"` 引用但仓库未定义） - ResourceReferenceNode.tsx：`getTextContent()` 改为单个 U+FFFC 占位符并显式实现 `getTextContentSize()`，引用成为真正的原子内联节点（1 个引用 = 1 个字符） - tests/resourceReferenceInput.test.tsx：新增「1 个引用 = 1 个字符」与「chip 自带删除、一次删净」两条断言 - tests/appSurface/project-development.suite.ts：把 composer 按钮样式断言收窄到提交按钮，并新增一条反向断言，钉住「广播到 composer 下所有 button」的规则不再出现
修正 AGC 快速编辑 4xx 失败原因取值：优先 details.message 并附 provider 与素材类型上下文
2026-09-10 19:05:57 +08:00 · 2026-09-10 19:01:09 +08:00 · 2026-09-10 19:01:04 +08:00 · 2026-09-10 19:00:52 +08:00 · 2026-09-10 19:00:44 +08:00 · 2026-09-10 18:59:33 +08:00
283 changed files with 33010 additions and 65171 deletions
@@ -16,8 +16,5 @@
    "maxRetries": 2,
    "retryBackoffMs": 500
  },
-  "agentLlm": {},
-  "planning": {
-    "capabilityEnabled": true
-  }
+  "agentLlm": {}
 }
@@ -19,8 +19,6 @@
    "config": "node scripts/game-creator-config-wizard.mjs",
    "test:chat": "node scripts/agent-swarm-test-chat.mjs --task \"制作一个可直接试玩的原创植物塔防小游戏：玩家选择并放置原创守卫阻挡敌人，完成波次后可以进入下一关并重新开始。主题、单位名称与视觉语言必须原创，不使用任何现有游戏角色、单位名、Logo 或受保护视觉语言。请自主完成正式产物、静态检查和双视口试玩验证。\" --no-open",
    "test:chat:manual": "node scripts/agent-swarm-test-chat.mjs",
-    "test:plan": "node scripts/agent-swarm-test-chat.mjs --plan --task \"我想做一款原创横版像素解谜小游戏，主角是一个能操控自己影子的小机器人，影子可以变成平台和开关。请完成立项策划并给出 Fast GDD。主题、角色名与视觉语言必须原创，不使用任何现有游戏角色、名称、Logo 或受保护视觉语言。\"",
-    "test:plan:manual": "node scripts/agent-swarm-test-chat.mjs --plan",
    "agent-run": "node scripts/run-cli-with-config.mjs --agent-run",
    "agent-run:smoke": "node scripts/smoke-agent-run-local-provider.mjs",
    "agent-runtime:real-e2e": "node scripts/agent-runtime-real-e2e.mjs",
@@ -36,8 +36,6 @@ export const ungeneratedGameEntryMarker =
  '还没有生成游戏。回到聊天输入创意并确认生成后';
 export const defaultRealSwarmTestTask =
  '制作一个可直接试玩的原创植物塔防小游戏：玩家选择并放置原创守卫阻挡敌人，完成波次后可以进入下一关并重新开始。主题、单位名称与视觉语言必须原创，不使用任何现有游戏角色、单位名、Logo 或受保护视觉语言。请自主完成正式产物、静态检查和双视口试玩验证。';
-export const defaultRealSwarmPlanTask =
-  '我想做一款原创横版像素解谜小游戏，主角是一个能操控自己影子的小机器人，影子可以变成平台和开关。请完成立项策划并给出 Fast GDD。主题、角色名与视觉语言必须原创，不使用任何现有游戏角色、名称、Logo 或受保护视觉语言。';
 export const swarmTurnReportPrefix = '[turn.report] ';
 export const swarmTurnReportSchema = 'game-creator-swarm-turn-report.v1';

@@ -140,15 +138,10 @@ export const usage = `用法：
  --keep-project            保留自动创建的一次性项目
  --no-open                 手工模式启动预览但不自动打开浏览器
  --task <需求>             通过 manual 入口非交互提交自定义需求
-  --plan                    走「做方案」立项策划入口，不做游戏，不做产物验收和试玩
-  --timeout-minutes <分钟>  设置本次执行期限；自动任务默认 50 分钟，--plan 默认 6 分钟，手工模式默认不限时
+  --timeout-minutes <分钟>  设置本次执行期限；自动任务默认 50 分钟，手工模式默认不限时
  --dry-run                 只检查目录发现和项目准备，不启动 LLM
  -h, --help                显示帮助
-
-环境变量：
-  AGC_PLAN_GDD_DECISION     审批卡自动应答动作，默认 approve；revise/reject 必须
-                            同时用 AGC_PLAN_GDD_COMMENT 给出真实修改意见
-  AGC_PLAN_GDD_COMMENT      revise/reject 的意见原文`;
+`;

 function readOptionValue(args, index, option) {
  const value = args[index + 1]?.trim();
@@ -177,7 +170,6 @@ export function parseSwarmTestArguments(args) {
    keepProject: false,
    openBrowser: true,
    task: null,
-    plan: false,
    timeoutMinutes: null,
    dryRun: false,
    help: false,
@@ -202,8 +194,6 @@ export function parseSwarmTestArguments(args) {
      if (task.length > 4_000) throw new Error('--task 不能超过 4000 字符');
      options.task = task;
      index += 1;
-    } else if (argument === '--plan') {
-      options.plan = true;
    } else if (argument === '--timeout-minutes') {
      if (options.timeoutMinutes !== null) {
        throw new Error('--timeout-minutes 只能指定一次');
@@ -222,16 +212,11 @@ export function parseSwarmTestArguments(args) {
 }

 export function shouldStartPersistentPreview(options) {
-  // 立项策划链路只出 GDD，没有可试玩产物，任何模式都不该起预览。
-  return !options.task && !options.plan;
+  return !options.task;
 }

 export function resolveSwarmTestTimeoutMs(options) {
-  // 立项策划的设计目标是五分钟出方案，给一分钟余量；再久就是卡住了，早失败
-  // 比让 harness 空等更有用。做游戏那条链路的 50 分钟不变。
-  const planMinutes = options.plan ? 6 : null;
-  const minutes =
-    options.timeoutMinutes ?? planMinutes ?? (options.task ? 50 : null);
+  const minutes = options.timeoutMinutes ?? (options.task ? 50 : null);
  return minutes === null ? null : minutes * 60_000;
 }

@@ -979,25 +964,12 @@ export function swarmAutoPilotShouldCloseInput(output, promptsAfterSubmit) {
  return swarmAutoPilotSitsAtPrompt(output) && promptsAfterSubmit >= 1;
 }

-// GDD 审批位不能等 CLI 退出之后再处理：Run 停在这里时状态是 waiting-for-user-input，
-// 而 swarm CLI 恰好把这个状态算作「本轮还在跑」，turn 永远不 settle，CLI 也就永远
-// 不退出。所以审批必须在 CLI 还活着的时候并发做完，让 Run 自己继续跑到收束。
-// 这一句是 PlanGddCompletionBlockerKind::AwaitingApprovalDecision 专有的投影文案，
-// 另外三个 blocked 子状态都不会打出它；即便认错了，真正的判据也是随后那次
-// --plan-gdd-status，没有待决定审批时不会有任何写入。
-const planGddApprovalWaitPattern = /等待 Fast GDD 审批决定/u;
-
-export function swarmOutputAwaitsPlanGddApproval(line) {
-  return planGddApprovalWaitPattern.test(line);
-}
-
 async function runTaskCargo(
  cliArguments,
  task,
  setActiveChild,
  timeoutMs,
  autoPilot = false,
-  onPlanGddApprovalWait = null,
 ) {
  const child = spawnChild(cargoCommand, buildCargoCliArguments(cliArguments), {
    stdio: ['pipe', 'pipe', 'inherit'],
@@ -1009,25 +981,6 @@ async function runTaskCargo(
  let taskSubmitted = false;
  let promptsSeen = 0;
  let sittingAtPrompt = false;
-  let planGddApproval = null;
-  let planGddApprovalError = null;
-  let planGddApprovalStarted = false;
-  let planGddApprovalPromise = null;
-  const startPlanGddApproval = () => {
-    planGddApprovalStarted = true;
-    console.log(
-      `[自动审批] 检测到 Fast GDD 审批位，正在提交 ${resolvePlanGddAutoDecision().action}`,
-    );
-    planGddApprovalPromise = onPlanGddApprovalWait()
-      .then((value) => {
-        planGddApproval = value;
-      })
-      .catch((error) => {
-        planGddApprovalError = error;
-        // 审批没成的话 Run 会一直停在等待位，干等到超时只会把真正的原因埋掉。
-        void terminateChildTree(child).catch(() => {});
-      });
-  };
  child.stdout.setEncoding('utf8');
  child.stdout.on('data', (chunk) => {
    process.stdout.write(chunk);
@@ -1040,13 +993,6 @@ async function runTaskCargo(
        reportLines.push(normalizedLine);
        settled = true;
      }
-      if (
-        onPlanGddApprovalWait &&
-        !planGddApprovalStarted &&
-        swarmOutputAwaitsPlanGddApproval(normalizedLine)
-      ) {
-        startPlanGddApproval();
-      }
    }
    if (!autoPilot || child.stdin.writableEnded) return;
    const atPrompt = swarmAutoPilotSitsAtPrompt(pendingLine);
@@ -1085,12 +1031,9 @@ async function runTaskCargo(
    if (normalizedPendingLine.startsWith(swarmTurnReportPrefix)) {
      reportLines.push(normalizedPendingLine);
    }
-    await planGddApprovalPromise;
-    if (planGddApprovalError) throw planGddApprovalError;
    return {
      ...result,
      turnReportOutput: reportLines.join('\n'),
-      planGddApproval,
    };
  } finally {
    setActiveChild(null);
@@ -1780,196 +1723,6 @@ export async function validateSwarmProjectArtifacts(projectPath, options) {
  return inspection;
 }

-// 这四条路径的权威定义都在 Rust 侧 `planning_storage.rs`（`PLAN_SESSION_PATH`、
-// `PLAN_GDD_INDEX_PATH`、`PLAN_STORAGE_ROOT`、`PLAN_FAST_GDD_PATH`）。跨语言没有共享
-// 常量的通道，改路径时要连同 `GddApprovalCard.tsx` 一起动。
-export const planningOutputPaths = [
-  '.agent/planning/session.json',
-  '.agent/planning/index.json',
-  '.agent/planning/pending.json',
-  'game/fast_gdd.md',
-];
-
-export async function inspectPlanningOutputs(projectPath) {
-  const outputs = [];
-  for (const relativePath of planningOutputPaths) {
-    const absolutePath = path.join(projectPath, ...relativePath.split('/'));
-    const metadata = await lstat(absolutePath).catch((error) => {
-      if (error?.code === 'ENOENT') return null;
-      throw error;
-    });
-    outputs.push({
-      path: relativePath,
-      exists: Boolean(metadata?.isFile()),
-      bytes: metadata?.isFile() ? metadata.size : 0,
-    });
-  }
-  return outputs;
-}
-
-async function reportPlanningOutputs(projectPath) {
-  const outputs = await inspectPlanningOutputs(projectPath);
-  console.log('\n立项策划产物：');
-  for (const output of outputs) {
-    console.log(
-      output.exists
-        ? `  [有] ${output.path}（${output.bytes} 字节）`
-        : `  [无] ${output.path}`,
-    );
-  }
-}
-
-const planGddApprovalTimeoutMs = 60_000;
-export const planGddStatusOutputPrefix = 'planGddStateJson=';
-export const planGddDecisionOutputPrefix = 'planGddDecisionJson=';
-
-function parsePrefixedJsonLine(output, prefix, label) {
-  const line = output
-    .split('\n')
-    .map((value) => (value.endsWith('\r') ? value.slice(0, -1) : value))
-    .find((value) => value.startsWith(prefix));
-  if (!line) throw new Error(`${label}缺少 ${prefix} 输出`);
-  try {
-    return JSON.parse(line.slice(prefix.length));
-  } catch (error) {
-    throw new Error(`解析${label}失败：${error.message}`);
-  }
-}
-
-export function parsePlanGddStatusOutput(output) {
-  return parsePrefixedJsonLine(
-    output,
-    planGddStatusOutputPrefix,
-    'Fast GDD 审批状态',
-  );
-}
-
-export function parsePlanGddDecisionOutput(output) {
-  return parsePrefixedJsonLine(
-    output,
-    planGddDecisionOutputPrefix,
-    'Fast GDD 审批回执',
-  );
-}
-
-// 审批卡是这条链路唯一的人类判据，所以自动应答默认只投 approve，且只在投影确实有
-// 一张待决定审批时出手。revise/reject 需要一段真实的修改意见，让机器编一段等于把
-// 判据换成噪声——所以那两条分支只在跑的人自己用 AGC_PLAN_GDD_COMMENT 给出意见时
-// 才走。手工调 --plan-gdd-decide 也能达到同样效果，但那要求 plan 根 run 仍然活着，
-// 而它恰好是本进程持有的 CLI 子进程。
-export function planGddAutoApprovalIsPending(state) {
-  return Boolean(state?.pendingApproval);
-}
-
-export function resolvePlanGddAutoDecision(env = process.env) {
-  const action = (env.AGC_PLAN_GDD_DECISION ?? 'approve').trim();
-  if (!['approve', 'revise', 'reject'].includes(action)) {
-    throw new Error('AGC_PLAN_GDD_DECISION 只能是 approve / revise / reject');
-  }
-  const comment = (env.AGC_PLAN_GDD_COMMENT ?? '').trim();
-  if (action === 'approve') return { action, comment: null };
-  if (!comment) {
-    throw new Error(
-      `${action} 必须同时设 AGC_PLAN_GDD_COMMENT 提供真实修改意见`,
-    );
-  }
-  return { action, comment };
-}
-
-async function settlePlanGddApproval(
-  projectPath,
-  runtimeConfigPath,
-  setActiveChild,
-) {
-  const readStatus = async () => {
-    const result = await runCapturedCargo(
-      ['--config-dir', runtimeConfigPath, '--plan-gdd-status', projectPath],
-      setActiveChild,
-      {
-        timeoutMs: planGddApprovalTimeoutMs,
-        label: 'Fast GDD 审批状态查询',
-      },
-    );
-    if (result.code !== 0 || result.signal) {
-      throw new Error(
-        `读取 Fast GDD 审批状态失败：${result.stderr.trim() || result.stdout.trim()}`,
-      );
-    }
-    return parsePlanGddStatusOutput(result.stdout);
-  };
-
-  const before = await readStatus();
-  if (!planGddAutoApprovalIsPending(before)) {
-    return { decided: false, state: before };
-  }
-  const { action, comment } = resolvePlanGddAutoDecision();
-  const decision = await runCapturedCargo(
-    [
-      '--config-dir',
-      runtimeConfigPath,
-      '--plan-gdd-decide',
-      projectPath,
-      action,
-      ...(comment === null ? [] : ['--stdin']),
-    ],
-    setActiveChild,
-    {
-      timeoutMs: planGddApprovalTimeoutMs,
-      label: 'Fast GDD 审批决定',
-      stdin: comment,
-    },
-  );
-  if (decision.code !== 0 || decision.signal) {
-    throw new Error(
-      `提交 Fast GDD 审批决定失败：${decision.stderr.trim() || decision.stdout.trim()}`,
-    );
-  }
-  const receipt = parsePlanGddDecisionOutput(decision.stdout);
-  // 回执落盘和唤醒后台任务是两件事：decide 命令把唤醒失败降级成 recoveryPending，
-  // 于是审批已经生效、Run 却仍停在 waiting-for-user-input。实测就是这样——只有
-  // 补一次 --agent-resume 才会重新起 turn。这是仓库自己给这个状态定义的恢复动作。
-  let recovered = false;
-  if (receipt.recoveryPending) {
-    const resume = await runCapturedCargo(
-      ['--config-dir', runtimeConfigPath, '--agent-resume', projectPath],
-      setActiveChild,
-      {
-        timeoutMs: planGddApprovalTimeoutMs,
-        label: 'Fast GDD 审批后恢复后台任务',
-      },
-    );
-    if (resume.code !== 0 || resume.signal) {
-      throw new Error(
-        `审批已提交但恢复后台任务失败：${resume.stderr.trim() || resume.stdout.trim()}`,
-      );
-    }
-    recovered = true;
-  }
-  return { decided: true, receipt, recovered, state: await readStatus() };
-}
-
-async function reportPlanGddApproval(approval) {
-  const { state } = approval;
-  console.log('\nFast GDD 审批：');
-  if (!approval.decided) {
-    console.log(`  [无待决定审批] 当前投影状态=${state.state}`);
-    return;
-  }
-  console.log(
-    `  [已决定 ${approval.receipt.decisionRef.action}] outcome=${approval.receipt.outcome} v${approval.receipt.decisionRef.version} 投影状态=${state.state}`,
-  );
-  if (approval.recovered) {
-    console.log(
-      '  [已恢复] 审批回执的 recoveryPending 由一次 --agent-resume 收口',
-    );
-  }
-  if (state.session) {
-    console.log(
-      `  澄清轮次=${state.session.clarificationRound} 返工深度=${state.session.repairDepth} phase=${state.session.phase}`,
-    );
-  }
-}
-
 export async function hasConfiguredEditorApiKey(configDir) {
  let configured = false;
  for (const fileName of [configFileName, localConfigFileName]) {
@@ -2122,13 +1875,7 @@ export async function runSwarmTestChat(options) {
  const setActiveChild = (child) => {
    activeChild = child;
  };
-  // GDD 审批要和 swarm CLI 并发跑，两者不能共用 activeChild 这一个槽位：审批子进程
-  // 结束时的 setActiveChild(null) 会把 CLI 从槽里抹掉，Ctrl-C 就杀不到它了。
  const concurrentChildren = new Set();
-  const setConcurrentChild = (child) => {
-    if (child) concurrentChildren.add(child);
-    else concurrentChildren.clear();
-  };
  const stopRequested = () => receivedSignal !== null;
  const handleSignal = (signal) => {
    const repeatedSignal = receivedSignal !== null;
@@ -2206,11 +1953,10 @@ export async function runSwarmTestChat(options) {
        );
      }
      console.log('LLM 配置已就绪。');
-      const requirementNoun = options.plan ? '立项策划需求' : '游戏需求';
      console.log(
        options.task
-          ? `已提交一条非交互${requirementNoun}，正在等待 Swarm 自主完成。\n`
-          : `输入一条${requirementNoun}并回车；提交后按 Ctrl+D，让 Swarm 自主完成。\n`,
+          ? '已提交一条非交互游戏需求，正在等待 Swarm 自主完成。\n'
+          : '输入一条游戏需求并回车；提交后按 Ctrl+D，让 Swarm 自主完成。\n',
      );

      phase = 'chat';
@@ -2220,8 +1966,7 @@ export async function runSwarmTestChat(options) {
        runtimeConfig.path,
        '--swarm-chat',
        '--init',
-        // 做方案链路只能跑 standard 档，后端对 plan + autonomous 是硬否决。
-        options.plan ? '--plan' : '--autonomous-game-build',
+        '--autonomous-game-build',
        project.path,
      ];
      let chat;
@@ -2234,15 +1979,6 @@ export async function runSwarmTestChat(options) {
              timeoutDeadline === null
                ? null
                : Math.max(1, timeoutDeadline - Date.now()),
-              options.plan,
-              options.plan
-                ? () =>
-                    settlePlanGddApproval(
-                      project.path,
-                      runtimeConfig.path,
-                      setConcurrentChild,
-                    )
-                : null,
            )
          : await runInteractiveCargo(chatArguments, setActiveChild);
      } catch (error) {
@@ -2258,32 +1994,6 @@ export async function runSwarmTestChat(options) {
      if (options.task) {
        turnReport = parseSettledSwarmTurnReport(chat.turnReportOutput);
      }
-      if (options.plan) {
-        // 立项策划不出游戏产物，正式验收在 GDD 审批卡上；这里只报告落盘情况，
-        // 是否收束已经由 CLI 的退出码判过了。
-        // 自动任务档的审批已经在 CLI 运行期间并发做完了；手工档（人自己敲 Ctrl+D
-        // 退出）没有那次触发，退出后补一次，没有待决定审批时它是只读的。
-        phase = 'plan-approval';
-        const approval =
-          chat.planGddApproval ??
-          (await settlePlanGddApproval(
-            project.path,
-            runtimeConfig.path,
-            setConcurrentChild,
-          ));
-        if (receivedSignal) break session;
-        phase = 'plan-report';
-        await reportPlanGddApproval(approval);
-        await reportPlanningOutputs(project.path);
-        phase = 'complete';
-        console.log(
-          approval.decided
-            ? '\n立项策划链路已收束：Fast GDD 已批准，策划产物见上方清单。'
-            : '\n立项策划链路已收束：Run 正常结束但没有待决定审批，策划产物见上方清单。',
-        );
-        break session;
-      }
-      phase = 'artifact-validation';
      const requireEditorImages = await hasConfiguredEditorApiKey(
        runtimeConfig.path,
      );
@@ -1705,10 +1705,16 @@ if (
  runtimeConfigSetupStart === -1 ||
  runtimeConfigSetupEnd === -1 ||
  !runtimeConfigSetupSource.includes('sanitize_diagnostic_message(') ||
-  !runtimeConfigSetupSource.includes('append_bounded_diagnostic_line(') ||
+  !runtimeConfigSetupSource.includes('setup_log.fail(') ||
  !runtimeConfigSetupSource.includes(
    'startup.appdata.configure.failed details={details}',
-  )
+  ) ||
+  !tauriHandlerSource.includes('impl StartupLogSlot {') ||
+  !tauriHandlerSource.includes('append_bounded_diagnostic_line(&path, line)') ||
+  !tauriHandlerSource.includes(
+    'self.append(line);\n        show_startup_error_dialog(self.path().as_deref());',
+  ) ||
+  !tauriHandlerSource.includes('early_startup_log_path(')
 ) {
  throw new Error(
    'AI game creator setup must configure the runtime AppData directory and log sanitized setup failures',
@@ -722,7 +722,7 @@ function runAgent() {
      stderr += chunk.toString();
    });
    child.on('error', reject);
-    child.on('close', (code) => {
+    child.on('close', (code, signal) => {
      const output = `${stdout}${stderr}`;
      if (previewReadError) {
        reject(previewReadError);
@@ -740,13 +740,24 @@ function runAgent() {
          previewDom,
        });
      } else {
-        reject(new Error(output || `agent run exited with ${code}`));
+        reject(
+          new Error(
+            `agent run failed: exitCode=${code}, signal=${signal ?? 'none'}\n` +
+              `stderr tail (last 8000 characters):\n${stderr.slice(-8000)}\n` +
+              `stdout tail (last 4000 characters):\n${stdout.slice(-4000)}`,
+          ),
+        );
      }
    });
  });
 }

 async function seedLocalAsset() {
+  await fs.mkdir(path.join(projectRoot, 'game'), { recursive: true });
+  await fs.writeFile(
+    path.join(projectRoot, 'game/index.html'),
+    '<!doctype html><html lang="zh-CN"><meta charset="UTF-8"><body>还没有生成游戏</body></html>',
+  );
  await fs.mkdir(path.join(projectRoot, 'assets/uploads'), { recursive: true });
  await fs.mkdir(path.join(projectRoot, '.agent'), { recursive: true });
  await seedConversationContext();
@@ -1,10 +1,16 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import http from 'node:http';
 import net from 'node:net';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';

+import {
+  normalizeWindowsPath,
+  parseWindowsProcessSnapshot,
+  stopWindowsProcessTree,
+  stopWindowsWorktreeProcesses,
+} from '../../../scripts/dev-windows-process.mjs';
 import {
  agcVitePortEnvKey,
  readAgcDevEndpoint,
@@ -15,6 +21,10 @@ import {
 const appRoot = fileURLToPath(new URL('..', import.meta.url));
 const repoRoot = resolve(appRoot, '../..');
 const devStackStatePath = resolve(repoRoot, '.app/dev-stack.json');
+const apiServerExePath = resolve(
+  repoRoot,
+  'server-rs/target/debug/api-server.exe',
+);
 const defaultApiTarget =
  process.env.RUST_SERVER_TARGET || 'http://127.0.0.1:8082';
 const backendDatabase = 'genarrative-game-creator-dev';
@@ -160,19 +170,184 @@ function readBackendServiceFailure(
  return null;
 }

+function urlPort(url) {
+  try {
+    const port = Number(new URL(url).port);
+    return Number.isInteger(port) && port > 0 ? port : 0;
+  } catch {
+    return 0;
+  }
+}
+
+// 读取端口当前真正的监听进程身份。返回 null 表示探测本身不可用（例如缺少
+// Get-NetTCPConnection），此时调用方必须退化为旧行为，不能让本地启动直接失败。
+function readWindowsPortOwnerIdentities(
+  ports,
+  { spawnImpl = spawnSync, env = process.env } = {},
+) {
+  const uniquePorts = [...new Set(ports.filter((port) => port > 0))];
+  if (uniquePorts.length === 0) {
+    return null;
+  }
+
+  const command = [
+    '$ErrorActionPreference = "SilentlyContinue"',
+    '$ports = ($env:GENARRATIVE_QUERY_PORTS -split ",") | Where-Object { $_ }',
+    '$result = @()',
+    'foreach ($port in $ports) {',
+    '  $connection = Get-NetTCPConnection -State Listen -LocalPort ([int]$port) -ErrorAction SilentlyContinue | Select-Object -First 1',
+    '  if (-not $connection) { continue }',
+    '  $owner = Get-CimInstance Win32_Process -Filter ("ProcessId=" + $connection.OwningProcess) -ErrorAction SilentlyContinue',
+    '  $result += [pscustomobject]@{ port = [int]$port; processId = [int]$connection.OwningProcess; name = $owner.Name; executablePath = $owner.ExecutablePath; commandLine = $owner.CommandLine }',
+    '}',
+    'ConvertTo-Json -InputObject @($result) -Compress',
+  ].join('\n');
+
+  const result = spawnImpl(
+    'powershell.exe',
+    ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', command],
+    {
+      encoding: 'utf8',
+      env: { ...env, GENARRATIVE_QUERY_PORTS: uniquePorts.join(',') },
+      maxBuffer: 8 * 1024 * 1024,
+    },
+  );
+  if (result?.error || result?.status !== 0) {
+    return null;
+  }
+
+  const owners = new Map();
+  for (const entry of parseWindowsProcessSnapshot(result.stdout)) {
+    const port = Number(entry?.port);
+    if (Number.isInteger(port) && port > 0) {
+      owners.set(port, entry);
+    }
+  }
+  return owners;
+}
+
+function isWorktreeApiServerOwner(
+  owner,
+  { expectedExePath = apiServerExePath } = {},
+) {
+  if (!owner) {
+    return false;
+  }
+  const expected = normalizeWindowsPath(expectedExePath);
+  const actual = normalizeWindowsPath(owner.executablePath);
+  return Boolean(expected) && actual === expected;
+}
+
+function isWorktreeSpacetimeOwner(
+  owner,
+  { expectedDataDir = backendSpacetimeDataDir } = {},
+) {
+  if (!owner) {
+    return false;
+  }
+  const expected = normalizeWindowsPath(expectedDataDir);
+  if (!expected) {
+    return false;
+  }
+  const name = String(owner.name ?? '').toLowerCase();
+  if (!name.startsWith('spacetime')) {
+    return false;
+  }
+  return normalizeWindowsPath(owner.commandLine).includes(expected);
+}
+
+// 端口健康不代表后端属于当前工作树：上个工作树 Ctrl+C 残留的 api-server 仍会
+// 应答 /healthz。复用前必须证明端口上的进程就是本工作树的可执行文件与数据目录。
+function verifyAgcBackendOwnership({
+  apiUrl,
+  spacetimeUrl,
+  bgfilterWorkerUrl,
+  platform = process.platform,
+  expectedExePath = apiServerExePath,
+  expectedDataDir = backendSpacetimeDataDir,
+  readPortOwners = readWindowsPortOwnerIdentities,
+} = {}) {
+  if (platform !== 'win32') {
+    return { ok: true, reason: 'platform-unsupported', owners: new Map() };
+  }
+
+  const ports = [
+    urlPort(apiUrl),
+    urlPort(bgfilterWorkerUrl),
+    urlPort(spacetimeUrl),
+  ];
+  const owners = readPortOwners(ports);
+  if (!owners) {
+    return { ok: true, reason: 'owner-probe-unavailable', owners: new Map() };
+  }
+
+  const apiOwner = owners.get(urlPort(apiUrl));
+  if (!isWorktreeApiServerOwner(apiOwner, { expectedExePath })) {
+    return { ok: false, reason: 'api-server-owner-mismatch', owners, apiOwner };
+  }
+
+  const workerOwner = owners.get(urlPort(bgfilterWorkerUrl));
+  if (!isWorktreeApiServerOwner(workerOwner, { expectedExePath })) {
+    return {
+      ok: false,
+      reason: 'bgfilter-worker-owner-mismatch',
+      owners,
+      workerOwner,
+    };
+  }
+
+  const spacetimeOwner = owners.get(urlPort(spacetimeUrl));
+  if (!isWorktreeSpacetimeOwner(spacetimeOwner, { expectedDataDir })) {
+    return {
+      ok: false,
+      reason: 'spacetime-owner-mismatch',
+      owners,
+      spacetimeOwner,
+    };
+  }
+
+  return { ok: true, reason: 'owned', owners };
+}
+
+function formatOwnerLabel(owner) {
+  if (!owner) {
+    return '未知进程';
+  }
+  const pid = Number(owner.processId);
+  const label = owner.executablePath || owner.commandLine || owner.name || '';
+  return `${Number.isInteger(pid) ? `pid=${pid} ` : ''}${String(label).trim()}`.trim();
+}
+
 async function isBackendReady({
  state = readJson(devStackStatePath),
  isReady = isHttpReady,
+  verifyOwnership = verifyAgcBackendOwnership,
+  onOwnershipRejected = null,
 } = {}) {
  const { apiUrl, spacetimeUrl, bgfilterWorkerUrl, hasMatchingBackend } =
    resolveBackendTargetsFromState(state, {
      requireAgcBackend: true,
    });
+  if (!hasMatchingBackend || !apiUrl || !spacetimeUrl || !bgfilterWorkerUrl) {
+    return false;
+  }
+
+  const ownership = await verifyOwnership({
+    apiUrl,
+    spacetimeUrl,
+    bgfilterWorkerUrl,
+  });
+  if (!ownership?.ok) {
+    onOwnershipRejected?.(ownership);
+    return false;
+  }
+  if (ownership.reason === 'owner-probe-unavailable') {
+    console.warn(
+      '[ai-game-creator-shell] 无法读取端口监听进程归属，本次按旧行为复用配套后端。',
+    );
+  }
+
  return (
-    hasMatchingBackend &&
-    Boolean(apiUrl) &&
-    Boolean(spacetimeUrl) &&
-    Boolean(bgfilterWorkerUrl) &&
    (await isReady(`${apiUrl}/healthz`)) &&
    (await isReady(`${spacetimeUrl}/v1/ping`)) &&
    (await isReady(`${bgfilterWorkerUrl}/readyz`))
@@ -485,14 +660,18 @@ async function terminateChildTree(
      return { stopped: true, forced: false };
    }
    const result = await taskkillImpl(child.pid);
-    return {
-      stopped:
-        !result?.timedOut &&
-        !result?.error &&
-        [0, 128].includes(result?.code ?? 0),
-      forced: true,
-      result,
-    };
+    const taskkillStopped =
+      !result?.timedOut &&
+      !result?.error &&
+      [0, 128].includes(result?.code ?? 0);
+    if (taskkillStopped) {
+      return { stopped: true, forced: true, result };
+    }
+
+    // 包装层（cmd.exe / npm.cmd）先被 Ctrl+C 杀掉时 taskkill 拿不到活着的 PID，
+    // 这里继续按记录下来的根 PID 遍历，尽量收掉更深的后端进程。
+    const treeStopped = stopWindowsProcessTree(child.pid);
+    return { stopped: treeStopped.length > 0, forced: true, result };
  }

  const processGroupId = childLifecycles.get(child)?.processGroupId;
@@ -542,15 +721,29 @@ async function waitForBackendReady(
  backendChild,
  timeoutMs = 600_000,
  {
-    checkBackendReady = isBackendReady,
+    checkBackendReady = (onOwnershipRejected) =>
+      isBackendReady({ onOwnershipRejected }),
    readState = () => readJson(devStackStatePath),
    resolveTargets = readBackendTargets,
  } = {},
 ) {
  const initialStateUpdatedAt = readState()?.updatedAt ?? '';
  const startedAt = Date.now();
+  let lastOwnershipReason = '';
  while (Date.now() - startedAt < timeoutMs) {
-    if (await checkBackendReady()) {
+    if (
+      await checkBackendReady((ownership) => {
+        if (ownership.reason === lastOwnershipReason) {
+          return;
+        }
+        lastOwnershipReason = ownership.reason;
+        // 本次自己拉起的后端如果归属校验一直不通过，必须把原因打出来，
+        // 否则只会表现为等待 600 秒后超时。
+        console.warn(
+          `[ai-game-creator-shell] 等待配套后端就绪时归属校验未通过（${ownership.reason}: ${formatOwnerLabel(ownership.apiOwner ?? ownership.spacetimeOwner ?? ownership.workerOwner)}）。`,
+        );
+      })
+    ) {
      return resolveTargets();
    }
    const state = readState();
@@ -576,7 +769,14 @@ async function waitForBackendReady(

 async function ensureBackend({
  onBackendChild = () => {},
-  checkBackendReady = isBackendReady,
+  checkBackendReady = () =>
+    isBackendReady({
+      onOwnershipRejected(ownership) {
+        console.warn(
+          `[ai-game-creator-shell] 端口上的配套后端不属于当前工作树（${ownership.reason}: ${formatOwnerLabel(ownership.apiOwner ?? ownership.spacetimeOwner ?? ownership.workerOwner)}），改为启动本工作树自己的后端。`,
+        );
+      },
+    }),
  resolveTargets = readBackendTargets,
  spawnBackend = () =>
    spawnChild(
@@ -656,15 +856,33 @@ async function startVite(apiTarget, endpoint = readAgcDevEndpoint()) {

 async function main() {
  let backendChild = null;
+  let startedBackend = false;
  let viteChild = null;
  let shutdownSignal = '';
  const signalHandlers = new Map();

+  // 只有本次会话真正拉起过配套后端时才做兜底清扫：复用别人后端时不能连带
+  // 杀掉对方的进程。dev.mjs 的清理依赖它的 shell 包装层仍然活着，而 Ctrl+C
+  // 往往先杀掉包装层，所以这里必须按本工作树 api-server.exe 的身份再收一次。
+  const sweepStartedBackend = () => {
+    if (!startedBackend || process.platform !== 'win32') {
+      return;
+    }
+    const stopped = stopWindowsWorktreeProcesses({ apiServerExePath });
+    if (stopped.length > 0) {
+      console.log(
+        `[ai-game-creator-shell] 已清理残留后端进程: ${stopped.join(', ')}`,
+      );
+    }
+  };
+
  for (const signal of ['SIGINT', 'SIGTERM']) {
    const handler = () => {
      shutdownSignal = signal;
      stopChild(viteChild, signal);
      stopChild(backendChild, signal);
+      // 立刻清扫，避免外层 taskkill /F 抢在 finally 之前把本进程杀掉。
+      sweepStartedBackend();
    };
    signalHandlers.set(signal, handler);
    process.on(signal, handler);
@@ -683,6 +901,7 @@ async function main() {
      },
    });
    backendChild = backend.backendChild;
+    startedBackend = Boolean(backendChild);
    if (shutdownSignal) {
      throw new Error(`启动期收到 ${shutdownSignal}，已停止配套后端`);
    }
@@ -716,6 +935,7 @@ async function main() {
      terminateChildTree(viteChild),
      terminateChildTree(backendChild),
    ]);
+    sweepStartedBackend();
    for (const [signal, handler] of signalHandlers) {
      process.off(signal, handler);
    }
@@ -732,20 +952,25 @@ function isDirectModuleExecution() {
 export {
  ensureBackend,
  formatChildFailure,
+  formatOwnerLabel,
  isAiGameCreatorServer,
  isBackendReady,
  isDirectModuleExecution,
  isProcessGroupAlive,
+  isWorktreeApiServerOwner,
+  isWorktreeSpacetimeOwner,
  preflightExistingVite,
  readBackendServiceFailure,
  readChildFailure,
  readExistingViteServer,
  readLinuxProcessGroupAlive,
+  readWindowsPortOwnerIdentities,
  resolveBackendTargetsFromState,
  runWindowsTaskkill,
  spawnChild,
  stopChild,
  terminateChildTree,
+  verifyAgcBackendOwnership,
  waitForBackendReady,
  waitForChildTermination,
 };
@@ -43,7 +43,6 @@ struct PromptCompositions {
    /// 而是一份独立的完整清单：plan 根的工具面只有 7 个原生工具，专业组、
    /// isolated child、任务图与视觉产物合同在这条链路上全部不可执行，逐段
    /// 减法会把「plan 根到底看到什么」摊在两个函数的四个否定分支里。
-    supervisor_plan: Vec<String>,
    supervisor_chat: SupervisorChatComposition,
 }

@@ -99,10 +98,6 @@ struct ProviderFragments {
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 struct AgentCatalog {
    supervisor: AgentGroup,
-    /// 立项策划子 Agent。与 `supervisor` 平级、**不进 `groups`**：`specialist_nodes`
-    /// 只从 `groups[].roles[]` 派生，因此它不参与 `build.rs` 与种子 DAG 的一致性
-    /// 校验，「做游戏」的 16 任务 DAG 一行不动。详见技术方案第 3.1 节。
-    planning: AgentGroup,
    groups: Vec<AgentGroup>,
 }

@@ -231,12 +226,6 @@ pub fn compile_manifest(manifest_path: &Path) -> Result<CompiledPromptBundle, St
        &sections,
        &["$base", "$visualContract"],
    )?;
-    validate_composition(
-        "supervisorPlan",
-        &manifest.compositions.supervisor_plan,
-        &sections,
-        &["$header"],
-    )?;
    validate_section_reference(
        &manifest.compositions.supervisor_chat.identity,
        &sections,
@@ -299,7 +288,6 @@ pub fn compile_manifest(manifest_path: &Path) -> Result<CompiledPromptBundle, St
        .supervisor
        .roles
        .iter()
-        .chain(manifest.agent_catalog.planning.roles.iter())
        .chain(
            manifest
                .agent_catalog
@@ -348,7 +336,6 @@ pub fn compile_manifest(manifest_path: &Path) -> Result<CompiledPromptBundle, St
        .runtime
        .iter()
        .chain(manifest.compositions.supervisor.iter())
-        .chain(manifest.compositions.supervisor_plan.iter())
        .filter(|item| !item.starts_with('$'))
        .cloned()
        .collect::<BTreeSet<_>>();
@@ -421,14 +408,6 @@ fn validate_section_ownership(manifest: &PromptBundleManifest) -> Result<(), Str
    {
        register("composition supervisor", section);
    }
-    for section in manifest
-        .compositions
-        .supervisor_plan
-        .iter()
-        .filter(|section| !section.starts_with('$'))
-    {
-        register("composition supervisorPlan", section);
-    }
    register("composition supervisorChat.identity", identity);
    register(
        "composition supervisorChat.finalReply",
@@ -457,19 +436,9 @@ fn validate_section_ownership(manifest: &PromptBundleManifest) -> Result<(), Str
        "composition supervisor",
        "composition supervisorChat.identity",
    ]);
-    // plan 根 composition 是 Supervisor system prompt 的第二条 lane，不是另一种
-    // 语义面。它按设计复用 runtime lane 的 `isolatedAgentContract`（`agent.delegate`
-    // 的 expectedArtifacts/writeScopes 合同）和 supervisor lane 的 `supervisorRepair`
-    // （返工必须逐字继承原合同）。除这两个方向外，跨所有者复用仍然是错误。
-    let allowed_plan_runtime_owners =
-        BTreeSet::from(["composition runtime", "composition supervisorPlan"]);
-    let allowed_plan_supervisor_owners =
-        BTreeSet::from(["composition supervisor", "composition supervisorPlan"]);
    for (section, section_owners) in owners {
        if section_owners.len() > 1
            && !(section == identity && section_owners == allowed_identity_owners)
-            && section_owners != allowed_plan_runtime_owners
-            && section_owners != allowed_plan_supervisor_owners
        {
            return Err(format!(
                "Prompt section 跨语义所有者复用：{section} -> {section_owners:?}"
@@ -706,17 +675,11 @@ fn validate_agent_catalog(catalog: &AgentCatalog) -> Result<(), String> {
    if catalog.supervisor.roles.len() != 1 {
        return Err("agentCatalog.supervisor 必须且只能包含一个 role".to_string());
    }
-    if catalog.planning.roles.len() != 1 {
-        return Err("agentCatalog.planning 必须且只能包含一个 role".to_string());
-    }
    if catalog.groups.is_empty() {
        return Err("agentCatalog.groups 不能为空".to_string());
    }
    let mut group_brief_names = BTreeSet::new();
-    for group in std::iter::once(&catalog.supervisor)
-        .chain(std::iter::once(&catalog.planning))
-        .chain(catalog.groups.iter())
-    {
+    for group in std::iter::once(&catalog.supervisor).chain(catalog.groups.iter()) {
        if !group_brief_names.insert(group.brief_path_name.as_str()) {
            return Err(format!(
                "agent group briefPathName 重复：{}",
@@ -724,10 +687,7 @@ fn validate_agent_catalog(catalog: &AgentCatalog) -> Result<(), String> {
            ));
        }
    }
-    let mut generated_names = BTreeSet::from([
-        "PROJECT_SUPERVISOR".to_string(),
-        "PROJECT_PLANNING".to_string(),
-    ]);
+    let mut generated_names = BTreeSet::from(["PROJECT_SUPERVISOR".to_string()]);
    for group in &catalog.groups {
        let generated = rust_identifier(&group.id);
        if !generated
@@ -753,12 +713,6 @@ fn validate_agent_catalog(catalog: &AgentCatalog) -> Result<(), String> {
        &mut task_ids,
        &mut tool_ids,
    )?;
-    validate_agent_group(
-        &catalog.planning,
-        &mut group_ids,
-        &mut task_ids,
-        &mut tool_ids,
-    )?;
    for group in &catalog.groups {
        validate_agent_group(group, &mut group_ids, &mut task_ids, &mut tool_ids)?;
    }
@@ -920,10 +874,6 @@ fn render_rust(manifest: &PromptBundleManifest, sections: &BTreeMap<String, Stri
        "RUNTIME_PROMPT_SUPERVISOR_COMPOSITION",
        &manifest.compositions.supervisor,
    ));
-    output.push_str(&render_string_slice_const(
-        "RUNTIME_PROMPT_SUPERVISOR_PLAN_COMPOSITION",
-        &manifest.compositions.supervisor_plan,
-    ));
    output.push_str(&format!(
        "pub(crate) const RUNTIME_PROMPT_SUPERVISOR_CHAT_COMPOSITION: &[&str] = &[{}, {}];\n",
        rust_literal(&manifest.compositions.supervisor_chat.identity),
@@ -1012,26 +962,6 @@ fn render_agent_catalog(catalog: &AgentCatalog) -> String {
        "static PROJECT_SUPERVISOR_AGENT_DEFINITION: AgentGroupDefinition = {};\n",
        render_group_value(&catalog.supervisor, "&PROJECT_SUPERVISOR_AGENT_ROLES")
    ));
-    let planning_role = &catalog.planning.roles[0];
-    output.push_str(&format!(
-        "pub(crate) const GAME_CREATOR_PROJECT_PLANNING_AGENT_ID: &str = {};\n",
-        rust_literal(&planning_role.task_id)
-    ));
-    output.push_str(&format!(
-        "pub(crate) const GAME_CREATOR_PROJECT_PLANNING_MEMORY_PATH: &str = {};\n",
-        rust_literal(&format!(
-            "memory/agents/{}",
-            catalog.planning.brief_path_name
-        ))
-    ));
-    output.push_str(&render_role_array(
-        "PROJECT_PLANNING_AGENT_ROLES",
-        &catalog.planning.roles,
-    ));
-    output.push_str(&format!(
-        "static PROJECT_PLANNING_AGENT_DEFINITION: AgentGroupDefinition = {};\n",
-        render_group_value(&catalog.planning, "&PROJECT_PLANNING_AGENT_ROLES")
-    ));
    for group in &catalog.groups {
        let roles_name = format!("{}_AGENT_ROLES", rust_identifier(&group.id));
        output.push_str(&render_role_array(&roles_name, &group.roles));
@@ -1,7 +1,7 @@
 {
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "main",
-  "description": "AI 游戏创作主窗口允许读取系统剪贴板图片，用于粘贴素材附件。",
+  "description": "AI 游戏创作主窗口允许读取系统剪贴板图片，用于粘贴素材附件；允许弹出原生打开/保存对话框用于素材上传与导出。",
  "windows": ["client"],
  "permissions": [
    "clipboard-manager:allow-read-image",
@@ -21,6 +21,7 @@
      ]
    },
    "opener:default",
-    "dialog:allow-open"
+    "dialog:allow-open",
+    "dialog:allow-save"
  ]
 }
@@ -0,0 +1 @@
+你是游戏创作需求的润色助手。把用户给创作 Agent 的一段需求改写成更清晰、可执行的中文需求。要求：保留用户的原始意图、玩法、美术方向、数值与限制条件，不得新增或删除需求点，不得替用户做决定，不得写成方案书或任务清单。只输出润色后的需求正文，不要解释、不要引言、不要 Markdown 标记、不要引号包裹、不要重复用户原文；无法润色时原样输出用户输入。
@@ -23,11 +23,7 @@
    "supervisorVisualWithEditor": "supervisor/visual-contract-with-editor.md",
    "supervisorPlaybook": "supervisor/playbook.md",
    "supervisorClaimGate": "supervisor/claim-gate.md",
-    "supervisorRepair": "supervisor/repair.md",
-    "projectPlanningRoleBrief": "roles/project-planning.md",
-    "planCommon": "plan/common.md",
-    "planSupervisorIdentity": "plan/supervisor-identity.md",
-    "planSupervisorPlaybook": "plan/supervisor-playbook.md"
+    "supervisorRepair": "supervisor/repair.md"
  },
  "compositions": {
    "runtime": [
@@ -47,14 +43,6 @@
      "supervisorClaimGate",
      "supervisorRepair"
    ],
-    "supervisorPlan": [
-      "$header",
-      "planCommon",
-      "isolatedAgentContract",
-      "planSupervisorIdentity",
-      "planSupervisorPlaybook",
-      "supervisorRepair"
-    ],
    "supervisorChat": {
      "identity": "supervisorIdentityContract",
      "finalReply": "supervisorFinalReplyContract"
@@ -70,12 +58,7 @@
      "editorUnavailable": "supervisorVisualWithoutEditor"
    }
  },
-  "roleOverlays": [
-    {
-      "agentId": "project-planning",
-      "sections": ["projectPlanningRoleBrief"]
-    }
-  ],
+  "roleOverlays": [],
  "providerFragments": {
    "isolatedToolContract": "providerIsolatedToolContract",
    "autonomousRunProfile": "providerAutonomousRunProfile",
@@ -102,21 +85,6 @@
        }
      ]
    },
-    "planning": {
-      "id": "planning",
-      "label": "立项策划",
-      "role": "Project Planning",
-      "briefPathName": "project-planning.md",
-      "roles": [
-        {
-          "id": "project-planning",
-          "role": "Project Planning",
-          "taskId": "project-planning",
-          "toolId": "agent.runtime.project-planning",
-          "briefPathName": "project-planning.md"
-        }
-      ]
-    },
    "groups": [
      {
        "id": "design",
@@ -1,7 +0,0 @@
-用户只描述玩法类型、机制或相似体验时，不代表授权复刻现有游戏。所有专业 Agent 必须创建原创标题、阵营、资源、单位名称、角色造型、界面术语和视觉语言；禁止沿用、翻译或近似改写现有游戏的专有角色、单位名、Logo、贴图、标志性布局与受保护视觉语言。除非用户明确提供有权使用的项目内素材，否则不得把 Sunflower、Peashooter、向日葵、豌豆射手、僵尸等知名塔防元素写入策划、记忆、代码、图片提示或正式产物。
-
-静态委派协议：新 agent.delegate 必须提交 1-8 条 acceptanceCriteria、0-16 个精确项目内非私有 expectedArtifacts，以及 nullable repairOfDelegationId/runId/continuationOfDelegationId/questionsSha256/answersSha256，普通委派后三项传 null。专业 Agent 收到的 task 会携带完整合同。Supervisor 认领回执后必须区分 evidence-ready、needs-user-input 与 needs-repair；前者仍需语义验收，needs-repair 不能作为成功。专业 Agent 若缺少会实质改变结果的用户事实，不能调用 user.input_request，必须以最终回复首行 `AGC_NEEDS_USER_INPUT_V1`，下一行短 JSON `{"questions":[...]}` 返回 1-3 个结构化问题；Runtime 会把它作为内部回执交给 Supervisor。Supervisor 对每个原 delivery 逐一用现有 user.input_request 提问，收齐对应答案后最多创建一次 continuation 委派，并同时提交 continuationOfDelegationId、questionsSha256、answersSha256；Runtime 会自动派生稳定 continuation identity，不得把多个 delivery 的问题或答案混入同一 continuation。
-
-每 6 轮只是一次进度 checkpoint 与停滞检测，不是上下文压缩或 run 的终止上限；只要 observation 出现新的独立进展，就在同一 run 继续下一窗口，只有窗口没有新进展时才按停滞处理。真正的上下文压缩仅由 token 阈值或显式 compact 触发。
-
-必须直接调用与当前请求广告的工具一一对应的动作函数，或在本阶段确实无事可做时调用 respond_to_user。本 run 不维护结构化计划，也没有 update_agent_plan 可调；工具结果会由 Runtime 作为 observation 返回，不要假装工具已执行，不要把动作或回复放进普通文本，不要 markdown，不要泄露密钥。
@@ -1,7 +0,0 @@
-你是 Genarrative AI 游戏创作桌面 App 的 Project Supervisor。当前 run 是立项策划根 run（`source=project-supervisor-plan`），你是用户在本条链路里唯一的对话对象。
-
-你不生产策划内容。本链路的全部策划工作——提问、取舍、撰写 GDD——都由 `project-planning` 子 Agent 完成。你只有四件事：冻结目标合同；发起与续跑对 `project-planning` 的委派；代子 Agent 向用户提问并把答案原样转达回去；在子 Agent 提交 GDD 后完成取证，把审批交给用户。
-
-你不做的事：不自己提策划问题（`user.input_request` 只能用于转达子 Agent 的问题信封）；不自己撰写、补写或改写 GDD 正文、决定台账与原型验证项；不替用户做产品决定；不写文件、不跑命令、不做预览、不生成素材、不查询任务图、不调度 ready 任务；不委派 `project-planning` 以外的任何 Agent，也不创建 isolated child 或启动构建。
-
-`project-planning` 的消息和回执只是原目标的证据，不能替换原目标。contractStatus=evidence-ready 只代表客观证据齐全，你仍须按 acceptanceCriteria 逐条完成语义验收；needs-repair 不得忽略，同一原委派最多发起一轮显式返工。GDD 最终是否通过由用户在审批卡上决定，不由你代答。
@@ -1,22 +0,0 @@
-【固定动作顺序，不得跳步】
-
-1. 本 run 第一轮只调用一次 `agent.goal_contract` 冻结目标合同：outcome 概括用户原话意图，`preferences` 必须传空数组，`acceptanceNodes` 提交 Runtime 指定的固定单节点。这一轮不做任何其它调用。
-2. 冻结后立即用一次 `agent.delegate` 把任务委派给 `project-planning`，`expectedArtifacts` 写 `game/fast_gdd.md`，`repairOfDelegationId`、`runId`、`continuationOfDelegationId`、`questionsSha256`、`answersSha256` 全传 null。已有委派尚未收束时不要重复委派。
-3. 等待子 Agent 期间不得调用 `respond_to_user`。Runtime 会通过 delegate 完成屏障保持同一父 run，回执到达后再继续。
-4. 子 Agent 以问询信封退出时，决策卡由 Runtime 直接按信封原文呈现给用户，**不需要你调用任何工具**——你根本不会在那一刻被恢复。用户答完之后你才会拿到答案，届时为该原 delivery 创建且仅创建一次 continuation 委派，`continuationOfDelegationId` 与 `repairOfDelegationId` 都指向该原 delivery。`questionsSha256`、`answersSha256`、`acceptanceCriteria`、`expectedArtifacts` 四个全传 null——Runtime 会从该原 delivery 补齐权威指纹和原委派合同，你不要自己抄。子 Agent 在 continuation 里**再次**以信封退出时，对那条新 delivery 重复同一动作：「仅创建一次」约束的是单条 delivery，不是整条链，澄清预算未用尽时这个循环继续。Runtime 会在委派 task 末尾写明已用轮次与上限，不需要你自己数，也不要替它宣布预算已尽。
-5. 回执 contractStatus=evidence-ready 且 GDD 已提交时，用 `file.read` 从第 1 行读到 `game/fast_gdd.md` 末尾取证，每次都传 `maxLines: 240`（上限），尽量一页读完；确实需要第二页时从上一页的下一行开始，不要重复读同一段。每次 `file.read` 的 observation 末尾都带着 `sourceAgentId` / `sourceRunId` / `sourceActionId` 三个字段，把它们原样抄成 evidence 的 `{agentId, runId, actionId}`，用一次 `agent.acceptance_update` 一并提交即可——evidence 是按这三个字段整体查回执的，回忆错任何一个都会被判成"缺少持久动作回执"。不要为了取这些字段再去查动作历史。取证完成前审批卡不会出现。
-6. 用户在审批卡上选择修改或退回时，直接创建返工委派：`repairOfDelegationId` 指向原 delegationId，`runId`、`acceptanceCriteria`、`expectedArtifacts` 都传 null——Runtime 会从原 delivery 继承权威合同，不需要先 `agent.run_status` 去取再手抄。把用户原话完整附在 task 里。「同一原委派只能返工一次」约束的是单条 delivery，不是整条链：用户看过新稿再点一次修改，就对那条新 delivery 重复同一动作，这个循环没有次数上限——`repair_depth` 防的是 runaway agent，而每一轮修订都由用户亲手触发，人本身就是循环边界。不要替 Runtime 宣布「这是最后一次修改机会」，也不要因此把多条意见攒到一轮里改完。用户通过后只做一句简短收尾。
-
-【转达的规则】
-
- 把用户答案回灌给 `project-planning` 时，逐条列出全部已确认决定，每条格式为 `[已确认] 第N轮问的是：{question 原文} ｜ 候选项：{option1.label} ／ {option2.label} ／ {option3.label} → 用户答：{原文}`。**问题原文和三个选项标签必须带上**：`{header}` 只写到「第N轮·当前要决定：{主题}」这一层，答案落在选项上；子 Agent 每轮都是全新 run，除了这段正文什么都看不到，只给它主题和答案，「类似B」「B · 沙盒里程碑成长」这类答案就无从解读，它只能把同一件事再问一遍。用户答案原文一字不改、不归纳、不拆分、不搬轮次；任务长度接近上限时压缩你自己的说明文字和选项描述，绝不压缩用户答案、问题原文和选项标签。
- 策划链路的澄清信封**恰好一题**，不是通用静态委派协议里的 1-3 题：`project-planning` 每轮只提一个主要决定，Runtime 也只接受一题，多于一题会在出卡时被拒。委派 task 里不要写“1-3 个结构化问题”。
- 上一条格式里的三个选项标签就是决策卡上的 A、B 和“需要原型验证”，必须原样转述、一个都不能省；B 是用户确认的 `confirmed/user_option`，不能转成默认建议。用户后续自由填写推翻了更早的决定时，你只负责把两轮答案的原文都原样带到，并说明后者更晚；怎么记进决定台账由 `project-planning` 判断，不要替它裁定哪条作废。
-
-【委派合同的边界】
-
-委派 `project-planning` 时，acceptanceCriteria 只写产物形状、覆盖范围与红线（例如必须交付 `game/fast_gdd.md`、必须原创、必须只定义一个 MVP 闭环），**不得替用户预先裁定产品取舍**。用户没有指定的玩法规则、数值、关卡量级、美术方向和目标人群，一律留给策划子 Agent 按其 3 轮问询预算决定是提问还是按默认建议填写；不要写“未指定的标注为立项假设”“自行假设后继续”这类指令，那会把问询预算作废。平台事实（自包含 Web、desktop/mobile 双视口、keyboard/touch 双输入、本地 HTTP 预览）由 Runtime 固定注入，属于已定事实，不得要求标为待定、建议或开放项。
-
-**本轮指令三选一。** 委派任务正文里，除了用户原始意图和已确认答案原文，你只能再写一句“本轮该做什么”，且必须是下面三个之一：**继续澄清**（默认，不附加任何前置条件）、**直接出稿**（仅当用户明确要求跳过问询）、**按意见修订**（仅审批返回修改或退回时）。不要自己描述“什么情况下才该提问”“若缺少会实质改变结果的事实则……”“否则直接提交完整 GDD”——那不在这三项里。提问预算怎么花，由 `project-planning` 按 Runtime 注入的判据决定。
-
-不要向用户暴露内部 task/event、工具计划、动态 child ID 或调试状态。
@@ -1,33 +0,0 @@
-你是“立项策划 Agent”（`agentId=project-planning`），由 Project Supervisor 通过静态 `agent.delegate` 委派。你的工作是把一句用户需求收敛成可审批的 MVP Fast GDD；你只负责玩法澄清、原型验证建议和最小 GDD，不负责完整游戏构建。
-
-## 身份与边界
-
- 当前 run 固定为 `source=agent-delegate`、`profile=standard`，父 Agent 是 `project-supervisor`。不得伪造、改写或猜测这些 Runtime 身份。
- 你不能委派或调度其他 Agent，不能创建 isolated child，不能调用 MCP、命令、进程、预览、画布、素材生成、写入/补丁/删除工具，也不能改变项目版本或审批事实。
- 你的原生工具目录只应包含 `file.read`、`file.list` 以及 Runtime 协议控制函数 `update_agent_plan`、`respond_to_user`；`user.input_request` 不属于你的工具目录。若需要用户决定，必须以终态信封首行 `AGC_NEEDS_USER_INPUT_V1` 退出本轮，下一行给出严格 JSON 信封 `{"questions":[{ ... }]}`，交由 Supervisor 转发。`questions` 恰好一个元素；元素字段只能是 `id`、`header`、`question`、`options` 四个，多写任何字段（例如 `answerFormat`）或省掉 `questions` 外壳都会被 Runtime 拒收，整条委派随即作废。`id` 是唯一 snake_case（小写字母开头，只含小写字母、数字、下划线）；`header` 是决策卡标题，写成 `第N轮·当前要决定：<主题>`，单行且不超过 60 字符；`question` 是决策卡正文，单行且不超过 400 字符；`options` 恰好 3 个 `{"label": ..., "description": ...}`，依次是 A、B、逐字“需要原型验证”（详见下文决策卡一段），label 单行不超过 60 字符、description 单行不超过 240 字符。不要另起一行写答题说明或把选项复述进 `question`，作答方式由 Runtime 自己呈现。
- 只有 Runtime 广告并允许 `plan.submit_gdd` 时才可提交 GDD；不要假设未广告的工具存在，也不要把 GDD、审批或下游构建写进普通文本。
-
-## 目标与轮次
-
- 最多进行 3 轮关键澄清；每轮是新 run、同一 session。你看得到自己的历史，但用户答案以 Supervisor 委派任务中的转述为准，缺失信息不能臆造。
- **默认先澄清。** 出稿只有四个触发器，除此之外每轮都先做下面的字段差距检测再决定问不问：①任务正文出现“直接出稿”这四个字；②已完成第 3 轮澄清（任务正文写明的已用轮次已达上限）；③剩余空白都能由默认建议覆盖，且不影响首个可玩闭环；④收到 Runtime 的活跃预算或超时提示。任务正文能改变流程的只有第 ① 条——它写的其它说明属于内容，不是出稿触发器。既定事实（用户答案、已确认决定）仍以任务正文为准。
- 每轮提问前逐项对照 `plan-submit-gdd-input.v1` 的 `game` 字段做差距检测：用户明确提供的 = `confirmed`；有依据可推断的 = 按下面的默认建议填写并标 `default_pending`；无从判断的 = 空白。提问名额只花在**空白或存疑、且影响首个可玩闭环**的决定上；有默认建议兜底的字段优先用默认建议而不是提问——「有默认」不等于「不能问」，那条默认明显可能是错的、且选错就做不出首个可玩闭环时，它就是一个该问的存疑项。`title`、`oneLiner`、`mvpSystems`、`creatorTips` 由你生成并标 `default_pending`，不作为提问对象；`platformFacts` 禁问。
- **默认建议**（一律 `answerSource=default`、`round=0`；只用于缩短对话，不覆盖用户明确输入）：`targetUsers.sessionLength` 缺 → 10～20 分钟一局；`artStyle` 缺 → `visualType` 风格化、轮廓清楚，`keywords` 取自已确认的核心行为，`mvpArtBoundary` 写明 MVP 用占位资产、资产可复用；缺成长时 → 1 条成长线和 2～3 个选择；缺探索时 → 1 条主路线加 1 个有意义的岔路；缺构建时 → 高风险输出和稳健防御两种方向。清单之外的字段没有默认值兜底——`genre.fusion`、`targetUsers.coreUsers` / `preferences` / `referenceGames`、`outOfScope` 缺失时都算空白，该不该花一轮问它们由上面的判据决定，不要自己拍一个值填掉就当它已经定了。**`pillars` 与 `coreLoop` 没有默认建议**：它们就是首个可玩闭环本身，空白时属于该问的空白，不得用默认值填掉。
- 优先顺序：核心行为与本局目标 → 重玩动力 → 制作边界与 MVP。每轮最多问一个主要决定。**已确认决定关掉的那条轴不得重问。** 任务正文里每条 `[已确认]` 都带着当轮的问题原文和三个选项标签，先照它判断哪些轴已经关闭，本轮的问题必须落在另一条还没关闭的轴上。把已确认答案换个说法再问一遍——例如用户已经选定“自由经营、靠成就和攒钱升级推进”，你又拿“短周期经营目标 vs 沙盒里程碑成长”去问——是白烧一轮预算。所有轴都已关闭时按出稿触发器③直接出稿。
- 决策卡的 header 写成“第N轮·当前要决定：<主题>”，最多 60 字符。N 是 Runtime 从委派谱系派生的当前轮号，写错会被 Runtime 拒收：首轮恒为 1；之后每次续跑的任务正文都会写明已用轮次与上限，本轮该用的 N 就是“已用轮次 + 1”。`<主题>` 是这一轮真正要定的那件事本身（例如“塔的构筑方式”“每局变化来源”），一句话说完、不带状态标记——它会原样落进决定台账的 `topic`，也是你下一轮辨认哪些轴已经关掉的唯一线索，写成“关键决定”这类空话等于把它作废。正文只问尚未由平台事实或 MVP 规则排除的真实产品取舍，并说明为什么现在问；每张卡固定提供三个选项：A 是你的推荐方案（label 以 `A ·`、`A:`、`A：` 或 `A-` 开头并写明推荐、好处和代价），B 是形状不同且真实可行的平行备选（label 以 `B ·`、`B:`、`B：` 或 `B-` 开头并写明后果和代价），第三项逐字为“需要原型验证”，description 必须给出 30～90 分钟微型原型、试玩对象、观察信号和通过标准。自由输入按用户原话处理。
-
-## 低幻觉与 GDD 约束
-
- 用户描述玩法类型、机制或“像某款游戏”时，不代表授权复刻该游戏。游戏名称、世界观、角色与单位名、阵营、资源、界面术语和视觉语言必须原创；不得沿用、翻译或近似改写现有游戏的专有名称、Logo、标志性布局与受保护视觉语言，也不得把它们写进 GDD 正文、决定台账或原型验证项。用户提到的相似作品只能作为抽象品类参考，`targetUsers.referenceGames` 同样不得填入受保护名称。你的工具面窄，但内容红线不因此放宽——GDD 是整条产线的上游。
- 决定台账记录当前 GDD 的决定快照。澄清阶段的 A、B 或自由填写得到的用户决定标 `confirmed`，选择“需要原型验证”标 `prototype_pending`；未提问、由你按默认建议填写的字段标 `default_pending`、`answerSource=default`、`round=0`。审批阶段的用户修改意见是本轮最高优先级：由该意见新增或改写的决定使用 `answerSource=user_revision`、`round=0`，并按当前意见重新填写 `topic`、`state` 和 `answerSummary`。
- 以当前 GDD 为基线，仅修改用户审批意见明确涉及的内容，以及为保持内部一致性所必需同步调整的派生内容。未被意见涉及的内容保持不变；如果意见与过去决定冲突，以最新意见为准。不要把用户未要求的其它方向自行扩展进本轮修订。提交时仍须提供完整 GDD 快照，但完整快照不代表可以任意重写未涉及内容。
- `prototypeValidationItems` 是必填字段（没有就传空数组），与 `prototype_pending` 决定**一一对应**：每条 `prototype_pending` 决定必须有一个同 id 的验证项，每个验证项也必须对应一条 `prototype_pending` 决定，最多 3 项。除了用户亲选“需要原型验证”之外，你自己也可以主动标：手感、节奏、可读性、难度曲线这类你没问过、但选错就做不出首个可玩闭环的判断，标 `prototype_pending`（`answerSource=default`、`round=0`）比标 `default_pending` 诚实——那不是一个默认值，是一个没人验证过的假设。每项写清 30～90 分钟微型原型做什么、让谁试玩、观察什么信号、什么算通过。
- 不得编造具体游戏的机制、数值、销量、人群规模、团队规模或来源。写 `targetUsers` 时按已确认的类型与核心行为描述典型玩家即可。
- 只定义一个完整可玩闭环。MVP 不含多人、商城、服务器、开放世界、赛季、复杂社交、完整剧情或全量内容，除非用户明确改变范围。
- GDD 至少覆盖：游戏名称与类型、一句话描述、2～4 条游戏支柱、核心循环、目标用户、美术方向、3～6 个最小 MVP 系统、先做/暂缓/验证/扩展条件、决定状态和审批请求。不要把 Runtime 注入的身份、时间、指纹、审批 receipt 或平台事实当作 Provider 输入字段。
- 平台事实由 Runtime 固定注入为自包含 Web、desktop/mobile 双视口、keyboard/touch 双输入、本地 HTTP 预览；不得修改、删减或向用户询问。
-
-## 输出纪律
-
- 澄清模式只返回 `AGC_NEEDS_USER_INPUT_V1` 终态信封，不再调用其他函数；成稿模式只在 `plan.submit_gdd` 被广告时调用它并等待 Runtime 校验；收到 revise/reject observation 后按同一 GDD 谱系修订，收到 approve 后只做简短收尾。
- 必须直接调用当前请求广告的原生函数；不要输出 JSON、代码围栏或内部思考过程，不要假装已经写入文件、完成审批或启动构建。
@@ -16,6 +16,7 @@ mod direct_codex_attachments;
 mod direct_codex_audit;
 mod direct_project_history;
 mod direct_project_turn_history;
+mod direct_codex_references;
 mod direct_runtime;
 mod direct_tool_bridge;
 mod direct_tools_mcp;
@@ -42,6 +43,7 @@ pub(crate) use direct_codex_attachments::*;
 pub(crate) use direct_codex_audit::*;
 pub(crate) use direct_project_history::*;
 pub(crate) use direct_project_turn_history::*;
+pub(crate) use direct_codex_references::*;
 pub(crate) use direct_runtime::*;
 pub(crate) use direct_tool_bridge::*;
 pub(crate) use direct_tools_mcp::*;
@@ -3777,8 +3777,6 @@ pub(crate) async fn direct_game_creator_codex_chat_at_with_optional_observer(
        request_slot: "direct-chat".to_string(),
        web_search_enabled: config.llm.web_search_enabled,
        allow_idle_context_compaction: false,
-        // direct-codex 不是立项策划链路，没有 planning session 可绑定。
-        planning_session_binding: None,
    };
    let api_kind =
        parse_game_creator_llm_api_kind(&config.llm.api_kind).map_err(|error| error.to_string())?;
@@ -3845,8 +3843,6 @@ pub(crate) async fn direct_game_creator_home_codex_chat(
        request_slot: "direct-home-chat".to_string(),
        web_search_enabled: config.llm.web_search_enabled,
        allow_idle_context_compaction: false,
-        // 直连 Codex 的首页对话不属于任何立项策划 session。
-        planning_session_binding: None,
    };
    let api_kind =
        parse_game_creator_llm_api_kind(&config.llm.api_kind).map_err(|error| error.to_string())?;
@@ -4180,7 +4176,6 @@ mod tests {
            request_slot: "slot-1".to_string(),
            web_search_enabled: false,
            allow_idle_context_compaction: false,
-            planning_session_binding: None,
        }
    }

@@ -0,0 +1,328 @@
+use super::*;
+
+pub(crate) const MAX_DIRECT_CODEX_REFERENCES: usize = 32;
+const MAX_DIRECT_CODEX_REFERENCE_ID_CHARS: usize = 200;
+const MAX_DIRECT_CODEX_REFERENCE_LABEL_CHARS: usize = 160;
+const MAX_DIRECT_CODEX_REFERENCE_SOURCE_CHARS: usize = 32;
+const MAX_DIRECT_CODEX_REFERENCE_ELEMENT_CHARS: usize = 80;
+const MAX_DIRECT_CODEX_REFERENCE_TEXT_CHARS: usize = 240;
+
+const DIRECT_CODEX_REFERENCE_HEADER: &str =
+    "[本轮用户引用素材：以下均为当前项目已确认的安全引用。请使用稳定资源 ID 和项目相对路径读取，不要读取或输出其它路径。]";
+
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase", tag = "type")]
+pub(crate) enum DirectCodexTurnReference {
+    #[serde(rename = "resource")]
+    Resource(DirectCodexResourceReference),
+    #[serde(rename = "runtime-region")]
+    RuntimeRegion(DirectCodexRuntimeRegionReference),
+}
+
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DirectCodexResourceReference {
+    pub(crate) resource_id: String,
+    #[serde(default)]
+    pub(crate) label: Option<String>,
+    #[serde(default)]
+    pub(crate) source: Option<String>,
+}
+
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DirectCodexRuntimeRegionReference {
+    #[serde(default)]
+    pub(crate) label: Option<String>,
+    #[serde(default)]
+    pub(crate) run_id: Option<String>,
+    #[serde(default)]
+    pub(crate) version_id: Option<String>,
+    #[serde(default)]
+    pub(crate) element_tag: Option<String>,
+    #[serde(default)]
+    pub(crate) element_role: Option<String>,
+    #[serde(default)]
+    pub(crate) text: Option<String>,
+    #[serde(default)]
+    pub(crate) width: Option<f64>,
+    #[serde(default)]
+    pub(crate) height: Option<f64>,
+    #[serde(default)]
+    pub(crate) resource_ids: Vec<String>,
+}
+
+fn sanitize_reference_text(value: &str, max_chars: usize) -> Option<String> {
+    let sanitized = value
+        .trim()
+        .chars()
+        .filter(|character| !character.is_control())
+        .take(max_chars)
+        .collect::<String>();
+    if sanitized.is_empty() {
+        None
+    } else {
+        Some(sanitized)
+    }
+}
+
+fn sanitize_reference_label(value: Option<&str>) -> Option<String> {
+    value.and_then(|value| sanitize_reference_text(value, MAX_DIRECT_CODEX_REFERENCE_LABEL_CHARS))
+}
+
+fn sanitize_reference_source(value: Option<&str>) -> Option<String> {
+    let value = sanitize_reference_text(value?, MAX_DIRECT_CODEX_REFERENCE_SOURCE_CHARS)?;
+    if value
+        .chars()
+        .all(|character| character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.'))
+    {
+        Some(value)
+    } else {
+        None
+    }
+}
+
+fn sanitize_reference_element(value: Option<&str>) -> Option<String> {
+    let value = sanitize_reference_text(value?, MAX_DIRECT_CODEX_REFERENCE_ELEMENT_CHARS)?;
+    if value
+        .chars()
+        .all(|character| character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.'))
+    {
+        Some(value)
+    } else {
+        None
+    }
+}
+
+fn sanitize_reference_dimension(value: Option<f64>) -> Option<u32> {
+    value
+        .filter(|value| value.is_finite() && *value > 0.0)
+        .map(|value| value.round().clamp(1.0, 100_000.0) as u32)
+}
+
+fn asset_display_label(asset: &GameCreationAppAssetManifestEntry) -> String {
+    let basename = asset
+        .local_path
+        .rsplit(['/', '\\'])
+        .next()
+        .unwrap_or(&asset.id);
+    let without_extension = basename
+        .rsplit_once('.')
+        .map(|(name, _)| name)
+        .unwrap_or(basename)
+        .trim();
+    if without_extension.is_empty() {
+        asset.id.clone()
+    } else {
+        without_extension
+            .chars()
+            .filter(|character| !character.is_control())
+            .take(MAX_DIRECT_CODEX_REFERENCE_LABEL_CHARS)
+            .collect()
+    }
+}
+
+fn validate_resource_reference_id(value: &str) -> Result<String, String> {
+    let resource_id = value.trim();
+    if resource_id.is_empty()
+        || resource_id.chars().count() > MAX_DIRECT_CODEX_REFERENCE_ID_CHARS
+        || resource_id.chars().any(char::is_control)
+    {
+        return Err("引用的素材 ID 无效，请移除后重新选择".to_string());
+    }
+    Ok(resource_id.to_string())
+}
+
+fn render_resource_reference_line(
+    manifest: &GameCreationAppManifest,
+    reference: &DirectCodexResourceReference,
+) -> Result<String, String> {
+    let resource_id = validate_resource_reference_id(&reference.resource_id)?;
+    let asset = manifest
+        .assets
+        .iter()
+        .find(|asset| asset.id == resource_id)
+        .ok_or_else(|| "引用的素材已不存在，请移除后重新选择".to_string())?;
+    let local_path = sanitize_attachment_local_path(&asset.local_path)
+        .ok_or_else(|| "引用的素材路径无效，请移除后重新选择".to_string())?;
+    let label = sanitize_reference_label(reference.label.as_deref())
+        .unwrap_or_else(|| asset_display_label(asset));
+    let source = sanitize_reference_source(reference.source.as_deref())
+        .unwrap_or_else(|| "unknown".to_string());
+    Ok(format!(
+        "- 素材 ID：{resource_id}；名称：{label}；类型：{}；媒体类型：{}；项目路径：{local_path}；来源：{source}",
+        asset.kind, asset.media_type
+    ))
+}
+
+fn render_runtime_region_reference_line(
+    manifest: &GameCreationAppManifest,
+    reference: &DirectCodexRuntimeRegionReference,
+) -> Result<String, String> {
+    let label = sanitize_reference_label(reference.label.as_deref())
+        .unwrap_or_else(|| "运行画面区域".to_string());
+    let run_id = sanitize_reference_source(reference.run_id.as_deref());
+    let version_id = sanitize_reference_source(reference.version_id.as_deref());
+    let element_tag = sanitize_reference_element(reference.element_tag.as_deref());
+    let element_role = sanitize_reference_element(reference.element_role.as_deref());
+    let text = reference
+        .text
+        .as_deref()
+        .and_then(|value| sanitize_reference_text(value, MAX_DIRECT_CODEX_REFERENCE_TEXT_CHARS));
+    let width = sanitize_reference_dimension(reference.width);
+    let height = sanitize_reference_dimension(reference.height);
+
+    let mut related_resource_ids = Vec::new();
+    for resource_id in &reference.resource_ids {
+        let resource_id = validate_resource_reference_id(resource_id)?;
+        if !manifest.assets.iter().any(|asset| asset.id == resource_id) {
+            return Err("运行画面引用的素材已变化，请重新点选".to_string());
+        }
+        related_resource_ids.push(resource_id);
+    }
+
+    let mut parts = vec![format!("名称：{label}")];
+    if let Some(run_id) = run_id {
+        parts.push(format!("运行标识：{run_id}"));
+    }
+    if let Some(version_id) = version_id {
+        parts.push(format!("版本标识：{version_id}"));
+    }
+    if let Some(element_tag) = element_tag {
+        parts.push(format!("元素：{element_tag}"));
+    }
+    if let Some(element_role) = element_role {
+        parts.push(format!("角色：{element_role}"));
+    }
+    if let Some(text) = text {
+        parts.push(format!("文本摘要：{text}"));
+    }
+    if let (Some(width), Some(height)) = (width, height) {
+        parts.push(format!("尺寸：{width}x{height}"));
+    }
+    if !related_resource_ids.is_empty() {
+        parts.push(format!("关联素材 ID：{}", related_resource_ids.join(",")));
+    }
+    Ok(format!("- 运行画面区域：{}", parts.join("；")))
+}
+
+pub(crate) fn render_direct_codex_references_section(
+    root: &Path,
+    references: &[DirectCodexTurnReference],
+) -> Result<Option<String>, String> {
+    if references.is_empty() {
+        return Ok(None);
+    }
+    if references.len() > MAX_DIRECT_CODEX_REFERENCES {
+        return Err(format!("一次最多引用 {MAX_DIRECT_CODEX_REFERENCES} 个素材"));
+    }
+    let manifest = read_manifest_for_project(root)?;
+    let mut lines = Vec::with_capacity(references.len());
+    for reference in references {
+        lines.push(match reference {
+            DirectCodexTurnReference::Resource(reference) => {
+                render_resource_reference_line(&manifest, reference)?
+            }
+            DirectCodexTurnReference::RuntimeRegion(reference) => {
+                render_runtime_region_reference_line(&manifest, reference)?
+            }
+        });
+    }
+    Ok(Some(
+        std::iter::once(DIRECT_CODEX_REFERENCE_HEADER.to_string())
+            .chain(lines)
+            .collect::<Vec<_>>()
+            .join("\n"),
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixture_project() -> tempfile::TempDir {
+        let directory = tempfile::tempdir().expect("temp project");
+        let root = directory.path();
+        std::fs::create_dir_all(root.join(".agent")).expect("create agent dir");
+        let mut manifest = new_game_creation_app_manifest("project-1", "测试项目");
+        manifest.assets.push(GameCreationAppAssetManifestEntry {
+            id: "asset-hero".to_string(),
+            kind: "character".to_string(),
+            media_type: "image/png".to_string(),
+            local_path: "assets/hero.png".to_string(),
+            source: GameCreationAppAssetSource {
+                kind: GameCreationAppAssetSourceKind::Uploaded,
+                canvas_project_id: None,
+                resource_id: None,
+                asset_object_id: None,
+                task_id: None,
+                prompt: None,
+                model: None,
+                generation_route: None,
+                generation_kind: None,
+                reference_resource_ids: Vec::new(),
+            },
+            image_sequence_frames: None,
+            image_sequence_duration_ms: None,
+            category: game_creation_app_asset_category_for_kind("character"),
+            tags: Vec::new(),
+        });
+        write_manifest(&root.join(".agent/manifest.json"), &manifest).expect("write manifest");
+        directory
+    }
+
+    #[test]
+    fn resource_reference_uses_manifest_identity_and_never_accepts_client_paths() {
+        let project = fixture_project();
+        let reference: DirectCodexTurnReference = serde_json::from_str(
+            r#"{"type":"resource","resourceId":"asset-hero","label":"主角","source":"asset-picker","localPath":"C:\\secret.png"}"#,
+        )
+        .expect("reference json");
+        let section = render_direct_codex_references_section(
+            project.path(),
+            std::slice::from_ref(&reference),
+        )
+        .expect("render")
+        .expect("section");
+        assert!(section.contains("素材 ID：asset-hero"));
+        assert!(section.contains("名称：主角"));
+        assert!(section.contains("项目路径：assets/hero.png"));
+        assert!(!section.contains("C:\\secret.png"));
+    }
+
+    #[test]
+    fn deleted_resource_fails_closed() {
+        let project = fixture_project();
+        let reference: DirectCodexTurnReference = serde_json::from_str(
+            r#"{"type":"resource","resourceId":"asset-missing","label":"不存在"}"#,
+        )
+        .expect("reference json");
+        let error = render_direct_codex_references_section(
+            project.path(),
+            std::slice::from_ref(&reference),
+        )
+        .expect_err("missing resource");
+        assert_eq!(error, "引用的素材已不存在，请移除后重新选择");
+    }
+
+    #[test]
+    fn runtime_region_keeps_only_safe_summary_and_existing_resource_ids() {
+        let project = fixture_project();
+        let reference: DirectCodexTurnReference = serde_json::from_str(
+            r#"{"type":"runtime-region","label":"开始按钮","runId":"run-1","elementTag":"button","elementRole":"button","text":"开始游戏","width":120.4,"height":40.2,"resourceIds":["asset-hero"],"html":"<button onclick=secret>"}"#,
+        )
+        .expect("reference json");
+        let section = render_direct_codex_references_section(
+            project.path(),
+            std::slice::from_ref(&reference),
+        )
+        .expect("render")
+        .expect("section");
+        assert!(section.contains("运行画面区域：名称：开始按钮"));
+        assert!(section.contains("文本摘要：开始游戏"));
+        assert!(section.contains("尺寸：120x40"));
+        assert!(section.contains("关联素材 ID：asset-hero"));
+        assert!(!section.contains("onclick"));
+        assert!(!section.contains("secret"));
+    }
+}
@@ -4414,6 +4414,7 @@ pub(crate) async fn chat_with_game_creator_direct_codex(
    creation_type: Option<String>,
    client_turn_id: Option<String>,
    attachments: Option<Vec<DirectCodexTurnAttachment>>,
+    references: Option<Vec<DirectCodexTurnReference>>,
 ) -> Result<String, String> {
    let root = Path::new(project_path.trim());
    let turn_id = normalize_direct_client_turn_id(client_turn_id.as_deref())?;
@@ -4428,16 +4429,33 @@ pub(crate) async fn chat_with_game_creator_direct_codex(
        &prompt,
        attachments.as_deref().unwrap_or_default(),
    );
-    let user_prompt = match render_direct_codex_user_prompt(
-        &prompt,
-        attachments.as_deref().unwrap_or_default(),
-    ) {
+    let attachments = attachments.unwrap_or_default();
+    let references = references.unwrap_or_default();
+    let mut user_prompt = match render_direct_codex_user_prompt(&prompt, &attachments) {
        Ok(prompt) => prompt,
+        Err(_) if !references.is_empty() && prompt.trim().is_empty() => String::new(),
        Err(error) => {
            audit.finish(false);
            return Err(error);
        }
    };
+    if let Some(reference_section) = match render_direct_codex_references_section(root, &references)
+    {
+        Ok(section) => section,
+        Err(error) => {
+            audit.finish(false);
+            return Err(error);
+        }
+    } {
+        if !user_prompt.trim().is_empty() {
+            user_prompt.push_str("\n\n");
+        }
+        user_prompt.push_str(&reference_section);
+    }
+    if user_prompt.trim().is_empty() {
+        audit.finish(false);
+        return Err("聊天内容不能为空".to_string());
+    }
    let reply = match run_direct_game_creator_turn_at_with_creation_type_and_emitter(
        root,
        &user_prompt,
@@ -4710,10 +4728,10 @@ mod tests {
        assert!(!prompt.contains("你是 Codex"));
        assert!(prompt.contains("不要等待 Supervisor"));
        assert!(prompt.contains("提示词与技能"));
-        assert!(prompt.contains("AGC 工程合同（仅说明项目边界，不是流程门槛）"));
+        assert!(prompt.contains("AGC 工程合同：当前 cwd 是用户选择的项目目录"));
        assert!(prompt.contains("客户端扩展列表中用户已启用的第三方 MCP"));
        assert!(prompt.contains("用户明确指定第三方 MCP Server 或工具时"));
-        assert!(prompt.contains("先按需读取当前 cwd 下适用的 `AGENTS.md`"));
+        assert!(prompt.contains("先读取当前 cwd 下适用的 AGENTS.md、README 或项目说明"));
        assert!(prompt.contains("agc_write_file"));
        assert!(prompt.contains("content 必须是目标文件的完整原始 UTF-8 正文"));
        assert!(prompt.contains("不得把 command.exec 的 Exit code、Wall time、Output 包装"));
@@ -1161,6 +1161,8 @@ fn bridge_registered_resource(
        "localPath": asset.local_path,
        "kind": asset.kind,
        "mediaType": asset.media_type,
+        "category": asset.category,
+        "tags": asset.tags,
        "canvasProjectId": asset.source.canvas_project_id,
        "resourceId": asset.source.resource_id,
        "assetObjectId": asset.source.asset_object_id,
@@ -2781,6 +2783,8 @@ mod tests {
            local_path: "assets/art-spritesheet-slices/player.png".to_string(),
            image_sequence_frames: None,
            image_sequence_duration_ms: None,
+            category: game_creation_app_asset_category_for_kind("art-spritesheet-slice"),
+            tags: Vec::new(),
            source: GameCreationAppAssetSource {
                kind: GameCreationAppAssetSourceKind::Canvas,
                canvas_project_id: Some("canvas-1".to_string()),
@@ -2844,6 +2848,8 @@ mod tests {
                },
            ]),
            image_sequence_duration_ms: Some(4_000),
+            category: game_creation_app_asset_category_for_kind("character-animation"),
+            tags: Vec::new(),
            source: GameCreationAppAssetSource {
                kind: GameCreationAppAssetSourceKind::Canvas,
                canvas_project_id: Some("canvas-1".to_string()),
@@ -2863,6 +2869,8 @@ mod tests {
            projection["imageSequenceFrames"][0]["objectKey"],
            "animations/frame-01.png"
        );
+        assert_eq!(projection["category"], "character");
+        assert_eq!(projection["tags"], json!([]));
        let serialized = projection.to_string();
        assert!(!serialized.contains("signed.invalid"));
        assert!(!serialized.contains("private prompt"));
@@ -2870,6 +2878,42 @@ mod tests {
        assert!(!serialized.contains("private.invalid"));
    }

+    #[test]
+    fn bridge_registered_resource_projects_manifest_classification_verbatim() {
+        let asset = GameCreationAppAssetManifestEntry {
+            id: "spec-1".to_string(),
+            kind: "spec".to_string(),
+            media_type: "application/json".to_string(),
+            local_path: "assets/specs/hero.json".to_string(),
+            image_sequence_frames: None,
+            image_sequence_duration_ms: None,
+            category:
+                shared_contracts::game_creation_app::GameCreationAppAssetCategory::UiInteraction,
+            tags: vec!["主角".to_string(), "第一版".to_string()],
+            source: GameCreationAppAssetSource {
+                kind: GameCreationAppAssetSourceKind::Generated,
+                canvas_project_id: None,
+                resource_id: None,
+                asset_object_id: None,
+                task_id: None,
+                prompt: Some("private prompt".to_string()),
+                model: Some("private model".to_string()),
+                generation_route: None,
+                generation_kind: None,
+                reference_resource_ids: Vec::new(),
+            },
+        };
+
+        let projection = bridge_registered_resource(&asset, false);
+        assert_eq!(projection["kind"], "spec");
+        assert_eq!(projection["category"], "ui-interaction");
+        assert_eq!(projection["tags"], json!(["主角", "第一版"]));
+        assert_eq!(projection["imageSequenceFrames"], Value::Null);
+        let serialized = projection.to_string();
+        assert!(!serialized.contains("private prompt"));
+        assert!(!serialized.contains("private model"));
+    }
+
    #[test]
    fn bridge_success_warnings_are_redacted_before_serialization() {
        let root = tempfile::tempdir().expect("warning redaction root");
@@ -256,7 +256,7 @@ fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value {
        }),
        json!({
                "name": "agc_list_registered_assets",
-                "description": "查询当前项目由客户端权威 manifest 登记的资源与未完成资源 operation。结果有界且只包含项目相对路径、稳定资源身份、序列帧身份和恢复状态，不返回 prompt、模型、签名 URL、宿主路径或凭据。",
+                "description": "查询当前项目由客户端权威 manifest 登记的资源与未完成资源 operation。结果有界且只包含项目相对路径、稳定资源身份、功能分类与自定义标签、序列帧身份和恢复状态，不返回 prompt、模型、签名 URL、宿主路径或凭据。",
                "inputSchema": {
                    "type": "object",
                    "properties": {
@@ -27,8 +27,9 @@ pub(in crate::agent) use canvas_generation::{
    commit_prepared_platform_art_asset_at, commit_prepared_platform_art_asset_strict_slices_at,
    generate_platform_art_asset_with_retained_runtime_options_at,
    generate_platform_art_asset_with_runtime_options_at,
-    platform_art_generation_error_result_unknown, register_existing_platform_art_slices_at,
-    request_platform_art_asset_with_runtime_options_at, restore_platform_art_asset_bytes_at,
+    platform_art_generation_error_result_unknown, recover_persisted_visual_generation_options,
+    register_existing_platform_art_slices_at, request_platform_art_asset_with_runtime_options_at,
+    restore_platform_art_asset_bytes_at,
    retained_platform_art_generation_runtime_spritesheet_identity_at,
    retained_platform_art_generation_runtime_state_matches_direct_stage_at,
    validate_platform_art_png_bytes_with_limits,
@@ -429,6 +429,87 @@ impl Default for PlatformArtAssetGenerationOptions {
    }
 }

+pub(in crate::agent) fn recover_persisted_visual_generation_options(
+    root: &Path,
+    pending: &AgentRuntimePendingToolAction,
+    prompt: &str,
+    requested: &PlatformArtAssetGenerationOptions,
+) -> Result<Option<PlatformArtAssetGenerationOptions>, String> {
+    let context = platform_art_generation_runtime_context_from_pending(pending);
+    let Some(state) = read_platform_art_generation_runtime_state(root, &context)? else {
+        return Ok(None);
+    };
+    let (path, ratio, size, kind, label, generation_kind) = match context.agent_id.as_str() {
+        "art-director" => (
+            "assets/art-spec.png",
+            "1:1",
+            "1K",
+            "icon-spec",
+            "游戏统一视觉规范图",
+            "spec",
+        ),
+        "design-foundation" => (
+            "assets/ui-prototype.png",
+            "16:9",
+            "2K",
+            "ui-prototype",
+            "游戏横屏界面原型图",
+            "ui-design",
+        ),
+        "art-asset-plan" => (
+            "assets/art-spritesheet.png",
+            "1:1",
+            "1K",
+            "art-spritesheet",
+            "游戏首版核心美术素材",
+            "icon-spritesheet",
+        ),
+        _ => return Ok(None),
+    };
+    let mut options = requested.clone();
+    let label = if context.agent_id == "design-foundation"
+        && options
+            .output_path
+            .as_deref()
+            .is_some_and(design_foundation_ui_page_output_path_is_valid)
+    {
+        "游戏功能页面设计图"
+    } else {
+        label
+    };
+    if options.output_path.is_none() {
+        options.output_path = Some(path.to_string());
+    }
+    for (value, default) in [
+        (&mut options.aspect_ratio, ratio),
+        (&mut options.image_size, size),
+        (&mut options.asset_kind, kind),
+        (&mut options.asset_label, label),
+    ] {
+        if value.is_empty() {
+            *value = default.to_string();
+        }
+    }
+    let snapshot = platform_art_generation_runtime_request_snapshot(&state)?;
+    // 只恢复经过身份校验的已有请求；显式改参和新请求仍走当前合同。
+    if snapshot.generation_kind == generation_kind
+        && snapshot.generation_prompt == build_platform_art_asset_prompt(prompt, &[], &options)
+        && options.asset_kind == kind
+        && options.aspect_ratio == ratio
+        && options.image_size == size
+        && (options.output_path.as_deref() == Some(path)
+            || (context.agent_id == "design-foundation"
+                && options
+                    .output_path
+                    .as_deref()
+                    .is_some_and(design_foundation_ui_page_output_path_is_valid)))
+    {
+        Ok(Some(options))
+    } else {
+        Ok(None)
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct ExistingPlatformArtAssetFingerprint {
    local_path: String,
@@ -6705,6 +6786,8 @@ fn register_platform_art_slice_manifest_entries_at(
                    local_path: registration.local_path.clone(),
                    image_sequence_frames: None,
                    image_sequence_duration_ms: None,
+                    category: game_creation_app_asset_category_for_kind("art-spritesheet-slice"),
+                    tags: Vec::new(),
                    source,
                });
                ids.push(id);
@@ -8895,13 +8978,13 @@ mod canvas_generation_tests {
    }

    #[test]
-    fn strict_spritesheet_contract_requires_the_grid_2x2_provider_receipt() {
+    fn strict_spritesheet_contract_accepts_variable_slices_without_fixed_layout() {
        let canvas_context = ExternalCanvasGenerationContext {
            project_id: "canvas-project".to_string(),
            asset_folder_id: "asset-folder".to_string(),
            canvas_name: "contract-test".to_string(),
        };
-        let slices = (0..4)
+        let slices = (0..3)
            .map(|index| {
                let download = rgba_test_png(100 + index);
                let validated = validate_platform_art_png_bytes_with_limits(
@@ -8927,7 +9010,7 @@ mod canvas_generation_tests {
                }
            })
            .collect::<Vec<_>>();
-        let error = validate_strict_platform_art_spritesheet_contract(
+        validate_strict_platform_art_spritesheet_contract(
            &slices,
            &canvas_context,
            Some("canvas-project"),
@@ -8941,9 +9024,7 @@ mod canvas_generation_tests {
            true,
            true,
        )
-        .expect_err("missing fixed-layout proof must not be accepted");
-
-        assert!(error.contains("grid-2x2"));
+        .expect("valid slice identities and pixel evidence do not require a fixed layout");
    }

    #[test]
@@ -10168,7 +10249,8 @@ mod canvas_generation_tests {
    }

    #[tokio::test]
-    async fn accepted_runtime_generation_rejects_changed_intent_before_operation_get() {
+    async fn accepted_runtime_generation_checks_running_operation_before_rejecting_changed_intent()
+    {
        let temporary = tempfile::tempdir().expect("create changed-intent recovery project");
        let root = temporary.path();
        init_local_game_project_at(root, "changed-intent", "旧异步生成意图隔离")
@@ -10188,6 +10270,31 @@ mod canvas_generation_tests {
            .set_nonblocking(true)
            .expect("set changed intent fixture nonblocking");
        let base_url = format!("http://{}", listener.local_addr().expect("fixture address"));
+        let (request_sender, request_receiver) = std::sync::mpsc::channel();
+        let (stop_sender, stop_receiver) = std::sync::mpsc::channel();
+        let server = std::thread::spawn(move || loop {
+            if stop_receiver.try_recv().is_ok() {
+                break;
+            }
+            let (mut stream, _) = match listener.accept() {
+                Ok(connection) => connection,
+                Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+                    std::thread::sleep(Duration::from_millis(5));
+                    continue;
+                }
+                Err(error) => panic!("accept changed intent request: {error}"),
+            };
+            request_sender
+                .send(read_test_http_request(&mut stream))
+                .expect("capture status request");
+            write_test_json_response(
+                &mut stream,
+                "200 OK",
+                &serde_json::json!({
+                    "data": {"operationId": "old-operation", "status": "running"}
+                }),
+            );
+        });
        let runtime_context = PlatformArtGenerationRuntimeContext {
            agent_id: "art-director".to_string(),
            task_id: "art-director".to_string(),
@@ -10253,10 +10360,15 @@ mod canvas_generation_tests {
            error.contains("当前生成意图与已持久化请求快照不一致"),
            "{error}"
        );
-        assert!(matches!(
-            listener.accept(),
-            Err(error) if error.kind() == std::io::ErrorKind::WouldBlock
-        ));
+        stop_sender.send(()).expect("stop changed intent fixture");
+        server.join().expect("join changed intent fixture");
+        let requests = request_receiver.try_iter().collect::<Vec<_>>();
+        assert_eq!(
+            requests.len(),
+            1,
+            "only the existing operation may be queried"
+        );
+        assert!(requests[0].starts_with("GET /api/external/v1/generations/old-operation "));
        assert!(game_creator_agent_runtime_external_generation_exists(
            root,
            &runtime_context.agent_id,
@@ -10265,7 +10377,8 @@ mod canvas_generation_tests {
    }

    #[tokio::test]
-    async fn accepted_derived_generation_rejects_changed_art_spec_before_operation_get() {
+    async fn accepted_derived_generation_checks_running_operation_before_rejecting_changed_art_spec(
+    ) {
        let temporary = tempfile::tempdir().expect("create changed reference project");
        let root = temporary.path();
        init_local_game_project_at(root, "changed-reference", "规范图身份隔离")
@@ -10310,6 +10423,31 @@ mod canvas_generation_tests {
            .set_nonblocking(true)
            .expect("set changed reference fixture nonblocking");
        let base_url = format!("http://{}", listener.local_addr().expect("fixture address"));
+        let (request_sender, request_receiver) = std::sync::mpsc::channel();
+        let (stop_sender, stop_receiver) = std::sync::mpsc::channel();
+        let server = std::thread::spawn(move || loop {
+            if stop_receiver.try_recv().is_ok() {
+                break;
+            }
+            let (mut stream, _) = match listener.accept() {
+                Ok(connection) => connection,
+                Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => {
+                    std::thread::sleep(Duration::from_millis(5));
+                    continue;
+                }
+                Err(error) => panic!("accept changed reference request: {error}"),
+            };
+            request_sender
+                .send(read_test_http_request(&mut stream))
+                .expect("capture status request");
+            write_test_json_response(
+                &mut stream,
+                "200 OK",
+                &serde_json::json!({
+                    "data": {"operationId": "old-background-operation", "status": "running"}
+                }),
+            );
+        });
        let runtime_context = PlatformArtGenerationRuntimeContext {
            agent_id: "direct-codex-art".to_string(),
            task_id: "direct-codex-art-game-background".to_string(),
@@ -10412,10 +10550,19 @@ mod canvas_generation_tests {
            "{error}"
        );
        assert!(error.contains("当前规范图身份"), "{error}");
-        assert!(matches!(
-            listener.accept(),
-            Err(error) if error.kind() == std::io::ErrorKind::WouldBlock
-        ));
+        stop_sender
+            .send(())
+            .expect("stop changed reference fixture");
+        server.join().expect("join changed reference fixture");
+        let requests = request_receiver.try_iter().collect::<Vec<_>>();
+        assert_eq!(
+            requests.len(),
+            1,
+            "only the existing operation may be queried"
+        );
+        assert!(
+            requests[0].starts_with("GET /api/external/v1/generations/old-background-operation ")
+        );
        assert!(game_creator_agent_runtime_external_generation_exists(
            root,
            &runtime_context.agent_id,
@@ -10809,6 +10956,38 @@ mod canvas_generation_tests {
        mark_platform_art_generation_runtime_accepted(root, state, "test-operation-id", 0)
            .expect("accept current generation fixture");

+        let sparse_options = PlatformArtAssetGenerationOptions {
+            output_path: Some(AGENT_RUNTIME_ART_SPEC_PATH.to_string()),
+            aspect_ratio: String::new(),
+            image_size: String::new(),
+            asset_kind: String::new(),
+            asset_label: String::new(),
+            ..Default::default()
+        };
+        assert_eq!(
+            recover_persisted_visual_generation_options(root, &pending, prompt, &sparse_options)
+                .expect("recover persisted defaults"),
+            Some(options.clone())
+        );
+        assert!(recover_persisted_visual_generation_options(
+            root,
+            &pending,
+            "显式改变生成意图",
+            &sparse_options,
+        )
+        .unwrap()
+        .is_none());
+        let mut explicit_options = sparse_options.clone();
+        explicit_options.asset_kind = "game-background".to_string();
+        assert!(recover_persisted_visual_generation_options(
+            root,
+            &pending,
+            prompt,
+            &explicit_options,
+        )
+        .unwrap()
+        .is_none());
+
        resume_game_creator_agent_background_tasks_at(root)
            .expect("resume accepted generation through recovery scan");
        let first = request_receiver
@@ -11063,19 +11242,18 @@ mod canvas_generation_tests {
    }

    #[test]
-    fn canonical_art_spritesheet_request_has_exactly_four_ordered_categories() {
+    fn canonical_art_spritesheet_request_preserves_project_requirements() {
        let descriptions = canonical_art_spritesheet_icon_descriptions("原创收集玩法");
-        assert_eq!(descriptions.len(), 4);
-        for (index, description) in descriptions.iter().enumerate() {
-            assert!(description.starts_with(&format!("第 {} 类", index + 1)));
-        }
+        assert_eq!(descriptions.len(), 1);
+        assert!(descriptions[0].contains("原创收集玩法"));
+        assert!(descriptions[0].contains("数量、类别、排列和切片方式由本次需求决定"));
    }

    #[test]
    fn canonical_art_spritesheet_descriptions_obey_external_editor_item_limit() {
        let descriptions = canonical_art_spritesheet_icon_descriptions(&"原创玩法需求".repeat(128));

-        assert_eq!(descriptions.len(), 4);
+        assert!(!descriptions.is_empty());
        assert!(descriptions
            .iter()
            .all(|description| description.chars().count() <= 200));
@@ -11466,7 +11644,7 @@ mod canvas_generation_tests {
    }

    #[test]
-    fn strict_slice_commit_rejects_non_four_slice_results_before_replacing_the_sheet() {
+    fn strict_slice_commit_rejects_empty_slice_results_before_replacing_the_sheet() {
        let temporary = tempfile::tempdir().expect("create strict slice project");
        let root = temporary.path();
        init_local_game_project_at(root, "strict-slices", "严格切片测试")
@@ -11481,9 +11659,9 @@ mod canvas_generation_tests {
            &replacement_options(),
            |_| Ok(()),
        )
-        .expect_err("strict spritesheet commit must require exactly four slices");
+        .expect_err("strict spritesheet commit must require at least one slice");

-        assert!(error.contains("恰好包含 4 个独立切片"));
+        assert!(error.contains("至少需要一个独立切片"));
        assert_eq!(fs::read(path).expect("read preserved sheet"), b"old-image");
        assert!(!root
            .join("assets/art-spritesheet-slices/manifest.json")
@@ -337,9 +337,6 @@ pub(crate) fn agent_role_memory_relative_path_for_task(task_id: &str) -> Result<
    if task_id == GAME_CREATOR_PROJECT_SUPERVISOR_AGENT_ID {
        return Ok(GAME_CREATOR_PROJECT_SUPERVISOR_MEMORY_PATH.to_string());
    }
-    if task_id == GAME_CREATOR_PROJECT_PLANNING_AGENT_ID {
-        return Ok(GAME_CREATOR_PROJECT_PLANNING_MEMORY_PATH.to_string());
-    }
    for group in GAME_CREATOR_AGENT_GROUP_DEFINITIONS {
        for role in group.roles {
            if role.task_id == task_id {
@@ -44,7 +44,6 @@ pub(in crate::agent) use run_status_observation::*;
 pub(in crate::agent) use structured_plan::*;
 pub(in crate::agent) use tool_plan_protocol::*;

-pub(crate) use crate::agent::runtime_protocol::plan_gdd_completion_blocker_at_locked;
 #[cfg(test)]
 pub(crate) use action_audit::agent_runtime_action_receipt_public_safe_detail_for_test;
 #[cfg(test)]
@@ -74,7 +73,6 @@ pub(crate) use context_compaction::compact_game_creator_agent_runtime_session_at
 pub(crate) use parallel_ledger::{
    agent_runtime_confirmation_path_component, agent_runtime_parallel_read_batch_len,
    agent_runtime_tool_allowed_for_agent, agent_runtime_tool_is_parallel_safe_read,
-    agent_runtime_tool_rejected_by_agent_identity,
    game_creator_agent_runtime_parallel_read_batch_path,
    game_creator_agent_runtime_pending_tool_action_path,
    game_creator_agent_runtime_provider_action_batch_path,
@@ -106,6 +104,7 @@ pub(crate) use project_gates::{
    prepare_agent_runtime_project_mutation_locked, process_session_completion_blocker_at,
    project_verification_completion_blocker, project_verification_completion_blocker_at,
    static_delegate_completion_blocker_at, structured_plan_completion_blocker,
+    try_acquire_game_creator_agent_runtime_project_write_lock,
    validate_agent_runtime_pending_verification_gate_before,
 };
 #[cfg(test)]
@@ -116,7 +115,6 @@ pub(crate) use project_gates::{
 };
 pub(crate) use provider_action_batch::{
    prepare_game_creator_agent_runtime_provider_action_batch,
-    prepare_game_creator_agent_runtime_provider_action_batch_with_planning_binding,
    update_game_creator_agent_runtime_provider_batch_member, AgentRuntimePendingToolAction,
    AgentRuntimeProviderActionBatch,
 };
@@ -147,9 +145,6 @@ pub(crate) use tool_plan_protocol::parse_game_creator_agent_tool_plan_response;
 pub(crate) use tool_policy_snapshot::{
    agent_runtime_acceptance_evidence_tools,
    agent_runtime_autonomous_design_foundation_command_is_allowed, agent_runtime_executable_tools,
-    agent_runtime_native_executable_tools, agent_runtime_plan_root_supervisor_tools,
-    agent_runtime_plan_root_supervisor_tools_for_stage,
-    agent_runtime_tool_policy_snapshot_for_run_at, plan_root_supervisor_stage_at,
-    plan_root_supervisor_stage_at_locked, PlanRootSupervisorStage,
-    AGENT_RUNTIME_CANVAS_ASSET_KINDS, AGENT_RUNTIME_PROJECT_PLANNING_ACTION_TOOLS,
+    agent_runtime_native_executable_tools, agent_runtime_tool_policy_snapshot_for_run_at,
+    AGENT_RUNTIME_CANVAS_ASSET_KINDS,
 };
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`你是游戏创作需求的润色助手。把用户给创作 Agent 的一段需求改写成更清晰、可执行的中文需求。要求：保留用户的原始意图、玩法、美术方向、数值与限制条件，不得新增或删除需求点，不得替用户做决定，不得写成方案书或任务清单。只输出润色后的需求正文，不要解释、不要引言、不要 Markdown 标记、不要引号包裹、不要重复用户原文；无法润色时原样输出用户输入。`