@ninkch/dsh-infinite-canvas 0.19.2 → 0.19.4

package/assets/canvas-director/moves/fight-rhythm.md

@@ -0,0 +1,77 @@
+---
+moves_id: fight-rhythm
+title: 打斗节奏
+kind: moves
+---
+
+# 打斗节奏
+
+打斗不是"更快地打架"，是**用镜头组织给观众建立重量感**。观众记住的从来不是招式，是某一下砸下去之后身体停住的那两帧。
+
+## 实测基线
+
+对一段 10 秒 / 300 帧的实拍打斗做了逐镜切分，读数如下——把这些数字当基准，不要凭感觉：
+
+- **10 镜 / 10 秒，平均 1.0 秒一镜**。打斗没有想象中那么快剪。
+- **最短 0.27 秒**（约 8 帧）：发力瞬间，用来制造刺痛，一镜只用一次。
+- **最长 1.80 秒**（约 54 帧）：第一击接触，用来交代两人关系与武器，可长。
+- **景别严格交替**：特写 → 双人中景 → 大全景 → 特写，**几乎每一镜都在换景别，没有连续两镜同景别**。
+- **大全景只给两件事**：空间交代与招式高潮。其余全部落在中近景，节省信息成本。
+- 结构是：建置（中景，平视）→ 接触（双人中景，长）→ 反打（过肩）→ 高潮碎切（0.5 / 0.27 / 1.6）→ 情绪长镜 → 大全景收。
+
+## 节奏三段
+
+| 段 | 时长占比 | 镜头数 | 景别主力 | 目的 |
+|---|---|---|---|---|
+| 建置 | 15–20% | 2–3 | 中景 / 中近景 | 交代站位、武器、谁先动 |
+| 高潮 | 55–65% | 5–8 | 特写 / 双人中景交替 | 打击密度推上去，碎切在这里 |
+| 收束 | 20–25% | 2–3 | 情绪长镜 + 大全景 | 停一下，让重量落地 |
+
+节奏变化必须**可数**：同一段里至少出现一次明显的时长反差（例：1.8s 叙事 → 0.5s + 0.27s 快切 ×2 → 1.5s 反转 → 5s 情绪长镜）。全程 1.0 秒均匀切 = 没有节奏。
+
+---
+
+## 五条可迁移手法
+
+### 1. 刀锋入画特写
+
+- **做什么**：先给"武器的压迫"，再给"人"。刀尖从画面一侧入画、虚化，压向对方的脸，占据画面 1/3。
+- **为什么有效**：威胁感比直接拍动作更强——观众先感到危险，再看到危险属于谁。
+- **怎么拍**：大特写 / 镜头 85–135mm / 刀尖在前景虚化、脸在中景实 / 时长 0.8–1.2s / 一个镜一次。
+
+### 2. 受力点插入镜
+
+- **做什么**：不拍全身对打，用极低角度的局部特写承担"物理重量"——靴底、剑身抽击、缠绕的衣料、被撞的木栏。
+- **为什么有效**：全身镜里动作会被压缩成小位移；局部镜可以让材质与形变占满画面，重量感来自形变。
+- **怎么拍**：大特写 / 镜头 50–85mm / 贴地或贴物机位 / 时长 0.5–1.0s / 同段最多两次。
+
+### 3. 反打过肩表现从容
+
+- **做什么**：攻击方在前景虚化（只留后脑或肩线），防守方正面中景、从容站位、微微抬眼或微笑。
+- **为什么有效**：一个镜头就把强弱关系倒过来——观众立刻知道防守方还没用力。
+- **怎么拍**：过肩 / 镜头 50mm / 前景虚到只剩轮廓 / 防守方正面对焦、占画面高度 60–70% / 时长 1.0–1.8s。
+
+### 4. 情绪停顿长镜
+
+- **做什么**：打斗中间插一个 1.5–2 秒的低机位近景，人物贴近地面、发丝垂落、呼吸可见、微表情清晰。
+- **为什么有效**：比继续加速更抓人。观众在高速段被强行减速，注意力反而被拧紧。
+- **怎么拍**：近景 / 镜头 85mm / 机位贴近地面 0.3–0.5m / 时长 1.5–2s / 一镜一次，放在高潮之后。
+
+### 5. 双色服装对位
+
+- **做什么**：两方角色在服装上给**两个可区分的色块**（例：红 vs 墨绿），并在整场打斗中保持不换装。
+- **为什么有效**：打斗镜头里角色辨识度靠色块，不是靠脸——脸在动作中永远是糊的。
+- **怎么拍**：在提示词里把两方服装色固定成短语，逐镜逐字重复；光线变化时也保持相对色相不变。
+
+---
+
+## 生成时的明确边界
+
+**这一段必须读懂，它决定了成品质量。**
+
+本卡只提供**镜头节奏与景别组织手法**，不承诺逐帧还原参考视频里的具体武打动作。
+
+- 具体招式（怎么出拳、怎么格挡、身体重心怎么转移）**不能靠文字提示词硬凑**。用文字描述武打动作，模型只能给出"挥了一下"的糊动作，这是必然结果，不是参数没调好。
+- 要真实动作，走两条路：① **3D 导演台的骨骼动画**（有真实关节角度与时间曲线）；② 拿实拍或动捕参考做视频参考输入。
+- 打斗分镜里，把文字用在**该写的地方**：景别、机位、时长、光向、服装色块、打击后的身体状态（"停在半跪，右手撑地，头抬起看向对方"）。这些都可执行。
+- 反过来，**不要写**："一记凌厉的侧踢接转身肘击" 这种招式描述——模型会给你一段谁也没看懂的肢体运动。

