@ninkch/dsh-infinite-canvas 0.18.4 → 0.18.6

package/client.js

@@ -20,7 +20,9 @@ window.__ModuleLoader__.load({
     const NODE_W = 240;
     const CRAFT_SKILL = 'canvas-craft'; // 内置创作方法论技能（未选技能时默认注入）
 
-    const NODE_TYPES = ['text', 'shot', 'image-gen', 'video-gen', 'image-asset', 'video-asset'];
+    // 节点类型的唯一事实源是 TYPE_LABEL / TYPE_KIND / PORTS（见下方）：历史上这里还有一个
+    // 写死的类型清单常量，既不完整（缺 script/storyboard/finalcut/group）又无人引用，
+    // 已由 IC-02 删除；audit.mjs 会断言它不会复活。
 
     // 每类节点的端口定义（kind: text | image | video）
     const PORTS = {
@@ -45,10 +47,11 @@ window.__ModuleLoader__.load({
       },
       'video-gen': {
         inputs: [{ id: 'prompt', kind: 'text' }, { id: 'frame', kind: 'image' }, { id: 'ref', kind: 'image' }],
-        outputs: [{ id: 'out', kind: 'video' }, { id: 'last', kind: 'image' }],
+        // last = 真·最后一帧（画面结尾）；tailpick = 续帧接力的最佳选帧（动作进行中/清晰/不抖）
+        outputs: [{ id: 'out', kind: 'video' }, { id: 'tailpick', kind: 'image' }, { id: 'last', kind: 'image' }],
       },
       'image-asset': { inputs: [{ id: 'in', kind: 'image' }], outputs: [{ id: 'out', kind: 'image' }] },
-      'video-asset': { inputs: [{ id: 'in', kind: 'video' }], outputs: [{ id: 'out', kind: 'video' }, { id: 'last', kind: 'image' }] },
+      'video-asset': { inputs: [{ id: 'in', kind: 'video' }], outputs: [{ id: 'out', kind: 'video' }, { id: 'tailpick', kind: 'image' }, { id: 'last', kind: 'image' }] },
       'finalcut': { inputs: [{ id: 'in', kind: 'video' }], outputs: [] },
       'group': { inputs: [], outputs: [] },
     };
@@ -188,6 +191,7 @@ window.__ModuleLoader__.load({
       'duplicate': '复制节点 (Ctrl+D)',
       'confirmDel': '确认删除?',
       'newProject': '新建项目',
+      'emptyProjectHint': '还没有项目。点上方「新建项目」创建第一个项目，或直接在对话里说「创建一个项目叫…」。',
       'projectName': '项目名称',
       'renameHint': '双击名称重命名',
       'delProjectHint': '删除项目及其资产',
@@ -258,6 +262,32 @@ window.__ModuleLoader__.load({
       'hideKey': '隐藏（脱敏显示）',
       'supportBtn': '帮助与反馈',
       'supportTitle': '帮助与反馈',
+      // 快捷键面板（左上角浮层）
+      'keysBtn': '快捷键',
+      'keysTitle': '快捷键与操作',
+      'guideDesc': '在对话旁直接分镜、生成视频与成片',
+      'hostTakenTitle': '画布已在另一侧打开',
+      'hostTakenHint': '同一时刻画布只能在一处运行（共享同一份节点与生成状态），点击下方按钮把画布切换到这里。',
+      'hostTakeOver': '把画布切换到这里',
+      'keysHint': '点击按钮收起；Esc 也可关闭',
+      'keysDrag': '画布操作',
+      'keysEdit': '编辑',
+      'keysView': '视图',
+      'kAltDrag': '按住 Alt 拖动节点：自由摆放，不推挤/不吸附（可覆盖穿过其他节点）',
+      'kDrag': '拖动节点：碰到邻居时实时推挤让位（保持不重叠）',
+      'kShiftDrag': 'Shift + 拖动：临时关闭对齐吸附',
+      'kShiftClick': 'Shift + 点击：加选/取消选中节点',
+      'kMarquee': 'Shift + 拖动空白：框选',
+      'kMiddle': '中键拖动：平移画布',
+      'kWheel': '滚轮：以指针为中心缩放',
+      'kDblClick': '双击空白：添加节点菜单',
+      'kRightClick': '右键：节点/画布菜单',
+      'kUndo': 'Ctrl / ⌘ + Z：撤销',
+      'kRedo': 'Ctrl / ⌘ + Shift + Z（或 Ctrl + Y）：重做',
+      'kCopy': 'Ctrl / ⌘ + D：复制选中节点',
+      'kDel': 'Delete / Backspace：删除选中的节点或连线',
+      'kEsc': 'Esc：关闭菜单 / 取消选择',
+      'kZoomKeys': '双击项目名：重命名项目',
       'supportNote': '有问题或改进建议，提 Issue 或进群反馈。',
       'supportGithub': 'GitHub 仓库',
       'supportIssues': '访问 GitHub，提 Issue',
@@ -296,7 +326,7 @@ window.__ModuleLoader__.load({
       'lbHint': '点击空白处或按 Esc 关闭',
       'resizeList': '拖拽调整分镜列表高度',
       'frameModeLabel': '衔接',
-      'frameModeHint': '首帧口连线时的处理方式。网关禁止首帧与参考图混用：融合=尾帧降级为第1张参考图（保留实体参考图，衔接为软约束）；硬首帧=用真首帧参数（画面绝对承接，但放弃参考图）；忽略=不使用首帧',
+      'frameModeHint': '首帧来源的处理方式（首帧=上一段尾帧，用于跨段接戏）。网关禁止首帧与参考图混用：融合=尾帧降级为第1张参考图（保留实体参考图，衔接为软约束+提示词锚定）；硬首帧=用真首帧参数（画面绝对承接，但放弃参考图）；忽略=不使用首帧。即使没有连 frame 线，续帧段也会自动取上一段尾帧作首帧',
       'frameModeAuto': '参考图融合',
       'frameModeHard': '硬首帧（弃参考图）',
       'frameModeOff': '忽略首帧',
@@ -308,6 +338,8 @@ window.__ModuleLoader__.load({
       'allProjects': '全部项目',
       'currentProject': '当前项目',
       'expandDone': '已铺开为一次多镜头生成：{n} 镜合成为一条视频（时长 = 各镜之和）',
+      'expandGenCreated': '已为 {n} 个缺失资产新建图片生成节点（设定图提示词已按技能规范写好）——先生成资产图，再生成视频',
+      'expandAssetReused': '{n} 个直接复用资产库已有图片',
       'multiShotHint': '多镜头模式：提示词由上游分镜表组合（全部镜头按顺序+时长合成一条提示词），一次性生成整段视频',
       'aiNeedScript': '分镜节点还没有剧本来源：连线上游剧本节点，或在节点里粘贴剧本',
       'upstreamStillRunning': '上游剧本节点还没生成完成（有连线时内容只从连线取）；等它完成后再生成分镜',
@@ -385,10 +417,12 @@ window.__ModuleLoader__.load({
       'modelsLabel': '模型',
       'modelNamePh': '模型 ID（如 doubao-seedance-2.0）',
       'starDefault': '设为默认模型（节点未指定时自动路由到这里）',
-      'noModelsCfg': '未配置模型——节点运行将报错',
+      'noModelsCfg': '未配置模型——运行会提示先配置（对话侧将返回可读错误）',
       'errNoImageModel': '未指定图片模型：请在设置里配置图片模型并星标默认模型，或在节点上选择模型',
       'errNoVideoModel': '未指定视频模型：请在设置里配置视频模型并星标默认模型，或在节点上选择模型',
       'consistencyTitle': '一致性检查',
+      'refreshCheck': '刷新',
+      'refreshCheckHint': '按当前设定集重新校验（生成后补全的设定集条目不会让旧告警自动消失）',
       'restartHint': '插件后台尚未加载最新版本：请重启一次 DeepSeek Harness 后重试（仅首次更新需要）',
       'rpcFail': '请求失败',
       'skillEnhance': '技能增强（用已安装技能替代内置专家方法论）',
@@ -531,7 +565,24 @@ window.__ModuleLoader__.load({
       'ungroup': '解散分组',
       'redraw': '重绘',
       'lastFrame': '尾帧',
+      'tailPick': '尾帧选帧',
+      'tailPickHint': '续帧接力用的尾帧：从片尾多帧里选「动作进行中、清晰、不抖」的一帧，而不是机械取最后一帧',
       'chainNext': '接续下一镜',
+      'chainInfo': '续帧：首帧来自上一段尾帧',
+      'chainAuto': '自动取上一段尾帧作首帧',
+      'chainManual': '首帧来自连线',
+      'contToggle': '分镜衔接',
+      'contToggleHint': '开启后，分镜会为每镜写出「承接上镜尾态 / 接点尾态（动作进行中）/ 运镜延续 / 段落类型」——分段生成才能接得上',
+      'shotTail': '接点尾态',
+      'segOpening': '首段·交代',
+      'segContinuation': '续帧',
+      'segNew_character': '新角色入场',
+      'segScene_change': '换场',
+      'segCloseup': '特写插入',
+      'segCut': '特写插入',
+      'seamOk': '接缝通过',
+      'seamFail': '接缝偏跳',
+      'seamHint': '接缝校验：本段首帧与上一段尾帧的画面相似度',
       'craftCard': 'Craft 后期（ArtCraft）',
       'craftUnreachable': 'Craft 未连接：确认 dsh-artcraft 插件已安装/启用并重启过 Harness',
       'craftDataRoot': '数据目录',
@@ -596,6 +647,7 @@ window.__ModuleLoader__.load({
       'duplicate': 'Duplicate (Ctrl+D)',
       'confirmDel': 'Confirm delete?',
       'newProject': 'New project',
+      'emptyProjectHint': 'No projects yet. Click "New project" above to create the first one, or just say "create a project called…" in the chat.',
       'projectName': 'Project name',
       'renameHint': 'Double-click to rename',
       'delProjectHint': 'Delete project and its assets',
@@ -667,6 +719,32 @@ window.__ModuleLoader__.load({
       'hideKey': 'Hide key (masked)',
       'supportBtn': 'Help & feedback',
       'supportTitle': 'Help & feedback',
+      // Shortcuts panel (floating, top-left of the canvas)
+      'keysBtn': 'Shortcuts',
+      'keysTitle': 'Shortcuts & gestures',
+      'guideDesc': 'Storyboard, generate and cut right beside the chat',
+      'hostTakenTitle': 'The canvas is open elsewhere',
+      'hostTakenHint': 'The canvas runs in one place at a time (one shared node graph and generation state). Move it here with the button below.',
+      'hostTakeOver': 'Move the canvas here',
+      'keysHint': 'Click the button again to collapse; Esc also closes',
+      'keysDrag': 'Canvas',
+      'keysEdit': 'Editing',
+      'keysView': 'View',
+      'kAltDrag': 'Hold Alt while dragging a node: free placement, no pushing / no snapping (may overlap other nodes)',
+      'kDrag': 'Drag a node: neighbours are pushed aside in real time (nodes never overlap)',
+      'kShiftDrag': 'Shift + drag: temporarily disable alignment snapping',
+      'kShiftClick': 'Shift + click: add / remove a node from the selection',
+      'kMarquee': 'Shift + drag on empty canvas: marquee select',
+      'kMiddle': 'Middle-button drag: pan the canvas',
+      'kWheel': 'Wheel: zoom around the pointer',
+      'kDblClick': 'Double-click empty canvas: add-node menu',
+      'kRightClick': 'Right-click: node / canvas context menu',
+      'kUndo': 'Ctrl / ⌘ + Z: undo',
+      'kRedo': 'Ctrl / ⌘ + Shift + Z (or Ctrl + Y): redo',
+      'kCopy': 'Ctrl / ⌘ + D: duplicate selected nodes',
+      'kDel': 'Delete / Backspace: delete selected nodes or edge',
+      'kEsc': 'Esc: close menu / clear selection',
+      'kZoomKeys': 'Double-click the project name: rename the project',
       'supportNote': 'Found a bug or have an idea? File an issue or join the group.',
       'supportGithub': 'GitHub repository',
       'supportIssues': 'Visit GitHub & file an issue',
@@ -704,7 +782,7 @@ window.__ModuleLoader__.load({
       'lbHint': 'Click outside or press Esc to close',
       'resizeList': 'Drag to resize the shot list',
       'frameModeLabel': 'Chaining',
-      'frameModeHint': 'How the first-frame input is used. The gateway forbids mixing first_frame with reference_image: Fuse = the tail frame becomes reference image #1 (keeps entity refs; continuity is a soft constraint); Hard = true first_frame param (exact continuity, drops refs); Ignore = do not use the frame',
+      'frameModeHint': 'How the first frame is sourced (first frame = previous segment tail, for cross-segment continuity). The gateway forbids mixing first_frame with reference_image: Fuse = tail frame becomes reference image #1 (keeps entity refs; soft constraint + prompt anchoring); Hard = true first_frame param (exact continuity, drops refs); Ignore = no frame. Even without a frame wire, continuation segments auto-take the previous tail',
       'frameModeAuto': 'Fuse with refs',
       'frameModeHard': 'Hard first frame',
       'frameModeOff': 'Ignore frame',
@@ -716,6 +794,8 @@ window.__ModuleLoader__.load({
       'allProjects': 'All projects',
       'currentProject': 'Current project',
       'expandDone': 'Expanded to one multi-shot generation: {n} shots composed into a single video',
+      'expandGenCreated': 'Created {n} image-generation node(s) for assets that had no image yet, with sheet prompts already written — generate the asset images first, then the video',
+      'expandAssetReused': '{n} reused from the asset library',
       'multiShotHint': 'Multi-shot mode: the prompt is composed from the upstream storyboard (all shots, in order, with durations) and generated as one clip',
       'aiNeedScript': 'The storyboard has no script source: connect an upstream script node, or paste a script into the node',
       'upstreamStillRunning': 'The upstream script node is still generating (with a wire, content comes only from the wire); wait for it before splitting shots',
@@ -755,6 +835,7 @@ window.__ModuleLoader__.load({
       'scriptAssetPrefix': 'Script-',
       'storyboardAssetPrefix': 'Shots-',
       'defaultProject': 'My Canvas',
+      'emptyProjectHint': 'No projects yet. Click "New Project" above to create your first one, or just ask the assistant: "create a project called …".',
       'shotPrefix': 'Shot ',
       'shotsUnit': 'shots',
       'savedOk': 'Saved as asset',
@@ -793,10 +874,12 @@ window.__ModuleLoader__.load({
       'modelsLabel': 'Models',
       'modelNamePh': 'Model id (e.g. doubao-seedance-2.0)',
       'starDefault': 'Set as default model (nodes without a selection route here)',
-      'noModelsCfg': 'No models configured — node runs will fail',
+      'noModelsCfg': 'No models configured — runs will ask you to configure first (readable error in chat)',
       'errNoImageModel': 'No image model selected: configure image models in Settings and star a default, or pick one on the node',
       'errNoVideoModel': 'No video model selected: configure video models in Settings and star a default, or pick one on the node',
       'consistencyTitle': 'Consistency check',
+      'refreshCheck': 'Refresh',
+      'refreshCheckHint': 'Re-check against the current series bible (entries added after generation do not clear stale warnings automatically)',
       'restartHint': 'The plugin backend is not loaded yet: restart DeepSeek Harness once and retry (first update only)',
       'rpcFail': 'Request failed',
       'skillEnhance': 'Skill boost (use installed Harness skills instead of built-in experts)',
@@ -939,7 +1022,24 @@ window.__ModuleLoader__.load({
       'ungroup': 'Ungroup',
       'redraw': 'Redraw from this',
       'lastFrame': 'Last frame',
+      'tailPick': 'Tail pick',
+      'tailPickHint': 'Tail frame used for chaining: the best "mid-motion, sharp, stable" frame near the end, not blindly the last one',
       'chainNext': 'Chain next shot',
+      'chainInfo': 'Chained: first frame comes from the previous segment tail',
+      'chainAuto': 'Auto: previous segment tail as first frame',
+      'chainManual': 'First frame from wire',
+      'contToggle': 'Continuity',
+      'contToggleHint': 'When on, the storyboard writes a tail state / start state / camera carry-over / segment type for every shot — that is what makes separately generated segments connect',
+      'shotTail': 'Hand-off tail',
+      'segOpening': 'Opening',
+      'segContinuation': 'Continuation',
+      'segNew_character': 'New character',
+      'segScene_change': 'Scene change',
+      'segCloseup': 'Insert',
+      'segCut': 'Insert',
+      'seamOk': 'Seam OK',
+      'seamFail': 'Seam jump',
+      'seamHint': 'Seam check: similarity between this segment first frame and the previous tail frame',
       'craftCard': 'Craft post (ArtCraft)',
       'craftUnreachable': 'Craft not connected: make sure dsh-artcraft is installed/enabled and Harness was restarted',
       'craftDataRoot': 'Data root',
@@ -1248,6 +1348,44 @@ window.__ModuleLoader__.load({
 .dshic-mask-stage img{max-width:100%;max-height:52vh;display:block;}
 .dshic-mask-paint{position:absolute;inset:0;width:100%;height:100%;cursor:crosshair;touch-action:none;}
 .dshic-mask-toolbar{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}
+/* 快捷键入口（工具栏内）+ 下拉面板（绝对定位在按钮下方） */
+.dshic-keys-wrap{position:relative;display:inline-flex;flex:none;}
+.dshic-keys-btn{display:inline-flex;align-items:center;gap:5px;height:28px;padding:0 9px;border-radius:8px;
+  border:none;background:transparent;cursor:pointer;font:inherit;font-size:13px;white-space:nowrap;flex:none;
+  color:var(--dsw-alias-label-primary);}
+.dshic-keys-btn:hover{background:color-mix(in srgb,var(--dsw-alias-label-primary) 8%,transparent);}
+.dshic-keys-btn.is-open{background:color-mix(in srgb,var(--dsw-alias-brand-primary) 18%,transparent);color:var(--dsw-alias-brand-primary);}
+.dshic-keys-btn-label{line-height:1;}
+.dshic-keys-caret{font-size:9px;opacity:.75;line-height:1;}
+/* 面板右对齐：按钮位于工具栏右半侧，向左展开才不会出屏；窄屏换行时也跟随按钮 */
+.dshic-keys-pop{position:absolute;right:0;top:calc(100% + 6px);z-index:30;
+  width:330px;max-height:min(70vh,520px);overflow:auto;box-sizing:border-box;padding:10px 12px;
+  border-radius:10px;border:1px solid var(--dsw-alias-border-l2);
+  background:color-mix(in srgb,var(--dsw-alias-bg-overlay) 72%,transparent);
+  backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);
+  box-shadow:0 8px 24px color-mix(in srgb,var(--dsw-alias-bg-base) 50%,transparent);}
+.dshic-keys-title{font-size:12px;font-weight:600;color:var(--dsw-alias-label-primary);margin-bottom:8px;}
+.dshic-keys-group{margin-bottom:9px;}
+.dshic-keys-group-title{font-size:11px;font-weight:600;letter-spacing:.04em;text-transform:uppercase;
+  color:var(--dsw-alias-label-secondary);opacity:.8;margin-bottom:4px;}
+.dshic-keys-row{display:flex;align-items:baseline;gap:8px;padding:2px 0;font-size:12px;line-height:17px;}
+.dshic-keys-key{flex:none;min-width:84px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
+  font-size:11px;color:var(--dsw-alias-label-primary);background:color-mix(in srgb,var(--dsw-alias-label-primary) 8%,transparent);
+  border-radius:4px;padding:1px 5px;text-align:center;white-space:nowrap;}
+.dshic-keys-text{flex:1;min-width:0;color:var(--dsw-alias-label-secondary);word-break:break-word;}
+.dshic-keys-hint{margin-top:2px;padding-top:7px;border-top:1px solid var(--dsw-alias-border-l2);
+  font-size:11px;color:var(--dsw-alias-label-secondary);opacity:.75;}
+/* Alt 自由摆放（不推挤）时的节点轮廓：虚线 + 轻微透明，明确"现在可以覆盖穿过" */
+.dshic-node.is-free-drag{outline:2px dashed var(--dsw-alias-brand-primary);outline-offset:2px;opacity:.92;}
+/* 会话右栏：画布页签（占位卡） */
+.dshic-host-taken{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;
+  background:var(--dsw-alias-bg-base);z-index:5;}
+.dshic-host-taken-card{max-width:320px;display:flex;flex-direction:column;align-items:center;gap:10px;
+  padding:20px 22px;border:1px solid var(--dsw-alias-border-l2);border-radius:12px;
+  background:var(--dsw-alias-bg-layer-1);text-align:center;}
+.dshic-host-taken-title{font-size:13px;font-weight:600;}
+.dshic-host-taken-hint{font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary);}
+.dshic-pane-tab-title{font-size:12px;font-weight:500;}
 /* 小地图 */
 .dshic-minimap{position:absolute;right:12px;bottom:12px;width:160px;height:100px;background:var(--dsw-alias-bg-overlay);
   border:1px solid var(--dsw-alias-border-l2);border-radius:8px;z-index:15;overflow:hidden;cursor:pointer;box-sizing:border-box;
@@ -1607,15 +1745,17 @@ window.__ModuleLoader__.load({
      *  light=true（图片生成专用）：只保留风格行与 [图N] 名称绑定——参考图本身就是外观事实源，
      *  内联设定全文会稀释参考图约束，且文字渲染型模型（Qwen-Image）会把追加文本直接画进画面（用户实测：
      *  设定集全文被渲染成画面右下角的乱码文字块、剧情词凭空生成道具）。视频路径不用 light（不渲染文字，上下文有益）。 */
-    function buildEffectivePrompt(prompt, refs, entities, bible, light) {
+    function buildEffectivePrompt(prompt, refs, entities, bible, light, opts) {
       const zh = effLang() !== 'en';
+      // 续帧降级模式（图1=尾帧）下实体参考图实际是图2..N+1 —— 与请求侧 videoRefNote 统一口径
+      const picOffset = (opts && opts.picOffset) || 0;
       const bind = refs.map((r, i) => {
         if (r.entity) {
           const ent = matchBibleEntity(r.entity, bible);
           const desc = light ? '' : ((ent && ent.desc) || '');
-          return `[图${i + 1}] ${entityLabelOf((ent || {}).kind || 'prop')} ${r.entity}${desc ? '（' + desc + '）' : ''}`;
+          return `[图${i + 1 + picOffset}] ${entityLabelOf((ent || {}).kind || 'prop')} ${r.entity}${desc ? '（' + desc + '）' : ''}`;
         }
-        return `[图${i + 1}] ${catLabel(r.category)}：${r.name}`;
+        return `[图${i + 1 + picOffset}] ${catLabel(r.category)}：${r.name}`;
       }).join('；');
       const entLines = light ? [] : entities.map((e) => `${entityLabelOf(e.kind)} ${e.name}：${e.desc}`);
       return [
@@ -1665,6 +1805,541 @@ window.__ModuleLoader__.load({
       return [].concat(b.characters || [], b.scenes || [], b.props || [])
         .map((x) => (x && x.name ? String(x.name).trim() : '')).filter(Boolean);
     }
+
+    // ---------- 分镜衔接（续帧接力 / 段落调度 / 接缝校验）----------
+    //  为什么需要它：每段视频是**独立采样**的，模型不知道上一段最后发生了什么。分镜只写"本镜拍什么"、
+    //  不写"接在哪、怎么接"，模型就自己脑补起点 → 每段各演各的。行业解法不是提示词玄学，而是三层工程：
+    //   ① 分镜层写「承接上镜尾态 / 本镜起始态 / 接点尾态（动作进行中）/ 运镜延续」；
+    //   ② 生成层把上一段尾帧作为本段首帧（首尾帧模式优先，其次尾帧降级为第 1 张参考图并软锚定）；
+    //   ③ 剪辑/校验层比对接缝（尾帧 vs 下段首帧），超阈值打回。
+    /** 归一到 0-1 的相似度（0.8 以上视为同一画面）。数字或 null。 */
+    function normSim(x) {
+      const v = Number(x);
+      if (!Number.isFinite(v)) return null;
+      return Math.max(0, Math.min(1, v > 1.0001 ? v / 100 : v));
+    }
+    /** 镜头画面文本（visual + motion），用于衔接描述与相似度兜底。 */
+    function shotVisualText(sh) {
+      if (!sh) return '';
+      return [String(sh.visual || '').trim(), String(sh.motion || '').trim()].filter(Boolean).join('；');
+    }
+    /**
+     * 镜头衔接规划：把「尾部状态 / 起始状态 / 运镜延续 / 段落类型 / 接缝档位」统一解出来。
+     * 分镜字段可手写（tail/start/cam），缺失时用 visual 兜底——**绝不编造剧情**，只做"能确认的推断"。
+     * seg:   'opening'（首段，交代）| 'continuation'（续帧，默认）| 'new_character'（新角色入场，参考图模式）
+     *        | 'scene_change'（换场，不接尾帧）| 'closeup'（特写/细节插入，接缝不被画面盯着看 → 标准放宽）
+     * join:  'strict'（同步长硬接）| 'loose'（跨场/换景，允许软接）| 'cut'（特写插入，跳切合理，不接力）
+     * @returns {{seg,name,join,fromTail,fromShot,tail,start,cam,chain,note}}
+     */
+    function shotContinuityPlan(sh, prev, idx) {
+      const s = sh || {};
+      const i = Number.isFinite(Number(idx)) ? Number(idx) : 0;
+      const prevShot = i > 0 ? (prev || null) : null;
+      const segRaw = String(s.seg || '').trim().toLowerCase();
+      const SEG_ALIAS = {
+        opening: 'opening', open: 'opening', '首段': 'opening', '开场': 'opening',
+        continuation: 'continuation', cont: 'continuation', '续': 'continuation', '续帧': 'continuation', '承接': 'continuation',
+        new_character: 'new_character', newchar: 'new_character', '新角色': 'new_character', '入场': 'new_character',
+        scene_change: 'scene_change', scene: 'scene_change', '换场': 'scene_change', '转场': 'scene_change',
+        closeup: 'closeup', insert: 'closeup', '特写': 'closeup', '插入': 'closeup',
+      };
+      let seg = SEG_ALIAS[segRaw] || '';
+      const boxed = (k) => String(s[k] || '').trim();
+      if (!seg) {
+        if (!prevShot) seg = 'opening';
+        else if (/换场|场景切换|转场|另一处|另一场景|切至|切到|次日|翌日|与此同时|数日后|[Cc]ut to/.test(shotVisualText(s))) seg = 'scene_change';
+        else if (/新角色|首次出场|走进来|入镜|入场|冒出|推门进|[Ee]nters?/.test(shotVisualText(s))) seg = 'new_character';
+        else if (Number(s.duration) > 0 && Number(s.duration) < 1.5 && !(s.dialogue || []).length) seg = 'closeup';
+        else seg = 'continuation';
+      }
+      if (seg === 'opening' && prevShot) seg = 'continuation'; // 首段只能在第 1 镜；后面标"开场"视为续帧
+      // 接缝档位：换场/新角色入场都放宽（新角色段本就不承接上段画面），特写插入允许跳切
+      const join = (seg === 'scene_change' || seg === 'new_character') ? 'loose' : seg === 'closeup' ? 'cut' : 'strict';
+      // 只有真正需要画面承接的段落才接力尾帧；新角色入场首帧若来自上一段，新角色反而无从进入
+      const chain = seg === 'continuation' && !!prevShot;
+      // ownTail = 本镜的接点尾态（留给**下一镜**）；cam = 本镜运镜（同样留给下一镜延续）
+      const tail = boxed('tail');
+      const cam = boxed('cam');
+      // prevTail = **上一镜**的接点尾态 = 本镜的起始态（衔接块要引用的是它，不是本镜自己的 tail）。
+      // 旧分镜没写 tail 时退到上一镜的「最后动作」——诚实标注来源，而不是拿本镜画面冒充。
+      let prevTail = '';
+      let prevTailSource = '';
+      if (prevShot) {
+        const pt = String(prevShot.tail || '').trim();
+        const pm = String(prevShot.motion || '').trim();
+        if (pt) { prevTail = pt; prevTailSource = 'tail'; }
+        else if (pm) { prevTail = pm; prevTailSource = 'motion'; }
+      }
+      const start = boxed('start');
+      return {
+        idx: i, seg, join, fromTail: i > 0, fromShot: i > 0, chain,
+        name: String(s.title || '').trim(),
+        tail, cam, start, prevTail, prevTailSource,
+        note: boxed('note'),
+      };
+    }
+    /**
+     * 由上一段分镜的尾镜推出本分镜的「承接约束」（跨分镜表接戏）。
+     * 与 aiStoryboardShots 的 prevTail 契约一致：{ label, text, shot }，但这里显式带出衔接字段。
+     */
+    function storyboardContinuityNote(prevShots, label, zh) {
+      const arr = (prevShots || []).filter(Boolean);
+      const tailShot = arr.length ? arr[arr.length - 1] : null;
+      if (!tailShot) return null;
+      // 尾镜的 tail/cam 是直接字段（第 0 镜没有"上一镜"，规划器不会替它推断，所以直接读字段）
+      const plan = shotContinuityPlan(tailShot, null, 0);
+      const tailState = String(tailShot.tail || '').trim();
+      const camState = String(tailShot.cam || '').trim();
+      const text = [
+        zh ? '尾镜画面：' : 'Tail frame: ', String(tailShot.visual || '').trim(),
+        tailState ? (zh ? '\n尾镜接点尾态（本段第 1 镜必须从这里继续，动作处于进行中）：' + tailState
+          : '\nTail hand-off state (shot 1 continues from here, mid-motion): ' + tailState) : '',
+        camState ? (zh ? '\n尾镜运镜（第 1 镜须同向延续）：' + camState : '\nTail camera (shot 1 continues the same direction): ' + camState) : '',
+        String(tailShot.motion || '').trim() ? '\n' + (zh ? '尾镜最后动作：' : 'Tail last action: ') + String(tailShot.motion).trim() : '',
+      ].filter(Boolean).join('');
+      return { label: String(label || ''), text: text + '\n', shot: tailShot, plan };
+    }
+    /**
+     * 镜头衔接块（写进视频提示词）：让模型知道"接在哪、从哪起、留什么给下一段"。
+     * 只在分镜明确给出衔接信息或确属跨分镜承接时生成；普通首镜（无上游）返回 ''，绝不无中生有。
+     */
+    function shotContinuityBlock(plan, opts) {
+      const p = plan || {};
+      const o = opts || {};
+      const zh = o.zh !== false;
+      if (!p.fromShot) return '';
+      const isFirst = p.idx === 0;
+      // 段类型：本分镜表内续帧 / 承接上一个分镜表 / 不接（换场·特写插入）
+      let kindLine = '';
+      if (p.seg === 'scene_change') kindLine = zh ? '段落类型：换场（不承接上一镜画面，直接建立新空间；环境声可延续）' : 'Segment type: scene change (do not continue the previous frame; establish the new space; ambience may carry over)';
+      else if (p.seg === 'closeup') kindLine = zh ? '段落类型：特写/细节插入（可与上一镜跳切，不要求画面连续）' : 'Segment type: insert close-up (jump cut allowed, no frame continuity required)';
+      else if (p.seg === 'new_character') kindLine = zh ? '段落类型：新角色入场（新角色须在画面中自然进入，不得凭空出现）' : 'Segment type: new character enters (must enter naturally, never pop in)';
+      else if (p.seg === 'continuation') kindLine = zh
+        ? (isFirst ? '段落类型：承接上一个分镜表（本分镜第 1 镜从上一镜结尾继续，不重演、不重新建立场景）' : '段落类型：续帧（从上一镜结尾继续，不重演）')
+        : (isFirst ? 'Segment type: continues the previous storyboard (no re-establishing, no replay)' : 'Segment type: continuation (continue from the previous shot, no replay)');
+      const parts = [];
+      // 承接上镜结尾：引用的是**上一镜**的接点尾态（本镜的起始态），不是本镜自己的 tail。
+      // 旧分镜没写 tail 时用上一镜的 motion 兜底，并诚实标注来源（不拿本镜画面冒充上一镜结尾）。
+      if (p.prevTail && (p.seg === 'continuation' || p.seg === 'new_character')) {
+        const src = p.prevTailSource === 'motion'
+          ? (zh ? '（上一镜未写接点尾态，按其最后动作推断）' : ' (previous shot has no explicit hand-off state; inferred from its last action)')
+          : '';
+        parts.push((zh ? '承接上镜结尾（本镜起始态，不得重置姿态/位置/手持物）：' : 'Continue from the previous shot end state (start exactly here; do not reset posture/position/handheld props): ') + p.prevTail + src);
+      } else if (p.start && p.seg === 'continuation') {
+        parts.push((zh ? '本镜起始态：' : 'Start state: ') + p.start);
+      }
+      // 运镜延续：优先用上一镜的运镜（本镜要接着走）；没有则用本镜自己写的 cam
+      if (p.cam) parts.push((zh ? '运镜延续：' : 'Camera continues: ') + p.cam + (zh ? '（方向与速度保持，不反向、不突变）' : ' (same direction and speed; no reversal, no sudden change)'));
+      // 本镜的接点尾态单独提示，明确它是留给下一段的（同时提醒不要在片尾收成定格）
+      if (p.tail && p.seg === 'continuation') {
+        parts.push((zh ? '本镜接点（片尾停在此状态，保持动作进行中，不要演完站定）' : 'End this shot on this hand-off state, still mid-motion; do not settle to a static pose') + '：' + p.tail);
+      }
+      if (p.note) parts.push((zh ? '接戏要求：' : 'Continuity requirement: ') + p.note);
+      if (!kindLine && !parts.length) return '';
+      const head = zh ? '【衔接】' : '[Continuity] ';
+      const end = zh
+        ? '禁止重启姿态、禁止重新建立场景、禁止改变人物朝向与站位（除非剧情明确要求）'
+        : 'Never reset posture, never re-establish the scene, never change facing or blocking unless the story demands it';
+      const body = [kindLine].concat(parts, [end]).filter(Boolean);
+      // 统一标点：拼接前去掉各自尾部标点，避免出现「。；」这种叠标点
+      const clean = body.map((x) => String(x).replace(/[。；;.、\s]+$/, '')).filter(Boolean);
+      return head + clean.join(zh ? '；' : '; ') + (zh ? '。' : '.');
+    }
+    /**
+     * 首帧（上一段尾帧）的软锚定说明：把首帧图钉在"第 1 帧"，模型只允许往后运动。
+     * 接口不支持硬首帧时这是**提高权重**，不是锁像素——调用方要给用户可见的告警。
+     */
+    function frameAnchorText(opts) {
+      const o = opts || {};
+      const zh = o.zh !== false;
+      if (!o.hasFrame) return '';
+      const asFirst = o.role === 'first_frame';
+      return zh
+        ? (asFirst
+          ? '【首帧锚定】本次输入的首帧图就是上一段视频的结尾画面：第 1 帧必须与该图完全一致（构图、人物位置、朝向、手持道具、光线），只允许从第 1 帧之后继续运动。'
+          : '【首帧锚定】[图1] 是上一段视频的结尾画面（衔接参考，非风格参考）：第 1 帧必须与 [图1] 的画面一致——构图、人物位置、朝向、手持道具、主光方向都不得改动，只允许往后延续运动。')
+        : (asFirst
+          ? '[First-frame anchor] The input first frame IS the last frame of the previous segment: frame 1 must match it exactly (framing, blocking, facing, handheld props, light) and motion starts only after frame 1.'
+          : '[First-frame anchor] [Picture 1] is the last frame of the previous segment (a continuity reference, not a style reference): frame 1 must match it - framing, blocking, facing, handheld props and key light unchanged; only continue the motion.');
+    }
+    /**
+     * 尾帧选帧评分：不是"取最后一帧"——最后一帧常落在动作顶点/运动模糊/遮挡/收敛抖动上。
+     * 返回 0-1 分，越高越适合当下一段首帧（动作进行中、清晰、无遮挡、不抖）。
+     * @param m { motion（相邻帧差 0-1）, sharp（清晰度 0-1）, coverage（前景占比 0-1）, jitter（模型收敛抖动 0-1）, complete（动作完成度 0-1） }
+     */
+    function tailFrameScore(m) {
+      const c = (x, d) => (Number.isFinite(Number(x)) ? Math.max(0, Math.min(1, Number(x))) : d);
+      const motion = c(m && m.motion, 0.5);
+      const sharp = c(m && m.sharp, 0.5);
+      const coverage = c(m && m.coverage, 1);
+      const jitter = c(m && m.jitter, 0);
+      const complete = c(m && m.complete, 0.5);
+      // 动作"进行中"最好：太快（模糊/顶点）或完全静止（定格）都扣分
+      const motionFit = 1 - Math.abs(motion - 0.45) / 0.55;
+      // 动作完成度：留 30% 未完成最利于续接（完成度 0.7 附近满分，1=完成态扣分）
+      const incomplete = 1 - Math.abs(complete - 0.7) / 0.7;
+      const score = 0.34 * Math.max(0, motionFit) + 0.30 * sharp + 0.16 * coverage + 0.14 * Math.max(0, incomplete) - 0.22 * jitter;
+      return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * 帧间相似度（接缝校验）：只比较缩略灰度图，抗压缩噪声。
+     * 指标：MAD（平均绝对差）、粗糙结构相关（16 宫格均值相关）——两者都要过才算接得上。
+     * @param a/b { data: Uint8ClampedArray|number[]（RGBA）, w, h }（同尺寸，调用方先缩到 32×32 灰度或同等）
+     */
+    function frameSeamMetrics(a, b) {
+      const ga = a && a.data, gb = b && b.data;
+      if (!ga || !gb || !ga.length || ga.length !== gb.length) return null;
+      const n = ga.length;
+      let sad = 0;
+      let ma = 0, mb = 0;
+      for (let i = 0; i < n; i++) { sad += Math.abs(ga[i] - gb[i]); ma += ga[i]; mb += gb[i]; }
+      ma /= n; mb /= n;
+      let cov = 0, va = 0, vb = 0;
+      for (let i = 0; i < n; i++) { const da = ga[i] - ma, db = gb[i] - mb; cov += da * db; va += da * da; vb += db * db; }
+      const corr = (va > 1e-6 && vb > 1e-6) ? cov / Math.sqrt(va * vb) : (Math.abs(ma - mb) < 6 ? 1 : 0);
+      // 宫格结构相似：把图切成 G×G 求每格均值，再做相关（对整体位移/缩放不敏感，抓"画面是否同一空间"）
+      const G = 16;
+      const side = Math.round(Math.sqrt(n)) || 1;
+      const cellA = new Array(G * G).fill(0), cellB = new Array(G * G).fill(0), cnt = new Array(G * G).fill(0);
+      for (let i = 0; i < n; i++) {
+        const x = i % side, y = Math.floor(i / side);
+        const gx = Math.min(G - 1, Math.floor((x / side) * G));
+        const gy = Math.min(G - 1, Math.floor((y / side) * G));
+        const k = gy * G + gx;
+        cellA[k] += ga[i]; cellB[k] += gb[i]; cnt[k]++;
+      }
+      let cm = 0;
+      const ca = cellA.map((v, k) => (cnt[k] ? v / cnt[k] : 0)), cb = cellB.map((v, k) => (cnt[k] ? v / cnt[k] : 0));
+      for (let k = 0; k < ca.length; k++) cm += ca[k] / ca.length;
+      let cv = 0, cv2 = 0, cva = 0, cvb = 0;
+      for (let k = 0; k < ca.length; k++) { const da = ca[k] - cm, db = cb[k] - cm; cv += da * db; cva += da * da; cvb += db * db; }
+      const gridCorr = (cva > 1e-6 && cvb > 1e-6) ? cv / Math.sqrt(cva * cvb) : 0;
+      return {
+        mad: sad / n, // 0-255
+        corr, // -1..1
+        gridCorr, // -1..1
+        sim: Math.max(0, Math.min(1, 0.35 * corr + 0.65 * gridCorr)), // 0-1 综合相似度
+      };
+    }
+    /** 接缝判定：超过档位阈值才算"接得上"，否则给出明确原因（供 UI 打回/告警）。 */
+    function seamVerdict(metrics, join) {
+      if (!metrics) return { ok: true, sim: null, note: '' };
+      const thr = join === 'loose' ? 0.35 : join === 'cut' ? 0.15 : 0.55;
+      const sim = metrics.sim;
+      const ok = sim >= thr;
+      return {
+        ok, sim, thr,
+        note: ok ? '' : ('接缝相似度 ' + sim.toFixed(2) + ' < 阈值 ' + thr.toFixed(2) + '（' + (join === 'loose' ? '跨场/换景' : join === 'cut' ? '特写插入' : '同场续帧') + '）：画面可能跳变'),
+      };
+    }
+
+    // ---------- 视频「参考生成」结构化提示词（对齐 MiniMax H3 / 优云智算的优化后格式）----------
+    //  为什么需要它：机械拼装（风格 + [图N] 绑定 + 镜头列表 + 设定集全文）会让模型把台词/场景判错；
+    //  这个格式把「素材 → 主体 → 分镜 → 台词 → 声音」显式绑定，模型据此做音画同步与口型对齐。
+    /** 参考图 → 主体信息：实体名（@引用或资产名解析）、品类、设定集描述。 */
+    function subjectInfoFromRef(ref, bible) {
+      const raw = String((ref && ref.name) || '').trim();
+      let name = String((ref && ref.entity) || '').trim();
+      let kind = ref && ref.category === 'character' ? 'character' : ref && ref.category === 'scene' ? 'scene' : ref && ref.category === 'prop' ? 'prop' : '';
+      if (!name) {
+        const m = /^(角色|场景|道具)[-_／/]/.exec(raw);
+        if (m) kind = m[1] === '角色' ? 'character' : m[1] === '场景' ? 'scene' : 'prop';
+        name = raw
+          .replace(/^(角色|场景|道具)[-_／/]\s*/, '')
+          .replace(/\s*\d{1,2}-\d{1,2}\s+\d{1,2}:\d{2}[\s\S]*$/, '')
+          .replace(/\s*(设定图|参考图|多视图|三视图)[\s\S]*$/, '')
+          .trim();
+      }
+      const ent = bible && name ? matchBibleEntity(name, bible) : null;
+      return { name: ent ? ent.name : name, kind: (ent && ent.kind) || kind, desc: ent ? String(ent.desc || '') : '' };
+    }
+    /** 描述压缩成一句：优先「外观：…」片段，其次首句，最长 80 字。 */
+    function condenseDesc(desc) {
+      const s = String(desc || '').replace(/\s+/g, ' ').trim();
+      if (!s) return '';
+      const ap = /外观[：:]\s*([^。；]+)/.exec(s);
+      const seg = ap ? ap[1] : s.split(/[。；]/)[0];
+      const one = String(seg || '').replace(/^[，,、\s]+/, '').trim();
+      return one.length > 80 ? one.slice(0, 80) + '…' : one;
+    }
+    /** 设定集描述里的「声音：…」→ 说话人声音标注（台词的音色依据）。 */
+    function voiceFromDesc(desc) {
+      const m = /声音[：:]\s*([^。；]+)/.exec(String(desc || ''));
+      return m ? m[1].trim() : '';
+    }
+    /**
+     * 由分镜表 + 参考图生成「参考生成」结构化提示词。
+     * 段名保持英文（与厂商优化后的协议一致），正文用中文；没有参考图时返回 ''（调用方回退到普通提示词）。
+     * @param shots 分镜镜头（visual/motion/duration/dialogue/sfx/title/characters/scene/props）
+     * @param refs  collectRefs 结果（顺序即 <Picture N>）
+     * @param bible 设定集（desc 提供外观/声音信息）
+     * @param opts  { zh, prompt（节点上手写的补充说明）, music（非叙事音乐，来自扩展参数） }
+     */
+    function buildStructuredVideoPrompt(shots, refs, bible, opts) {
+      const o = opts || {};
+      const zh = o.zh !== false;
+      const list = (shots || []).filter((s) => s && (String(s.visual || '').trim() || String(s.motion || '').trim() || (s.dialogue || []).length));
+      if (!list.length) return '';
+      // 主体分配：一个实体一个 Subject，可对应多张 Picture；顺序 = 参考图中首次出现
+      const subjects = [];
+      const byKey = new Map();
+      // 续帧降级模式（图1=上一段尾帧）：请求侧 videoRefNote/frameAnchorText 都把尾帧编号为 [图1]、
+      // 实体参考图为 [图2..N+1] —— <Picture N> 绑定必须整体偏移一位，否则同一提示词里
+      // <Picture 1> 说实体、[图2] 才是实体，主体-素材绑定自相矛盾（参考生成格式赖以工作的锚点）。
+      const picOffset = (o.hasFrame && o.frameRole === 'reference_image') ? 1 : 0;
+      (refs || []).forEach((r, i) => {
+        const info = subjectInfoFromRef(r, bible);
+        if (!info || !info.name) return;
+        const key = info.name.toLowerCase();
+        let sub = byKey.get(key);
+        if (!sub) {
+          sub = { name: info.name, kind: info.kind, desc: info.desc, voice: voiceFromDesc(info.desc), pics: [], voiced: false };
+          subjects.push(sub);
+          byKey.set(key, sub);
+        }
+        if (!sub.pics.includes(i + 1 + picOffset)) sub.pics.push(i + 1 + picOffset);
+      });
+      if (!subjects.length) return '';
+      const sid = (sub) => subjects.indexOf(sub) + 1;
+      const pic = (n2) => '<Picture ' + n2 + '>';
+      // 名称 → <Subject N>（长名优先，避免"瓦力"吃掉"瓦力的铃铛"）；顺带清掉 @引用@ 的包裹符号，
+      // 否则会留下「@<Subject 2>@」这种残迹（@ 是画布内的引用语法，不该发给视频模型）
+      const ordered = subjects.slice().sort((a, b) => b.name.length - a.name.length);
+      const mentionRe = /@([^@\s，。；、,;:.!?！？「」（）()]{1,24})@/g;
+      const rewrite = (text) => {
+        let out = String(text || '');
+        if (out.includes('@')) {
+          out = out.replace(mentionRe, (all, inner) => {
+            const hit = subjects.find((sub) => sub.name.toLowerCase() === String(inner).trim().toLowerCase());
+            if (hit) return '<Subject ' + sid(hit) + '>';
+            return inner; // 未登记的 @名称@ 去掉包裹符号（不要再把画布语法发给模型）
+          });
+        }
+        for (const sub of ordered) {
+          if (!sub.name) continue;
+          out = out.split(sub.name).join('<Subject ' + sid(sub) + '>');
+        }
+        return out;
+      };
+      // 说话人编号：跨镜台词按首次出现顺序 (S1)、(S2)…
+      const speakers = [];
+      const speakerId = (roleName) => {
+        const nm = String(roleName || '').trim();
+        if (!nm) return '';
+        let i = speakers.findIndex((x) => x.name === nm);
+        if (i < 0) { speakers.push({ name: nm, voiced: false }); i = speakers.length - 1; }
+        return 'S' + (i + 1);
+      };
+      // 绝对时间轴
+      let acc = 0;
+      const starts = list.map((s) => { const st = acc; acc += Math.max(0.1, Number(s.duration) || 3); return st; });
+      const total = acc;
+      const fmtT = (sec) => {
+        const ms = Math.max(0, Math.round(sec * 1000));
+        const m = Math.floor(ms / 60000);
+        const s2 = Math.floor((ms % 60000) / 1000);
+        return String(m).padStart(2, '0') + ':' + String(s2).padStart(2, '0') + '.' + String(ms % 1000).padStart(3, '0');
+      };
+      const appearsIn = (sub) => list.map((_, i) => i + 1).filter((idx) => {
+        const s = list[idx - 1];
+        const hay = [s.visual, s.motion, s.title, (s.characters || []).join(' '), s.scene, (s.props || []).join(' '), (s.dialogue || []).map((d) => d && d.role).join(' ')].join(' ');
+        return hay.includes(sub.name);
+      });
+      const outs = [];
+      // ① 主体定义（素材绑定）
+      outs.push('subject_definitions:');
+      subjects.forEach((sub, i) => {
+        const brief = condenseDesc(sub.desc);
+        outs.push('<Subject ' + (i + 1) + '> 是 ' + sub.pics.map(pic).join('、') + ' 中的 ' + sub.name
+          + (brief ? '：' + brief : (sub.kind ? '（' + entityLabelOf(sub.kind) + '）' : '')));
+      });
+      // ② 总述（只写事实，不臆造剧情）
+      const first = String(list[0].title || '').trim();
+      const last = String(list[list.length - 1].title || '').trim();
+      outs.push('summary:');
+      outs.push('[参考生成] 目标视频共 ' + list.length + ' 镜、总时长 ' + (Math.round(total * 10) / 10) + ' 秒'
+        + (first || last ? '：从「' + (first || '起始镜') + '」开始，到「' + (last || '收束镜') + '」结束' : '')
+        + '。主体：' + subjects.map((s) => '<Subject ' + sid(s) + '>').join('、') + '。'
+        + (o.prompt ? ' ' + String(o.prompt).trim() : ''));
+      // ③ 保真核对（每个主体出现在哪些镜）
+      outs.push('retention_analysis:');
+      subjects.forEach((sub) => {
+        const where = appearsIn(sub);
+        const brief = condenseDesc(sub.desc) || (sub.kind ? entityLabelOf(sub.kind) : sub.name);
+        outs.push('<Subject ' + sid(sub) + '>（出现于 ' + (where.length ? where.map((i) => '[Shot ' + i + ']').join('、') : '未明确出现') + '）：fully_preserved —— 保持' + brief + '。');
+      });
+      // ④ 逐镜描述（画面 + 运镜 + 台词 + 音效）
+      outs.push('detailed_description:');
+      const style = String((bible && bible.style) || '').trim();
+      if (style) outs.push((zh ? '风格：' : 'Style: ') + style);
+      const hasDialogue = list.some((s) => (s.dialogue || []).some((d) => String((d && d.line) || '').trim()));
+      if (hasDialogue) {
+        outs.push(zh
+          ? '台词必须由画面内对应的主体当场开口说出（口型与台词同步、语气贴合情绪）；严禁画外音/旁白。'
+          : 'Dialogue must be spoken on screen by the matching subject with lip-sync; never voice-over.');
+      }
+      // 跨段续帧：首帧锚定（上一段尾帧作为本段第 1 帧）——放在逐镜之前，权重最高
+      const anchor = frameAnchorText({ hasFrame: !!o.hasFrame, role: o.frameRole, zh });
+      if (anchor) outs.push(anchor);
+      list.forEach((s, i) => {
+        const parts = [];
+        // 镜头衔接：段类型 + 承接上镜尾态 + 运镜延续（只对**本分镜表内**的镜头生成；
+        // 第 1 镜跨段承接由 frameAnchorText/调用方负责，避免同一句话说两遍）
+        const plan = shotContinuityPlan(s, list[i - 1], i);
+        if (i > 0) {
+          const cb = shotContinuityBlock(plan, { zh });
+          // 衔接块自带句末标点，作为段落级前置说明独立成句（去掉句末标点后由上层分隔符统一）
+          if (cb) parts.push(rewrite(cb).replace(/[。.]+$/, ''));
+        }
+        const visual = rewrite(String(s.visual || '').trim());
+        if (visual) parts.push(visual);
+        const motion = rewrite(String(s.motion || '').trim());
+        if (motion) parts.push((zh ? '运镜/动作：' : 'Camera/Action: ') + motion);
+        const dls = (s.dialogue || [])
+          .map((d) => ({ role: String((d && d.role) || '').trim(), line: String((d && d.line) || '').trim() }))
+          .filter((d) => d.line);
+        if (dls.length) {
+          const txt = dls.map((d) => {
+            const sp = speakerId(d.role);
+            const sub = subjects.find((x) => x.name === d.role);
+            const spk = speakers.find((x) => x.name === d.role);
+            const useVoice = !!(sub && sub.voice && spk && !spk.voiced);
+            if (useVoice) spk.voiced = true;
+            const who = sub ? ('<Subject ' + sid(sub) + '>（' + sp + '）') : (d.role ? d.role + '（' + sp + '）' : sp);
+            const lang = /[\u4e00-\u9fa5]/.test(d.line) ? 'Chinese' : 'English';
+            const said = useVoice
+              ? (zh ? ' 用' + sub.voice + '说' : ' says (voice: ' + sub.voice + ')')
+              : (zh ? ' 说' : ' says');
+            return who + said + '：<d>[' + lang + '] ' + d.line + '</d>';
+          }).join('；');
+          parts.push((zh ? '台词：' : 'Dialogue: ') + txt);
+        }
+        const sfx = rewrite(String(s.sfx || '').trim());
+        if (sfx) parts.push((zh ? '音效：' : 'SFX: ') + sfx);
+        const title = String(s.title || '').trim();
+        outs.push('[Shot ' + (i + 1) + '] ' + fmtT(starts[i]) + (zh ? ' 起' : '')
+          + (title ? '（' + title + '）' : '') + '：' + parts.join(zh ? '；' : '; '));
+      });
+      // ⑤ 声音景观（各镜音效合并）
+      const sfxAll = [...new Set(list.map((s) => String(s.sfx || '').trim()).filter(Boolean))];
+      outs.push('overall_soundscape:');
+      outs.push(sfxAll.length ? sfxAll.join('；') : (zh ? '仅保留场景环境声，不添加额外音效' : 'Ambient scene sound only'));
+      // ⑥ 非叙事音乐（仅在用户显式给出时输出，绝不臆造）
+      const music = String(o.music || '').trim();
+      if (music) {
+        outs.push('non_diegetic_music:');
+        outs.push(music);
+      }
+      // ⑦ 跨段接戏（仅当本段承接上一段：有首帧尾帧接力或分镜标了承接）
+      const contLine = String(o.continuity || '').trim();
+      if (contLine) {
+        outs.push('continuity:');
+        outs.push(contLine);
+      }
+      return outs.join('\n');
+    }
+    /**
+     * 资产设定图提示词生成器（纯函数）：按 canvas-craft「资产设定图版式」的规范，从设定集条目
+     * 组装专业设定集排版提示词——角色走「六段式」，场景走「主图 + 环绕补充小图」，道具走
+     * 「标题 + 斜 45° 主图 + 细节特写 + 侧视图 + 圆形色卡」。
+     * 共同铁律（技能实测结论）：版面里绝不渲染成段文字（文字型模型画长文本必乱码），
+     * 只允许 ≤4 字短标签；同一资产在所有分格中外观完全一致。
+     * @param kind 'character' | 'scene' | 'prop'
+     * @param name 资产名（设定集条目名）
+     * @param desc 设定集描述（含「外观：…」时只取该片段作为外观事实）
+     * @param bible 设定集（style 提供风格基调）
+     * @param zh 中文提示词（false → 英文）
+     */
+    function buildAssetSheetPrompt(kind, name, desc, bible, zh) {
+      const nm = String(name || '').trim() || (zh ? '未命名资产' : 'Unnamed asset');
+      const raw = String(desc || '').trim();
+      // 外观要点：优先「外观：…」片段（技能的写法约定），否则整段描述；去掉「声音：…」（画图用不到）
+      const look = (() => {
+        const ap = /外观[：:]\s*([^。；\n]+)/.exec(raw);
+        const seg = ap ? ap[1] : raw.replace(/声音[：:][^。；\n]*/g, '').trim();
+        return seg.replace(/\s+/g, ' ').trim();
+      })();
+      const style = String((bible && bible.style) || '').trim() || (zh ? '写实电影感' : 'realistic cinematic');
+      const lookLine = look ? look : (zh ? '（设定集未提供外观描述：按名称与常识绘制，保持朴素克制）' : '(no appearance notes in the bible: keep it plain and coherent)');
+      if (kind === 'scene') {
+        return zh
+          ? [
+            '【总起】' + style + ' 的场景设定图：一张主场景大图占画面主体，周围环绕补充小图；所有格子的光线方向、天气与色调统一，等大长条格一律不要。',
+            '【主体·主场景】全景建立镜头，交代空间结构、纵深与光线方向（主光来自哪一侧要能看出来）：' + lookLine + '。',
+            '【环绕补充小图（3–6 张，位置与数量不拘）】右侧一列：多角度图（俯瞰／贴地／第一人称视线等其他机位）+ 其他时间图（夜景／雨雾／逆光等同一场景的不同时段天气）；底部一排：细节格（标志物／入口／材质纹理／关键道具在场景中的位置）。',
+            '【标注】每张小图下方一行短标注，不超过 6 字（如「入口·夜」「雨中·逆光」）。',
+            '【文字规则】图内只允许上述短标注：黑色细体、笔画清楚；不写大标题、不写说明段或长句。',
+            '【画面白名单】画面内容只来自该场景与它的固有陈设；不出现剧情人物的面部特写、不出现与该场景无关的器物、没有文字水印。',
+          ].join('\n')
+          : [
+            '[Overall] A ' + style + ' location sheet: one large establishing image dominates the frame, ringed by supporting detail images; every panel shares the same light direction, weather and colour grade. No equal-width strip panels.',
+            '[Main image] A wide establishing shot that explains the space, its depth and where the key light comes from: ' + lookLine + '.',
+            '[Supporting images (3-6, placement free)] Right column: alternative angles (overhead / ground level / first-person sightline) plus other times of day (night / rain / backlit); bottom row: detail panels (landmark, entrance, material texture, where the key prop sits).',
+            '[Captions] One short caption under each small image, 6 characters max (e.g. "entrance·night").',
+            '[Text rules] Only those short captions: thin dark strokes, clearly drawn; no headline, no paragraph, no long sentence.',
+            '[Whitelist] Everything in frame comes from this location and its fixed dressing; no character close-ups, no unrelated objects, no watermark.',
+          ].join('\n');
+      }
+      if (kind === 'prop') {
+        return zh
+          ? [
+            '【总起】' + style + ' 的道具设定图：深色简洁背景，同一道具在所有分格中的材质、比例与配色完全一致。',
+            '【标题】顶部道具名大标题（不超过 6 字）：' + nm + '。',
+            '【中央主图】道具斜 45° 悬浮展示，带氛围光与细微粒子，占画面主体：' + lookLine + '。',
+            '【细节特写 2–3 格】材质纹理、关键部件，格内不写字。',
+            '【侧栏侧视图】同一道具的正侧面完整形态（交代厚度与结构）。',
+            '【底部颜色参考】3–5 个圆形色卡，每个下方标注颜色名（不超过 3 字，如「赤红」「熔金」）。',
+            '【文字规则】图内文字只有标题、颜色名与短标签：黑色细体、笔画清楚、字要写大；禁止铭文、短诗、说明文字（必然乱码）。',
+            '【画面白名单】画面中只有该道具本体与上述分格内容；不出现人物、动物、场景陈设、其他道具、文字水印。',
+          ].join('\n')
+          : [
+            '[Overall] A ' + style + ' prop sheet: dark plain background, identical material, scale and palette in every panel.',
+            '[Title] One large prop-name heading at the top (6 characters max): ' + nm + '.',
+            '[Main image] The prop floating at a 45 degree angle with ambient light and fine particles, filling the frame: ' + lookLine + '.',
+            '[Detail close-ups, 2-3 panels] Material texture and key components, no text inside them.',
+            '[Side view] A clean front/side view of the same prop (thickness and construction visible).',
+            '[Colour reference] 3-5 round swatches along the bottom, each labelled with a colour name (3 characters max).',
+            '[Text rules] Only the heading, colour names and short labels: thin dark strokes, clearly drawn, large enough; no inscriptions, no verse, no paragraphs.',
+            '[Whitelist] Only this prop and the panels above; no people, no animals, no set dressing, no other props, no watermark.',
+          ].join('\n');
+      }
+      // 角色（默认）：六段式
+      return zh
+        ? [
+          '【总起】16:9 横版专业角色设定集排版：深色简洁背景，' + style + '，同一角色在所有分格中外观完全一致。',
+          '【身份锚】本图没有参考照片：以下外观描述是唯一形象事实，所有分格严格按它绘制，不得自行换装、改体型或改变配色。',
+          '【主体】中央大幅全身立绘（正面自然站姿）：' + lookLine + '。姿态为自然空手站立——四肢自然着地或下垂，口部闭合或自然吐舌，不抱、不拿、不叼、不踩、不坐任何外物。',
+          '【主图下方·三视图（必须项）】正面／侧面／背面三格全身站姿——同一角色只换角度，交代侧背形态（后续视频一致性靠它）。',
+          '【右侧窄栏·自上而下分块，每块内容全图只出现一次】① 脸部特写一格 + 一行不超过 12 字的五官短标注；② 表情格：6 个头部小头像分两行（每行 3 个），每个下方只标两字表情名。',
+          '【文字规则】图内文字极少：只保留两三个字的短标签，黑色细体、笔画清楚、字要写大；不写大标题、说明段或长句。',
+          '【画面白名单】画面中只有该角色本体与它的固定配饰（如项圈／挂牌），以及上述分格内容；没有任何被抱、被拿、被叼、被踩或被坐着的物品——纸箱、包裹、篮子、玩具、食物、乐器、器材、道具、家具一律不出现；没有其他人物、没有其他动物、没有场景陈设、没有文字水印。',
+        ].join('\n')
+        : [
+          '[Overall] A 16:9 landscape professional character sheet: dark plain background, ' + style + ', the same character looking identical in every panel.',
+          '[Identity anchor] There is no reference photo: the appearance description below is the only source of truth - every panel follows it exactly; no wardrobe change, no body change, no palette drift.',
+          '[Main figure] A large full-body standing figure in the centre (front, natural stance): ' + lookLine + '. Empty-handed stance - limbs resting naturally, mouth closed or tongue relaxed; nothing held, carried, bitten, stood on or sat on.',
+          '[Turnaround, required] Front / side / back full-body panels below the main figure - same character, only the angle changes (this carries video consistency later).',
+          '[Right column, stacked, each block drawn only once in the whole sheet] (1) one face close-up with a short feature note (12 characters max); (2) six small head icons for expressions in two rows of three, each labelled with a two-character expression name.',
+          '[Text rules] Very little text: two or three character labels only, thin dark strokes, clearly drawn and large; no headline, no paragraph, no long sentence.',
+          '[Whitelist] Only this character and its fixed accessories (collar, tag), plus the panels above; nothing is being held, carried, bitten, stood on or sat on - no boxes, parcels, baskets, toys, food, instruments, equipment, props or furniture; no other people, no other animals, no set dressing, no watermark.',
+        ].join('\n');
+    }
+    /** 资产设定图节点的规格：命名走技能约定（角色-<名> 设定图）、画幅/清晰度按版式（设定集排版需要细节）。
+     *  标签前缀恒用中文「角色-/场景-/道具-」——这是**数据契约**而非界面文案：categoryFromName 与
+     *  assetNameFor 都靠它把生成出来的资产自动归到正确品类（英文界面同样如此）。 */
+    function assetSheetNodeSpec(kind, name, bible, zh) {
+      const k = String(kind || '');
+      const label = entityLabelOf(k) + '-' + String(name || '').trim() + ' 设定图';
+      const ent = matchBibleEntity(name, bible);
+      const desc = (ent && ent.desc) || '';
+      return {
+        kind: k,
+        label,
+        prompt: buildAssetSheetPrompt(k, name, desc, bible, zh),
+        size: '2K',
+        ratio: '16:9', // 设定集排版（角色三视图 + 侧栏）横版信息量最大
+      };
+    }
 // <<<MENTION_PURE_END>>>
 
       /** 解析提示词里的 @引用：返回命中实体 + 其名下的参考图资产与**声音参考资产**（按实体出现顺序、各实体内按生成时间）。
@@ -1858,6 +2533,9 @@ window.__ModuleLoader__.load({
     const assetUrlCache = new Map();
     const assetNameCache = new Map(); // assetId -> name（连线绑定的同步名称查询）
     function fileUrlFor(rel) { return '/' + NS + '/api/file?rel=' + encodeURIComponent(rel); }
+    /** 磁盘落盘扩展名（IC-B3 统一后唯一保留的 mime→ext 映射）：mime 子类型直取，
+     *  非法子类型回退 .bin。与 extForDownload 的区别：落盘时 mime 已由生成链路给出
+     *  （mp4-first 录制 / png 编码），不存在"从文件名猜"的场景——这里没有任何名字兜底。 */
     function extFromMime(mime) {
       const sub = String(mime || '').split(';')[0].split('/')[1] || 'bin';
       return /^[a-z0-9]{1,8}$/i.test(sub) ? sub : 'bin';
@@ -1905,7 +2583,8 @@ window.__ModuleLoader__.load({
     }
     async function saveAssetRecord(projectId, kind, blob, meta) {
       const id = uid('a');
-      const mime = blob.type || (kind === 'image' ? 'image/png' : 'video/webm');
+      const mime = blob.type && blob.type !== 'application/octet-stream' ? blob.type
+        : (kind === 'image' ? 'image/png' : 'video/mp4');
       const rec = {
         id, projectId, kind,
         mime,
@@ -1920,36 +2599,29 @@ window.__ModuleLoader__.load({
       if (meta && Array.isArray(meta.entities) && meta.entities.length) rec.entities = meta.entities;
       if (meta && meta.nodeLabel) rec.nodeLabel = meta.nodeLabel;
       if (meta && meta.effectivePrompt) rec.effectivePrompt = meta.effectivePrompt;
-      if (S.dataRoot) {
-        if (S.store === 'sqlite') {
-          // 0.18 主路径：上传 CAS 对象（内容寻址去重）→ 服务端建资产行（任意浏览器/远程立即可见）
-          const r = await fetch('/' + NS + '/api/object', { method: 'POST', body: blob });
-          if (!r.ok) throw new Error('资产上传失败: ' + (await r.text()));
-          const j = await r.json();
-          rec.sha = j.sha;
-          rec.size = j.size || blob.size;
-          rec.stored = 'cas';
-          const proj = S.projects.find((p) => p.id === projectId);
-          const saved = await hostRpc('assetCreate', { asset: assetIndexRecord(rec), projectName: (proj && proj.name) || '' });
-          const out = (saved && saved.asset) || rec;
-          assetMem.set(out.id, out);
-          assetNameCache.set(out.id, out.name);
-          return out;
-        }
-        // JSON 降级（Host 无 node:sqlite）：旧落盘路径 + 索引镜像
-        const rel = `projects/${projectId}/${kind}/${assetFileBase(rec)}.${extFromMime(mime)}`;
-        const r = await fetch('/' + NS + '/api/asset?rel=' + encodeURIComponent(rel), { method: 'POST', body: blob });
-        if (!r.ok) throw new Error('资产落盘失败: ' + (await r.text()));
-        rec.rel = rel;
-        rec.size = blob.size;
-        rec.stored = 'disk';
-      } else {
-        rec.blob = blob;
-        rec.stored = 'idb';
+      // 【硬规则】资产文件一律落数据目录的项目文件夹（projects/<项目>/<类型>/<文件>），元数据进
+      // canvas.db；IndexedDB 已废弃——未配置数据目录时明确报错，绝不静默塞进浏览器。
+      if (!S.dataRoot) {
+        throw new Error('未设置数据根目录：资产无法持久化（浏览器 IndexedDB 存储已废弃）。请在 画布 → 设置 → 数据根目录 里配置后重新生成。');
+      }
+      const rel = `projects/${projectId}/${kind}/${assetFileBase(rec)}.${extFromMime(mime)}`;
+      const r = await fetch('/' + NS + '/api/asset?rel=' + encodeURIComponent(rel), { method: 'POST', body: blob });
+      if (!r.ok) throw new Error('资产落盘失败: ' + (await r.text()));
+      rec.rel = rel;
+      rec.size = blob.size;
+      rec.stored = 'disk';
+      const proj = S.projects.find((p) => p.id === projectId);
+      if (S.store === 'sqlite') {
+        // 主路径：文件落项目文件夹 + 元数据进 canvas.db（任意浏览器/远程立即可见）
+        const saved = await hostRpc('assetCreate', { asset: assetIndexRecord(rec), projectName: (proj && proj.name) || '' });
+        const out = (saved && saved.asset) || rec;
+        assetMem.set(out.id, out);
+        assetNameCache.set(out.id, out.name);
+        return out;
       }
-      await idbPut(rec);
+      await idbPut(rec); // JSON 降级模式（宿主缺 node:sqlite）：本机元数据缓存
       assetNameCache.set(rec.id, rec.name);
-      if (S.dataRoot) mirrorAssetIndex(rec); // JSON 降级模式：元数据镜像进 assets.json
+      mirrorAssetIndex(rec); // 元数据镜像进 assets.json
       return rec;
     }
     /** 资产元数据索引记录（去 blob；文本资产保留 text 以便导入端免读文件即可预览）。 */
@@ -1975,8 +2647,8 @@ window.__ModuleLoader__.load({
         projectId: rec.projectId, projectName: (proj && proj.name) || rec.projectId, asset: assetIndexRecord(rec),
       }).catch(() => { /* 索引失败不影响资产本身 */ });
     }
-    /** 数据根目录就绪后：把浏览器 IndexedDB 里的存量 blob 资产搬进服务端（CAS + 资产行），搬完即从本地退役。
-     *  0.17 旧版本的"落盘到项目文件夹 + assets.json 索引"由 Host 侧 v1→v2 迁移负责，这里只处理从未落盘的遗留。 */
+    /** 数据根目录就绪后：把浏览器 IndexedDB 里的存量 blob 资产搬到数据目录的项目文件夹
+     *  （projects/<项目>/<类型>/<文件>），搬完从 IndexedDB 移除——**IndexedDB 只减不增，最终清零**。 */
     async function autoMigrateAssetsToRoot() {
       if (!S.dataRoot) return;
       try {
@@ -1986,16 +2658,15 @@ window.__ModuleLoader__.load({
         let done = 0;
         for (const rec of pending) {
           try {
-            const r = await fetch('/' + NS + '/api/object', { method: 'POST', body: rec.blob });
+            const mime = rec.blob.type || rec.mime || (rec.kind === 'image' ? 'image/png' : 'video/mp4');
+            const rel = `projects/${rec.projectId}/${rec.kind}/${assetFileBase(rec)}.${extFromMime(mime)}`;
+            const r = await fetch('/' + NS + '/api/asset?rel=' + encodeURIComponent(rel), { method: 'POST', body: rec.blob });
             if (!r.ok) continue;
-            const j = await r.json();
-            const meta = { ...rec, sha: j.sha, size: rec.size || rec.blob.size };
+            const meta = { ...rec, rel, size: rec.size || rec.blob.size };
             delete meta.blob;
-            meta.stored = 'cas';
+            meta.stored = 'disk';
             const proj = S.projects.find((p) => p.id === rec.projectId);
-            const saved = await hostRpc('assetCreate', { asset: assetIndexRecord(meta), projectName: (proj && proj.name) || '' });
-            const out = (saved && saved.asset) || meta;
-            assetMem.set(out.id, out);
+            await hostRpc('assetCreate', { asset: assetIndexRecord(meta), projectName: (proj && proj.name) || '' });
             try { await idbDelete(rec.id); } catch { /* 本地清理失败不阻塞迁移 */ }
             done++;
           } catch { /* 单个失败继续下一个 */ }
@@ -2084,7 +2755,8 @@ window.__ModuleLoader__.load({
       const g = cv.getContext('2d');
       const rnd = mulberry32(hashStr(prompt || 'demo'));
       const hues = [0, 1, 2, 3].map(() => Math.floor(rnd() * 360));
-      const mimes = ['video/webm;codecs=vp9', 'video/webm;codecs=vp8', 'video/webm', 'video/mp4'];
+      // mp4 优先（现代 Chrome/Edge 原生支持 H.264 录制）：webm 只是兜底，保证产物统一为 mp4
+      const mimes = ['video/mp4;codecs=avc1.42E01E', 'video/mp4', 'video/webm;codecs=vp9', 'video/webm;codecs=vp8', 'video/webm'];
       const mime = (typeof MediaRecorder !== 'undefined') && mimes.find((m) => MediaRecorder.isTypeSupported(m));
       if (!mime) throw new Error('当前环境不支持 MediaRecorder，无法使用演示视频生成');
       const stream = cv.captureStream(30);
@@ -2272,21 +2944,49 @@ window.__ModuleLoader__.load({
       } catch { /* 解析失败返回 null */ }
       return null;
     }
+    /** 魔数嗅探真实编码（IC-04 抽出的纯函数）：只认 PNG/JPEG/WebP 三类平台可收的字节签名。
+     *  返回 { mime, ext, kind }；不匹配（改后缀的 AVIF/HEIC 等）返回 null，调用方给出可执行报错。 */
+    function sniffImageEncoding(u8) {
+      const isPng = u8 && u8[0] === 0x89 && u8[1] === 0x50 && u8[2] === 0x4e && u8[3] === 0x47;
+      const isJpg = u8 && u8[0] === 0xff && u8[1] === 0xd8 && u8[2] === 0xff;
+      const isWebp = u8 && u8[0] === 0x52 && u8[1] === 0x49 && u8[2] === 0x46 && u8[3] === 0x46
+        && u8[8] === 0x57 && u8[9] === 0x45 && u8[10] === 0x42 && u8[11] === 0x50;
+      if (isPng) return { mime: 'image/png', ext: 'png', kind: 'png' };
+      if (isJpg) return { mime: 'image/jpeg', ext: 'jpg', kind: 'jpeg' };
+      if (isWebp) return { mime: 'image/webp', ext: 'webp', kind: 'webp' };
+      return null;
+    }
+    /** 参考图登记（IC-04 抽出的纯流程）：先用解码尺寸登记，被平台以 width/height
+     *  口径拒绝（EXIF 旋转图：浏览器解码会交换宽高，平台读原始文件）时用文件原始尺寸重试一次。
+     *  api = async (method, path, body) => 响应；两次都失败时抛出带两次原因的错误。 */
+    async function registerReferenceAsset(api, regPayload, meta) {
+      try {
+        return await api('POST', '/image/v1/assets', regPayload(meta.width, meta.height));
+      } catch (e) {
+        const msg = String((e && e.message) || e);
+        const alt = meta.rawWidth && meta.rawHeight && (meta.rawWidth !== meta.width || meta.rawHeight !== meta.height);
+        if (!/width\/?height/i.test(msg) || !alt) throw e;
+        try {
+          const reg = await api('POST', '/image/v1/assets', regPayload(meta.rawWidth, meta.rawHeight));
+          console.info('[infinite-canvas] 参考图登记改用文件原始尺寸成功：' + meta.rawWidth + '×' + meta.rawHeight);
+          return reg;
+        } catch (e2) {
+          throw new Error(msg + '；改用文件原始尺寸 ' + meta.rawWidth + '×' + meta.rawHeight + ' 重试仍失败：' + ((e2 && e2.message) || e2));
+        }
+      }
+    }
     /** 参考图上传前置：魔数嗅探真实编码（平台仅收 JPG/PNG/WebP，且校验声明 MIME 与实际字节一致——
      *  改后缀的 AVIF/HEIC 会在登记时报 "Params [Width/Height] not available"）+ 测像素尺寸
      *  （同时给出解码尺寸与文件原始尺寸，登记不一致时用原始尺寸重试）。 */
     async function imageBlobMeta(input) {
       const blob = input.blob || input;
       const head = new Uint8Array(await blob.slice(0, 16).arrayBuffer());
-      const isPng = head[0] === 0x89 && head[1] === 0x50 && head[2] === 0x4e && head[3] === 0x47;
-      const isJpg = head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff;
-      const isWebp = head[0] === 0x52 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x46
-        && head[8] === 0x57 && head[9] === 0x45 && head[10] === 0x42 && head[11] === 0x50;
-      if (!isPng && !isJpg && !isWebp) {
+      const sniffed = sniffImageEncoding(head);
+      if (!sniffed) {
         throw new Error('参考图编码不受支持：平台仅接受 JPG/PNG/WebP 原生编码（当前文件的实际字节不是这三类，常见于改后缀的 AVIF/HEIC）——请转成 JPG/PNG 后重新挂参考图');
       }
-      const mime = isPng ? 'image/png' : isJpg ? 'image/jpeg' : 'image/webp';
-      const ext = isPng ? 'png' : isJpg ? 'jpg' : 'webp';
+      const mime = sniffed.mime;
+      const ext = sniffed.ext;
       let raw = null;
       try { raw = rawImageDims(new Uint8Array(await blob.slice(0, 262144).arrayBuffer())); } catch { /* 忽略 */ }
       let width = 0;
@@ -2298,7 +2998,7 @@ window.__ModuleLoader__.load({
         try { bmp.close && bmp.close(); } catch { /* 忽略 */ }
       } catch { /* 解码失败时退回文件头尺寸 */ }
       if (!width || !height) { if (raw) { width = raw.w; height = raw.h; } }
-      if (!width || !height) throw new Error('参考图尺寸测量失败');
+      if (!width || !height) throw new Error('参考图尺寸测量失败（' + mime + '，文件头与浏览器解码都没读出宽高——文件可能已损坏）');
       return { blob, mime, ext, width, height, rawWidth: raw ? raw.w : width, rawHeight: raw ? raw.h : height };
     }
     async function compshareImageTask(prompt, refs, s, opts) {
@@ -2308,6 +3008,7 @@ window.__ModuleLoader__.load({
       if (!base) throw new Error('未配置图片 API 地址（优云智算：https://cp.compshare.cn）');
       const headers = { 'Content-Type': 'application/json', Accept: 'application/json', Authorization: 'Bearer ' + String(s.apiKey || '').trim() };
       const extra = parseExtraParams(s.extra); // 透传：optimize_prompt / use_context_ir 等任务级字段
+      if (o.warn && Array.isArray(refs) && refs.length > 10) o.warn('参考图 ' + refs.length + ' 张超过优云上限 10 张，本次只使用前 10 张');
       // 报错附带实际发出的参数：登记/提交被拒时一眼看到缺什么、值是多少（不再靠猜）
       const bodySummary = (b) => {
         if (!b || typeof b !== 'object') return '';
@@ -2352,22 +3053,15 @@ window.__ModuleLoader__.load({
         });
         if (!put.ok) throw new Error('参考图上传失败 HTTP ' + put.status + '：' + put.text.slice(0, 200));
         // 登记：宽高必须与平台解析出的文件尺寸一致。浏览器解码尺寸与文件原始尺寸在
-        // EXIF 旋转图上不同 → 先用解码尺寸，被拒（Params [Width/Height] not available）时用原始尺寸重试一次
+        // EXIF 旋转图上不同 → 先用解码尺寸，被拒（Params [Width/Height] not available）时用原始尺寸重试一次。
+        // 重试发生过 = 这张图带 EXIF 旋转，节点上给一条可见提示（用户下次换图心里有数）
         const regPayload = (w, h) => ({ object_key: up.object_key, file_name: fileName, content_type: meta.mime, file_size: meta.blob.size, width: w, height: h });
-        let reg = null;
-        try {
-          reg = await api('POST', '/image/v1/assets', regPayload(meta.width, meta.height));
-        } catch (e) {
-          const msg = String((e && e.message) || e);
-          const alt = meta.rawWidth && meta.rawHeight && (meta.rawWidth !== meta.width || meta.rawHeight !== meta.height);
-          if (!/width\/?height/i.test(msg) || !alt) throw e;
-          try {
-            reg = await api('POST', '/image/v1/assets', regPayload(meta.rawWidth, meta.rawHeight));
-            console.info('[infinite-canvas] 参考图登记改用文件原始尺寸成功：' + meta.rawWidth + '×' + meta.rawHeight);
-          } catch (e2) {
-            throw new Error(msg + '；改用文件原始尺寸 ' + meta.rawWidth + '×' + meta.rawHeight + ' 重试仍失败：' + ((e2 && e2.message) || e2));
-          }
-        }
+        let retried = false;
+        const reg = await registerReferenceAsset(api, (w, h) => {
+          if (w === meta.rawWidth && h === meta.rawHeight && (meta.rawWidth !== meta.width || meta.rawHeight !== meta.height)) retried = true;
+          return regPayload(w, h);
+        }, meta);
+        if (retried && o.warn) o.warn('参考图带 EXIF 旋转：平台按文件原始尺寸 ' + meta.rawWidth + '×' + meta.rawHeight + ' 登记成功（浏览器解码是 ' + meta.width + '×' + meta.height + '）');
         const aid = reg && reg.reference && reg.reference.asset_id;
         if (!aid) throw new Error('参考图登记失败：响应中没有 reference.asset_id');
         if (ref.assetId) compAssetIdCache.set(ref.assetId, aid);
@@ -2551,6 +3245,8 @@ window.__ModuleLoader__.load({
       const body = {
         model: s.model,
         content,
+        // 声音参考与首次提交保持同一口径：降级换格式不能静默丢掉音色对齐（否则无任何告警）
+        ...((o.audioRefs || []).length ? { audios: await Promise.all((o.audioRefs || []).slice(0, 3).map((b) => blobToDataUrl(b))) } : {}),
         metadata: {
           duration: Math.round(Number(o.duration)) || 5,
           ratio: o.ratio || '16:9',
@@ -3149,6 +3845,18 @@ window.__ModuleLoader__.load({
         return await downloadVideo(url, {});
       },
     };
+    /** 各视频厂商的参考素材上限（与各 runner 内部的截断口径一致）：
+     *  超出上限会被截断——必须显式告警（o.warn → 节点 genWarn），绝不静默丢素材。 */
+    const VIDEO_REF_CAPS = {
+      wan: { img: 10 },
+      minimaxv2: { img: 9, audio: 3 },
+      openai: { img: 8 },
+      seedance: { img: 8 },
+      // img:0 = 该厂商的协议**没有任何实体参考图入口**（已核对各自 runner：只收首帧/提示词）——
+      // 曾误标 img:1：恰 1 张时静默弃用不告警，≥2 张时告警"用前 1 张"实际 0 张，全部误导
+      kling: { img: 0 }, vidu: { img: 0 }, runway: { img: 0 }, veo: { img: 0 },
+      luma: { img: 0 }, pixverse: { img: 0 }, minimax: { img: 0 }, stability: { img: 0 },
+    };
     async function apiVideo(prompt, frameBlob, s, opts) {
       const o = opts || {};
       // 节点级扩展参数（手动参数框）与供应商扩展参数合并（节点优先），各 runner 的 mergeExtra 自动生效
@@ -3165,10 +3873,30 @@ window.__ModuleLoader__.load({
       if (o.frameMode === 'hard' && frameBlob) o.hardFrame = true;
       // 厂商预设层：显式选择了厂商格式（或旧配置自动识别）→ 走该厂商的官方协议适配器
       const vendor = detectVideoVendor(s);
+      let vendorDowngraded = false; // IC-03：识别到厂商但无适配器 → 降级走 OpenAI 兼容通用链（节点上可见）
+      // 参考素材上限检查：超出即告警（截断发生在各 runner 内，这里先把事实说清楚）。
+      // 未知厂商兜底 8 = IC-03 降级后的 OpenAI 兼容链实际发送上限。
+      if (o.warn) {
+        const caps = VIDEO_REF_CAPS[vendor] || { img: 8 };
+        const refCount = o.hardFrame ? 0 : (Array.isArray(o.refs) ? o.refs.length : 0);
+        if (refCount > (caps.img || 0)) {
+          o.warn(caps.img
+            ? ('参考图 ' + refCount + ' 张超过该厂商上限 ' + caps.img + ' 张，本次只使用前 ' + caps.img + ' 张')
+            : ('该厂商不支持实体参考图，本次将忽略 ' + refCount + ' 张参考图（仅保留首帧与提示词；角色/场景一致性请改用支持参考图的厂商）'));
+        }
+        const audCount = Array.isArray(o.audioRefs) ? o.audioRefs.length : 0;
+        if (audCount > (caps.audio || 0)) o.warn('参考音频 ' + audCount + ' 条超过该厂商上限 ' + (caps.audio || 0) + ' 条，本次只使用前 ' + (caps.audio || 0) + ' 条');
+      }
       if (vendor !== 'openai' && vendor !== 'seedance') {
         const run = VIDEO_VENDOR_RUNNERS[vendor];
-        if (!run) throw new Error('暂未适配的视频厂商格式：' + vendor);
-        return await run(prompt, frameBlob, s, o);
+        if (!run) {
+          // IC-03：识别到的厂商没有官方适配器 → 不再硬失败（历史：`暂未适配的视频厂商格式：X` 直接炸），
+          // 降级走下方 OpenAI 兼容通用链，并把降级事实放节点上（绝不静默换协议）。
+          if (o.warn) o.warn('未识别到「' + vendor + '」的官方适配器，本次按 OpenAI 兼容格式发送（/v1/video/generations，失败自动降级 Seedance content[] / Sora /videos）——若该厂商协议不同，请在供应商设置里显式选择厂商');
+          vendorDowngraded = true; // 源码级契约锚点（test-vendor-detect 断言）：降级必须留痕
+        } else {
+          return await run(prompt, frameBlob, s, o);
+        }
       }
       // OpenAI 风格视频接口（JUAI 等：/v1/video/generations）优先识别——
       // 即使误把协议设成 seedance 也不走火山官方协议（两者状态/结果字段不同）
@@ -3396,36 +4124,250 @@ window.__ModuleLoader__.load({
 
     /** 从视频 Blob 提取最后一帧为 PNG（通用：任何 API 生成的视频都能取尾帧）。 */
     async function extractLastFrame(videoBlob) {
+      const r = await extractTailFrames(videoBlob, { count: 2, span: 0.2 });
+      if (!r || !r.last) throw new Error('尾帧提取失败');
+      return r.last;
+    }
+    /**
+     * 尾帧候选抽取（续帧接力的关键）：**不取最后一帧**。
+     * 最后一帧常落在动作顶点、运动模糊、遮挡、模型收敛抖动上——用它当下一段首帧，接缝必然跳。
+     * 做法：取末尾若干帧做候选，给每帧打「动作进行中 / 清晰 / 无遮挡 / 不抖」分，取最高分那帧。
+     * @returns { blobs: Blob[], picks: Array<{ t, blob, score, metrics }>, best: { blob, t, score } | null }
+     */
+    async function extractTailFrames(videoBlob, opts) {
+      const o = opts || {};
+      const count = Math.max(2, Math.min(24, Number(o.count) || 9)); // 候选帧数（末段采样）
+      const span = Math.max(0.1, Math.min(2, Number(o.span) || 0.8)); // 采样窗口：结尾前 0.8s
       const url = URL.createObjectURL(videoBlob);
+      let v = null;
       try {
-        const v = document.createElement('video');
+        v = document.createElement('video');
         v.src = url; v.muted = true; v.preload = 'auto';
         await new Promise((res, rej) => {
           v.onloadedmetadata = () => res();
           v.onerror = () => rej(new Error('视频解码失败'));
-          setTimeout(res, 10000);
+          setTimeout(res, 12000);
+        });
+        const dur = Number(v.duration);
+        if (!isFinite(dur) || dur <= 0) throw new Error('视频时长不可用');
+        const canvas = document.createElement('canvas');
+        canvas.width = v.videoWidth || 1280;
+        canvas.height = v.videoHeight || 720;
+        const ctx = canvas.getContext('2d', { willReadFrequently: true });
+        // 采样时刻：结尾前 span 秒内均匀取 count 帧，最后一帧贴近片尾
+        const t0 = Math.max(0, dur - span);
+        const times = [];
+        for (let i = 0; i < count; i++) times.push(Math.min(dur - 0.02, t0 + (span * i) / Math.max(1, count - 1)));
+        times[times.length - 1] = Math.max(0, dur - 0.04);
+        const grabs = [];
+        for (const t of times) {
+          await new Promise((res) => {
+            let done = false;
+            const fin = () => { if (!done) { done = true; res(); } };
+            v.onseeked = fin;
+            try { v.currentTime = t; } catch { fin(); }
+            setTimeout(fin, 4000);
+          });
+          await new Promise((res) => {
+            if (v.readyState >= 2) return res();
+            v.oncanplay = res;
+            setTimeout(res, 2000);
+          });
+          try {
+            ctx.drawImage(v, 0, 0, canvas.width, canvas.height);
+          } catch { continue; }
+          // 缩略灰度（64×36）：算清晰度/运动/结构用，够用且极快
+          const tw = 64, th = Math.max(1, Math.round((64 * canvas.height) / Math.max(1, canvas.width)));
+          const small = document.createElement('canvas');
+          small.width = tw; small.height = th;
+          const sctx = small.getContext('2d', { willReadFrequently: true });
+          sctx.drawImage(canvas, 0, 0, tw, th);
+          const img = sctx.getImageData(0, 0, tw, th);
+          const gray = new Uint8ClampedArray(tw * th);
+          let sum = 0;
+          for (let i = 0; i < gray.length; i++) {
+            const r = img.data[i * 4], g = img.data[i * 4 + 1], b = img.data[i * 4 + 2];
+            const y = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+            gray[i] = y; sum += y;
+          }
+          // 清晰度：拉普拉斯响应均值（越高越锐利）
+          let lap = 0, lapN = 0;
+          for (let y2 = 1; y2 < th - 1; y2++) {
+            for (let x2 = 1; x2 < tw - 1; x2++) {
+              const i = y2 * tw + x2;
+              const l = 4 * gray[i] - gray[i - 1] - gray[i + 1] - gray[i - tw] - gray[i + tw];
+              lap += Math.abs(l); lapN++;
+            }
+          }
+          const sharpRaw = lapN ? lap / lapN : 0;
+          // 前景占比：与画面均值的偏离度（粗估有人/物主体的程度）
+          let dev = 0;
+          const mean = sum / gray.length;
+          for (let i = 0; i < gray.length; i++) dev += Math.abs(gray[i] - mean);
+          const coverageRaw = gray.length ? dev / gray.length : 0;
+          grabs.push({ t, gray, sharpRaw, coverageRaw, full: null });
+          // 全分辨率 PNG 只对最终入选帧生成（省内存）
+        }
+        if (!grabs.length) throw new Error('尾帧采样失败');
+        // 帧间差（运动幅度）+ 收敛抖动（相邻帧差突然变小 = 定格；突然变大 = 抖）
+        const diffs = [];
+        for (let i = 1; i < grabs.length; i++) {
+          const a = grabs[i - 1].gray, b = grabs[i].gray;
+          let s2 = 0;
+          for (let k = 0; k < a.length; k++) s2 += Math.abs(a[k] - b[k]);
+          diffs.push(a.length ? s2 / a.length / 255 : 0); // 0-1
+        }
+        const maxSharp = Math.max(...grabs.map((g) => g.sharpRaw), 1e-6);
+        const picks = grabs.map((g, i) => {
+          const prevDiff = i > 0 ? diffs[i - 1] : (diffs[0] || 0);
+          const nextDiff = i < diffs.length ? diffs[i] : prevDiff;
+          const motion = Math.max(0, Math.min(1, (prevDiff * 6))); // 归一：0.17/帧 ≈ 满运动
+          const sharp = Math.max(0, Math.min(1, g.sharpRaw / maxSharp));
+          const coverage = Math.max(0, Math.min(1, g.coverageRaw / 60));
+          // 收敛抖动：自身运动相对邻域突变（模型末端常见突变）
+          const jitter = Math.min(1, Math.abs(prevDiff - nextDiff) * 8);
+          // 动作完成度：越接近片尾越可能"演完了"（末 3 帧按时间梯度推断）
+          const complete = Math.max(0, Math.min(1, 0.35 + (i / Math.max(1, grabs.length - 1)) * 0.65));
+          const score = tailFrameScore({ motion, sharp, coverage, jitter, complete });
+          return { t: g.t, score, metrics: { motion, sharp, coverage, jitter, complete }, gray: g.gray, idx: i };
         });
-        if (!isFinite(v.duration) || v.duration <= 0) throw new Error('视频时长不可用');
+        const best = picks.slice().sort((a, b) => b.score - a.score)[0];
+        // 为入选帧 + 末帧各生成一张全分辨率 PNG（末帧始终产出，保证 last 端口行为不变）
+        const wanted = new Set([best.idx, grabs.length - 1]);
+        const blobs = new Map();
+        for (const gi of [...wanted].sort((a, b) => a - b)) {
+          const g = grabs[gi];
+          await new Promise((res) => {
+            let done = false;
+            const fin = () => { if (!done) { done = true; res(); } };
+            v.onseeked = fin;
+            try { v.currentTime = g.t; } catch { fin(); }
+            setTimeout(fin, 4000);
+          });
+          await new Promise((res) => { if (v.readyState >= 2) return res(); v.oncanplay = res; setTimeout(res, 2000); });
+          try { ctx.drawImage(v, 0, 0, canvas.width, canvas.height); } catch { continue; }
+          const blob = await new Promise((res) => canvas.toBlob(res, 'image/png'));
+          if (blob) blobs.set(gi, blob);
+        }
+        const lastBlob = blobs.get(grabs.length - 1) || blobs.get(best.idx) || null;
+        const bestBlob = blobs.get(best.idx) || lastBlob;
+        return {
+          last: lastBlob,
+          best: bestBlob,
+          bestT: best.t,
+          bestScore: best.score,
+          picks: picks.map((p) => ({ t: p.t, score: p.score, metrics: p.metrics })),
+        };
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    }
+    /** 缩略灰度（接缝校验用）：任意图 Blob → 32×32 RGBA。 */
+    async function grayThumb(blob, size) {
+      const n = Math.max(8, Math.min(128, Number(size) || 32));
+      const url = URL.createObjectURL(blob);
+      try {
+        const img = new Image();
+        img.src = url;
+        await new Promise((res, rej) => {
+          img.onload = () => res();
+          img.onerror = () => rej(new Error('图片解码失败'));
+          setTimeout(res, 8000);
+        });
+        const cv = document.createElement('canvas');
+        cv.width = n; cv.height = n;
+        const ctx = cv.getContext('2d', { willReadFrequently: true });
+        // 保持比例居中裁切（letterbox 会稀释位移信号，直接拉伸更敏感）
+        ctx.drawImage(img, 0, 0, n, n);
+        const im = ctx.getImageData(0, 0, n, n);
+        const gray = new Uint8ClampedArray(n * n);
+        for (let i = 0; i < gray.length; i++) {
+          gray[i] = Math.round(0.299 * im.data[i * 4] + 0.587 * im.data[i * 4 + 1] + 0.114 * im.data[i * 4 + 2]);
+        }
+        return { data: gray, w: n, h: n };
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    }
+    /** 首帧抽取（末段续帧时校验用）：视频开头第一帧 PNG。 */
+    async function extractFirstFrame(videoBlob) {
+      const url = URL.createObjectURL(videoBlob);
+      try {
+        const v = document.createElement('video');
+        v.src = url; v.muted = true; v.preload = 'auto';
         await new Promise((res) => {
-          v.onseeked = res;
-          try { v.currentTime = Math.max(0, v.duration - 0.05); } catch { res(); }
-          setTimeout(res, 5000);
+          let done = false;
+          const fin = () => { if (!done) { done = true; res(); } };
+          v.onloadedmetadata = fin;
+          v.onerror = fin;
+          setTimeout(fin, 10000);
         });
         await new Promise((res) => {
-          if (v.readyState >= 2) return res();
-          v.oncanplay = res;
-          setTimeout(res, 3000);
+          let done = false;
+          const fin = () => { if (!done) { done = true; res(); } };
+          v.onseeked = fin;
+          try { v.currentTime = 0.02; } catch { fin(); }
+          setTimeout(fin, 4000);
         });
+        await new Promise((res) => { if (v.readyState >= 2) return res(); v.oncanplay = res; setTimeout(res, 2000); });
         const cv = document.createElement('canvas');
-        cv.width = v.videoWidth; cv.height = v.videoHeight;
+        cv.width = v.videoWidth || 1280; cv.height = v.videoHeight || 720;
         cv.getContext('2d').drawImage(v, 0, 0);
-        const blob = await new Promise((res) => cv.toBlob(res, 'image/png'));
-        if (!blob) throw new Error('尾帧提取失败');
-        return blob;
+        return await new Promise((res) => cv.toBlob(res, 'image/png'));
       } finally {
         URL.revokeObjectURL(url);
       }
     }
+    /** 续帧链：找到「上一个视频生成节点」。按可靠性依次尝试：
+     *  ① frame 口连线的来源视频（用户显式指定；也支持从视频资产节点回溯）；
+     *  ② 同一上游分镜表连出的其它视频节点里、已生成且位置更靠上的那一个（一个分镜表铺多个视频段）；
+     *  ③ **沿分镜表的 prev 承接链向上游找**：上游分镜表所连的视频节点。
+     *     标准短剧布局是「一场一个分镜表 + 一场一个视频」，此时每个视频节点的上游分镜表都不同，
+     *     ①②永远找不到——这是主用法，必须支持。逐级向上并防环。 */
+    function autoPrevVideoNode(n) {
+      const frameEdge = S.graph.edges.find((x) => x.toNode === n.id && x.toPort === 'frame');
+      if (frameEdge) {
+        const src = S.graph.nodes[frameEdge.fromNode];
+        if (src && src.type === 'video-gen' && src.data.assetId) return src;
+        if (src && src.type === 'video-asset') {
+          const up = S.graph.edges.find((e) => e.toNode === src.id && e.toPort === 'in');
+          const pv = up && S.graph.nodes[up.fromNode];
+          if (pv && pv.type === 'video-gen' && pv.data.assetId) return pv;
+        }
+      }
+      const promptEdge = S.graph.edges.find((x) => x.toNode === n.id && x.toPort === 'prompt');
+      if (!promptEdge) return null;
+      const sbId = promptEdge.fromNode;
+      const sb = S.graph.nodes[sbId];
+      // ② 同一分镜表内的兄弟视频段
+      const sibs = S.graph.edges
+        .filter((x) => x.fromNode === sbId && x.toPort === 'prompt')
+        .map((x) => S.graph.nodes[x.toNode])
+        .filter((v) => v && v.id !== n.id && v.type === 'video-gen' && v.data.assetId && (v.y < n.y || (v.y === n.y && v.x < n.x)));
+      if (sibs.length) {
+        sibs.sort((a, b) => (b.y - a.y) || (b.x - a.x)); // 最近的一段（同列/同排里最靠近的上一段）
+        return sibs[0];
+      }
+      // ③ 沿 prev 链向上游分镜表找它连出的视频段（跨分镜表续帧 = 标准用法）
+      let curSb = sb;
+      const seen = new Set([sbId]);
+      for (let hop = 0; hop < 32 && curSb; hop++) {
+        const prevEdge = S.graph.edges.find((x) => x.toNode === curSb.id && x.toPort === 'prev');
+        const upSb = prevEdge && S.graph.nodes[prevEdge.fromNode];
+        if (!upSb || upSb.type !== 'storyboard' || seen.has(upSb.id)) break;
+        seen.add(upSb.id);
+        const vids = S.graph.edges
+          .filter((x) => x.fromNode === upSb.id && x.toPort === 'prompt')
+          .map((x) => S.graph.nodes[x.toNode])
+          .filter((v) => v && v.type === 'video-gen' && v.data.assetId);
+        if (vids.length) {
+          vids.sort((a, b) => (b.y - a.y) || (b.x - a.x));
+          return vids[0];
+        }
+        curSb = upSb; // 上一场还没生成则继续向上找更早的已成片段
+      }
+      return null;
+    }
     /** 链式下一镜：以本镜尾帧为首帧，克隆一个视频生成节点并自动连线。 */
     function chainNext(n) {
       const c = { x: n.x + 320, y: n.y + 60 };
@@ -3438,8 +4380,12 @@ window.__ModuleLoader__.load({
           nd2.data.resolution = n.data.resolution || '720P';
           nd2.data.ratio = n.data.ratio || '16:9';
           nd2.data.videoModel = nodeVideoModelRef(n);
+          // 与自动续帧保持同一默认（auto = 尾帧降级为首张参考图，保留实体参考图，衔接为软约束）。
+          // 硬首帧会放弃角色/场景参考图，不该作为默认——用户需要绝对承接时自己在下拉里选。
+          nd2.data.frameMode = 'auto';
         }
-        s.graph.edges.push({ id: uid('e'), fromNode: n.id, fromPort: 'last', toNode: nn.id, toPort: 'frame' });
+        // 尾帧接力：优先「最佳选帧」（动作进行中/清晰），退到真·尾帧
+        s.graph.edges.push({ id: uid('e'), fromNode: n.id, fromPort: (n.data.lastPickAssetId ? 'tailpick' : 'last'), toNode: nn.id, toPort: 'frame' });
       });
       pushHistory();
       toast(T('lastFrame') + ' → ' + T('portFrame') + ' ✓');
@@ -3493,18 +4439,35 @@ window.__ModuleLoader__.load({
       for (const seg of segments) {
         const v = document.createElement('video');
         v.src = seg.url; v.preload = 'auto'; v.playsInline = true;
-        await new Promise((res, rej) => {
-          v.onloadedmetadata = () => res();
-          v.onerror = () => rej(new Error('视频加载失败: ' + seg.name));
-          setTimeout(res, 15000);
+        // 加载失败必须留下来而不是静默丢弃：静默丢弃 = 用户以为全片都合进去了
+        let loadErr = null;
+        await new Promise((res) => {
+          let settled = false;
+          const fin = () => { if (!settled) { settled = true; res(); } };
+          v.onloadedmetadata = fin;
+          v.onerror = () => { loadErr = '视频解码失败（格式不支持或文件损坏）'; fin(); };
+          setTimeout(fin, 15000); // 超时也继续：时长拿不到时按 8s 兜底
+        });
+        if (loadErr && !(isFinite(v.duration) && v.duration > 0)) {
+          throw new Error((seg.name || '片段') + '：' + loadErr + '——请确认该段视频能正常播放（可在节点上预览）');
+        }
+        const clipDur = isFinite(v.duration) && v.duration > 0 ? v.duration : 0;
+        // 编辑时长（分镜时长）用于裁剪：不能超过真实素材时长
+        const trimSec = seg.dur && seg.dur > 0 ? Math.min(seg.dur, clipDur || seg.dur) : 0;
+        totalMs += (trimSec || clipDur || 8) * 1000;
+        vids.push({
+          v, name: seg.name, sub: seg.sub || '', withAudio: seg.withAudio !== false,
+          ttsUrl: seg.ttsUrl || null, ttsEl: null, ttsSrc: null, started: false, srcNode: null,
+          trim: trimSec || null, // 裁剪到该秒数（0/null = 用完整片段）
+          clipDur, // 素材真实时长（可能为 0：元数据没拿到）
+          startAt: 0,
         });
-        const trimSec = seg.dur && seg.dur > 0 ? Math.min(seg.dur, (isFinite(v.duration) && v.duration > 0 ? v.duration : seg.dur)) : 0;
-        totalMs += trimSec * 1000 || (isFinite(v.duration) && v.duration > 0 ? v.duration * 1000 : 8000);
-        vids.push({ v, name: seg.name, sub: seg.sub || '', withAudio: seg.withAudio !== false, ttsUrl: seg.ttsUrl || null, ttsEl: null, ttsSrc: null, started: false, srcNode: null, dur: seg.dur || null, startAt: 0 });
       }
+      if (!vids.length) throw new Error('没有可合成的片段');
       const cv = document.createElement('canvas'); cv.width = W; cv.height = H;
       const g = cv.getContext('2d');
-      const mimes = ['video/webm;codecs=vp9,opus', 'video/webm;codecs=vp8,opus', 'video/webm', 'video/mp4'];
+      // mp4 优先（含音轨：H.264 + AAC）：webm 只是兜底，保证成片统一为 mp4
+      const mimes = ['video/mp4;codecs=avc1.42E01E,mp4a.40.2', 'video/mp4', 'video/webm;codecs=vp9,opus', 'video/webm;codecs=vp8,opus', 'video/webm'];
       const mime = (typeof MediaRecorder !== 'undefined') && mimes.find((m) => MediaRecorder.isTypeSupported(m));
       if (!mime) throw new Error('当前环境不支持视频录制');
       const stream = cv.captureStream(30);
@@ -3566,67 +4529,102 @@ window.__ModuleLoader__.load({
       }
       let idx = 0;
       let done = false;
+      let failed = null;
       let blackUntil = 0;
       let lastProgressIdx = -1;
+      let lastTickAt = 0;
+      // 看门狗：即使某段 video 元素永远不触发 ended/timeupdate（解码卡住、seek 失效），
+      // 也按"本段应有时长"强制推进——否则用户只看到"运行中"永远不结束。
+      const startedAt = performance.now();
       startPlayback(vids[0]);
       await new Promise((resolve) => {
+        function finish(err) {
+          if (done) return;
+          done = true;
+          failed = err || null;
+          resolve();
+        }
         function frame() {
-          if (done) return resolve();
-          const now = performance.now();
-          const item = vids[idx];
-          const v = item.v;
-          // 黑场过渡窗口
-          if (blackUntil && now < blackUntil) {
+          if (done) return;
+          try {
+            const now = performance.now();
+            const item = vids[idx];
+            if (!item) return finish();
+            const v = item.v;
+            // 每段超时保护：单段最多等到 应有+10s，超过即视为该段已结束（不卡死整片）
+            if (item.startAt && item.hardDeadline && now > item.hardDeadline) {
+              stopItem(item);
+              idx++;
+              if (idx >= vids.length) return finish();
+              if (transition === 'black') blackUntil = now + 350;
+            }
+            // 黑场过渡窗口
+            if (blackUntil && now < blackUntil) {
+              g.fillStyle = '#000'; g.fillRect(0, 0, W, H);
+              requestAnimationFrame(frame);
+              return;
+            }
+            blackUntil = 0;
+            startPlayback(item);
+            if (lastProgressIdx !== idx) { lastProgressIdx = idx; if (onProgress) onProgress(idx / Math.max(1, vids.length), item.name); }
+            const clipDur = isFinite(v.duration) && v.duration > 0 ? v.duration : item.clipDur;
+            // 有效时长 = 裁剪时长（若有）与素材真实时长的较小值
+            const effDur = item.trim && item.trim > 0 ? Math.min(item.trim, clipDur || item.trim) : clipDur;
+            if (!item.hardDeadline && item.startAt) item.hardDeadline = item.startAt + (effDur > 0 ? effDur * 1000 : 8000) + 10000;
+            const elapsed = item.startAt ? (now - item.startAt) / 1000 : 0;
+            // 叠化窗口：距本段结束还剩多少毫秒（effDur 为 0 时视为无限，不会误触发）
+            const remainMs = effDur > 0 ? (effDur - (v.currentTime || 0)) * 1000 : Infinity;
+            // 叠化：临近结束时提前启动下一片段
+            let next = null;
+            if (transition === 'fade' && idx < vids.length - 1 && remainMs <= td && Number.isFinite(remainMs)) {
+              next = vids[idx + 1];
+              startPlayback(next);
+            }
+            // 绘制当前片段
             g.fillStyle = '#000'; g.fillRect(0, 0, W, H);
-            requestAnimationFrame(frame);
-            return;
-          }
-          blackUntil = 0;
-          startPlayback(item);
-          if (lastProgressIdx !== idx) { lastProgressIdx = idx; if (onProgress) onProgress(idx / Math.max(1, vids.length), item.name); }
-          const clipDur = isFinite(v.duration) && v.duration > 0 ? v.duration : 0;
-          const effDur = item.dur && item.dur > 0 ? Math.min(item.dur, clipDur || item.dur) : clipDur;
-          const elapsed = item.startAt ? (now - item.startAt) / 1000 : 0;
-          const remainMs = dur ? (dur - v.currentTime) * 1000 : Infinity;
-          // 叠化：临近结束时提前启动下一片段
-          let next = null;
-          if (transition === 'fade' && idx < vids.length - 1 && remainMs <= td) {
-            next = vids[idx + 1];
-            startPlayback(next);
-          }
-          // 绘制当前片段
-          g.fillStyle = '#000'; g.fillRect(0, 0, W, H);
-          letterbox(v);
-          let fadeT = 0;
-          if (next && next.started) {
-            fadeT = clamp(1 - remainMs / td, 0, 1);
-            if (next.v.videoWidth) {
-              g.save(); g.globalAlpha = fadeT; letterbox(next.v); g.restore();
+            letterbox(v);
+            let fadeT = 0;
+            if (next && next.started) {
+              fadeT = clamp(1 - remainMs / td, 0, 1);
+              if (next.v.videoWidth) {
+                g.save(); g.globalAlpha = fadeT; letterbox(next.v); g.restore();
+              }
             }
+            // 字幕随叠化淡出/淡入
+            if (next && fadeT > 0.5) {
+              g.save(); g.globalAlpha = fadeT; drawSubtitle(g, W, H, next.sub); g.restore();
+            } else {
+              g.save(); g.globalAlpha = 1 - fadeT; drawSubtitle(g, W, H, item.sub); g.restore();
+            }
+            // 推进（三判据：播放器自报结束 / 到达有效时长 / 墙钟超时）
+            const ended = v.ended || (effDur > 0 && elapsed >= effDur - 0.03);
+            if (ended) {
+              stopItem(item);
+              idx++;
+              if (idx >= vids.length) return finish();
+              if (transition === 'black') blackUntil = now + 350;
+            }
+            lastTickAt = now;
+            requestAnimationFrame(frame);
+          } catch (e) {
+            // 帧循环内异常必须转成 reject：静默卡住比报错更糟
+            try { stopItem(vids[idx] || {}); } catch { /* 忽略 */ }
+            if (lastTickAt) void lastTickAt;
+            finish(e);
           }
-          // 字幕随叠化淡出/淡入
-          if (next && fadeT > 0.5) {
-            g.save(); g.globalAlpha = fadeT; drawSubtitle(g, W, H, next.sub); g.restore();
-          } else {
-            g.save(); g.globalAlpha = 1 - fadeT; drawSubtitle(g, W, H, item.sub); g.restore();
-          }
-          // 推进
-          const ended = v.ended || (effDur > 0 && elapsed >= effDur - 0.03);
-          if (ended) {
-            stopItem(item);
-            idx++;
-            if (idx >= vids.length) { done = true; resolve(); return; }
-            if (transition === 'black') blackUntil = now + 350;
-          }
-          requestAnimationFrame(frame);
         }
         requestAnimationFrame(frame);
-        setTimeout(() => { done = true; resolve(); }, totalMs + 30000);
+        // 全局兜底：总时长 + 30s（含看门狗余量）后强制收尾，并明确报告超时而不是假装成功
+        setTimeout(() => {
+          if (!done) finish(new Error('成片合成超时（已等待 ' + Math.round((performance.now() - startedAt) / 1000) + 's）：请检查所选片段是否都能正常播放'));
+        }, totalMs + 30000);
       });
       vids.forEach(stopItem);
       rec.stop();
       await stopped;
       if (audio) { try { audio.ac.close(); } catch { /* 忽略 */ } }
+      if (failed) throw failed;
+      if (!chunks.length) throw new Error('成片录制未产出数据（浏览器录制失败，请重试或降低分辨率）');
       return new Blob(chunks, { type: mime.split(';')[0] });
     }
 
@@ -3663,10 +4661,12 @@ window.__ModuleLoader__.load({
     const craft = {
       status: async () => { const r = await craftFetch('/status', {}, 20000, true); return await r.json(); },
       projects: async () => { const r = await craftFetch('/projects'); return await r.json(); },
-      write: async (rel, blob) => { const r = await craftFetch('/fs?action=write&rel=' + encodeURIComponent(rel), { method: 'POST', body: blob }, 180000); return await r.json(); },
-      writeText: async (rel, text) => { const r = await craftFetch('/fs?action=write&rel=' + encodeURIComponent(rel), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ rel, text }) }, 60000); return await r.json(); },
-      readText: async (rel) => { const r = await craftFetch('/fs?op=readtext&rel=' + encodeURIComponent(rel)); return (await r.json()).text; },
-      file: async (rel) => { const r = await craftFetch('/file?rel=' + encodeURIComponent(rel), {}, 180000); return await r.blob(); },
+      // BLK-02：所有文件类调用一律 base(项目绝对目录) + path(相对)，绝不发「无 base 的相对 rel」——
+      // 无 base 时 ArtCraft 按插件进程 cwd 解析，会 200 静默写到 DSH profile 目录（现场证据见 _qa/BLK-02）。
+      write: async (base, rel, blob) => { const r = await craftFetch('/fs?action=write&base=' + encodeURIComponent(base) + '&path=' + encodeURIComponent(rel), { method: 'POST', body: blob }, 180000); return await r.json(); },
+      writeText: async (base, rel, text) => { const r = await craftFetch('/fs?action=write&base=' + encodeURIComponent(base) + '&path=' + encodeURIComponent(rel), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ base, path: rel, text }) }, 60000); return await r.json(); },
+      readText: async (base, rel) => { const r = await craftFetch('/fs?op=readtext&base=' + encodeURIComponent(base) + '&path=' + encodeURIComponent(rel)); return (await r.json()).text; },
+      file: async (base, rel) => { const r = await craftFetch('/file?base=' + encodeURIComponent(base) + '&path=' + encodeURIComponent(rel), {}, 180000); return await r.blob(); },
       jobStart: async (p) => { const r = await craftFetch('/job', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(p) }, 30000); return await r.json(); },
       jobGet: async (id, tail) => { const r = await craftFetch('/job?id=' + encodeURIComponent(id) + '&tail=' + (tail || 12)); return await r.json(); },
       jobCancel: async (id) => { const r = await craftFetch('/job/cancel', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ id }) }); return await r.json(); },
@@ -3681,6 +4681,41 @@ window.__ModuleLoader__.load({
       update((s) => { s.craftStatus = { at: Date.now(), data }; });
       return data;
     }
+    // ---- BLK-02：ArtCraft 调用的目录基准 ----
+    // ArtCraft 是纯桥接、**没有自己的数据根**（0.3.x 起 /api/status 也不再返回 dataRoot）。
+    // 因此画布必须自己给出绝对基准：每个项目的目录 = <画布数据根>/projects/<物理文件夹>，
+    // 由 Host 的 projectDirGet 解析（meta 无条目时回退 id），再以 base + 相对 path 调 ArtCraft。
+    // 绝不发「无 base 的相对 rel」——那样会被按插件进程 cwd 解析、200 却写错目录（见 _qa/BLK-02）。
+    const craftBaseCache = new Map(); // projectId -> { at, abs }
+    async function craftBaseDir(pid) {
+      const id = String(pid || S.activeId || '');
+      if (!id) return null;
+      const hit = craftBaseCache.get(id);
+      if (hit && Date.now() - hit.at < 60000) return hit.abs;
+      let r = null;
+      try { r = await hostRpc('projectDirGet', { projectId: id }); } catch { r = null; }
+      if (r && r.ok && r.abs) { craftBaseCache.set(id, { at: Date.now(), abs: r.abs }); return r.abs; }
+      return null;
+    }
+    /** 取不到项目目录时明确失败（未配数据根/宿主过旧），不做任何相对路径兜底。 */
+    async function craftBaseDirRequired(pid) {
+      const abs = await craftBaseDir(pid);
+      if (!abs) throw new Error('未设置画布数据根目录：ArtCraft 调用需要绝对的项目目录作为基准（设置 → 数据根目录）');
+      return abs;
+    }
+    /** IC-B2：项目删除时清掉其 craft/ 后期目录（Host RPC projectCraftRemove，幂等、失败可见）。 */
+    async function craftProjectCleanup(pid) {
+      try {
+        const r = await hostRpc('projectCraftRemove', { projectId: pid });
+        if (r && r.ok === false && r.error) toast('Craft 目录清理未完成：' + r.error);
+      } catch { /* 旧 Host 无该 RPC → 静默（目录残留不影响功能） */ }
+    }
+    /** 项目目录下的相对路径 → 本机绝对路径（ArtCraft 的 args/FCP7 XML 都用它）。 */
+    function joinLocal(absDir, rel) {
+      const s = String(absDir || '').replace(/\//g, '\\').replace(/\\+$/, '');
+      const r = String(rel || '').replace(/\\/g, '/').replace(/^\/+/, '');
+      return s + '\\' + r.replace(/\//g, '\\');
+    }
     async function craftStatusSafe() {
       try { return await craft.status(); } catch { toast(T('craftUnreachable')); return null; }
     }
@@ -3689,25 +4724,14 @@ window.__ModuleLoader__.load({
       if (!cs || !cs.at || Date.now() - cs.at > 120000 || !cs.data || !cs.data.bins) return false;
       return Object.keys(cs.data.bins).some((k) => cs.data.bins[k] && cs.data.bins[k].found);
     }
-    function slugifyName(name) {
-      return String(name || '').replace(/[\\/:*?"<>|]/g, '').trim() || 'project';
-    }
-    function craftProjectSlug() {
-      const p = S.projects.find((x) => x.id === S.activeId);
-      if (!p) return 'project';
-      if (!p.slug) {
-        let base = slugifyName(p.name);
-        const taken = new Set(S.projects.filter((x) => x.id !== p.id && x.slug).map((x) => x.slug));
-        if (taken.has(base)) base = base + '-' + p.id.slice(-4);
-        p.slug = base;
-        lsSet(LS_PROJECTS, S.projects);
-      }
-      return p.slug;
-    }
-    // 资产 assetId → dataRoot 相对路径 映射（项目级元数据，localStorage）
+    // 资产 assetId → 项目内相对路径 映射（项目级元数据，localStorage）
     function craftMapLoad(pid) { return lsGet('dsh-ic:craftmap:' + pid, {}) || {}; }
     function craftMapSave(pid, map) { lsSet('dsh-ic:craftmap:' + pid, map); }
     function craftMapSet(pid, assetId, rel) { const m = craftMapLoad(pid); m[assetId] = rel; craftMapSave(pid, m); }
+    /** Craft 落盘/产物路径的扩展名（IC-B3 统一）：**文件名优先**——Craft 侧复用资产的
+     *  既有名字与扩展名（已登记的 media/graded 文件靠名字对回 ArtCraft 工程），mime 只兜底。
+     *  与 extForDownload（mime 优先）方向相反是有意的：下载侧扩展名必须反映真实容器，
+     *  落盘侧名字才是资产在 ArtCraft 工程里的稳定标识。 */
     function extForMime(mime, name) {
       const fromName = String(name || '').match(/(\.[a-z0-9]{2,5})$/i);
       if (fromName) return fromName[1].toLowerCase();
@@ -3721,6 +4745,36 @@ window.__ModuleLoader__.load({
       if (m.includes('wav')) return '.wav';
       return '.bin';
     }
+    /** IC-01/IC-B3：下载侧扩展名判定（**mime 优先** → 文件名白名单兜底 → kind 兜底）。
+     *  三套映射的分工（IC-B3 统一结论，各自单一职责）：
+     *  - extFromMime：磁盘落盘（mime 子类型直取，无名字兜底——落盘时 mime 由生成链路给出）
+     *  - extForMime：Craft 落盘/产物路径（文件名优先——名字是 ArtCraft 工程里的稳定标识）
+     *  - extForDownload：用户下载（mime 优先——扩展名必须反映真实容器，`final.2026`
+     *    这类带点号的资产名绝不能得到 `.2026`，所以名字兜底只认白名单） */
+    const DOWNLOAD_EXT_BY_MIME = [
+      [/^image\/png$/, '.png'], [/^image\/jpe?g$/, '.jpg'], [/^image\/webp$/, '.webp'], [/^image\/gif$/, '.gif'],
+      [/^video\/mp4$/, '.mp4'], [/^video\/quicktime$/, '.mov'], [/^video\/webm$/, '.webm'], [/^video\/x-matroska$/, '.mkv'],
+      [/^audio\/mpeg$/, '.mp3'], [/^audio\/mp4$/, '.m4a'], [/^audio\/(x-)?wav$/, '.wav'],
+      [/^text\/markdown$/, '.md'], [/^text\/plain$/, '.txt'],
+    ];
+    const DOWNLOAD_EXT_BY_NAME = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.mp4', '.mov', '.webm', '.mkv', '.mp3', '.m4a', '.wav', '.md', '.txt']);
+    function extForDownload(mime, name, kind) {
+      const m = String(mime || '').split(';')[0].trim().toLowerCase();
+      if (m) { for (const [re, ext] of DOWNLOAD_EXT_BY_MIME) if (re.test(m)) return ext; }
+      const nm = String(name || '').match(/\.([a-z0-9]{2,5})$/i);
+      if (nm) { const ext = '.' + nm[1].toLowerCase(); if (DOWNLOAD_EXT_BY_NAME.has(ext)) return ext; }
+      if (kind === 'image') return '.png';
+      if (kind === 'video') return '.mp4';
+      if (kind === 'audio') return '.mp3';
+      if (kind === 'text') return '.md';
+      return '.bin';
+    }
+    /** 下载名 = 可读前缀 + 真实扩展名。assetId 只为取 mime/kind；记录取不到时按 kind 兜底。 */
+    async function downloadNameForAsset(assetId, base, kind) {
+      let rec = null;
+      try { rec = assetId ? await idbGet(assetId) : null; } catch { rec = null; }
+      return base + extForDownload(rec && rec.mime, rec && rec.name, (rec && rec.kind) || kind);
+    }
     /** 资产落盘到 <项目>/media/（force=false 时已有映射则复用；force=true 覆盖写）。 */
     /** ArtCraft 工作区里的文件名：资产名（人工可读，如「角色-张山 多视图」）+ id 尾号（唯一，避免同名覆盖）。 */
     function assetFileBase(rec) {
@@ -3731,16 +4785,29 @@ window.__ModuleLoader__.load({
     }
     async function syncAssetToDisk(rec, opts = {}) {
       const pid = S.activeId;
+      const base = await craftBaseDirRequired(pid);
       const map = craftMapLoad(pid);
-      if (!opts.force && map[rec.id]) return map[rec.id];
-      // Craft 后期数据统一放在**画布数据根目录**的项目目录下：projects/<项目>/<slug 前缀去掉>/craft/…
-      // （ArtCraft 数据根目录 = 画布数据根目录时，即落在 <root>/projects/<项目>/craft/media/）
-      const rel = 'projects/' + craftProjectSlug() + '/craft/media/' + assetFileBase(rec) + extForMime(rec.mime, rec.name);
+      // 陈旧映射防护（旧版本升级边界）：映射存的是写入时刻的逻辑路径
+      // 'projects/<当时的物理文件夹>/craft/…'。BLK-02 后物理文件夹名来自数据根 meta，
+      // 旧版 slug-era 的映射前缀几乎必然 ≠ 现文件夹——直接复用会让 FilmCraft 导出/
+      // PhotoCraft 调色引用到不存在的媒体（"文件不存在"）。前缀不符 = 过期，强制重写。
+      const curPrefix = 'projects/' + craftFolderOf(base) + '/';
+      if (!opts.force && map[rec.id] && String(map[rec.id]).startsWith(curPrefix)) return map[rec.id];
+      // BLK-02：写入基准 = 项目绝对目录（base），路径只用 craft/ 下的相对段。
+      // ArtCraft 侧解析后落点 = <数据根>/projects/<物理文件夹>/craft/media/…；不再依赖 slug 与它的 cwd。
+      const rel = 'craft/media/' + assetFileBase(rec) + extForMime(rec.mime, rec.name);
       const blob = rec.blob || await assetBlob(rec.id);
       if (!blob) throw new Error('资产内容不可用: ' + rec.id);
-      await craft.write(rel, blob);
-      craftMapSet(pid, rec.id, rel);
-      return rel;
+      await craft.write(base, rel, blob);
+      const stored = 'projects/' + craftFolderOf(base) + '/' + rel; // 返回给 Host 侧取用（逻辑路径）
+      craftMapSet(pid, rec.id, stored);
+      return stored;
+    }
+    /** 从项目绝对目录里取物理文件夹名（base 的末段），用于拼 Host 可识别的逻辑路径。 */
+    function craftFolderOf(abs) {
+      const s = String(abs || '').replace(/[\\/]+$/, '');
+      const i = Math.max(s.lastIndexOf('\\'), s.lastIndexOf('/'));
+      return i >= 0 ? s.slice(i + 1) : s;
     }
     async function ensureAssetOnDisk(rec) { return syncAssetToDisk(rec, { force: false }); }
     async function videoDurationOf(blob) {
@@ -3835,8 +4902,9 @@ window.__ModuleLoader__.load({
       });
       return out.join('\n');
     }
-    /** FilmCraft 任务后台轮询：状态写回节点，done 后回收产物入资产库。 */
-    async function pollFilmcraftJob(nodeId, jobId, outRel) {
+    /** FilmCraft 任务后台轮询：状态写回节点，done 后回收产物入资产库。
+     *  base = 项目绝对目录（BLK-02：取产物也必须带 base，否则读到的是插件 cwd 下的同名文件）。 */
+    async function pollFilmcraftJob(nodeId, jobId, outRel, base) {
       const deadline = Date.now() + 30 * 60 * 1000; // 与 jobStart 的 timeoutMs 对齐：绝不无限轮询
       for (;;) {
         if (Date.now() > deadline) {
@@ -3856,7 +4924,7 @@ window.__ModuleLoader__.load({
         });
         if (snap.status === 'done') {
           try {
-            const blob = await craft.file(outRel);
+            const blob = await craft.file(base, outRel);
             const rec = await saveAssetRecord(S.activeId, 'video', blob, {
               name: T('finalCutDone') + '-FC-' + new Date().toISOString().slice(5, 16).replace('T', ' '),
               prompt: 'filmcraft export', source: 'filmcraft', category: 'finalcut',
@@ -4013,9 +5081,8 @@ window.__ModuleLoader__.load({
             s.projects = s.projects.filter((p) => !gone.has(p.id));
             if (gone.has(s.activeId)) {
               if (s.projects.length === 0) {
-                const p = { id: uid('p'), name: T('defaultProject'), createdAt: Date.now(), updatedAt: Date.now() };
-                s.projects.push(p);
-                s.activeId = p.id;
+                // OBS-UI-1：删光后进入空态，不再自动建「我的画布」占位（同 initStore 口径）
+                s.activeId = null;
                 s.graph = emptyGraph();
               } else {
                 s.activeId = s.projects[0].id;
@@ -4157,6 +5224,8 @@ window.__ModuleLoader__.load({
     /** 启动时把本地全部项目推给 Host：让对话能看到并操作画布上已有的项目（客户端为内容权威）。 */
     async function pushAllProjectsToHost() {
       if (hostSyncStopped) return;
+      // OBS-UI-1：空态（用户还没建任何项目）不推送——否则空态下的占位也会写进 canvas.db
+      if (!S.projects.length) return;
       for (const p of [...S.projects]) {
         try {
           const doc = loadGraphDoc(p.id) || emptyGraph();
@@ -4444,14 +5513,25 @@ window.__ModuleLoader__.load({
       }
       return out;
     }
-    async function aiStoryboardShots(scriptText, requirement, count, model, onDelta, prevTail) {
+    async function aiStoryboardShots(scriptText, requirement, count, model, onDelta, prevTail, opts) {
       const settings = loadSettings();
       const bible = bibleBlock(loadBible(S.activeId));
       const zh = effLang() !== 'en';
+      const contOn = !(opts && opts.cont === false); // 分镜衔接开关（默认开）
+      const contFields = (() => {
+        if (zh) {
+          return contOn
+            ? '{"title":"…","visual":"…","motion":"…","tail":"…","cam":"…","start":"…","seg":"continuation","characters":["…"],"scene":"…","props":["…"],"duration":3,"dialogue":[{"role":"陈拾","line":"收件时间，1999……"}],"sfx":"邮包搭扣声、撕纸声"}'
+            : '{"title":"…","visual":"…","motion":"…","characters":["…"],"scene":"…","props":["…"],"duration":3,"dialogue":[{"role":"陈拾","line":"收件时间，1999……"}],"sfx":"邮包搭扣声、撕纸声"}';
+        }
+        return contOn
+          ? '{"title":"…","visual":"…","motion":"…","tail":"…","cam":"…","start":"…","seg":"continuation","characters":["…"],"scene":"…","props":["…"],"duration":3,"dialogue":[{"role":"Chen","line":"…"}],"sfx":"zipper snap, paper tear"}'
+          : '{"title":"…","visual":"…","motion":"…","characters":["…"],"scene":"…","props":["…"],"duration":3,"dialogue":[{"role":"Chen","line":"…"}],"sfx":"zipper snap, paper tear"}';
+      })();
       const jsonContract = zh
         ? [
             '把剧本拆解为「多镜头一次性视频生成」的分镜脚本：铺开后由**一个视频生成节点**把全部镜头按顺序与时长写进同一条提示词，由视频模型一次性生成整段视频（镜头间由模型直接硬切，不是一镜一视频再拼接）。',
-            '只输出一个 JSON 对象：{"shots":[{"title":"…","visual":"…","motion":"…","characters":["…"],"scene":"…","props":["…"],"duration":3,"dialogue":[{"role":"陈拾","line":"收件时间，1999……"}],"sfx":"邮包搭扣声、撕纸声"}]}。',
+            '只输出一个 JSON 对象：{"shots":[' + contFields + ']}。',
             '规则：',
             '- visual 是本镜画面描述（景别、人物外观与站位、场景、光线、构图，60 字内）；',
             '- **visual 与 motion 里的角色/场景/道具必须写成 @资产名@ 引用形式**（前后各一个 @ 精确包裹，如「@陈拾@ 在 @城市街头@ 的围挡旁拿起 @奇怪快递件@」）；名称必须与设定集/资产**逐字一致**；剧本原文里已出现的 @资产名@ 锚点要在镜头中原样保留（名称逐字一致）；名称内不得含 @、空格或标点；@ 后绝不允许直接跟其他文字（必须以 @ 闭合）——系统会隐藏两个 @ 并把名称显示为蓝色加粗，未登记的 @名称@ 会被一致性检查提示补充；',
@@ -4467,10 +5547,21 @@ window.__ModuleLoader__.load({
             '- **按情绪选景别**：孤独/绝望/宏大危机=远景；对峙/动作/关系建立=全景；对话/试探/信息交换=中景；震惊/怀疑/内心动摇=近景；崩溃/嘶吼/情绪爆发=特写；关键细节/道具揭示=大特写——冲突用全景、揭秘转近景、爆发给特写、反转可拉远，景别变化本身在讲情绪；',
             '- **快切镜头（<1.5s）的 visual/motion 要极短**（一个动作、一句画内信息），信息量大的镜头才配长时长——时长与内容量必须匹配；',
             '- 只输出 JSON，不要输出任何其他内容。',
-          ].join('\n')
+          ].concat(contOn ? [
+            '',
+            '**【分镜衔接·硬性】成片是分段生成的，每段模型看不到上一段画面——衔接只能靠写在分镜里的"接点"。除末镜外，每镜都必须写 tail 与 cam：**',
+            '- **tail（接点尾态）**：本镜**最后一刻**的状态，一行写清——人物姿势停在哪个动作的中途、朝向、视线落点、手持物位置、位置关系（如「右手抬到胸口一半，视线仍锁在 @陈拾@ 脸上，@糯糯@ 停在他左后方半步」「已侧身转到 3/4 面，还没完全转身面对对方」）。**必须是"动作进行中"的状态，不能写成"已经完成/站定/看向"**——切点停在静止定格，下一镜就没有动作可接，接缝必然暴露；',
+            '- **cam（运镜延续）**：本镜运镜的方向与速度，写成下一镜可以直接"接着走"的形式（如「右移横移，匀速，未停」「缓推向面部，接近停住」）；末镜写「收束静止」；**全片避免相邻镜反向运镜**（上一镜右移、下一镜突然左移 = 观众立刻感觉跳），需要反向时把切点设计成遮挡/过肩/特写插入；',
+            '- **start（仅第 1 镜或 seg 非续帧的镜头需要）**：本镜起始状态；续帧镜头不写 start（它会自动承接上一镜 tail）；',
+            '- **seg（段落类型）**：`continuation` 续帧（默认，绝大多数镜头）、`scene_change` 换场/切换地点时间、`new_character` 新角色首次出场、`closeup` 特写/细节插入（允许跳切）、`opening` 仅第 1 镜且无上游承接时；',
+            '- **一镜只做一个主动作**：转身、走路、推镜、换表情不要塞进同一镜——模型只会执行前半段，下一镜就对不上；',
+            '- **一段一运镜**：不要又推又横移又摇；',
+            '- **大位移拆镜**：人物横移超过画面 1/4、或场景大换位，就再拆一镜（用不同景别接，而不是一镜硬走）；',
+            '- **轴线一致**：两人对话，同一轴线关系（如男左女右）在相邻镜必须保持一致，不得越轴。',
+          ] : []).join('\n')
         : [
             'Break the script into shots for ONE multi-shot video generation: after expansion, a single video-gen node composes ALL shots (in order, with durations) into one prompt, and the video model generates the whole clip in one call (hard cuts inside the model — not one video per shot stitched together).',
-            'Output only one JSON object: {"shots":[{"title":"…","visual":"…","motion":"…","characters":["…"],"scene":"…","props":["…"],"duration":3,"dialogue":[{"role":"Chen","line":"…"}],"sfx":"zipper snap, paper tear"}]}.',
+            'Output only one JSON object: {"shots":[' + contFields + ']}.',
             'Rules:',
             '- visual = the shot\'s frame description (shot size, wardrobe, staging, light, framing, <=60 words);',
             '- **characters/scenes/props inside visual and motion must be written as @Name@ references** (an @ on each side, e.g. "@Chen@ picks up @Parcel@ by @Street@"); names must match the bible/assets VERBATIM, with no @, space or punctuation inside; an @ must never be followed directly by other text (always close with @) - the UI hides the @s and shows the name in blue bold; unregistered @Name@ is flagged by the consistency check;',
@@ -4486,7 +5577,18 @@ window.__ModuleLoader__.load({
             '- **Pick the shot size by emotion**: loneliness/despair/grand crisis = wide; confrontation/action/relationship = full; dialogue/probing/info exchange = medium; shock/suspicion/inner shake = close-up; breakdown/screaming/emotional burst = extreme close-up; key detail/prop reveal = big close-up — conflicts play wide, reveals move close, bursts go extreme, reversals can pull wide; the changing distance itself tells the emotion;',
             '- **Rapid cuts (<1.5s) get minimal visual/motion** (one action, one piece of in-frame information); long durations are earned by information density — duration must match content;',
             '- Output JSON only.',
-          ].join('\n');
+          ].concat(contOn ? [
+            '',
+            '**[CONTINUITY - HARD] the film is generated in segments and each segment cannot see the previous one, so the "hand-off point" must be written into the storyboard. Every shot except the last MUST carry tail and cam:**',
+            '- **tail (hand-off tail state)**: the state at the LAST instant of this shot, in one line - where the posture stops mid-motion, facing, gaze target, hand/prop position, blocking (e.g. "right hand half-way up to the chest, eyes still locked on @Chen@, @Nuonuo@ half a step behind his left shoulder"). It MUST be a mid-motion state, never a settled/completed pose: a cut on a static freeze leaves nothing for the next shot to continue, which is exactly what makes the seam visible;',
+            '- **cam (camera carry-over)**: the move direction and speed of this shot, written so the next shot can continue it (e.g. "lateral right, constant speed, never stops"; "slow push-in, almost settled"). Last shot: "settle to static". Avoid reversing direction on adjacent shots (right pan then sudden left pan reads as a jump); if you need a reversal, make the cut a wipe/over-shoulder/insert close-up;',
+            '- **start**: the start state, needed only for shot 1 or shots whose seg is not a continuation; continuation shots omit it (they inherit the previous tail);',
+            '- **seg (segment type)**: `continuation` (default, most shots), `scene_change` (new place/time), `new_character` (a character appears for the first time), `closeup` (insert/detail, jump cut allowed), `opening` (only shot 1 with no upstream continuation);',
+            '- **one primary action per shot**: never pack a turn + walk + push-in + expression change into one shot - the model only executes the first half and the next shot cannot match it;',
+            '- **one camera move per shot**;',
+            '- **split big displacements**: if a character crosses more than 1/4 of the frame, or the staging changes a lot, break it into another shot (different shot size) instead of one long move;',
+            '- **keep the axis**: in a dialogue, the same side relationship (e.g. man left / woman right) must hold across adjacent shots - never cross the line.',
+          ] : []).join('\n');
       const methodology = await loadSkillRules(settings.skillStoryboard, zh)
         || await loadSkillRules(CRAFT_SKILL, zh); // 未选技能时默认注入内置创作方法论
       const system = [
@@ -4514,27 +5616,35 @@ window.__ModuleLoader__.load({
         const sh = prevTail.shot;
         if (!sh) return null;
         const dl = (sh.dialogue || []).map((d) => d.role + (zh ? '：' : ': ') + d.line).join(zh ? '；' : '; ');
+        const tailState = String(sh.tail || '').trim();
+        const camState = String(sh.cam || '').trim();
         return zh
           ? `【承接约束·硬性】本分镜承接「${label}」的最后一镜——**只承接它的结尾瞬间，不要重演它**：\n`
             + `  尾镜画面：${String(sh.visual || '').trim()}\n`
             + `  尾镜最后动作：${String(sh.motion || '').trim()}\n`
+            + (tailState ? `  尾镜接点尾态（本分镜第 1 镜必须从这里继续，动作处于进行中）：${tailState}\n` : '')
+            + (camState ? `  尾镜运镜（第 1 镜须同向延续，不得反向、不得突变）：${camState}\n` : '')
             + (dl ? `  尾镜台词：${dl}\n` : '')
             + (String(sh.sfx || '').trim() ? `  尾镜音效/环境声：${String(sh.sfx).trim()}\n` : '')
             + `要求：\n`
             + `  1) 第 1 镜从上一镜的**最后一个动作**继续（人物位置、朝向、情绪、光线保持一致），不得重新建立场景、不得跳回远景交代、不得切换地点；\n`
             + `  2) 与上一镜的画面重叠**不超过 0.2 秒**（不要重演上一镜的内容）；\n`
             + `  3) **背景声连续**：环境音/音效自然延续（风声、电流声、街道底噪等），不得突然静音或更换环境声；\n`
-            + `  4) 第 1 镜的画面描述里明确写出承接关系（如「承接上一镜，<角色>保持<姿态>，继续…」）。`
+            + `  4) 第 1 镜的画面描述里明确写出承接关系（如「承接上一镜，<角色>保持<姿态>，继续…」）；\n`
+            + `  5) 第 1 镜的 seg 标 continuation，并**不要写 start**（自动承接上一镜 tail）。`
           : `[CONTINUITY CONSTRAINT - HARD] This storyboard continues the LAST SHOT of "${label}" - continue only its final instant, do NOT replay it:\n`
             + `  Tail frame: ${String(sh.visual || '').trim()}\n`
             + `  Tail last action: ${String(sh.motion || '').trim()}\n`
+            + (tailState ? `  Tail hand-off state (shot 1 must continue from here, mid-motion): ${tailState}\n` : '')
+            + (camState ? `  Tail camera (shot 1 continues the same direction, no reversal, no sudden change): ${camState}\n` : '')
             + (dl ? `  Tail dialogue: ${dl}\n` : '')
             + (String(sh.sfx || '').trim() ? `  Tail SFX/ambience: ${String(sh.sfx).trim()}\n` : '')
             + `Requirements:\n`
             + `  1) Shot 1 continues from the LAST ACTION of the previous shot (same position, facing, emotion, light) - no re-establishing, no wide reset, no location change;\n`
             + `  2) overlap with the previous shot must be <= 0.2s (do not replay the previous shot);\n`
             + `  3) ambient background sound continues naturally (wind, electrical hum, street noise) - never cut to silence or swap ambience;\n`
-            + `  4) state the continuity explicitly in shot 1's frame description.`;
+            + `  4) state the continuity explicitly in shot 1's frame description;\n`
+            + `  5) shot 1 uses seg=continuation and omits start (it inherits the previous tail).`;
       })();
       const prevLine = cont || '';
       const user = [
@@ -4569,6 +5679,11 @@ window.__ModuleLoader__.load({
         title: String(s.title || (T('shotPrefix') + (i + 1))).slice(0, 24),
         visual: String(s.visual || ''),
         motion: String(s.motion || ''),
+        // 分镜衔接（分段生成的接戏依据）：接点尾态 / 运镜延续 / 起始态 / 段落类型
+        tail: String(s.tail || '').trim().slice(0, 120),
+        cam: String(s.cam || '').trim().slice(0, 80),
+        start: String(s.start || '').trim().slice(0, 120),
+        seg: String(s.seg || '').trim().toLowerCase().slice(0, 20),
         characters: Array.isArray(s.characters) ? s.characters.map(String).slice(0, 6) : [],
         scene: String(s.scene || ''),
         props: Array.isArray(s.props) ? s.props.map(String).slice(0, 6) : [],
@@ -4660,35 +5775,27 @@ window.__ModuleLoader__.load({
         source: (meta && meta.source) || 'ai',
         category: (meta && meta.category) || 'script',
       };
-      // 文本资产：0.18 起正文随元数据进 canvas.db（预览/下载不必回读文件）；
-      // JSON 降级落盘 .md 文件；无数据目录降级为仅 IndexedDB。绝不阻塞生成主流程。
-      if (S.dataRoot && S.store === 'sqlite') {
-        try {
-          const proj = S.projects.find((p) => p.id === projectId);
-          const saved = await hostRpc('assetCreate', { asset: assetIndexRecord(rec), projectName: (proj && proj.name) || '' });
-          const out = (saved && saved.asset) || rec;
-          assetMem.set(out.id, out);
-          assetNameCache.set(out.id, out.name);
-          return out;
-        } catch (err) {
-          console.warn('[infinite-canvas] 文本资产入库失败（降级为浏览器存储）:', String((err && err.message) || err));
-        }
-      } else if (S.dataRoot) {
-        try {
-          const rel = `projects/${projectId}/text/${assetFileBase(rec)}.md`;
-          const blob = new Blob([rec.text], { type: 'text/markdown' });
-          const r = await fetch('/' + NS + '/api/asset?rel=' + encodeURIComponent(rel), { method: 'POST', body: blob });
-          if (!r.ok) throw new Error(await r.text());
-          rec.rel = rel;
-          rec.size = blob.size;
-          rec.stored = 'disk';
-        } catch (err) {
-          console.warn('[infinite-canvas] 文本资产落盘失败（降级为浏览器存储）:', String((err && err.message) || err));
-        }
+      // 文本资产：文件（.md）落数据目录的项目文件夹，正文同时进 canvas.db（预览/下载不必回读文件）。
+      // 未设数据目录时明确报错（IndexedDB 已废弃），绝不静默。
+      if (!S.dataRoot) throw new Error('未设置数据根目录：文本资产无法持久化（IndexedDB 已废弃）。请在设置里配置数据根目录。');
+      const rel = `projects/${projectId}/text/${assetFileBase(rec)}.md`;
+      const blob = new Blob([rec.text], { type: 'text/markdown' });
+      const r = await fetch('/' + NS + '/api/asset?rel=' + encodeURIComponent(rel), { method: 'POST', body: blob });
+      if (!r.ok) throw new Error('文本资产落盘失败: ' + (await r.text()));
+      rec.rel = rel;
+      rec.size = blob.size;
+      rec.stored = 'disk';
+      const proj = S.projects.find((p) => p.id === projectId);
+      if (S.store === 'sqlite') {
+        const saved = await hostRpc('assetCreate', { asset: assetIndexRecord(rec), projectName: (proj && proj.name) || '' });
+        const out = (saved && saved.asset) || rec;
+        assetMem.set(out.id, out);
+        assetNameCache.set(out.id, out.name);
+        return out;
       }
       await idbPut(rec);
       assetNameCache.set(rec.id, rec.name);
-      if (S.dataRoot) mirrorAssetIndex(rec); // JSON 降级模式：镜像进 assets.json
+      mirrorAssetIndex(rec); // JSON 降级模式：镜像进 assets.json
       return rec;
     }
 
@@ -4718,6 +5825,8 @@ window.__ModuleLoader__.load({
       updateBusy: false,
       updateMsg: null,
       updateDismissed: false,
+      keysOpen: false,       // 左上角快捷键面板是否展开（纯 UI 状态，不持久化）
+      canvasHost: null,      // 画布当前宿主：'main'（全屏面板）| 'pane'（会话右栏页签）| null——同一时刻只允许一处实例
     };
     const listeners = new Set();
     let saveTimer = null;
@@ -4774,9 +5883,16 @@ window.__ModuleLoader__.load({
     }
     function initStore() {
       S.projects = lsGet(LS_PROJECTS, []);
-      if (!Array.isArray(S.projects) || S.projects.length === 0) {
-        S.projects = [{ id: uid('p'), name: T('defaultProject'), createdAt: Date.now(), updatedAt: Date.now() }];
-        lsSet(LS_PROJECTS, S.projects);
+      if (!Array.isArray(S.projects)) S.projects = [];
+      // OBS-UI-1：不再自动创建「我的画布」空项目——干净客户端每次打开面板都会
+      // 经 pushAllProjectsToHost 把它写进 canvas.db（QA 实测 13→14 持续累积）。
+      // 空列表 = 空态：画布显示"新建项目"引导，用户显式点击才真正建项目。
+      if (S.projects.length === 0) {
+        S.activeId = null;
+        S.graph = emptyGraph();
+        V.x = 60; V.y = 40; V.scale = 1;
+        S.ready = true;
+        return;
       }
       const active = lsGet(LS_ACTIVE, null);
       S.activeId = S.projects.some((p) => p.id === active) ? active : S.projects[0].id;
@@ -5170,6 +6286,8 @@ window.__ModuleLoader__.load({
     function servedAssetId(src, fromPort) {
       if (!src || !src.data) return null;
       if (fromPort === 'last') return src.data.lastAssetId || null;
+      // tailpick = 尾帧「最佳选帧」（续帧接力首选：动作进行中/清晰/不抖）
+      if (fromPort === 'tailpick') return src.data.lastPickAssetId || src.data.lastAssetId || null;
       return src.data.assetId || null;
     }
     async function resolveAssetBlob(nodeId, portId) {
@@ -5324,7 +6442,7 @@ window.__ModuleLoader__.load({
       flushSave();
       try {
         const prev = prevSceneTail(n); // 场 N-1 的尾镜 → 作为本场第 1 镜的硬性承接约束
-        const shots = await aiStoryboardShots(st, n.data.requirement, n.data.count || 6, n.data.model, (kind, d) => aiStreamAppend(n.id, kind, d), prev);
+        const shots = await aiStoryboardShots(st, n.data.requirement, n.data.count || 6, n.data.model, (kind, d) => aiStreamAppend(n.id, kind, d), prev, { cont: n.data.cont !== false });
         // 未闭合引用自愈：句尾丢闭合 @ 的引用按设定集名补全（否则参考图静默丢失）
         const _known = bibleNames(loadBible(S.activeId));
         for (const sh of shots) {
@@ -5377,21 +6495,36 @@ window.__ModuleLoader__.load({
         return v != null ? v : defSub;
       };
       const metas = [];
+      const skipped = []; // 被跳过的片段必须让用户看见：静默少段 = 用户以为全片都合进去了
       for (const x of segs) {
-        if (!x.nd.data.assetId) continue;
+        const segName = String((x.nd.data && x.nd.data.label) || TYPE_LABEL()[x.nd.type] || '片段');
+        if (!x.nd.data.assetId) { skipped.push(segName + '（还没有生成结果）'); continue; }
         try {
           const rec = await idbGet(x.nd.data.assetId);
           const blob = await assetBlob(x.nd.data.assetId);
-          if (blob) {
-            const ttsId = n.data.tts && n.data.tts[x.e.id] && n.data.tts[x.e.id].assetId;
-            const ttsUrl = ttsId ? await assetUrl(ttsId) : null;
-            // 分镜的编辑时长（1-3s 级）作为成片裁剪依据：API 生成的片段偏长，成片时裁到分镜时长
-            const editDur = Number(x.nd.data.editDuration) || null;
-            metas.push({ url: URL.createObjectURL(blob), name: (rec && rec.name) || 'seg', sub: getSub(x), ttsUrl, dur: editDur || undefined });
-          }
-        } catch { /* 跳过加载失败的片段 */ }
+          if (!blob) { skipped.push(segName + '（资产读不到，可能是文件已被删除）'); continue; }
+          if (!blob.size) { skipped.push(segName + '（资产为空文件）'); continue; }
+          const ttsId = n.data.tts && n.data.tts[x.e.id] && n.data.tts[x.e.id].assetId;
+          const ttsUrl = ttsId ? await assetUrl(ttsId) : null;
+          // 分镜的编辑时长（1-3s 级）作为成片裁剪依据：API 生成的片段偏长，成片时裁到分镜时长
+          const editDur = Number(x.nd.data.editDuration) || null;
+          metas.push({ url: URL.createObjectURL(blob), name: (rec && rec.name) || 'seg', sub: getSub(x), ttsUrl, dur: editDur || undefined });
+        } catch (e) {
+          skipped.push(segName + '（读取失败：' + String((e && e.message) || e) + '）');
+        }
+      }
+      if (!metas.length) {
+        throw new Error(skipped.length
+          ? ('没有可合成的片段——' + skipped.join('；'))
+          : T('noSegments'));
+      }
+      if (skipped.length) {
+        // 不阻断合成，但必须在节点上留痕（否则"少了一段"会被当成 bug 却查不到原因）
+        update((s) => {
+          const nd = s.graph.nodes[n.id];
+          if (nd) nd.data.genWarn = '已跳过 ' + skipped.length + ' 个片段：' + skipped.join('；');
+        });
       }
-      if (!metas.length) throw new Error(T('noSegments'));
       update((s) => { const nd = s.graph.nodes[n.id]; if (nd) { nd.data.status = 'running'; nd.data.error = null; nd.data.progress = '0%'; } });
       flushSave();
       try {
@@ -5431,9 +6564,20 @@ window.__ModuleLoader__.load({
       const ctl = new AbortController();
       genAbort.ctl = ctl;
       genActive++;
+      // 生成告警收集器：参考素材截断、厂商参数落空等"需要用户知道"的事实，一律挂到节点上（绝不静默）
+      const addWarn = (msg) => {
+        if (!msg) return;
+        update((s) => {
+          const nd = s.graph.nodes[n.id];
+          if (!nd) return;
+          const prev = String(nd.data.genWarn || '').trim();
+          if (prev.includes(msg)) return;
+          nd.data.genWarn = prev ? (prev + '；' + msg) : String(msg);
+        });
+      };
       update((s) => {
         const nd = s.graph.nodes[n.id];
-        if (nd) { nd.data.status = 'running'; nd.data.error = null; nd.data.stopNote = null; }
+        if (nd) { nd.data.status = 'running'; nd.data.error = null; nd.data.stopNote = null; nd.data.genWarn = null; }
         s.running = true; // 单节点触发（对话/节点按钮）也显示停止按钮
       });
       flushSave(); // 立刻落盘 + 推送 Host：切走画面/对话查询都能看到"运行中"
@@ -5455,7 +6599,7 @@ window.__ModuleLoader__.load({
           // 模型解析：节点选择优先，未指定路由到星标默认模型；都没有 = 明确报错（不再静默走演示模式）
           const mcfg = resolveImageModelCfg(settings, nodeImageModelRef(n));
           if (!mcfg) throw new Error(T('errNoImageModel'));
-          const blob = await apiImage(p, metas, mcfg, { size: n.data.size, ratio: n.data.ratio, nodeExtra: n.data.imgExtra });
+          const blob = await apiImage(p, metas, mcfg, { size: n.data.size, ratio: n.data.ratio, nodeExtra: n.data.imgExtra, warn: addWarn });
           const rec = await saveAssetRecord(S.activeId, 'image', blob, {
             name: assetNameFor(n, entities, 'image'),
             prompt: stripMentionMarks(prompt), effectivePrompt: p,
@@ -5468,17 +6612,115 @@ window.__ModuleLoader__.load({
           });
           commitGenResult(n.id, rec.id, false, 'image');
         } else {
-          const frameBlob = await resolveAssetBlob(n.id, 'frame');
           const { refs, entities, audioBlobs } = await collectRefs(n, prompt, bible);
-          const p = buildEffectivePrompt(prompt, refs, entities, bible);
+          // 上游是分镜表 → 走厂商「参考生成」结构化提示词（主体/分镜/台词/声音显式绑定，音画同步；
+          // 机械拼装会让模型把台词与场景判错）；节点上已手写结构化提示词则原样尊重。
+          const sbUp = (() => {
+            const e2 = S.graph.edges.find((x) => x.toNode === n.id && x.toPort === 'prompt');
+            const src = e2 && S.graph.nodes[e2.fromNode];
+            return src && src.type === 'storyboard' ? src : null;
+          })();
+          const shotList = sbUp && Array.isArray(sbUp.data.shots) ? sbUp.data.shots : [];
+          const handWritten = String(n.data.prompt || '').trim();
+          // 分镜衔接规划：段落类型（续帧/换场/新角色/特写插入）+ 首镜承接口 + 是否接力尾帧
+          const zh = effLang() !== 'en';
+          const plan = (() => {
+            if (!shotList.length) return { first: null, chain: false, join: 'loose', seg: 'opening', fromShot: false };
+            const first = shotContinuityPlan(shotList[0], null, 0);
+            // 分镜衔接总开关（分镜表 cont）：关掉 = 不做跨段承接、不自动取尾帧、不写衔接块
+            const contOn = sbUp ? sbUp.data.cont !== false : true;
+            // 跨分镜表承接：上游分镜表「衔接上一镜」输入口 ← 上一个分镜表「尾镜」输出口
+            const prevSb = (() => {
+              const e2 = S.graph.edges.find((x) => x.toNode === (sbUp && sbUp.id) && x.toPort === 'prev');
+              const src = e2 && S.graph.nodes[e2.fromNode];
+              return src && src.type === 'storyboard' ? src : null;
+            })();
+            const prevNote = prevSb ? storyboardContinuityNote(prevSb.data.shots || [], String(prevSb.data.label || ''), zh) : null;
+            let seg = first.seg;
+            // 第 1 镜没有表内上一镜时，可承接上一个分镜表 → 实质是续帧
+            if (seg === 'opening' && prevNote) seg = 'continuation';
+            const join = (seg === 'scene_change' || seg === 'new_character') ? 'loose' : seg === 'closeup' ? 'cut' : 'strict';
+            // 只有续帧段才自动取上一段尾帧；其余段落没有可承接的画面
+            const chain = contOn && seg === 'continuation';
+            return { first, chain, seg, join, fromShot: contOn && !!prevNote, contOn };
+          })();
+          // 首帧来源：① frame 口连线（用户显式）② 续帧链自动取「上一个视频」的尾帧
+          let frameBlob = await resolveAssetBlob(n.id, 'frame');
+          let frameAuto = false;
+          if (!frameBlob && plan.chain) {
+            const prevVid = autoPrevVideoNode(n);
+            if (prevVid && prevVid.data.assetId) {
+              try {
+                const vb = await assetBlob(prevVid.data.assetId);
+                if (vb) {
+                  // 优先复用它已选好的最佳尾帧（避免重复解码整段视频）；没有再现场选帧
+                  if (prevVid.data.lastPickAssetId && prevVid.data.lastAssetVideo === prevVid.data.assetId) {
+                    frameBlob = await assetBlob(prevVid.data.lastPickAssetId).catch(() => null);
+                  }
+                  if (!frameBlob) {
+                    const tail = await extractTailFrames(vb, { count: 9, span: 0.8 }).catch(() => null);
+                    frameBlob = (tail && (tail.best || tail.last)) || null;
+                  }
+                  if (frameBlob) {
+                    frameAuto = true;
+                    addWarn('已自动取「' + String(prevVid.data.label || '上一段视频') + '」的尾帧作为本段首帧（续帧接力）');
+                  }
+                }
+              } catch { /* 取不到尾帧则降级为纯参考图生成 */ }
+            }
+          }
+          const frameMode = n.data.frameMode || 'auto';
+          const useFrame = frameMode !== 'off' && !!frameBlob;
+          // 硬首帧只在"不挂实体参考图"时可用（多数厂商 first_frame 与 reference_image 互斥）；
+          // 续帧段若还要实体参考图 → 尾帧降级为首张参考图 + 软锚定（frameAnchorText 会写明）
+          const hardFrame = useFrame && frameMode === 'hard';
+          const anchorRole = (useFrame && !hardFrame && refs.length) ? 'reference_image' : 'first_frame';
+          let music = '';
+          try { const ex2 = parseExtraParams(n.data.vidExtra); if (ex2 && typeof ex2.music === 'string') music = ex2.music; } catch { /* 扩展参数非法时忽略音乐提示 */ }
+          // 跨段承接说明：本分镜第 1 镜承接上一个分镜表尾镜（续帧时首帧图已带画面，这里补文字约束）
+          const continuity = (() => {
+            if (!plan.fromShot) return '';
+            const st = shotList[0] || {};
+            const tail = String(st.tail || '').trim();
+            const bits = [];
+            if (plan.seg === 'continuation') {
+              bits.push(zh ? '本段是上一段的直接续帧：第 1 帧从上一段结尾接着演，不重演、不重新建立场景、不切换机位' : 'This segment continues the previous one: start from its last frame, no replay, no re-establishing, no camera reset');
+              if (tail) bits.push((zh ? '起始状态：' : 'Start state: ') + tail);
+            } else if (plan.seg === 'scene_change') {
+              bits.push(zh ? '本段换场：不承接上一段画面，但环境声/情绪可延续' : 'Scene change: do not continue the previous frame; ambience and mood may carry over');
+            } else if (plan.seg === 'new_character') {
+              bits.push(zh ? '本段有新角色入场：新角色必须从画面内自然进入（走入/被带入），不得凭空出现' : 'A new character enters: they must enter naturally from within the frame, never pop in');
+            }
+            return bits.join(zh ? '；' : '; ');
+          })();
+          let p;
+          // 图1=尾帧（降级模式）时实体参考图为图2..N+1：两条提示词组装路径都要同步偏移
+          const effOpts = { picOffset: (useFrame && anchorRole === 'reference_image') ? 1 : 0 };
+          if (handWritten.includes('subject_definitions')) {
+            p = handWritten; // 高级用法：手写结构化提示词，原样发送
+          } else if (shotList.length) {
+            p = buildStructuredVideoPrompt(shotList, refs, bible, {
+              zh, prompt: handWritten, music, hasFrame: useFrame, frameRole: anchorRole, continuity,
+            });
+            if (!p) p = buildEffectivePrompt(prompt, refs, entities, bible, false, effOpts); // 无参考图时回退
+          } else {
+            p = buildEffectivePrompt(prompt, refs, entities, bible, false, effOpts);
+          }
+          // 非结构化路径（无参考图/手写提示词）也要有首帧锚定与承接说明
+          if (!shotList.length || !p.includes('subject_definitions')) {
+            const pre = [frameAnchorText({ hasFrame: useFrame, role: anchorRole, zh }), continuity].filter(Boolean).join(zh ? '；' : '; ');
+            if (pre) p = pre + '\n' + p;
+          }
           const mcfg = resolveVideoModelCfg(settings, nodeVideoModelRef(n));
           if (!mcfg) throw new Error(T('errNoVideoModel'));
-          const blob = await apiVideo(p, frameBlob, mcfg, {
+          const blob = await apiVideo(p, useFrame ? frameBlob : null, mcfg, {
             duration: n.data.duration, resolution: n.data.resolution, ratio: n.data.ratio,
-            frameMode: n.data.frameMode || 'auto', // auto=尾帧降级为参考图 / hard=硬首帧（放弃参考图） / off=忽略首帧
+            frameMode, // auto=尾帧降级为参考图（保留实体参考图）/ hard=硬首帧（放弃参考图）/ off=忽略首帧
+            hardFrame,
             refs: refs.map((r) => r.blob),
             refNames: refs.map((r) => r.entity || r.name || ''), // 跨镜衔接标注用（图2..N 的实体名）
             nodeExtra: n.data.vidExtra, // 节点级扩展参数（手动参数框，如 {"use_context_ir":true}）
+            warn: addWarn, // 参考素材超限等告警回传（节点上可见）
             // 任务提交成功即持久化 task id：轮询中断/页面关闭后仍可凭 id 回查结果（钱花了就必须能找回）
             onTask: (tid, qurl) => {
               update((s) => { const nd = s.graph.nodes[n.id]; if (nd) { nd.data.taskId = String(tid || ''); nd.data.taskQueryUrl = String(qurl || ''); } });
@@ -5495,6 +6737,13 @@ window.__ModuleLoader__.load({
             nodeLabel: (n.data && n.data.label) || '',
             category: 'finalcut', // 节点生成的视频 = 成片（实体归属由 entities 字段承担，不占用分类）
           });
+          // 记录续帧来源（节点上可追溯：本段是从哪一段接过来的）
+          if (useFrame) {
+            update((s) => {
+              const nd = s.graph.nodes[n.id];
+              if (nd) { nd.data.chainFrom = frameAuto ? (autoPrevVideoNode(n) || {}).id || null : 'wired'; }
+            });
+          }
           commitGenResult(n.id, rec.id, false, 'video');
           // 实测结果与设置不一致时留可见提示（厂商忽略 size/duration 是常见情况，必须让人看见而不是静默）
           try {
@@ -5507,22 +6756,55 @@ window.__ModuleLoader__.load({
               else if (wantRatio === '9:16' && gotLandscape) notes.push('厂商返回 ' + meta.w + '×' + meta.h + '（横屏），与设置的 9:16 不符');
               const wantDur = Number(n.data && n.data.duration) || 0;
               if (wantDur && meta.d && Math.abs(meta.d - wantDur) > 1.5) notes.push('实际时长 ' + meta.d.toFixed(1) + 's ≠ 设置 ' + wantDur + 's（厂商单次上限或已钳制）');
-              if (notes.length) update((s) => { const nd = s.graph.nodes[n.id]; if (nd) nd.data.genWarn = notes.join('；'); });
+              if (notes.length) addWarn(notes.join('；')); // 追加而非覆盖：本轮更早的告警（自动续帧/参考图超限/厂商降级）不能被抹掉
             }
           } catch { /* 探测失败不影响生成 */ }
-          // 尾帧提取（通用）：供 last 端口输出与链式下一镜使用
+          // 尾帧抽取（续帧接力的关键）：末段多帧候选里选「动作进行中/清晰/不抖」的一帧，
+          // 而不是机械取最后一帧（最后一帧常在动作顶点/模糊/抖动上）。
           try {
-            const fBlob = await extractLastFrame(blob);
-            const fRec = await saveAssetRecord(S.activeId, 'image', fBlob, {
-              name: T('lastFrame') + '-' + (n.data.label || n.id.slice(-4)),
-              prompt: 'last frame of ' + prompt.slice(0, 60), source: 'api', category: 'image',
-            });
-            update((s) => {
-              const nd = s.graph.nodes[n.id];
-              if (nd) { nd.data.lastAssetId = fRec.id; nd.data.lastAssetVideo = rec.id; }
-              s.assetsTick++;
-            });
+            const tail = await extractTailFrames(blob, { count: 9, span: 0.8 });
+            if (tail && tail.last) {
+              const fRec = await saveAssetRecord(S.activeId, 'image', tail.last, {
+                name: T('lastFrame') + '-' + (n.data.label || n.id.slice(-4)),
+                prompt: 'last frame of ' + prompt.slice(0, 60), source: 'api', category: 'image',
+              });
+              // 最佳选帧单独存一份（last 口保持"真·最后一帧"语义，接力用"最佳帧"）
+              let pickRec = null;
+              if (tail.best && tail.best !== tail.last) {
+                pickRec = await saveAssetRecord(S.activeId, 'image', tail.best, {
+                  name: T('tailPick') + '-' + (n.data.label || n.id.slice(-4)),
+                  prompt: 'continuity tail pick t=' + Number(tail.bestT || 0).toFixed(2) + 's; ' + prompt.slice(0, 40),
+                  source: 'api', category: 'image',
+                });
+              }
+              update((s) => {
+                const nd = s.graph.nodes[n.id];
+                if (nd) {
+                  nd.data.lastAssetId = fRec.id; nd.data.lastAssetVideo = rec.id;
+                  nd.data.lastPickAssetId = pickRec ? pickRec.id : fRec.id;
+                  nd.data.tailPickMeta = { t: Number(tail.bestT || 0), score: Math.round((tail.bestScore || 0) * 100) / 100 };
+                }
+                s.assetsTick++;
+              });
+            }
           } catch { /* 尾帧提取失败不影响主流程 */ }
+          // 接缝校验：本段首帧 vs 上一段尾帧（续帧段才有意义）。不达标 → 节点上可见告警（不静默）
+          if (useFrame && plan.chain) {
+            try {
+              const first = await extractFirstFrame(blob);
+              if (first) {
+                const ga = await grayThumb(frameBlob, 32);
+                const gb = await grayThumb(first, 32);
+                const met = frameSeamMetrics(ga, gb);
+                const v = seamVerdict(met, plan.join);
+                update((s) => {
+                  const nd = s.graph.nodes[n.id];
+                  if (nd) nd.data.seam = { ok: v.ok, sim: v.sim == null ? null : Math.round(v.sim * 100) / 100, thr: v.thr, note: v.note, at: Date.now() };
+                });
+                if (!v.ok) addWarn('接缝校验未通过：' + v.note + '（建议：调低运动幅度重生成，或改用"硬首帧"模式）');
+              }
+            } catch { /* 校验失败不影响产物 */ }
+          }
         }
         return true;
       } catch (err) {
@@ -5618,7 +6900,9 @@ window.__ModuleLoader__.load({
     // ============================================================
     // 画布交互（平移 / 缩放 / 拖动 / 连线 / 框选）
     // ============================================================
-    const drag = { mode: null, sx: 0, sy: 0, moved: false, nodeStarts: null, marquee: null, linkFrom: null, shift: false };
+    // altNoPush：本次拖动是否处于「按住 Alt 自由摆放」模式（不推挤邻居、也不吸附加固）。
+    // 注意每次 pointermove 都重新读 e.altKey，所以拖动中途按下/松开 Alt 会实时切换。
+    const drag = { mode: null, sx: 0, sy: 0, moved: false, nodeStarts: null, marquee: null, linkFrom: null, shift: false, altNoPush: false };
 
     function onCanvasPointerDown(e) {
       const target = e.target;
@@ -5673,6 +6957,7 @@ window.__ModuleLoader__.load({
       drag.mode = 'node';
       drag.sx = e.clientX; drag.sy = e.clientY;
       drag.moved = false;
+      drag.altNoPush = !!e.altKey; // 起手就按住 Alt → 整段拖动自由摆放
       const ids = S.sel.has(n.id) ? [...S.sel] : [n.id];
       // 分组拖动时携带其成员
       const allIds = [];
@@ -5726,10 +7011,15 @@ window.__ModuleLoader__.load({
       } else if (drag.mode === 'node') {
         if (Math.abs(dxs) + Math.abs(dys) > 2) drag.moved = true;
         let dxw = dxs / V.scale, dyw = dys / V.scale;
+        // 按住 Alt = 自由摆放：跳过对齐吸附 + 跳过碰撞推挤（允许穿过/覆盖其他节点）。
+        // 典型场景：矩阵布局里挪中间的节点，普通拖动会把整片邻居推开打乱布局，Alt 拖动只挪它自己。
+        // 实时读 e.altKey（而不是只看起手那一刻）：拖动途中按下/松开立即生效。
+        const noPush = !!e.altKey;
+        drag.altNoPush = noPush;
         // 对齐吸附：以首个拖动节点为基准，与其他节点左/中/右、上/中/下对齐（容差 6px）
         const prim = drag.nodeStarts[0];
         const ndP = prim && S.graph.nodes[prim.id];
-        if (ndP && !e.shiftKey && drag.nodeStarts.length) {
+        if (ndP && !e.shiftKey && !noPush && drag.nodeStarts.length) {
           const snap = 6 / V.scale;
           const ph = ndP.h || 96;
           const px = prim.x + dxw, py = prim.y + dyw;
@@ -5751,6 +7041,15 @@ window.__ModuleLoader__.load({
           if (bestV) dxw += bestV.delta;
           if (bestH) dyw += bestH.delta;
           showGuides(bestV ? bestV.line : null, bestH ? bestH.line : null);
+        } else if (noPush) {
+          hideGuides(); // Alt 自由摆放：吸附线一并隐藏，避免"看着被吸住其实没吸"
+        }
+        // Alt 自由摆放的可见反馈：被拖节点加虚线轮廓，用户能立刻分清"现在没在推挤"
+        for (const st of drag.nodeStarts) {
+          const el = nodeEls.get(st.id);
+          if (!el) continue;
+          if (noPush) el.classList.add('is-free-drag');
+          else el.classList.remove('is-free-drag');
         }
         const movedIds = new Set();
         for (const st of drag.nodeStarts) {
@@ -5765,7 +7064,9 @@ window.__ModuleLoader__.load({
         }
         // —— 实时碰撞推挤（物理感）：拖动节点碰到谁，谁沿远离方向实时让位；被推者再推别人（级联）。
         //    上下左右同理：下节点上移碰到上节点 → 上节点实时上移；全程无弹跳，松手即定格。
-        resolvePushNow(movedIds);
+        //    按住 Alt 时**整段禁用**（不推挤 = 允许覆盖穿过），松手后位置照旧保留，不会弹回。
+        if (!noPush) resolvePushNow(movedIds);
+
         if (movedIds.size) {
           for (const e2 of S.graph.edges) {
             if (!movedIds.has(e2.fromNode) && !movedIds.has(e2.toNode)) continue;
@@ -5794,6 +7095,14 @@ window.__ModuleLoader__.load({
     function onCanvasPointerUp(e) {
       if (!drag.mode) return;
       const mode = drag.mode;
+      // 收尾：清掉 Alt 自由摆放的视觉标记（无论是否发生过移动，避免虚线轮廓残留在节点上）
+      if (mode === 'node') {
+        for (const st of (drag.nodeStarts || [])) {
+          const el = nodeEls.get(st.id);
+          if (el) el.classList.remove('is-free-drag');
+        }
+        drag.altNoPush = false;
+      }
       if (mode === 'node' && drag.moved) {
         // 拖动期间直接写了模型坐标，这里只需通知 + 保存
         notify();
@@ -6294,7 +7603,7 @@ window.__ModuleLoader__.load({
     function portLabel(pid) {
       const map = {
         prompt: T('portPrompt'), ref: T('portRef'), frame: T('portFrame'),
-        in: T('portIn'), out: T('portOut'), last: T('lastFrame'),
+        in: T('portIn'), out: T('portOut'), last: T('lastFrame'), tailpick: T('tailPick'),
         char: T('portChar'), scene: T('portScene'), prop: T('portProp'),
         visual: T('portVisual'), motion: T('portMotion'), script: T('portScript'),
         prev: T('portPrev'), tail: T('portTail'),
@@ -6744,7 +8053,9 @@ window.__ModuleLoader__.load({
           ? h('div', { key: 'ref', className: 'dshic-hint' },
               T('portFrame') + ' × ' + refEdges.length + ' · ' + T('connected'))
           : null,
-        kind === 'video' && S.graph.edges.some((x) => x.toNode === n.id && x.toPort === 'frame')
+        // 「衔接」下拉：视频节点**始终**显示——自动续帧（无 frame 线）也需要它来关闭接力或改硬首帧。
+        // 若有 frame 连线则额外说明连线数量。
+        kind === 'video'
           ? h('div', { key: 'fmode', className: 'dshic-node-row' },
               h('span', { className: 'dshic-shot-label', style: { flex: 'none' } }, T('frameModeLabel')),
               h('select', {
@@ -6764,6 +8075,23 @@ window.__ModuleLoader__.load({
         n.data.genWarn ? h('div', { key: 'gw', className: 'dshic-hint', style: { color: 'var(--dsw-alias-state-warning-primary, #d08700)' } }, '⚠ ' + n.data.genWarn) : null,
         n.data.stopNote ? h('div', { key: 'sn', className: 'dshic-hint' }, '⏹ ' + n.data.stopNote) : null,
         n.data.error ? h('div', { key: 'err', className: 'dshic-err' }, n.data.error) : null,
+        // 续帧状态：本段首帧来自哪里（上一段尾帧 / 连线）+ 接缝校验结果（不达标必须让人看见）
+        kind === 'video' && (n.data.chainFrom || n.data.seam)
+          ? h('div', { key: 'chain', className: 'dshic-hint', style: { display: 'flex', gap: 6, flexWrap: 'wrap', alignItems: 'center' } },
+              n.data.chainFrom
+                ? h('span', { title: T('chainInfo') }, '🔗 ' + (n.data.chainFrom === 'wired' ? T('chainManual') : T('chainAuto')))
+                : null,
+              n.data.seam
+                ? h('span', {
+                    title: T('seamHint'),
+                    style: { color: n.data.seam.ok ? 'var(--dsw-alias-state-success-primary, #2f9e44)' : 'var(--dsw-alias-state-warning-primary, #d08700)' },
+                  }, (n.data.seam.ok ? '✓ ' : '⚠ ') + (n.data.seam.ok ? T('seamOk') : T('seamFail')) + (n.data.seam.sim != null ? ' ' + n.data.seam.sim : ''))
+                : null,
+              n.data.tailPickMeta
+                ? h('span', { title: T('tailPickHint') }, '✂ ' + T('tailPick') + ' ' + Number(n.data.tailPickMeta.t || 0).toFixed(1) + 's')
+                : null,
+            )
+          : null,
         assetUrlV && kind === 'image'
           ? h('img', { key: 'img', className: 'dshic-preview', src: assetUrlV, draggable: false, 'data-no-drag': '1', style: { cursor: 'zoom-in' }, onPointerDown: (e) => e.stopPropagation(), onClick: (e) => { e.stopPropagation(); openLightbox('image', assetUrlV, n.data.label); } })
           : null,
@@ -6775,7 +8103,7 @@ window.__ModuleLoader__.load({
               h('button', {
                 type: 'button', className: 'dshic-mini is-ghost',
                 onPointerDown: (e) => e.stopPropagation(),
-                onClick: () => downloadBlobFromUrl(assetUrlV, (kind === 'image' ? 'image' : 'video') + '-' + n.id.slice(-5) + (kind === 'image' ? '.png' : '.webm')),
+                onClick: async () => downloadBlobFromUrl(assetUrlV, await downloadNameForAsset(n.data.assetId, (kind === 'image' ? 'image' : 'video') + '-' + n.id.slice(-5), kind)),
               }, Ic('download', 11), T('download')),
               h('button', {
                 type: 'button', className: 'dshic-mini is-ghost', disabled: S.running || n.data.status === 'running',
@@ -7251,23 +8579,6 @@ window.__ModuleLoader__.load({
           ? h('div', { key: 'stream', className: 'dshic-stream', title: aiStreamLine(n.id) },
               h('span', { className: 'dshic-stream-dot' }), aiStreamLine(n.id))
           : null,
-        h('div', { key: 'btns', className: 'dshic-node-row' },
-          h('div', { className: 'dshic-flex' }),
-          n.data.output ? h('button', {
-            type: 'button', className: 'dshic-mini is-ghost', title: T('expandScenes') + '（每场 → 文本+分镜表 组合）',
-            onPointerDown: (e) => e.stopPropagation(),
-            onClick: () => expandScriptToScenes(n),
-          }, Ic('expandAll', 11), T('expandScenes')) : null,
-          n.data.output ? h('button', {
-            type: 'button', className: 'dshic-mini is-ghost', title: T('saveTextAsset'),
-            onPointerDown: (e) => e.stopPropagation(),
-            onClick: async () => {
-              await saveTextAssetRecord(S.activeId, { name: (String(n.data.label || '').trim() || T('scriptAssetPrefix')) + ' ' + nowStamp(), text: n.data.output, category: 'script', prompt: n.data.idea });
-              update((s) => { s.assetsTick++; });
-              toast(T('savedOk'));
-            },
-          }, Ic('download', 11), T('saveTextAsset')) : null,
-        ),
         n.data.aiError ? h('div', { key: 'err', className: 'dshic-err' }, n.data.aiError) : null,
         h('span', { key: 'l2', className: 'dshic-shot-label' }, T('scriptOutputLabel')),
         h(PromptArea, {
@@ -7276,6 +8587,26 @@ window.__ModuleLoader__.load({
           placeholder: running ? T('aiRunning') : '',
           onChange: (v) => update((s) => { const nd = s.graph.nodes[n.id]; if (nd) nd.data.output = v; }),
         }),
+        // 结果相关操作放节点末尾左下角（与分镜节点同一规范：内容之后 + alignSelf:flex-start）——
+        // 这些按钮作用于「已经生成出来的剧本」，不该夹在生成按钮与输出正文之间。
+        n.data.output
+          ? h('div', { key: 'acts', className: 'dshic-node-row', style: { alignSelf: 'flex-start' } },
+              h('button', {
+                type: 'button', className: 'dshic-mini is-ghost', title: T('saveTextAsset'),
+                onPointerDown: (e) => e.stopPropagation(),
+                onClick: async () => {
+                  await saveTextAssetRecord(S.activeId, { name: (String(n.data.label || '').trim() || T('scriptAssetPrefix')) + ' ' + nowStamp(), text: n.data.output, category: 'script', prompt: n.data.idea });
+                  update((s) => { s.assetsTick++; });
+                  toast(T('savedOk'));
+                },
+              }, Ic('download', 11), T('saveTextAsset')),
+              h('button', {
+                type: 'button', className: 'dshic-mini', title: T('expandScenes') + '（每场 → 文本+分镜表 组合）',
+                onPointerDown: (e) => e.stopPropagation(),
+                onClick: () => expandScriptToScenes(n),
+              }, Ic('expandAll', 11), T('expandScenes')),
+            )
+          : null,
       ];
     }
 
@@ -7335,6 +8666,18 @@ window.__ModuleLoader__.load({
         try { await genStoryboardNode(n); } catch (e) { toast(String((e && e.message) || e)); }
       };
       const shots = n.data.shots || [];
+      // 一致性告警的手动重校验：告警是**生成时刻**算的，之后补全设定集不会让它们自动消失——
+      // 点刷新按当前设定集重算（checkShotConsistency 读的是实时 bible/资产名索引）
+      const [wvChecking, setWvChecking] = useState(false);
+      const revalidate = async () => {
+        if (wvChecking || !shots.length) return;
+        setWvChecking(true);
+        try {
+          const warnings = await checkShotConsistency(shots);
+          update((s) => { const nd = s.graph.nodes[n.id]; if (nd) nd.data.warnings = warnings; });
+        } catch { /* 校验失败保留旧告警 */ }
+        setWvChecking(false);
+      };
       return [
         h('div', { key: 'mrow', className: 'dshic-node-row' },
           h(ModelSelect, { value: n.data.model, title: T('llmLabel'), onChange: (v) => update((s) => { const nd = s.graph.nodes[n.id]; if (nd) nd.data.model = v; }) }),
@@ -7359,6 +8702,14 @@ window.__ModuleLoader__.load({
             options: [{ value: '0', label: T('autoShots') }].concat([3, 4, 6, 8, 10, 12, 16].map((x) => ({ value: String(x), label: x + ' ' + T('shotsUnit') }))),
             onChange: (v) => update((s) => { const nd = s.graph.nodes[n.id]; if (nd) nd.data.count = Number(v); }),
           }),
+          // 分镜衔接：写作时强制每镜带「承接上镜尾态 / 接点尾态 / 运镜延续」，并可标记段落类型
+          h('button', {
+            key: 'cont', type: 'button',
+            className: 'dshic-mini' + (n.data.cont !== false ? '' : ' is-ghost'),
+            title: T('contToggleHint'),
+            onPointerDown: (e) => e.stopPropagation(),
+            onClick: () => update((s) => { const nd = s.graph.nodes[n.id]; if (nd) nd.data.cont = nd.data.cont === false; }),
+          }, (n.data.cont !== false ? '✓ ' : '') + T('contToggle')),
           h('div', { className: 'dshic-flex' }),
         ),
         h('button', { key: 'gen', type: 'button', className: 'dshic-gen', disabled: running, onClick: generate, onPointerDown: (e) => e.stopPropagation() },
@@ -7373,22 +8724,43 @@ window.__ModuleLoader__.load({
         n.data.aiError ? h('div', { key: 'err', className: 'dshic-err' }, n.data.aiError) : null,
         (n.data.warnings || []).length
           ? h('div', { key: 'warn', className: 'dshic-card', style: { padding: 6, gap: 3 } },
-              h('div', { className: 'dshic-shot-label' }, T('consistencyTitle')),
+              h('div', { key: 'thead', className: 'dshic-node-row', style: { gap: 6 } },
+                h('div', { className: 'dshic-shot-label', style: { flex: 1, minWidth: 0 } }, T('consistencyTitle')),
+                // 手动重校验：生成时刻的告警在设定集补全后不会自动变绿——点一下按**当前**设定集重算
+                h('button', {
+                  type: 'button', className: 'dshic-mini is-ghost', title: T('refreshCheckHint'),
+                  disabled: wvChecking,
+                  onPointerDown: (e) => e.stopPropagation(),
+                  onClick: revalidate,
+                }, wvChecking ? h('span', { className: 'dshic-spin' }) : '↻', T('refreshCheck')),
+              ),
               n.data.warnings.map((w, i) => h('div', { key: i, className: 'dshic-err', style: { color: 'var(--dsw-alias-state-warn-primary)' } }, '· ' + w)),
             )
           : null,
         shots.length
           ? h('div', { key: 'listwrap', style: { position: 'relative', alignSelf: 'stretch' } },
               h('div', { key: 'list', className: 'dshic-shot-list', style: { maxHeight: listH + 'px' } },
-                shots.map((sh, i) => h('div', { key: i, className: 'dshic-shot-item', onPointerDown: (e) => e.stopPropagation() },
+                shots.map((sh, i) => {
+                  const pl = shotContinuityPlan(sh, shots[i - 1], i);
+                  return h('div', { key: i, className: 'dshic-shot-item', onPointerDown: (e) => e.stopPropagation() },
                   h('strong', {}, `${sh.title} · ${sh.duration}s `), ...mentionNodes(sh.visual),
+                  pl.seg !== 'continuation'
+                    ? h('div', { className: 'dshic-shot-label', style: { marginTop: 2, opacity: 0.9 } }, '〔' + T('seg' + pl.seg.charAt(0).toUpperCase() + pl.seg.slice(1)) + '〕')
+                    : null,
+                  String(sh.tail || '').trim()
+                    ? h('div', { className: 'dshic-shot-label', style: { marginTop: 2, opacity: 0.9 } }, '↳ ' + T('shotTail') + '：' + String(sh.tail).trim())
+                    : null,
+                  String(sh.cam || '').trim()
+                    ? h('div', { className: 'dshic-shot-label', style: { marginTop: 2, opacity: 0.85 } }, '🎥 ' + String(sh.cam).trim())
+                    : null,
                   (sh.dialogue || []).length
                     ? h('div', { className: 'dshic-shot-label', style: { marginTop: 3 } }, '台词 ' + sh.dialogue.map((d) => `${d.role}：${d.line}`).join('；'))
                     : null,
                   String(sh.sfx || '').trim()
                     ? h('div', { className: 'dshic-shot-label', style: { marginTop: 2, opacity: 0.85 } }, '音效 ' + String(sh.sfx).trim())
                     : null,
-                )),
+                );
+                }),
               ),
               h('div', { key: 'grip', className: 'dshic-shot-grip', title: T('resizeList'), onPointerDown: startResize }, '⌟'),
             )
@@ -7436,26 +8808,46 @@ window.__ModuleLoader__.load({
       // 项目资产名称索引（用于把角色/场景/道具连接到已有资产节点）
       const recs = await idbByProject(S.activeId).catch(() => []);
       const norm = (s) => String(s || '').trim().toLowerCase();
-      const nameIndex = recs.filter((r) => r.kind === 'image').map((r) => ({ id: r.id, name: norm(r.name), category: r.category }));
-      // 跨镜去重的实体清单：所有镜头共用的角色/场景/道具各一个参考图节点
-      const entityNames = [];
-      const pushName = (nm) => {
+      const nameIndex = recs.filter((r) => r.kind === 'image').map((r) => ({ id: r.id, name: norm(r.name), raw: String(r.name || ''), category: r.category }));
+      // 跨镜去重的实体清单：所有镜头共用的角色/场景/道具各一个参考节点（带品类——决定用哪种设定图版式）
+      const entities = [];
+      const pushEntity = (nm, kind) => {
         const q = String(nm || '').trim();
-        if (q && !entityNames.some((x) => x.toLowerCase() === q.toLowerCase())) entityNames.push(q);
+        if (!q) return;
+        if (entities.some((x) => x.name.toLowerCase() === q.toLowerCase())) return;
+        entities.push({ name: q, kind: kind || 'character' });
       };
       for (const sh of shots) {
-        (sh.characters || []).forEach(pushName);
-        if (sh.scene) pushName(sh.scene);
-        (sh.props || []).forEach(pushName);
+        (sh.characters || []).forEach((nm) => pushEntity(nm, 'character'));
+        pushEntity(sh.scene, 'scene');
+        (sh.props || []).forEach((nm) => pushEntity(nm, 'prop'));
       }
+      const zh = effLang() !== 'en';
+      const bible = loadBible(S.activeId);
+      let reuseAssets = 0; // 资产库已有 → 只挂节点
+      let newGens = 0;     // 库中没有 → 新建带提示词的图片生成节点
       update((s) => {
-        const findAssetNode = (name) => {
+        // 资产库命中（名称相等优先，其次包含匹配）——有图就直接挂资产节点，绝不重复生成
+        const findLibraryAsset = (name) => {
           const q = norm(name);
           if (!q) return null;
-          const hit = nameIndex.find((x) => x.name === q) || nameIndex.find((x) => x.name.includes(q) || q.includes(x.name));
-          if (!hit) return null;
+          return nameIndex.find((x) => x.name === q)
+            || nameIndex.find((x) => x.name.includes(q) || q.includes(x.name))
+            || null;
+        };
+        const findAssetNodeById = (assetId) => {
+          if (!assetId) return null;
           for (const nd of Object.values(s.graph.nodes)) {
-            if (nd.type === 'image-asset' && nd.data.assetId === hit.id) return nd;
+            if (nd.type === 'image-asset' && nd.data.assetId === assetId) return nd;
+          }
+          return null;
+        };
+        // 同标签的图片生成节点（上次铺开已建过）→ 复用，避免每点一次铺开又叠一层
+        const findGenNodeByLabel = (label) => {
+          const q = norm(label);
+          if (!q) return null;
+          for (const nd of Object.values(s.graph.nodes)) {
+            if (nd.type === 'image-gen' && norm(nd.data && nd.data.label) === q) return nd;
           }
           return null;
         };
@@ -7479,18 +8871,46 @@ window.__ModuleLoader__.load({
         const total = shots.reduce((a, sh) => a + Math.max(1, Number(sh.duration) || 3), 0);
         const videoGen = mk('video-gen', baseX + 360, baseY + 20, { prompt: '', duration: Math.max(1, Math.round(total)) });
         const videoAsset = mk('video-asset', baseX + 720, baseY + 20);
-        entityNames.forEach((nm, i) => {
-          let an = findAssetNode(nm);
-          if (!an) an = mk('image-asset', baseX, baseY + i * 130, { placeholderName: nm });
-          linkRaw(an, 'out', videoGen, 'ref');
+        entities.forEach((ent, i) => {
+          const y = baseY + i * 150;
+          const hit = findLibraryAsset(ent.name);
+          if (hit) {
+            let an = findAssetNodeById(hit.id);
+            if (!an) an = mk('image-asset', baseX, y, { assetId: hit.id }, hit.raw || hit.name);
+            linkRaw(an, 'out', videoGen, 'ref');
+            reuseAssets++;
+            return;
+          }
+          // 资产库没有该实体的图：建「图片生成」节点，并按 canvas-craft 资产设定图版式写好提示词
+          //（角色六段式 / 场景主图+环绕小图 / 道具标题+45°主图+细节+侧视+色卡）——生成后自动成为本段参考图
+          const spec = assetSheetNodeSpec(ent.kind, ent.name, bible, zh);
+          let gn = findGenNodeByLabel(spec.label);
+          if (!gn) {
+            gn = mk('image-gen', baseX, y, { prompt: spec.prompt, size: spec.size, ratio: spec.ratio }, spec.label);
+            newGens++;
+          }
+          linkRaw(gn, 'out', videoGen, 'ref');
         });
         linkRaw(n, 'out', videoGen, 'prompt'); // 多镜头提示词来自上游分镜表（不复制文本）
         linkRaw(videoGen, 'out', videoAsset, 'in');
+        // 把「上一段视频」的尾帧接到本段的 frame：铺开时就建好，用户按顺序生成即可自动接力。
+        // 找上一段的规则与 autoPrevVideoNode 一致（同分镜表兄弟段 / 沿 prev 链上溯的上游分镜表所连视频）。
+        (() => {
+          const prevVid = autoPrevVideoNode(videoGen);
+          if (!prevVid || !prevVid.id) return;
+          const fromPort = prevVid.data && prevVid.data.lastPickAssetId ? 'tailpick' : 'last';
+          linkRaw(prevVid, fromPort, videoGen, 'frame');
+        })();
         s.sel = new Set([videoGen.id]);
       });
       pushHistory();
       flushSave(); // 批量铺开立即推送，Host 侧立即可见
       toast(T('expandDone').replace('{n}', String(shots.length)));
+      // 铺开结果如实告知：哪些实体资产库已有、哪些新建了待生成的资产节点（提示词已写好）
+      if (newGens) {
+        setTimeout(() => toast(T('expandGenCreated').replace('{n}', String(newGens))
+          + (reuseAssets ? ' · ' + T('expandAssetReused').replace('{n}', String(reuseAssets)) : '')), 400);
+      }
       setTimeout(() => fitView(), 60);
     }
 
@@ -7542,6 +8962,9 @@ window.__ModuleLoader__.load({
         const st = await craftStatusSafe();
         if (!st) return;
         if (!(st.bins && st.bins.filmcraft && st.bins.filmcraft.found)) { toast(T('craftCliMissing').replace('{name}', 'filmcraft')); return; }
+        // BLK-02：先取项目绝对目录（ArtCraft 无数据根，必须由画布给 base）
+        let base;
+        try { base = await craftBaseDirRequired(S.activeId); } catch (e) { toast('Craft: ' + ((e && e.message) || e)); return; }
         const items = [];
         for (const x of segs) {
           if (!x.nd.data.assetId) continue;
@@ -7552,31 +8975,34 @@ window.__ModuleLoader__.load({
             const rel = await ensureAssetOnDisk({ ...(rec || {}), id: x.nd.data.assetId, blob });
             const vd = await videoDurationOf(blob);
             const ed = Number(x.nd.data.editDuration) || 0;
-            items.push({ rel, name: (rec && rec.name) || 'seg', sub: getSub(x), dur: ed > 0 ? Math.min(ed, vd) : vd });
+            // items.rel 用「项目目录下的相对路径」，FCP7 XML 里再拼成绝对路径
+            items.push({ rel: rel.slice(rel.indexOf('/craft/') + 1), name: (rec && rec.name) || 'seg', sub: getSub(x), dur: ed > 0 ? Math.min(ed, vd) : vd });
           } catch (e) { toast('Craft: ' + (e.message || e)); return; }
         }
         if (!items.length) { toast(T('noSegments')); return; }
-        const slug = craftProjectSlug();
         const dims = videoDimsFor({ resolution: n.data.resolution, ratio: n.data.ratio });
         const xml = buildFcp7Xml(items, {
           name: (S.projects.find((p) => p.id === S.activeId) || {}).name || 'project',
-          dataRoot: (st.dataRoot && st.dataRoot.path) || '',
+          dataRoot: base, // BLK-02：媒体绝对路径 = 项目目录 + items.rel（原读 ArtCraft 的 dataRoot 字段恒为空）
           width: dims.w, height: dims.h,
         });
+        const outRel = 'craft/out/final.mp4'; // 相对 base
         try {
-          await craft.writeText('projects/' + slug + '/craft/timeline.xml', xml);
-          await craft.writeText('projects/' + slug + '/craft/subs.srt', buildSrt(items));
+          await craft.writeText(base, 'craft/timeline.xml', xml);
+          await craft.writeText(base, 'craft/subs.srt', buildSrt(items));
         } catch (e) { return; /* craftFetch 已提示 */ }
         setFcDialog({
-          args: JSON.stringify(['--project', 'projects/' + slug + '/craft/drama.fcproj', '--import', 'projects/' + slug + '/craft/timeline.xml', '--export', 'projects/' + slug + '/craft/out/final.mp4'], null, 1),
-          outRel: 'projects/' + slug + '/craft/out/final.mp4',
+          // args 里一律绝对路径（job 的 cwd 语义不依赖）
+          args: JSON.stringify(['--project', joinLocal(base, 'craft/drama.fcproj'), '--import', joinLocal(base, 'craft/timeline.xml'), '--export', joinLocal(base, outRel)], null, 1),
+          outRel,
+          base,
         });
       };
-      const submitFc = (args, outRel) => {
-        craft.jobStart({ bin: 'filmcraft', args, outputs: [outRel], timeoutMs: 30 * 60 * 1000 }).then((job) => {
+      const submitFc = (args, outRel, base) => {
+        craft.jobStart({ bin: 'filmcraft', cwd: base, args, outputs: [outRel], timeoutMs: 30 * 60 * 1000 }).then((job) => {
           update((s) => { const nd = s.graph.nodes[n.id]; if (nd) { nd.data.fcJobId = job.id; nd.data.fcStatus = 'running'; } });
           setFcDialog(null);
-          pollFilmcraftJob(n.id, job.id, outRel);
+          pollFilmcraftJob(n.id, job.id, outRel, base);
         }).catch(() => { /* craftFetch 已提示 */ });
       };
       return [
@@ -7686,7 +9112,7 @@ window.__ModuleLoader__.load({
                 h('button', {
                   type: 'button', className: 'dshic-mini is-ghost',
                   onPointerDown: (e) => e.stopPropagation(),
-                  onClick: () => downloadBlobFromUrl(fcUrl, 'finalcut-fc-' + n.id.slice(-5) + '.mp4'),
+                  onClick: async () => downloadBlobFromUrl(fcUrl, await downloadNameForAsset(n.data.fcAssetId, 'finalcut-fc-' + n.id.slice(-5), 'video')),
                 }, Ic('download', 11), T('download')),
                 h('button', {
                   type: 'button', className: 'dshic-mini is-ghost', title: T('voiceExtractBtn'),
@@ -7705,7 +9131,7 @@ window.__ModuleLoader__.load({
                 h('button', {
                   type: 'button', className: 'dshic-mini is-ghost',
                   onPointerDown: (e) => e.stopPropagation(),
-                  onClick: () => downloadBlobFromUrl(assetUrlV, 'finalcut-' + n.id.slice(-5) + '.webm'),
+                  onClick: async () => downloadBlobFromUrl(assetUrlV, await downloadNameForAsset(n.data.assetId, 'finalcut-' + n.id.slice(-5), 'video')),
                 }, Ic('download', 11), T('download')),
                 h('div', { className: 'dshic-flex' }),
               ),
@@ -7843,6 +9269,8 @@ window.__ModuleLoader__.load({
           h(Btn, { onClick: () => zoomStep(1.18), title: T('zoomIn') }, Ic('zoomIn', 12)),
         ),
         h('div', { className: 'dshic-toolbar-sep' }),
+        h(ShortcutsPanel), // 快捷键入口（工具栏右侧，缩放控件与项目名之间）
+        h('div', { className: 'dshic-toolbar-sep' }),
         naming
           ? h('input', {
               className: 'dshic-input', style: { width: 160 }, autoFocus: true, defaultValue: proj ? proj.name : '',
@@ -7921,9 +9349,8 @@ window.__ModuleLoader__.load({
           try { localStorage.removeItem(LS_BIBLE + pid); } catch { /* 忽略 */ }
           if (s.activeId === pid) {
             if (s.projects.length === 0) {
-              const p = { id: uid('p'), name: T('defaultProject'), createdAt: Date.now(), updatedAt: Date.now() };
-              s.projects.push(p);
-              s.activeId = p.id;
+              // OBS-UI-1：删光后进入空态，不再自动建「我的画布」占位（同 initStore 口径）
+              s.activeId = null;
               s.graph = emptyGraph();
             } else {
               s.activeId = s.projects[0].id;
@@ -7938,7 +9365,17 @@ window.__ModuleLoader__.load({
         });
         lsSet(LS_PROJECTS, S.projects);
         lsSet(LS_ACTIVE, S.activeId);
-        try { hostRpc('projectsDelete', { id: pid }).catch(() => { /* 静默 */ }); } catch { /* 忽略 */ }
+        // IC-B2：先清 ArtCraft 后期目录**再**删项目——projectCraftRemove 靠 meta 条目解析物理文件夹，
+        // 若先删项目（meta 条目随之被清），清理会解析不到目录而"伪成功"，craft 残留无人知晓。
+        // 失败只 toast 不阻断删除（目录残留可手动清）。
+        await craftProjectCleanup(pid);
+        try {
+          const del = await hostRpc('projectsDelete', { id: pid });
+          // BLK-01 的清理结果必须可见：rmrf 部分失败（Windows 文件锁）时残留在盘上，
+          // 同名重建的项目会继承旧 assets.json 条目——用户至少要知道发生过什么。
+          const diskErrs = del && del.disk && Array.isArray(del.disk.errors) ? del.disk.errors : [];
+          if (diskErrs.length) toast('项目已删除，但磁盘清理有 ' + diskErrs.length + ' 项失败：' + diskErrs.join('；'));
+        } catch (e) { toast('删除请求失败（本地已移除，刷新后可能复现）：' + String((e && e.message) || e)); }
         if (!S.store) {
           // IndexedDB 模式（未设数据目录）：本地逐个清理
           try {
@@ -7969,6 +9406,10 @@ window.__ModuleLoader__.load({
               h('button', { type: 'button', className: 'dshic-mini is-ghost', title: T('cancel'), onClick: () => setCreating(false) }, '✕'),
             )
           : h('button', { key: 'newbtn', type: 'button', className: 'dshic-mini', style: { alignSelf: 'flex-start' }, onClick: () => { setCreating(true); setName(''); } }, Ic('plus', 11), T('newProject')),
+        !S.projects.length && !creating
+          ? h('div', { key: 'emptystate', className: 'dshic-hint', style: { alignSelf: 'flex-start', padding: '6px 2px', maxWidth: 260 } },
+              T('emptyProjectHint'))
+          : null,
         ...S.projects.map((p) => {
           const editing = editId === p.id;
           return h('div', {
@@ -8328,7 +9769,7 @@ window.__ModuleLoader__.load({
         onPointerDown: (e) => e.stopPropagation(),
         onClick: startRename,
       }, Ic('pencil', 11));
-      const downloadName = (a.name || 'asset') + (a.kind === 'image' ? '.png' : a.kind === 'video' ? '.webm' : a.kind === 'audio' ? '.mp3' : '.md');
+      const downloadName = (a.name || 'asset') + extForDownload(a.mime, a.name, a.kind);
       return h('div', { className: 'dshic-asset', onClick: a.kind === 'audio' ? undefined : () => onAdd(a), title: a.kind === 'text' ? T('textAssetHint') : a.kind === 'audio' ? '' : T('addAssetNode') },
         a.kind === 'text'
           ? h('div', { className: 'dshic-textcard is-title' },
@@ -8798,12 +10239,16 @@ window.__ModuleLoader__.load({
       useEffect(() => { probeCraft().then(() => force((x) => x + 1)); }, []);
       const cs = S.craftStatus;
       const data = cs && cs.data;
-      const slug = craftProjectSlug();
-      // Craft 后期目录 = **画布数据根目录** + 项目目录 + \craft（不再有 ArtCraft 独立数据目录的 second 口径）
-      const craftDir = S.dataRoot ? (S.dataRoot.replace(/[\\/]+$/, '') + '\\projects\\' + slug + '\\craft') : '';
-      // ArtCraft 自身的数据目录若与画布数据根目录不一致 → 后期文件会落到两处，必须提醒
-      const artRoot = data && data.dataRoot ? data.dataRoot.path : '';
-      const rootMismatch = !!(S.dataRoot && artRoot && artRoot.replace(/[\\/]+$/, '') !== S.dataRoot.replace(/[\\/]+$/, ''));
+      const [craftBase, setCraftBase] = useState('');
+      // BLK-02：后期目录由画布自己算 —— <数据根>/projects/<物理文件夹>/craft。
+      // ArtCraft 0.3.x 已无「自有数据根」概念（/status 无 dataRoot），故不再做两边对比，
+      // 改为把实际基准显示出来，供 QA/用户核对落点。
+      useEffect(() => {
+        let ok = true;
+        craftBaseDir(S.activeId).then((abs) => { if (ok) setCraftBase(abs || ''); }).catch(() => { /* 未配置数据根 */ });
+        return () => { ok = false; };
+      }, [S.activeId, S.dataRoot]);
+      const craftDir = craftBase ? (craftBase.replace(/[\\/]+$/, '') + '\\craft') : '';
       // Craft 家族全量动态渲染：ArtCraft /status 返回几款 bins 就渲染几款（当前 12 款），不再写死
       const binKeys = (data && data.bins ? Object.keys(data.bins) : []).sort();
       const readyCount = binKeys.filter((k) => data.bins[k] && data.bins[k].found).length;
@@ -8831,7 +10276,6 @@ window.__ModuleLoader__.load({
         ),
         open ? [
           craftDir ? h('div', { className: 'dshic-hint' }, T('craftDirLabel') + '：' + craftDir) : h('div', { className: 'dshic-err' }, T('craftDataRootNeed')),
-          rootMismatch ? h('div', { className: 'dshic-err' }, T('craftRootMismatch')) : null,
           ...(data ? binKeys.map((k) => binRow(k)) : []),
         ] : null,
       );
@@ -8861,11 +10305,15 @@ window.__ModuleLoader__.load({
         if (!rec || (!rec.blob && !rec.rel)) { toast(T('noResult')); return; }
         setRunning(true); setErr(null); setProgress('…');
         try {
+          // BLK-02：PhotoCraft 的输入/输出也一律 base(项目绝对目录) + 相对路径
+          const base = await craftBaseDirRequired(S.activeId);
           const mediaRel = await ensureAssetOnDisk(rec);
-          const outRel = 'projects/' + craftProjectSlug() + '/craft/out/graded/' + rec.id + '-graded' + extForMime(rec.mime, rec.name);
+          const mediaUnderBase = mediaRel.slice(mediaRel.indexOf('/craft/') + 1); // craft/media/…
+          const outRel = 'craft/out/graded/' + rec.id + '-graded' + extForMime(rec.mime, rec.name);
           const job = await craft.jobStart({
             bin: 'photocraft',
-            args: ['run', mediaRel, '--cmd', cmd, '--params', JSON.stringify(paramsObj), '--out', outRel],
+            cwd: base,
+            args: ['run', joinLocal(base, mediaUnderBase), '--cmd', cmd, '--params', JSON.stringify(paramsObj), '--out', joinLocal(base, outRel)],
             outputs: [outRel], timeoutMs: 600000,
           });
           setJobId(job.id);
@@ -8881,7 +10329,7 @@ window.__ModuleLoader__.load({
                 throw new Error('PhotoCraft ' + status + '：' + ((snap.stderr || '').split('\n').filter(Boolean).slice(-3).join('\n') || ''));
               }
               if (!(snap.outputs && snap.outputs[0] && snap.outputs[0].exists)) throw new Error('任务完成但未找到输出文件');
-              const blob = await craft.file(outRel);
+              const blob = await craft.file(base, outRel);
               const rec2 = await saveAssetRecord(S.activeId, 'image', blob, {
                 name: (rec.name || 'image') + '-graded',
                 prompt: 'photocraft ' + cmd, source: 'craft', category: rec.category || 'general',
@@ -8946,7 +10394,7 @@ window.__ModuleLoader__.load({
         let args;
         try { args = JSON.parse(argsText); } catch { setErr(T('craftInvalidJson')); return; }
         if (!Array.isArray(args)) { setErr(T('craftInvalidJson')); return; }
-        onSubmit(args, String(outRel || '').trim());
+        onSubmit(args, String(outRel || '').trim(), info.base);
       };
       return h('div', { className: 'dshic-mask-overlay', onPointerDown: (e) => { if (e.target === e.currentTarget) onClose(); } },
         h('div', { className: 'dshic-mask-card' },
@@ -8970,7 +10418,10 @@ window.__ModuleLoader__.load({
       const [val, setVal] = useState('');
       const [busy, setBusy] = useState(false);
       const [picking, setPicking] = useState(false);
+      const [stats, setStats] = useState(null); // 存储实况：是否真在用 SQLite、库在哪、多少数据
+      const loadStats = () => { hostRpc('dbStats').then((r) => setStats(r || null)).catch(() => setStats({ error: true })); };
       useEffect(() => { if (S.dataRoot) setVal(S.dataRoot); }, [S.dataRoot]);
+      useEffect(() => { loadStats(); }, [S.dataRoot, S.assetsTick]);
       const save = async () => {
         if (busy) return;
         setBusy(true);
@@ -9057,6 +10508,21 @@ window.__ModuleLoader__.load({
                 h('button', { type: 'button', className: 'dshic-mini', disabled: busy || picking, onPointerDown: (e) => e.stopPropagation(), onClick: save }, T('dataRootSave')),
               ),
               picking ? h('div', { className: 'dshic-hint', key: 'picking' }, T('dataRootPicking')) : null,
+              h('div', { className: 'dshic-row', key: 'stats', style: { alignItems: 'center', gap: 6 } },
+                h('span', { className: 'dshic-hint', style: { flex: 1, minWidth: 0 } },
+                  !stats ? '存储实况：读取中…'
+                    : stats.error ? '存储实况：无法读取（后端未提供该接口）'
+                    : (stats.store === 'sqlite'
+                      ? '存储实况：SQLite 库' + (stats.dbExists ? '（' + (stats.dbBytes / 1048576).toFixed(2) + ' MB' + (stats.walBytes ? ' + WAL ' + (stats.walBytes / 1048576).toFixed(2) + ' MB' : '') + '）' : '（未创建）') + ' · ' + stats.projects + ' 项目 · ' + stats.assets + ' 资产 · 检索 ' + (stats.fts || '-')
+                      : stats.store === 'json'
+                        ? '存储实况：JSON 降级模式（宿主运行时缺 node:sqlite，数据仍在数据目录的文件里）'
+                        : '存储实况：未设置数据目录（资产存浏览器本地 IndexedDB）')),
+                h('button', {
+                  type: 'button', className: 'dshic-mini is-ghost', title: '重新检测存储实况',
+                  onPointerDown: (e) => e.stopPropagation(), onClick: loadStats,
+                }, '↻'),
+              ),
+              stats && stats.dbPath ? h('div', { key: 'dbpath', className: 'dshic-hint' }, '库文件：' + stats.dbPath) : null,
               h('div', { className: 'dshic-row', key: 'row2' },
                 S.dataRoot ? h('button', { type: 'button', className: 'dshic-mini', onPointerDown: (e) => e.stopPropagation(), onClick: openDir }, T('dataRootOpen')) : null,
                 h('button', { type: 'button', className: 'dshic-mini is-ghost', disabled: busy || picking, title: T('dataRootImportHint'), onPointerDown: (e) => e.stopPropagation(), onClick: importFromRoot }, Ic('folder', 11), T('dataRootImportBtn')),
@@ -9663,6 +11129,81 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ============================================================
+    // 快捷键面板（画布左上角浮层）：按钮点开 → 下方展开半透明列表
+    //   纯展示、不持久化；点面板外或再点按钮或 Esc 收起。
+    //   内容与代码里**真实存在**的快捷键一一对应（改快捷键时同步这里）。
+    // ============================================================
+    function ShortcutsPanel() {
+      const open = !!S.keysOpen;
+      const wrapRef = useRef(null);
+      // 打开时：Esc 关闭 + 点击面板外关闭（都只在打开期间挂监听，避免常年占用全局事件）
+      useEffect(() => {
+        if (!open) return undefined;
+        const onKey = (e) => { if (e.key === 'Escape') { update((s) => { s.keysOpen = false; }); } };
+        // 用捕获阶段：画布/工具栏上的 handler 可能 stopPropagation，冒泡阶段会收不到
+        const onDown = (e) => {
+          const el = wrapRef.current;
+          if (el && e.target && el.contains && el.contains(e.target)) return; // 点面板内或按钮本身：交给按钮自己的 onClick 处理
+          update((s) => { s.keysOpen = false; });
+        };
+        window.addEventListener('keydown', onKey);
+        window.addEventListener('pointerdown', onDown, true);
+        return () => {
+          window.removeEventListener('keydown', onKey);
+          window.removeEventListener('pointerdown', onDown, true);
+        };
+      }, [open]);
+      // row(id, keyLabel, text)：id 仅作 React key；此前误收两参导致第三参（说明文案）被丢弃，
+      // 键位栏渲染成 "Alt + 拖动|0"、说明栏重复键名——整张面板的描述全部失效。
+      const row = (id, keyLabel, text) => h('div', { className: 'dshic-keys-row', key: id },
+        h('span', { className: 'dshic-keys-key' }, keyLabel),
+        h('span', { className: 'dshic-keys-text' }, text));
+      const group = (title, items) => h('div', { className: 'dshic-keys-group', key: title },
+        h('div', { className: 'dshic-keys-group-title' }, title),
+        ...items.map(([k, v], i) => row(k + '|' + i, k, v)));
+      return h('div', { className: 'dshic-keys-wrap', ref: wrapRef },
+        h('button', {
+          type: 'button',
+          className: cls('dshic-keys-btn', open && 'is-open'),
+          title: T('keysBtn'),
+          onPointerDown: (e) => e.stopPropagation(), // 不触发放大/拖拽等工具栏行为
+          onClick: (e) => { e.stopPropagation(); update((s) => { s.keysOpen = !s.keysOpen; }); },
+        }, h('span', { className: 'dshic-keys-btn-label' }, T('keysBtn')), h('span', { className: 'dshic-keys-caret' }, open ? '▴' : '▾')),
+        open
+          ? h('div', {
+              className: 'dshic-keys-pop',
+              onPointerDown: (e) => e.stopPropagation(), // 面板内点击不进画布
+              onWheel: (e) => e.stopPropagation(),
+            },
+              h('div', { className: 'dshic-keys-title' }, T('keysTitle')),
+              group(T('keysDrag'), [
+                ['Alt + 拖动', T('kAltDrag')],
+                ['拖动', T('kDrag')],
+                ['Shift + 拖动', T('kShiftDrag')],
+                ['Shift + 点击', T('kShiftClick')],
+                ['Shift + 框选', T('kMarquee')],
+                ['中键拖动', T('kMiddle')],
+                ['滚轮', T('kWheel')],
+                ['双击空白', T('kDblClick')],
+                ['右键', T('kRightClick')],
+              ]),
+              group(T('keysEdit'), [
+                ['Ctrl/⌘ Z', T('kUndo')],
+                ['Ctrl/⌘ ⇧ Z', T('kRedo')],
+                ['Ctrl/⌘ D', T('kCopy')],
+                ['Delete', T('kDel')],
+                ['Esc', T('kEsc')],
+              ]),
+              group(T('keysView'), [
+                ['双击项目名', T('kZoomKeys')],
+              ]),
+              h('div', { className: 'dshic-keys-hint' }, T('keysHint')),
+            )
+          : null,
+      );
+    }
+
     // ============================================================
     // 帮助与反馈：GitHub 仓库/Issue + 微信交流群二维码（插件静态资源）
     // ============================================================
@@ -9729,7 +11270,7 @@ window.__ModuleLoader__.load({
     // 插件入口
     // ============================================================
     return {
-      inject: ['slots', 'locale', 'layout'],
+      inject: ['slots', 'locale', 'layout', 'sidebarRightTabs'],
       apply(ctx) {
         CTX = ctx;
         ctx.effect(() => ctx.locale.register(NS, { zh: DICT_ZH, en: DICT_EN }), 'infinite-canvas: dictionaries');
@@ -9772,23 +11313,118 @@ window.__ModuleLoader__.load({
         // 面板根：包一层错误边界——任何渲染期崩溃都不再白屏，而是显示可复制的错误卡片
         PanelErrorBoundary.__dshicClass = true; // 冒烟 walker 标记
     function PanelRoot() {
-          return h(PanelErrorBoundary, null, h(CanvasPage));
+          return h(CanvasHostedApp, { host: 'main' });
         }
         ctx.slots.inject('main', () => ctx.slots.register({
           name: 'main',
           key: PANEL_ID,
           locale: NS,
         }, PanelRoot));
+        // —— 会话右侧面板：画布作为右栏页签（对话与画布同屏工作）——
+        // 契约照抄 dsh-client-ui-sidebar-terminal：**注册 id、三个槽位的 key、guide 条目 id 全部同一口径**。
+        // 关键在壳的 TabSlot：`renderSlot(seat, {}, { entryKey: definition?.id ?? tab.kind })` ——
+        // 插槽调度用的是注册表里的 definition.id，只有 kind 没进注册表时才回退到 kind。
+        // 上一次 body 槽位 key 写的是 kind（'infinite-canvas'）而注册 id 是包名，
+        // 于是永远命中 fallback：「这类内容还没有可用的查看方式」。
+        const CANVAS_TAB_KIND = 'infinite-canvas';
+        const CANVAS_TAB_ID = '@ninkch/dsh-infinite-canvas'; // = 注册 id = 槽位 key
+        function CanvasHostedApp({ host }) {
+          useApp();
+          useEffect(() => {
+            // 挂载即声明宿主（后开者接管）：在窄栏宿主里顺手收起画布自带的右侧栏（宽度不够）
+            const takeover = S.canvasHost !== host;
+            S.canvasHost = host;
+            if (takeover && host === 'pane' && S.rightOpen) S.rightOpen = false;
+            notify();
+            return () => { if (S.canvasHost === host) S.canvasHost = null; };
+          }, [host]);
+          if (S.canvasHost && S.canvasHost !== host) {
+            return h('div', { className: 'dshic-host-taken' },
+              h('div', { className: 'dshic-host-taken-card' },
+                h('div', { className: 'dshic-host-taken-title' }, T('hostTakenTitle')),
+                h('div', { className: 'dshic-host-taken-hint' }, T('hostTakenHint')),
+                h('button', {
+                  type: 'button', className: 'dshic-mini',
+                  onPointerDown: (e) => e.stopPropagation(),
+                  onClick: () => update((s) => { s.canvasHost = host; if (host === 'pane' && s.rightOpen) s.rightOpen = false; }),
+                }, T('hostTakeOver')),
+              ));
+          }
+          return h(PanelErrorBoundary, null, h(CanvasPage, { host }));
+        }
+        // 页签 kind 注册（**开始页卡片的真正来源**）：壳的 GuideBody 遍历注册表里每个 kind 的
+        // guide 数组渲染标准卡——只注册槽位不进注册表时，页签体存在但开始页永远不显示入口
+        //（首次上线时漏了这一步，卡片不出现）。DEFAULT_BAND='extension'：插件默认档，与
+        // builtin 一次性配对共存，无需显式 priority。
+        // 守卫：旧 runner 未提供 sidebarRightTabs 服务时跳过（保持全屏面板可用，不让整个插件挂掉）。
+        if (ctx.sidebarRightTabs && typeof ctx.sidebarRightTabs.register === 'function') {
+          ctx.effect(() => ctx.sidebarRightTabs.register({
+            id: CANVAS_TAB_ID, // ← 壳用这个 id 作为 slot entryKey 调度 body/title
+            kind: CANVAS_TAB_KIND,
+            multiple: false, // 一个页签足够（同 kind 再开 = 聚焦已有页签，壳的 page uniqueness 语义）
+            title: () => T('panel'), // chip 文本（未注册 title 槽位时的兜底口径）
+            guide: [{
+              id: 'open',
+              order: 30,
+              title: () => T('panel'),
+              description: () => T('guideDesc'),
+              icon: PanelIcon,
+            }],
+          }), 'infinite-canvas: tab type');
+        }
+        // 槽位 key = 注册 id（不是 kind）：与 TabSlot 的 entryKey 口径一致，否则永远落到 fallback
+        ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({
+          name: 'sidebar.right.pane.tab',
+          key: CANVAS_TAB_ID,
+          locale: NS,
+        }, () => h(CanvasHostedApp, { host: 'pane' })));
+        // 标题槽位同样用注册 id；缺了它 chip 显示注册表 title(address) 抓到的开页标题（也够用）
+        ctx.slots.inject('sidebar.right.pane.tab.title', () => ctx.slots.register({
+          name: 'sidebar.right.pane.tab.title',
+          key: CANVAS_TAB_ID,
+          locale: NS,
+        }, function CanvasPaneTitle() {
+          return h('span', { className: 'dshic-pane-tab-title' }, T('panel'));
+        }));
         // 冒烟测试专用缝隙（仅在 smoke-render.mjs 设置了该标记时存在）：
         // 直接暴露各页签组件与同步入口，让测试能逐个渲染/驱动，抓白屏与同步断链问题
         if (typeof window !== 'undefined' && window.__DSH_IC_SMOKE__) {
-          window.__DSH_IC_TABS__ = { ProjectsTab, AssetsTab, BibleTab, SettingsTab, CanvasPage };
+          window.__DSH_IC_TABS__ = { ProjectsTab, AssetsTab, BibleTab, SettingsTab, CanvasPage, ShortcutsPanel, CanvasHostedApp };
+          // 节点体组件出口：供 scripts/test-node-actions.mjs 断言「结果操作按钮必须在节点末尾左下角」的排版规范
+          window.__DSH_IC_NODES__ = { ScriptNodeBody, StoryboardNodeBody, GenNodeBody, FinalCutNodeBody, AssetNodeBody, TextNodeBody, ShotNodeBody };
+          // 成片合成（composeFinalCut）纯函数级出口：浏览器录制链路无法在 Node 端跑，
+          // 但合成主循环（分段推进/裁剪/转场/字幕）可以用假的 video/MediaRecorder 真实执行——
+          // 这正是历史上一处 "dur is not defined" 在真机上才炸的漏洞所在。
+          window.__DSH_IC_COMPOSE__ = {
+            composeFinalCut,
+            videoDimsFor,
+            drawSubtitle,
+            extractTailFrames,
+            grayThumb,
+            frameSeamMetrics,
+            seamVerdict,
+            tailFrameScore,
+          };
           window.__DSH_IC_SYNC__ = {
             hostSyncTick, mergeHostDoc, loadBible, loadGraphDoc,
             removeNodes, ungroupNode, undo, redo, pushHistory,
             graph: () => JSON.parse(JSON.stringify(S.graph)),
+            // 冒烟测试用：切换「快捷键面板」展开态，让展开后的列表也走一次真实渲染
+            setKeysOpen: (v) => { S.keysOpen = !!v; },
             state: () => ({ stopped: hostSyncStopped, busy: hostSyncBusy, projects: S.projects.map((p) => p.id), activeId: S.activeId, ready: S.ready }),
+            // 铺开到画布（缺资产 → 建带设定图提示词的图片生成节点）供 test-expand-assets 驱动
+            expandStoryboard,
+            // 纯函数出口：资产设定图提示词生成器（不依赖 DOM，可直接断言）
+            buildAssetSheetPrompt, assetSheetNodeSpec,
           };
+          // IC-01：下载侧扩展名判定的纯函数出口（供 scripts/test-download-ext.mjs 直接断言）
+          window.__DSH_IC_MEDIA__ = { extForDownload };
+          // IC-04：参考图上传三件套的纯函数出口（供 scripts/test-image-upload.mjs 直接断言）
+          window.__DSH_IC_IMGREF__ = { rawImageDims, sniffImageEncoding, registerReferenceAsset };
+          // IC-03：视频厂商识别/前缀归一化的纯函数出口（供 scripts/test-vendor-detect.mjs 直接断言）
+          window.__DSH_IC_VENDOR__ = { detectVideoVendor, gatewayPrefixFor, wanEndpoints, vendorBase, VIDEO_REF_CAPS };
+          // BLK-02：ArtCraft 目录基准相关的纯函数出口（供 scripts/test-craft-base.mjs 断言）
+          window.__DSH_IC_CRAFT__ = { craftBaseDir, craftBaseDirRequired, joinLocal, craftFolderOf, craft };
         }
       },
     };