package/assets/canvas-director/pack.js

@@ -0,0 +1,342 @@
+/**
+ * canvas-director 技能包：切片与索引的共享纯函数。
+ *
+ * 设计约束（务必遵守）：
+ *  - 纯函数：不读写 fs、不碰 DOM、不带副作用 → Host 与 Client 同源，且可直接单测。
+ *  - 按「生成能力」切片，绝不整份注入：一份透镜全文 12–22KB，全注入会吃掉几千 token，
+ *    而剧本只关心叙事与节奏、分镜只关心镜头语言、提示词只关心风格参数与负向词。
+ *  - 切片靠 Markdown 里的 `<!-- slice:xxx yyy -->` 标记 + `## ` 标题双重定位；
+ *    标记缺失时回落到纯标题匹配（保证「复制过来就能用」的鲁棒性）。
+ *
+ * 术语：kind = 生成能力（script / storyboard / prompt / assets），
+ *       layer = 数据层（lens 导演 / genre 叙事题材 / industry 行业题材 / form 类型规格 / look 影调 / moves 运镜）。
+ */
+
+/** Markdown 里 slice 标记的格式：`<!-- slice:story prompt -->`（一个标记可声明归属多个能力）。 */
+export const SLICE_RE = /^<!--\s*slice:([a-z ]+?)\s*-->\s*$/;
+
+/** 每张小节的「缺省归属」——标记缺失时用它兜底，避免老文件一个切片也取不到。 */
+export const SECTION_DEFAULT_SLICE = {
+  // 透镜
+  '一句话镜头 / Lens in one line': 'story shot prompt',
+  '适用场景': 'story',
+  '反例：这不是什么 / What this lens is NOT': 'story shot',
+  '核心风格关键词': 'story shot prompt',
+  '叙事方法': 'story',
+  '镜头语言': 'story shot',
+  '灯光与色彩': 'shot prompt assets',
+  '剪辑节奏': 'story',
+  '声音与音乐': 'story',
+  '人物与表演': 'story shot',
+  '风格参数 / Style parameters': 'shot prompt assets',
+  '可迁移拍摄清单': 'storyboard shot',
+  '提示词模板 / Prompt templates': 'prompt',
+  '落地示例 / Worked example': 'prompt',
+  // 叙事题材卡
+  '题材核心与观众为什么看': 'story',
+  '压力来源与冲突发动机': 'story',
+  '人物策略与信息权限': 'story',
+  '观众回报与情绪落点': 'story',
+  '常见场面颗粒': 'story prompt',
+  '集尾钩子取向': 'story',
+  '前中后期打法': 'story',
+  '制作难点': 'story shot',
+  '禁止漂移': 'story shot',
+  '证据与置信度': 'story',
+  // 行业题材卡
+  '视觉母题': 'story prompt',
+  '证据点': 'story prompt',
+  '常见承诺': 'story prompt',
+  '禁项': 'prompt',
+  '参考镜头': 'prompt',
+  // 类型规格卡
+  '交付规格': 'story shot prompt',
+  '结构块': 'story',
+  '这个类型的观众契约': 'story shot',
+  '与导演透镜冲突时的改写': 'story shot',
+  '类型级负向词': 'prompt',
+  // 影调卡
+  '成像底层': 'story shot prompt',
+  '形体与骨相': 'story shot prompt',
+  '影调与光比': 'shot prompt assets',
+  '色彩命题': 'shot prompt assets',
+  '空气与介质': 'shot prompt assets',
+  '光学与镜头': 'shot prompt assets',
+  '材质响应': 'prompt assets',
+  '特效语言': 'shot prompt',
+  '针对性禁项': 'prompt',
+  '负向词块': 'prompt',
+};
+
+/**
+ * 把一份 Markdown 切成 { title, slice, body } 的小节数组。
+ * - 首个 `## ` 之前的内容（frontmatter + 一级标题 + 前言）归入 `preamble`。
+ * - 小节内的 ``` 代码围栏不打断（围栏内的 `## ` 不算标题）。
+ */
+export function splitSections(md) {
+  const lines = String(md || '').split(/\r?\n/);
+  const sections = [];
+  let cur = null;
+  let pendingSlice = null;
+  let inFence = false;
+  const preamble = [];
+  for (const ln of lines) {
+    if (/^\s*```/.test(ln)) inFence = !inFence;
+    if (!inFence) {
+      const sm = SLICE_RE.exec(ln.trim());
+      if (sm) { pendingSlice = sm[1].trim(); continue; }
+      const hm = /^##\s+(.+)$/.exec(ln);
+      if (hm) {
+        if (cur) sections.push(cur);
+        const title = hm[1].trim();
+        cur = {
+          title,
+          slice: pendingSlice || SECTION_DEFAULT_SLICE[title] || 'story',
+          body: [],
+        };
+        pendingSlice = null;
+        continue;
+      }
+    }
+    if (cur) cur.body.push(ln);
+    else preamble.push(ln);
+  }
+  if (cur) sections.push(cur);
+  return sections.map((s) => ({ title: s.title, slice: s.slice, body: s.body.join('\n').replace(/^\n+|\n+$/g, '') }));
+}
+
+/** 按标题名精确取小节正文；找不到返回空串。 */
+export function sectionText(md, title) {
+  const hit = splitSections(md).find((s) => s.title === title);
+  return hit ? hit.body : '';
+}
+
+/** 生成能力 → 该能力需要的小节标签集合（kind 与 slice 标签不是同一套词，必须显式映射）。 */
+export const KIND_SLICES = {
+  // 剧本：叙事与节奏为主，镜头细节交给分镜；不取「镜头语言/风格参数/提示词模板」那些给分镜与提示词的节
+  script: ['story'],
+  // 分镜：镜头语言 + 灯光 + 可迁移清单；不取提示词模板与落地示例
+  storyboard: ['shot', 'storyboard'],
+  // 提示词：只取风格参数与提示词模板（外加灯光）；不取叙事、剪辑、表演
+  prompt: ['prompt'],
+  // 资产设定图：只取成像与材质相关
+  assets: ['assets'],
+};
+
+/** 取一份 Markdown 在某个生成能力下的全部小节正文（按出现顺序拼接）。 */
+export function pickSections(md, kind) {
+  const want = KIND_SLICES[String(kind || '').trim()];
+  if (!want) return '';
+  return splitSections(md)
+    .filter((s) => s.slice.split(/\s+/).some((t) => want.includes(t)))
+    .map((s) => '## ' + s.title + '\n\n' + s.body)
+    .join('\n\n');
+}
+
+/** 抽出 ```yaml 风格参数块原文（含围栏内文本，不含围栏本身）。没有则空串。 */
+export function yamlBlock(md) {
+  const m = /```ya?ml\s*\n([\s\S]*?)```/.exec(String(md || ''));
+  return m ? m[1].replace(/\s+$/, '') : '';
+}
+
+/** 抽出负向词：优先取「负向词块」小节里的英文逗号短语，其次取 yaml 的 negative_prompt_adds。 */
+export function negativePhrases(md) {
+  const text = String(md || '');
+  const sec = sectionText(text, '负向词块') || sectionText(text, '类型级负向词');
+  const fromSec = sec
+    ? sec.replace(/```[a-z]*\n?/g, '').split(/[,，\n]/)
+      .map((s) => s.replace(/^[-*\d.\s]+/, '').trim())
+      .filter((s) => /^[a-z][a-z0-9 '\-/]{2,}$/i.test(s))
+    : [];
+  if (fromSec.length) return [...new Set(fromSec)];
+  const y = yamlBlock(text);
+  const m = /negative_prompt_adds:\s*\[([^\]]*)\]/m.exec(y);
+  if (!m) return [];
+  return [...new Set(m[1].split(',').map((s) => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean))];
+}
+
+/** 从 frontmatter 读一个标量字段（不带引号处理之外的 YAML 特性）。 */
+export function frontmatterField(md, key) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(String(md || ''));
+  if (!fm) return '';
+  const m = new RegExp('^' + String(key).replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ':\\s*(.+)$', 'm').exec(fm[1]);
+  return m ? m[1].trim().replace(/^["']|["']$/g, '') : '';
+}
+
+/** 从 frontmatter 读一个内联数组字段（`a: [x, y]` 或 `a: x`）。 */
+export function frontmatterList(md, key) {
+  const raw = frontmatterField(md, key);
+  if (!raw) return [];
+  const inner = /^\[([\s\S]*)\]$/.exec(raw);
+  const body = inner ? inner[1] : raw;
+  return body.split(',').map((s) => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+}
+
+/** 从 frontmatter 读 spec 子块的键（`spec:\n  aspect: [...]` 这类两层缩进）。 */
+export function frontmatterSpec(md) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(String(md || ''));
+  if (!fm) return {};
+  const out = {};
+  let inSpec = false;
+  for (const ln of fm[1].split(/\r?\n/)) {
+    if (/^spec:\s*$/.test(ln)) { inSpec = true; continue; }
+    if (inSpec) {
+      if (/^\S/.test(ln)) { inSpec = false; continue; }         // 缩进归零 = spec 块结束
+      const m = /^\s+([A-Za-z0-9_]+):\s*(.+)$/.exec(ln);
+      if (!m) continue;
+      const v = m[2].trim().replace(/\s+#.*$/, '');
+      if (/^\[/.test(v)) out[m[1]] = frontmatterList('---\n' + m[1] + ': ' + v + '\n---', m[1]);
+      else if (/^-?\d+(\.\d+)?$/.test(v)) out[m[1]] = Number(v);
+      else out[m[1]] = v.replace(/^["']|["']$/g, '');
+    }
+  }
+  return out;
+}
+
+/** 拼装一段可注入的文本块：标题 + 分区，并返回字节数（UTF-8）。 */
+export function composePackText(blocks, opts) {
+  const o = opts || {};
+  const head = String(o.head || '').trim();
+  const parts = [];
+  if (head) parts.push(head);
+  for (const b of blocks || []) {
+    if (!b) continue;
+    const title = String(b.title || '').trim();
+    const body = String(b.body || '').trim();
+    if (!body) continue;
+    parts.push((title ? '### ' + title + '\n' : '') + body);
+  }
+  const text = parts.join('\n\n').trim();
+  return { text, bytes: utf8Bytes(text) };
+}
+
+/** UTF-8 字节数（不依赖 TextEncoder，纯算，便于在无环境桩下运行）。 */
+export function utf8Bytes(str) {
+  const s = String(str || '');
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 0x80) n += 1;
+    else if (c < 0x800) n += 2;
+    else if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) { n += 4; i++; } // 代理对
+    else n += 3;
+  }
+  return n;
+}
+
+/** 校验并归一 manifest；返回 { ok, errors, manifest }。 */
+export function parseManifest(json) {
+  const errors = [];
+  const m = (typeof json === 'string') ? safeJson(json) : (json || {});
+  if (!m || typeof m !== 'object') return { ok: false, errors: ['manifest 不是对象'], manifest: null };
+  const LAYERS = ['lenses', 'genres', 'industries', 'forms', 'looks'];
+  const out = {};
+  const ids = new Map();
+  for (const layer of LAYERS) {
+    const list = m[layer];
+    if (!Array.isArray(list)) { errors.push('缺少数组 ' + layer); out[layer] = []; continue; }
+    out[layer] = [];
+    for (const it of list) {
+      if (!it || typeof it !== 'object') { errors.push(layer + ' 含非对象项'); continue; }
+      const id = String(it.id || '').trim();
+      const name = String(it.name || '').trim();
+      if (!id) { errors.push(layer + ' 有项缺 id'); continue; }
+      if (!/^[a-z0-9][a-z0-9_-]*$/.test(id)) { errors.push(layer + '/' + id + ': id 只允许小写字母数字下划线连字符'); }
+      if (ids.has(id)) errors.push('id 重复：' + id + '（' + ids.get(id) + ' 与 ' + layer + '）');
+      ids.set(id, layer);
+      if (!name) errors.push(layer + '/' + id + ': 缺 name');
+      if (!String(it.file || '').trim()) errors.push(layer + '/' + id + ': 缺 file');
+      out[layer].push({
+        id,
+        name,
+        group: String(it.group || '').trim(),
+        file: String(it.file || '').trim(),
+        glyph: String(it.glyph || id).trim(),
+        oneliner: String(it.oneliner || '').trim(),
+        tier: String(it.tier || '').trim(),
+      });
+    }
+  }
+  return { ok: errors.length === 0, errors, manifest: out };
+}
+
+function safeJson(s) {
+  try { return JSON.parse(s); } catch { return null; }
+}
+
+/**
+ * 组装某个生成能力下的注入文本。
+ * items: [{ layer, md, meta }]，顺序即拼接顺序。
+ * 返回 { text, bytes, used: [{layer,id,bytes}] }
+ */
+export function buildPackText(kind, items, opts) {
+  const o = opts || {};
+  const zh = o.zh !== false;
+  const blocks = [];
+  const used = [];
+  for (const it of items || []) {
+    if (!it || !it.md) continue;
+    const meta = it.meta || {};
+    const name = meta.name || meta.id || it.layer;
+    let body = '';
+    if (it.layer === 'moves') {
+      body = String(it.md || '').trim();                        // 运镜词典整份注入（本身已是短条目）
+    } else {
+      body = pickSections(it.md, kind);
+    }
+    if (!body.trim()) continue;
+    blocks.push({ title: layerLabel(it.layer, zh) + '：' + name + (meta.oneliner ? ' —— ' + meta.oneliner : ''), body });
+    used.push({ layer: it.layer, id: meta.id || '', bytes: utf8Bytes(body) });
+  }
+  const head = o.head || '';
+  const r = composePackText(blocks, { head });
+  return { text: r.text, bytes: r.bytes, used };
+}
+
+/** 层的中文标签。 */
+export function layerLabel(layer, zh) {
+  const ZH = { lens: '导演透镜', genre: '题材', industry: '行业题材', form: '类型规格', look: '影调', moves: '运镜与节奏' };
+  const EN = { lens: 'Director lens', genre: 'Genre', industry: 'Industry', form: 'Delivery form', look: 'Look', moves: 'Camera & rhythm' };
+  const m = zh === false ? EN : ZH;
+  return m[layer] || layer;
+}
+
+/** 默认配置（老项目无该字段时就是它，保证行为与未引入技能包前完全一致）。 */
+export const DEFAULT_PROFILE = {
+  lens: '',
+  genres: [],
+  form: 'short-drama',
+  aspect: '',
+  targetSec: 0,
+  platform: '',
+  look: '',
+  genreMode: 'auto',
+};
+
+/** 归一技能配置：字符串裁剪、枚举由调用方给、非法回落、空值剔除。 */
+export function normalizeProfile(raw, allowed) {
+  const b = (raw && typeof raw === 'object') ? raw : {};
+  const a = allowed || {};
+  const pick = (v, list) => {
+    const s = String(v == null ? '' : v).trim();
+    if (!s) return '';
+    if (Array.isArray(list) && list.length && !list.includes(s)) return '';
+    return s;
+  };
+  const genres = Array.isArray(b.genres)
+    ? [...new Set(b.genres.map((x) => String(x == null ? '' : x).trim()).filter(Boolean))]
+      .filter((x) => !Array.isArray(a.genres) || !a.genres.length || a.genres.includes(x))
+      .slice(0, 12)
+    : [];
+  const sec = Number(b.targetSec);
+  return {
+    lens: pick(b.lens, a.lenses),
+    genres,
+    form: pick(b.form, a.forms) || DEFAULT_PROFILE.form,
+    aspect: pick(b.aspect, a.aspects),
+    targetSec: Number.isFinite(sec) && sec > 0 ? Math.round(sec) : 0,
+    platform: pick(b.platform, a.platforms),
+    look: pick(b.look, a.looks),
+    genreMode: (b.genreMode === 'narrative' || b.genreMode === 'industry') ? b.genreMode : 'auto',
+  };
+}

package/assets/canvas-studio/SKILL.md

@@ -8,6 +8,35 @@ description: 用无限画布（Infinite Canvas）做短剧/视频创作时使用
 画布是一个按项目组织的节点工作台：剧本 → 分镜 → 图片 → 视频 → 成片。你（对话模型）是操作者，
 **所有画布操作只能通过 canvas_* 工具完成**，不要臆造节点或项目状态。
 
+## 〇## 〇、本插件技能清单（开工前先看这一节）
+
+本插件（无限画布）提供 4 份技能，**各管一段，不要漏读**：
+
+| 技能 | 管什么 | 什么时候加载 |
+|---|---|---|
+| `canvas-studio` | 画布操作流程：建项目 / 写节点 / 触发生成 / 查状态 | 任何时候先读（本文件） |
+| `canvas-craft` | 创作方法论：剧本四要素、分镜六要素、提示词规范 | 写剧本或拆分镜前 |
+| `canvas-layout` | 节点布局纪律：一类型一列、绝不重叠 | 批量建节点前 |
+| `canvas-director` | **导演透镜 24 / 叙事题材 21 + 行业题材 10 / 类型规格 8 / 影调 9 / 运镜词典** | **写任何提示词前** |
+
+### 怎么知道有哪些可用
+
+调 `canvas_list_skills`：它一次返回 4 份技能及各自何时用、技能包四层完整清单（每层的 id 与名称）、以及当前项目的已选配置。
+
+### 怎么按口径写提示词
+
+调 `canvas_skill_pack({ projectId, kind })` 取切片，**不要整份读技能包文件**：
+
+- `kind: 'script'` —— 写剧本前
+- `kind: 'storyboard'` —— 拆分镜前
+- `kind: 'prompt'` —— 写图片或视频提示词前
+- `kind: 'assets'` —— 写角色/场景/道具设定图提示词前
+
+返回的文本可直接拼进你的系统提示。也可临时覆盖：`{ lens:'fincher', genres:['crime-police'], form:'trailer', look:'dark-myth-cg' }`；
+传 `set:true` 会把配置写进项目（此后画布自生成也用同一套）。
+
+**这是让对话写出的内容与画布自生成保持同一口径的唯一入口。** 跳过它直接写提示词，等于放弃用户已经选好的导演与题材。
+
 ## 一、硬约束（违反即视为操作失败）
 
 0. **设定集先行。** 写剧本、写分镜、生成任何画面之前，**必须先 `canvas_get_bible` 读设定集**：
@@ -107,9 +136,11 @@ description: 用无限画布（Infinite Canvas）做短剧/视频创作时使用
       **不带 = 默认画布**，会"报节点不存在"或写错画布。
     - 画布之间节点/连线互相隔离；**资产与设定集按项目共享**（所有画布同一份设定集、同一资产库），
       不要为不同画布重建设定集或重复上传资产。
-    - **专家人设给方向，技能判据是准绳**：内置分镜专家的 persona 已写入六要素 / 每场 1 个大特写 /
-      motion「起点→方式→终点」/ 同场连续三镜不同运动 / 每场冲撞点等硬规则，但仍以 `canvas-craft`
-      的完整判据与自检表为准；两者冲突时，**以技能判据为准**。
+    - **创作硬规则只有一份：`canvas-craft` 技能正文**（六要素 / 每场 1 个大特写 /
+      motion「起点→方式→终点」/ 同场连续三镜不同运动 / 每场冲撞点 / 因果钩子 / 术语勘误，全在里面）。
+      原先另有一份「专家人设」复述同一批规则，已移除——两条并存会给出互相矛盾的指令。
+      风格与题材侧（导演 / 题材 / 类型规格 / 影调）由 `canvas-director` 技能包的切片提供，
+      用 `canvas_skill_pack` 取，见本节开头的技能清单。
 
 ## 二、标准工作流（对话填提示词+连线+触发，生成由节点完成）
 

package/assets/director/engine.js

@@ -3528,7 +3528,10 @@ export function cameraFlyStep(cam, input, dt, opts) {
  * 单位一律是 CSS 像素 → 同一相机/同一 CSS 尺寸下两者必然一致（历史 bug：绘制用设备像素、拾取用 CSS，命中区偏移）。
  */
 export function gizmoMetrics(cam, sel, hCss, originOverride) {
-  const origin = originOverride || v3(sel.pos.x, sel.pos.y + (Number(sel.poseCenterY) || 0), sel.pos.z);
+  // 轴心 = 物体自身坐标系原点（人物是脚底中心），**不随姿态上浮**。
+  // 轴朝向由 objectAxes(sel) 给出 → 物体旋转时轴跟着转（人物倒地后 z 轴仍指向头）。
+  // 需要「轴心跟随身体」的场合显式传 originOverride（见 render 里的 gizmoFollowBody 开关）。
+  const origin = originOverride || v3(sel.pos.x, sel.pos.y, sel.pos.z);
   const depth = depthOf(cam, origin);
   const pxWorld = pixelSizeAt(cam, hCss, depth);
   const minWorld = Math.max(0.25, (Number(sel.h) || 1.7) / 3);
@@ -5551,8 +5554,13 @@ export function createDirectorGlRenderer(canvas) {
       if (o.gizmo && o.selectedId) {
         const sel = (scene.objects || []).find((x) => x.id === o.selectedId);
         if (sel) {
-          // gizmo 跟随姿态中心（倒地/下蹲时身体不在原点：让轴心贴住身体，而非留在地面）
-          const origin = v3(sel.pos.x, sel.pos.y + (Number(sel.poseCenterY) || 0), sel.pos.z);
+          // 轴心默认在物体原点（人物 = 脚底中心），轴朝向由 objectAxes(sel) 给出
+          // → 物体旋转时轴跟着转（人物倒地后 z 轴仍指向头），不是固定世界坐标。
+          // 「跟随身体」是显式开关：仅当选中项或场景打开 gizmoFollowBody 时才抬到髋高。
+          const followBody = !!(sel.gizmoFollowBody || o.gizmoFollowBody);
+          const origin = followBody
+            ? v3(sel.pos.x, sel.pos.y + (Number(sel.poseCenterY) || 0), sel.pos.z)
+            : v3(sel.pos.x, sel.pos.y, sel.pos.z);
           // 屏幕恒定大小（Blender: wm_gizmo_calculate_scale）：轴长 105 CSS px，环 0.62×轴长。
           // 尺寸唯一来源 gizmoMetrics，拾取用同一个函数 → 不可能再出现「画的位置和点不中」。
           const gm = gizmoMetrics(cam, sel, hCss, origin);
@@ -5939,7 +5947,12 @@ export function directorPickGizmo(scene, selectedId, w, h, sx, sy) {
   if (!cam) return null;
   // 与绘制完全同源：精确屏幕投影 + 同一个 gizmoMetrics（w/h 都是 CSS 尺寸）
   const project = (p) => directorScreenOf(cam, w, h, p);
-  const gm = gizmoMetrics(cam, sel, h);
+  // 轴心规则必须与绘制一致：默认物体原点，只有显式打开「跟随身体」才抬到髋高
+  const pickFollow = !!(sel.gizmoFollowBody || scene.gizmoFollowBody);
+  const pickOrigin = pickFollow
+    ? v3(sel.pos.x, sel.pos.y + (Number(sel.poseCenterY) || 0), sel.pos.z)
+    : v3(sel.pos.x, sel.pos.y, sel.pos.z);
+  const gm = gizmoMetrics(cam, sel, h, pickOrigin);
   const origin = gm.origin, L = gm.L, R = gm.R;
   const ax = objectAxes(sel);
   const AXES = [['x', ax.x], ['y', ax.y], ['z', ax.z]];