@ninkch/dsh-infinite-canvas 0.18.4 → 0.18.6

package/index.js

@@ -12,7 +12,6 @@ import { createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync,
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 
 const NAME = 'infinite-canvas';
@@ -179,14 +178,19 @@ function writeDataRootMeta(meta) {
   } catch { /* 清单写失败不影响主存储 */ }
 }
 function sanitizeFolderName(name) {
-  const s = String(name || '').replace(/[\\/:*?"<>|\u0000-\u001f]/g, '_').replace(/\s+/g, ' ').trim().slice(0, 60);
-  return s || '未命名项目';
+  const s = String(name || '').replace(/[\\/:*?"<>|\u0000-\u001f]/g, '_').replace(/\s+/g, ' ').trim().slice(0, 60)
+    .replace(/[.\s]+$/, ''); // Windows 尾随点/空格会被文件系统吞掉；纯 ".." 会让 path.join 上跳一级
+  return (!s || s === '.' || s === '..') ? '未命名项目' : s;
 }
 
 // ============================================================
-// 存储引擎 v2（0.18.0）：SQLite（node:sqlite）+ CAS 对象库
+// 存储引擎 v2（0.18.0）：SQLite（node:sqlite）+ 项目文件夹落盘
 //   <dataRoot>/canvas.db                元数据 + 项目文档 = 唯一事实源
-//   <dataRoot>/objects/<sha2>/<sha256>  媒体文件（内容寻址、去重、引用计数）
+//   <dataRoot>/projects/<项目>/<类型>/   媒体文件（0.18.5 起新上传一律落这里）
+//   <dataRoot>/objects/<sha2>/<sha256>  历史 CAS 对象库：**只读保留**
+//       ！0.18.0–0.18.4 上传的媒体在这里，删掉老用户的图/视频会 404
+//       ！IC-08 已退役写路径：不再有 POST /api/object，新上传不再产生对象
+//       ！删资产时仍按引用计数回收（gcObjectIfUnreferenced），避免只增不减
 // node:sqlite 需要 Node ≥22.5（DSH 捆绑 Node 24 满足）；不可用时整站回退 v1 JSON 存储。
 // ============================================================
 const require_ = createRequire(import.meta.url);
@@ -504,36 +508,8 @@ function dbAssetUpdate(id, patch) {
   return { ok: true, asset: rowToAsset(db.prepare('SELECT * FROM assets WHERE id = ?').get(row.id)) };
 }
 
-/** CAS 对象库 GC：扫描 objects/，删除无任何资产行引用的对象（mtime 超过 24h 才删，避免与并发上传竞态）。 */
-function dbObjectsGc() {
-  const root = dataRoot();
-  const db = getDb();
-  if (!root || !db) throw new Error('SQL 存储不可用');
-  const odir = objectsDirFor(root);
-  let scanned = 0;
-  let removed = 0;
-  const grace = Date.now() - 24 * 3600 * 1000;
-  try {
-    for (const bucket of readdirSync(odir)) {
-      const bdir = path.join(odir, bucket);
-      let stats = null;
-      try { stats = statSync(bdir); } catch { continue; }
-      if (!stats.isDirectory()) continue;
-      for (const f of readdirSync(bdir)) {
-        if (!/^[0-9a-f]{64}$/i.test(f)) continue;
-        scanned++;
-        const abs = path.join(bdir, f);
-        let st = null;
-        try { st = statSync(abs); } catch { continue; }
-        if (st.mtimeMs > grace) continue; // 近期写入：可能尚未登记资产行
-        if (objectRefCount(db, f) === 0) {
-          try { unlinkSync(abs); removed++; } catch { /* 忽略 */ }
-        }
-      }
-    }
-  } catch { /* 目录不存在 = 无对象 */ }
-  return { ok: true, scanned, removed };
-}
+/** CAS 对象库 GC 已随写路径退役（IC-08）：新上传不再产生 objects/，历史对象由删资产时的
+ *  引用计数回收（gcObjectIfUnreferenced）兜住，不需要独立的定期扫描入口。 */
 
 function readDocOrNull(id) {
   if (sqlActive()) {
@@ -580,6 +556,28 @@ function jsonAssetsList(args) {
   const nextCursor = start + limit < total ? Buffer.from(String(start + limit)).toString('base64') : null;
   return Promise.resolve({ ok: true, total, items: page, nextCursor });
 }
+/** IC-B4：FTS 存量孤儿清理（一次性维护，幂等）。assets_fts 里 id 不在 assets 表的行 = 孤儿
+ *  （0.18.0 存储重写期 DELETE FROM assets 绕过 dbAssetDelete 留下的，QA 实测 58 vs 56）。
+ *  只读判断 + 显式计数返回；顺带把"在 assets 却不在 fts"的漏登行补齐（反向孤儿，同样幂等）。 */
+function ftsReconcile(db) {
+  const orphans = db.prepare('SELECT f.id AS id FROM assets_fts f LEFT JOIN assets a ON a.id = f.id WHERE a.id IS NULL').all().map((r) => r.id);
+  const missing = db.prepare('SELECT a.id AS id FROM assets a LEFT JOIN assets_fts f ON f.id = a.id WHERE f.id IS NULL').all().map((r) => r.id);
+  const del = db.prepare('DELETE FROM assets_fts WHERE id = ?');
+  let removed = 0;
+  const errors = [];
+  for (const id of orphans) {
+    try { del.run(id); removed++; } catch (e) { errors.push(id + ': ' + String((e && e.message) || e)); }
+  }
+  let repaired = 0;
+  if (missing.length) {
+    const rows = db.prepare('SELECT id, name, prompt FROM assets WHERE id IN (' + missing.map(() => '?').join(',') + ')').all(...missing);
+    for (const r of rows) {
+      try { syncFts(db, r.id, r.name, r.prompt); repaired++; } catch (e) { errors.push(r.id + ': ' + String((e && e.message) || e)); }
+    }
+  }
+  return { ok: errors.length === 0, removed, repaired, fts: db.prepare('SELECT COUNT(*) AS n FROM assets_fts').get().n, assets: db.prepare('SELECT COUNT(*) AS n FROM assets').get().n, errors };
+}
+
 /** 确保项目的物理文件夹（按项目名）与清单条目存在；改名时尽力重命名目录（被占用/冲突则保留旧文件夹）。返回文件夹名。 */
 function ensureProjectFolder(pid, name) {
   const root = dataRoot();
@@ -693,15 +691,82 @@ function writeAssetIndex(pid, projectName, assets, opts) {
   renameSync(tmp, f);
   return { ok: true, folder, count: list.length };
 }
-/** 删除项目的数据目录镜像（项目被删除时调用）。 */
+/** 删除项目的数据目录镜像（项目被删除时调用）。
+ *  BLK-01：SQL 模式下目录名可能没有 meta 条目（实测就是项目 id），旧实现此时静默 return、
+ *  永远删不掉目录。现在：优先用 meta 的 folder；没有条目就回退 <pid>；两个候选都尝试删；
+ *  删除失败不再吞掉，返回值里带 removed/errors 供调用方暴露。
+ *  路径安全：folder/pid 可能来自调用方（canvas_delete_project 的 projectId 是外部输入），
+ *  含 `..` 或绝对路径时 path.join 会逃出数据根 → rmrf 删掉无关目录。与 IC-B2 的 craft 清理
+ *  同一防护：resolve 后必须仍落在 <dataRoot>/projects 之内，否则拒绝并记录。 */
 function removeDataRootProject(pid) {
+  const out = { removed: false, dirs: [], errors: [] };
   const root = dataRoot();
-  if (!root || !pid) return;
+  if (!root || !pid) return out;
   const meta = readDataRootMeta();
-  const entry = meta.projects.find((p) => p.id === pid);
+  const entry = meta.projects.find((p) => p.id === pid) || null;
+  const candidates = [];
+  if (entry && entry.folder) candidates.push(entry.folder);
+  if (!candidates.includes(pid)) candidates.push(pid);
   meta.projects = meta.projects.filter((p) => p.id !== pid);
-  writeDataRootMeta(meta);
-  if (entry) rmrf(path.join(root, 'projects', entry.folder));
+  try { writeDataRootMeta(meta); } catch (e) { out.errors.push('meta: ' + String((e && e.message) || e)); }
+  const projectsBase = path.resolve(path.join(root, 'projects'));
+  for (const folder of candidates) {
+    let dir = null;
+    try {
+      const cand = path.resolve(path.join(root, 'projects', String(folder)));
+      // 必须是 projects 的**子目录**（含 projects 本身在内的任何异常形态都拒绝：
+      // cand === projectsBase 时 rmrf 会清掉全部项目的媒体，比越界删除更糟）
+      if (cand === projectsBase || !cand.startsWith(projectsBase + path.sep)) {
+        out.errors.push('拒绝删除数据根之外的目录: ' + folder);
+        continue;
+      }
+      dir = cand;
+    } catch (e) { out.errors.push('路径异常: ' + String((e && e.message) || e)); continue; }
+    if (!existsSync(dir)) { out.dirs.push({ dir, existed: false }); continue; }
+    try { rmrf(dir); out.dirs.push({ dir, existed: true, removed: !existsSync(dir) }); if (!existsSync(dir)) out.removed = true; }
+    catch (e) { out.dirs.push({ dir, existed: true, removed: false }); out.errors.push(dir + ': ' + String((e && e.message) || e)); }
+  }
+  return out;
+}
+
+/** BLK-01：SQL 模式删除项目时的统一清理（两条删除入口共用，禁止各写一份）。
+ *  DB 行 → FTS 行 → 资产文件（rel/sha）→ 项目镜像目录 → meta 条目，每一处失败都返回可见。
+ *  不碰 craft/ 目录（归 IC-B2）。 */
+function sqlDeleteProjectRows(db, id, root) {
+  const result = { ok: true, projectId: id, fts: 0, assets: 0, files: 0, dir: null, errors: [] };
+  // 1) 资产行与它们占用的文件：先取快照，再删行
+  let rows = [];
+  try { rows = db.prepare('SELECT id, rel, sha FROM assets WHERE project_id = ?').all(id); } catch (e) { result.errors.push('select assets: ' + String((e && e.message) || e)); }
+  result.assets = rows.length;
+  // 2) FTS：DELETE FROM assets 绕过了 dbAssetDelete（那里才同步删 FTS）→ 这里逐条清
+  try {
+    const delFts = db.prepare('DELETE FROM assets_fts WHERE id = ?');
+    for (const r of rows) { try { delFts.run(r.id); result.fts++; } catch { /* 单条失败继续 */ } }
+  } catch (e) { result.errors.push('fts: ' + String((e && e.message) || e)); }
+  // 3) 资产文件（rel 镜像 / sha 对象）：删行前先按引用清理
+  try {
+    db.prepare('DELETE FROM assets WHERE project_id = ?').run(id);
+    db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+  } catch (e) { result.errors.push('delete rows: ' + String((e && e.message) || e)); }
+  if (root) {
+    const seen = new Set();
+    for (const r of rows) {
+      if (r.rel) {
+        try {
+          const mapped = physicalRel(r.rel) || r.rel;
+          const { abs } = safeJoin(root, mapped);
+          if (seen.has(abs)) continue;
+          seen.add(abs);
+          if (existsSync(abs)) { unlinkSync(abs); result.files++; }
+        } catch { /* 已不存在视为成功 */ }
+      }
+      if (r.sha) { try { gcObjectIfUnreferenced(db, root, r.sha); } catch { /* 对象清理失败不阻塞 */ } }
+    }
+  }
+  // 4) 项目镜像目录（含 meta 条目缺失时的 id 回退）
+  try { result.dir = removeDataRootProject(id); if (result.dir.errors.length) result.errors.push(...result.dir.errors); } catch (e) { result.errors.push('dir: ' + String((e && e.message) || e)); }
+  if (result.errors.length) result.ok = false;
+  return result;
 }
 /** 一次性迁移/对齐数据目录布局：旧 pid 文件夹 → 项目名文件夹，并镜像全部项目文档。 */
 function dataRootMigrate() {
@@ -1173,20 +1238,17 @@ function setDataRoot(raw) {
 }
 async function projectsDelete(args) {
   const id = String((args && args.id) || '');
+  let cleanup = null;
   if (sqlActive()) {
-    const db = getDb();
-    const root = dataRoot();
-    // 先收集对象引用：项目资产行删除后，仅本项目引用的 CAS 对象一并回收
-    const shas = db.prepare('SELECT DISTINCT sha FROM assets WHERE project_id = ? AND sha IS NOT NULL').all(id).map((r) => r.sha);
-    db.prepare('DELETE FROM assets WHERE project_id = ?').run(id);
-    db.prepare('DELETE FROM projects WHERE id = ?').run(id);
-    if (root) for (const sha of shas) gcObjectIfUnreferenced(db, root, sha);
+    // BLK-01：行 + FTS + 资产文件 + 镜像目录，一处收口（与 canvasDeleteProject 共用同一实现）
+    cleanup = sqlDeleteProjectRows(getDb(), id, dataRoot());
   } else {
     try { unlinkSync(projectFile(id)); } catch { /* 已不存在视为成功 */ }
     try { removeDataRootProject(id); } catch { /* 数据目录镜像清理失败不影响删除 */ }
   }
   try { addDeletedProjectId(id); } catch { /* 墓碑写失败不影响删除 */ }
-  return { ok: true };
+  // 清理失败必须可见：ok 保留删除语义，disk 字段给出磁盘侧实际结果
+  return { ok: true, disk: cleanup };
 }
 async function projectsSync() {
   const cfg = readIcConfig();
@@ -1480,6 +1542,9 @@ function writeIcDoc(id, doc) {
         id, String(doc.name || id).slice(0, 80), doc.createdAt || Date.now(), doc.updatedAt || Date.now(),
         doc.bibleUpdatedAt || 0, JSON.stringify(docSummary(doc)), JSON.stringify(doc.tombstones || []), JSON.stringify(doc),
       );
+    // SQL 模式也要保证数据目录里有 meta 映射（craft 清理/物理落盘按 folder 定位）：
+    // 目录与 project.json 镜像不再是主存储，但 folder 登记是 /api/asset 落盘与 ArtCraft 基准的前提。
+    try { ensureProjectFolder(id, (doc && doc.name) || id); } catch { /* meta 写失败不阻塞主存储 */ }
     return;
   }
   const f = projectFile(id);
@@ -1698,13 +1763,10 @@ async function canvasDeleteProject(args) {
   let name = id;
   const prevDoc = readDocOrNull(id);
   if (prevDoc && prevDoc.name) name = prevDoc.name;
+  let cleanup = null;
   if (sqlActive()) {
-    const db = getDb();
-    const root = dataRoot();
-    const shas = db.prepare('SELECT DISTINCT sha FROM assets WHERE project_id = ? AND sha IS NOT NULL').all(id).map((r) => r.sha);
-    db.prepare('DELETE FROM assets WHERE project_id = ?').run(id);
-    db.prepare('DELETE FROM projects WHERE id = ?').run(id);
-    if (root) for (const sha of shas) gcObjectIfUnreferenced(db, root, sha);
+    // BLK-01：与 projectsDelete 共用同一清理实现（行 + FTS + 资产文件 + 镜像目录）
+    cleanup = sqlDeleteProjectRows(getDb(), id, dataRoot());
   } else {
     try { unlinkSync(projectFile(id)); } catch { /* 已删除 */ }
     try { removeDataRootProject(id); } catch { /* 数据目录镜像清理失败不影响删除 */ }
@@ -1712,14 +1774,15 @@ async function canvasDeleteProject(args) {
   // 通知客户端把这个项目也从本地删掉，否则下次推送会把它复活 + 长效墓碑：拒收迟到的推送
   const cfg = readIcConfig();
   const prev = (cfg.ui && cfg.ui.deletedProjects) || [];
-  const prevTomb = Array.isArray(cfg.ui.deletedProjectIds) ? cfg.ui.deletedProjectIds : [];
+  // 防御：config 里可能根本没有 ui 段（新装/被手工清空）——直接解引用 cfg.ui 会 TypeError 打断删除
+  const prevTomb = Array.isArray(cfg.ui && cfg.ui.deletedProjectIds) ? cfg.ui.deletedProjectIds : [];
   cfg.ui = {
     ...(cfg.ui || {}),
     deletedProjects: [...new Set([...prev, id])].slice(-50),
     deletedProjectIds: [...new Set([...prevTomb, id])].slice(-200),
   };
   writeIcConfig(cfg);
-  return { ok: true, projectId: id, name };
+  return { ok: true, projectId: id, name, disk: cleanup };
 }
 async function canvasDeleteNode(args) {
   const id = String((args && args.projectId) || '');
@@ -1834,24 +1897,169 @@ async function canvasNodeStatus(args) {
         : [],
       // 音效/环境音：声音设计提示，随镜头透出给对话侧与视频提示词
       sfx: String((s && s.sfx) || '').slice(0, 120),
+      // 分镜衔接（分段生成的接戏依据）：接点尾态/运镜延续/起始态/段落类型——对话侧改写 shots 时必须一起带回
+      tail: String((s && s.tail) || '').slice(0, 160),
+      cam: String((s && s.cam) || '').slice(0, 120),
+      start: String((s && s.start) || '').slice(0, 160),
+      seg: String((s && s.seg) || '').slice(0, 24),
     }))
     : undefined;
+  const d = n.data || {};
   return {
-    projectId: pid, nodeId, type: n.type, label: (n.data && n.data.label) || '',
-    status: (n.data && n.data.status) || 'idle',
-    aiStatus: (n.data && n.data.aiStatus) || 'idle',
-    error: (n.data && (n.data.error || n.data.aiError)) || null,
-    output: String((n.data && n.data.output) || '').slice(0, 6000),
-    idea: String((n.data && n.data.idea) || '').slice(0, 2000),
-    assetId: (n.data && n.data.assetId) || null,
+    projectId: pid, nodeId, type: n.type, label: d.label || '',
+    status: d.status || 'idle',
+    aiStatus: d.aiStatus || 'idle',
+    // 文档级时间戳：canvas_generate_node 的等待循环用它区分「本轮真的跑过」与「上一次的残留终态」
+    docUpdatedAt: Number(doc.updatedAt) || 0,
+    error: d.error || d.aiError || null,
+    output: String(d.output || '').slice(0, 6000),
+    idea: String(d.idea || '').slice(0, 2000),
+    // 生成节点的对话框提示词与生成参数：对话侧读取后可精准改写（配合 canvas_update_node），不必删节点重建
+    prompt: String(d.prompt || '').slice(0, 4000),
+    text: String(d.text || '').slice(0, 4000),
+    script: String(d.script || '').slice(0, 2000),
+    requirement: String(d.requirement || '').slice(0, 1000),
+    ratio: d.ratio || null,
+    size: d.size || null,
+    duration: d.duration == null ? null : Number(d.duration),
+    resolution: d.resolution || null,
+    frameMode: d.frameMode || null,
+    count: d.count == null ? null : Number(d.count),
+    imageModel: d.imageModel || null,
+    videoModel: d.videoModel || null,
+    model: d.model || null,
+    stopNote: d.stopNote || null,
+    genWarn: d.genWarn || null,
+    lastAssetId: d.lastAssetId || null,
+    // 尾帧「最佳选帧」（续帧接力首选：动作进行中/清晰/不抖）
+    tailPickAssetId: d.lastPickAssetId || null,
+    tailPick: d.tailPickMeta || null,
+    // 续帧来源：'wired'=首帧来自 frame 连线；节点 id=自动取上一段视频尾帧
+    chainFrom: d.chainFrom || null,
+    // 接缝校验：{ ok, sim, thr, note }——同场续帧阈值 0.55 / 跨场 0.35 / 特写插入 0.15
+    seam: d.seam || null,
+    historyAssetIds: Array.isArray(d.history) ? d.history.map((x) => x && x.assetId).filter(Boolean).slice(-20) : [],
+    assetId: d.assetId || null,
     // 视频任务凭据：中断/超时后对话侧可凭 id 回查结果（钱花了就必须能找回）
-    taskId: (n.data && n.data.taskId) || null,
-    taskQueryUrl: (n.data && n.data.taskQueryUrl) || null,
+    taskId: d.taskId || null,
+    taskQueryUrl: d.taskQueryUrl || null,
     // 分镜表：一致性告警随状态返回——对话侧据此逐条补全设定集（缺失则要自动补充，绝不忽略）
-    warnings: Array.isArray(n.data && n.data.warnings) ? n.data.warnings : [],
+    warnings: Array.isArray(d.warnings) ? d.warnings : [],
     shots,
   };
 }
+/** 可被 canvas_update_node 修改的节点字段白名单（结构字段 id/type/x/y/w/h/data 一律不可写）。 */
+const NODE_PATCH_FIELDS = ['prompt', 'idea', 'output', 'text', 'script', 'requirement', 'label', 'ratio', 'size', 'duration', 'resolution', 'frameMode', 'count', 'imageModel', 'videoModel', 'model', 'cont'];
+/** 更新已有节点的字段：对话侧"改提示词 / 改参数"的唯一入口（此前只能删节点重建）。 */
+function canvasUpdateNode(args) {
+  const pid = String((args && args.projectId) || '');
+  const nodeId = String((args && args.nodeId) || '');
+  const doc = readDoc(pid);
+  const n = doc.nodes[nodeId];
+  if (!n) throw new Error('节点不存在: ' + nodeId + '（先用 canvas_list_projects 查看节点 id）');
+  const patch = (args && args.patch) || {};
+  const keys = Object.keys(patch);
+  if (!keys.length && patch.shots === undefined) throw new Error('patch 为空：请给出要修改的字段，如 { "prompt": "……" }');
+  const applied = [];
+  const skipped = [];
+  for (const k of keys) {
+    if (k === 'shots') continue; // 单独处理
+    if (!NODE_PATCH_FIELDS.includes(k)) { skipped.push(k); continue; }
+    let v = patch[k];
+    if (k === 'duration' || k === 'count') {
+      const num = Number(v);
+      // count 允许 0（=自动按内容节拍，与 canvasCreateNode 的语义一致）；duration 必须正数
+      if (!Number.isFinite(num) || num < 0 || (k === 'duration' && num <= 0)) {
+        throw new Error(k + (k === 'count' ? ' 需要非负数（0=自动按内容节拍）' : ' 需要正数') + '，收到：' + JSON.stringify(v));
+      }
+      v = k === 'count' ? Math.round(num) : num;
+    } else if (k === 'label') {
+      v = String(v == null ? '' : v).slice(0, 40);
+    } else if (k === 'cont') {
+      v = !(v === false || v === 'false' || v === 0 || v === '0'); // 分镜衔接开关：默认开
+    } else {
+      v = String(v == null ? '' : v);
+    }
+    n.data[k] = v;
+    applied.push(k);
+  }
+  if (patch.shots !== undefined) {
+    let arr = patch.shots;
+    if (typeof arr === 'string') {
+      try { arr = JSON.parse(arr); } catch { throw new Error('shots 需要 JSON 数组或 JSON 字符串'); }
+    }
+    if (!Array.isArray(arr)) throw new Error('shots 需要 JSON 数组');
+    // shots 是**整表替换**：只改一镜也必须先把全量读出来再传回（否则其它镜的 tail/cam 会被冲掉）。
+    // 这里做两层兜底：① 合法的 seg 取值归一化 ② 旧表里有衔接字段而新值没给时，按镜序保留旧值。
+    const oldShots = Array.isArray(n.data.shots) ? n.data.shots : [];
+    const SEG_OK = new Set(['opening', 'continuation', 'new_character', 'scene_change', 'closeup', 'cut', '']);
+    const SEG_NORM = { cut: 'closeup', close: 'closeup', insert: 'closeup', cont: 'continuation', open: 'opening', scene: 'scene_change' };
+    arr = arr.map((sh, i) => {
+      if (!sh || typeof sh !== 'object') return sh;
+      const out = { ...sh };
+      const segRaw = String(out.seg || '').trim().toLowerCase();
+      out.seg = SEG_NORM[segRaw] || (SEG_OK.has(segRaw) ? segRaw : '');
+      const old = oldShots[i] || {};
+      // 只补「本来是空的 + 旧值有」的衔接字段，绝不覆盖调用方明确给的新值
+      for (const k2 of ['tail', 'cam', 'start', 'seg']) {
+        if (!out[k2] && old[k2]) out[k2] = old[k2];
+      }
+      return out;
+    });
+    n.data.shots = arr;
+    applied.push('shots');
+  }
+  if (!applied.length) {
+    throw new Error('没有可应用的字段（允许：' + NODE_PATCH_FIELDS.join(' / ') + ' / shots）；收到：' + keys.join(' / '));
+  }
+  doc.updatedAt = Date.now();
+  writeIcDoc(pid, doc);
+  markDocChanged(pid);
+  return { projectId: pid, nodeId, type: n.type, label: n.data.label || '', applied, skipped, prompt: String(n.data.prompt || '').slice(0, 400) };
+}
+/** 触发节点执行并（可选）等待到终态：对话侧"改完提示词 → 点生成 → 拿结果"的一站式入口。
+ *  执行发生在画布侧（需要浏览器开着画布页面消费运行请求），等待超时不代表失败。 */
+async function canvasGenerateNode(args) {
+  const pid = String((args && args.projectId) || '');
+  const nodeId = String((args && args.nodeId) || '');
+  const waitSec = Math.max(0, Math.min(600, Number((args && args.waitSeconds) || 0)));
+  // 触发前快照：canvasRunNode 只写一次性 runRequest，真正的执行要等画布下一个 3s 同步 tick
+  // 才开始（状态才翻成 running）；而下面的首轮轮询在 2.5s 就发生——对**曾经跑过**的节点，
+  // 首轮会读到上一次的 done/error 并误当本次结果（页面关闭 100%、页开约 17% 触发）。
+  // 因此终态只有在「本轮确实跑过」时才可信：轮询中见过 running，或文档在触发后被写过
+  //（快进完成的短任务可能整体落在两次轮询之间，用文档时间戳兜底）。
+  const baseline = await canvasNodeStatus({ projectId: pid, nodeId }).catch(() => null);
+  const baseUpdatedAt = Number(baseline && baseline.docUpdatedAt) || 0;
+  const run = await canvasRunNode({ projectId: pid, nodeId });
+  if (!waitSec) {
+    return { ok: true, triggered: true, finished: false, projectId: pid, nodeId, type: run.type, label: run.label, status: 'running', note: '已触发执行；画布需处于打开状态才会真正执行，可用 canvas_node_status 查询进度' };
+  }
+  const deadline = Date.now() + waitSec * 1000;
+  let last = null;
+  let sawRunning = false;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 2500));
+    try { last = await canvasNodeStatus({ projectId: pid, nodeId }); } catch { continue; }
+    const st = String(last.status || '');
+    const ai = String(last.aiStatus || '');
+    if (st === 'running' || ai === 'running') { sawRunning = true; continue; }
+    // 终态可信门：没见过 running 且文档也没动过 → 这是触发前就挂着的旧终态，继续等
+    const confirmed = sawRunning || (baseUpdatedAt > 0 && (Number(last.docUpdatedAt) || 0) > baseUpdatedAt);
+    if (!confirmed) continue;
+    const isAiNode = last.type === 'script' || last.type === 'storyboard';
+    if (isAiNode) {
+      if (ai === 'error') return { ok: false, triggered: true, finished: true, projectId: pid, nodeId, type: last.type, label: last.label, status: 'error', error: last.error || 'AI 生成失败' };
+      if (ai !== 'running' && (String(last.output || '').trim() || (Array.isArray(last.shots) && last.shots.length))) {
+        return { ok: true, triggered: true, finished: true, projectId: pid, nodeId, type: last.type, label: last.label, status: 'done' };
+      }
+    } else if (st === 'done' || st === 'error') {
+      return { ok: st === 'done', triggered: true, finished: true, projectId: pid, nodeId, type: last.type, label: last.label, status: st, assetId: last.assetId || null, error: last.error || null };
+    }
+  }
+  const started = sawRunning || (last && (Number(last.docUpdatedAt) || 0) > baseUpdatedAt && baseUpdatedAt > 0);
+  return { ok: true, triggered: true, finished: false, projectId: pid, nodeId, type: last ? last.type : run.type, label: last ? last.label : run.label, status: last ? last.status : 'running',
+    note: started ? '等待超时，任务仍在进行；可继续用 canvas_node_status 查询' : '等待超时且未见本轮开始执行——画布页面很可能未打开（运行请求未被消费）；打开画布后会自动继续' };
+}
 async function canvasOpen(args) {
   const pid = String((args && args.projectId) || '');
   if (pid) {
@@ -1871,9 +2079,9 @@ const PORT_TABLE = {
   'script': { inputs: [], outputs: [{ id: 'out', kind: 'text' }] },
   'storyboard': { inputs: [{ id: 'prev', kind: 'text' }, { id: 'script', kind: 'text' }], outputs: [{ id: 'out', kind: 'text' }, { id: 'tail', kind: 'text' }] },
   'image-gen': { inputs: [{ id: 'prompt', kind: 'text' }, { id: 'ref', kind: 'image' }], outputs: [{ id: 'out', kind: 'image' }] },
-  'video-gen': { inputs: [{ id: 'prompt', kind: 'text' }, { id: 'frame', kind: 'image' }, { id: 'ref', kind: 'image' }], outputs: [{ id: 'out', kind: 'video' }, { id: 'last', kind: 'image' }] },
+  'video-gen': { inputs: [{ id: 'prompt', kind: 'text' }, { id: 'frame', kind: 'image' }, { id: 'ref', kind: 'image' }], 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: [] },
 };
@@ -2061,7 +2269,7 @@ async function updateInstall() {
 export const inject = ['webServer', 'tools'];
 
 // 仅供诊断 / 自动化测试（不属于 RPC 面，运行时行为不受影响）
-export const _internals = { updateCheck, updateInstall, npmLatestVersion, cmpVer, findPnpm, getProfileDir: () => PROFILE_DIR, getVersion: () => VERSION, dataRoot, setDataRoot, dataRootMigrate, dataRootImport, ensureProjectFolder, physicalRel, mirrorProjectToDataRoot, writeAssetIndex, removeAssetIndexEntry, readDataRootMeta, removeDataRootProject, deletedProjectIds, addDeletedProjectId, clearDeletedProjectId, fetchProxyForward, storyboardConsistencyWarnings, readAssetIndexNames, safeJoin, mimeOf, pipeFile, getIcConfigPath: () => CONFIG_PATH, canvasCreateProject, canvasWriteNode, canvasConnect, canvasDeleteProject, canvasDeleteNode, canvasRunNode, canvasNodeStatus, canvasGetBible, canvasUpdateBible, canvasCreateNode, canvasOpen, projectsList, projectsPut, projectsGet, projectsDelete, projectsSync, sqliteAvailable: () => !!SQLITE, getDb, closeDb, dbAssetsList, dbAssetsGet, dbAssetNames, dbAssetCreate, dbAssetUpdate, dbAssetDelete, dbObjectsGc, objectAbsFor, readDocOrNull, docExists, sqlActive, rpcMethods: () => _rpcMethods };
+export const _internals = { updateCheck, updateInstall, npmLatestVersion, cmpVer, findPnpm, getProfileDir: () => PROFILE_DIR, getVersion: () => VERSION, dataRoot, setDataRoot, dataRootMigrate, dataRootImport, ensureProjectFolder, physicalRel, mirrorProjectToDataRoot, writeAssetIndex, removeAssetIndexEntry, readDataRootMeta, removeDataRootProject, sqlDeleteProjectRows, deletedProjectIds, addDeletedProjectId, clearDeletedProjectId, fetchProxyForward, storyboardConsistencyWarnings, readAssetIndexNames, safeJoin, mimeOf, pipeFile, getIcConfigPath: () => CONFIG_PATH, canvasCreateProject, canvasWriteNode, canvasConnect, canvasDeleteProject, canvasDeleteNode, canvasRunNode, canvasNodeStatus, canvasGetBible, canvasUpdateBible, canvasCreateNode, canvasOpen, projectsList, projectsPut, projectsGet, projectsDelete, projectsSync, sqliteAvailable: () => !!SQLITE, getDb, closeDb, dbAssetsList, dbAssetsGet, dbAssetNames, dbAssetCreate, dbAssetUpdate, dbAssetDelete, objectAbsFor, ftsReconcile, readDocOrNull, docExists, sqlActive, rpcMethods: () => _rpcMethods, canvasUpdateNode, canvasGenerateNode };
 
 function resolveModel(providers, want) {
   const byProvider = want && want.provider
@@ -2223,6 +2431,74 @@ export function apply(ctx) {
         if (root) { try { exists = statSync(root).isDirectory(); } catch { /* 不存在 */ } }
         return { dataRoot: root, exists, configPath: CONFIG_PATH, sql: !!SQLITE, store: sqlActive() ? 'sqlite' : 'json' };
       },
+      /** BLK-02：项目在数据根下的**绝对目录** = <dataRoot>/projects/<物理文件夹>。
+       *  画布调 ArtCraft 时以它为 base（ArtCraft 0.3.x 无数据根概念、/status 也不再返回 dataRoot），
+       *  避免「无 base 的相对路径」被按插件进程 cwd 解析而静默写错目录。 */
+      async projectDirGet(args) {
+        const root = dataRoot();
+        const pid = String((args && args.projectId) || '');
+        if (!root) return { ok: false, error: '未设置数据根目录', projectId: pid };
+        if (!pid) return { ok: false, error: '缺少 projectId', projectId: pid };
+        const meta = readDataRootMeta();
+        const entry = meta.projects.find((p) => p.id === pid) || null;
+        const folder = entry ? entry.folder : sanitizeFolderName(pid);
+        const abs = path.join(root, 'projects', folder);
+        try { mkdirSync(abs, { recursive: true }); } catch { /* 目录建不出来交给调用方报错 */ }
+        return { ok: true, projectId: pid, folder, abs, dataRoot: root, legacy: !entry };
+      },
+      // IC-B4：FTS 存量孤儿一次性清理（幂等，可重复调；无 SQLite 时明确说不适用）
+      async ftsReconcile() {
+        if (!sqlActive()) return { ok: false, error: '当前不是 SQLite 存储模式，无 FTS 需要清理', applicable: false };
+        return ftsReconcile(getDb());
+      },
+      /** IC-B2：删除项目时清理其目录下的 craft/（ArtCraft 后期产物）。
+       *  客户端知道自己要删哪个项目，Host 按项目物理文件夹定位（与 projectDirGet 同一基准），
+       *  只删 projects/<folder>/craft 这一个子目录——绝不碰项目镜像、其他项目、数据根其他内容。
+       *  幂等：目录不存在也是成功；失败可见（removed=false + reason），不静默吞。 */
+      async projectCraftRemove(args) {
+        const root = dataRoot();
+        const pid = String((args && args.projectId) || '');
+        if (!root) return { ok: false, error: '未设置数据根目录', projectId: pid };
+        if (!pid) return { ok: false, error: '缺少 projectId', projectId: pid };
+        const meta = readDataRootMeta();
+        const entry = meta.projects.find((p) => p.id === pid) || null;
+        const folder = entry ? entry.folder : sanitizeFolderName(pid);
+        const craftDir = path.join(root, 'projects', folder, 'craft');
+        // 防御：拼出来的必须是 <root>/projects/<folder>/craft，任何异常形态都拒绝执行
+        if (path.resolve(craftDir).toLowerCase() !== craftDir.toLowerCase() || !craftDir.toLowerCase().includes((path.join(root, 'projects')).toLowerCase())) {
+          return { ok: false, error: '拒绝执行：目标目录形态异常', projectId: pid, craftDir };
+        }
+        if (!existsSync(craftDir)) return { ok: true, removed: false, existed: false, craftDir, projectId: pid };
+        try {
+          rmrf(craftDir);
+          const gone = !existsSync(craftDir);
+          return { ok: gone, removed: gone, existed: true, craftDir, projectId: pid, error: gone ? null : '目录仍存在（可能被占用）' };
+        } catch (e) {
+          return { ok: false, removed: false, existed: true, craftDir, projectId: pid, error: String((e && e.message) || e) };
+        }
+      },
+      // 存储实况：一眼看清"是否真在用 SQLite 库、库在哪、多少数据"（客户端设置页显示）
+      async dbStats() {
+        const root = dataRoot();
+        const dbPath = root ? path.join(root, 'canvas.db') : null;
+        const out = {
+          ok: true, sqlite: !!SQLITE, store: sqlActive() ? 'sqlite' : (root ? 'json' : 'none'),
+          dataRoot: root, dbPath, dbExists: false, dbBytes: 0, walBytes: 0, projects: 0, assets: 0, fts: null,
+        };
+        if (dbPath) {
+          try { const st = statSync(dbPath); out.dbExists = st.isFile(); out.dbBytes = st.size; } catch { /* 无库 */ }
+          try { const st2 = statSync(dbPath + '-wal'); out.walBytes = st2.size; } catch { /* 无 WAL */ }
+        }
+        if (sqlActive()) {
+          try {
+            const db = getDb();
+            out.projects = db.prepare('SELECT COUNT(*) AS n FROM projects').get().n;
+            out.assets = db.prepare('SELECT COUNT(*) AS n FROM assets').get().n;
+            out.fts = metaGet(db, 'fts_tokenizer');
+          } catch (e) { out.error = String((e && e.message) || e); }
+        }
+        return out;
+      },
       async dataRootSet(args) {
         return setDataRoot((args && args.root) ?? '');
       },
@@ -2318,7 +2594,7 @@ export function apply(ctx) {
         const next = { ...cur, ...(patch.name !== undefined ? { name: String(patch.name).slice(0, 80) } : {}), ...(patch.category !== undefined ? { category: String(patch.category || 'general') } : {}) };
         return writeAssetIndex(String(next.projectId), '', [next]);
       },
-      async objectsGc() { return dbObjectsGc(); },
+      // CAS 对象库 GC 已随写路径退役（IC-08）：见 dbObjectsGc 位置的说明。
       // 一键迁移/对齐：旧 pid 文件夹 → 项目名文件夹 + 全部项目文档镜像（v1 JSON 模式专用）
       async dataRootMigrate() {
         if (sqlActive()) return { ok: true, skipped: 'sqlite（数据目录即主存储，无需布局迁移）' };
@@ -2542,7 +2818,7 @@ export function apply(ctx) {
             additionalProperties: false,
           },
           output: {
-            schema: { type: 'object', properties: { ok: { type: 'boolean' }, text: { type: 'string' }, status: { type: 'string' }, assetId: { type: 'string' }, warnings: { type: 'array', items: { type: 'string' } }, shots: { type: 'array', items: { type: 'object', properties: { index: { type: 'number' }, title: { type: 'string' }, duration: { type: 'number' }, visual: { type: 'string' }, motion: { type: 'string' }, characters: { type: 'array', items: { type: 'string' } }, scene: { type: 'string' }, props: { type: 'array', items: { type: 'string' } } } } } }, required: ['ok', 'text'] },
+            schema: { type: 'object', properties: { ok: { type: 'boolean' }, text: { type: 'string' }, status: { type: 'string' }, assetId: { type: 'string' }, prompt: { type: 'string' }, ratio: { type: 'string' }, size: { type: 'string' }, duration: { type: 'number' }, resolution: { type: 'string' }, frameMode: { type: 'string' }, imageModel: { type: 'string' }, videoModel: { type: 'string' }, genWarn: { type: 'string' }, chainFrom: { type: 'string' }, seam: { type: 'object', properties: { ok: { type: 'boolean' }, sim: { type: 'number' }, thr: { type: 'number' }, note: { type: 'string' } } }, tailPickAssetId: { type: 'string' }, historyAssetIds: { type: 'array', items: { type: 'string' } }, warnings: { type: 'array', items: { type: 'string' } }, shots: { type: 'array', items: { type: 'object', properties: { index: { type: 'number' }, title: { type: 'string' }, duration: { type: 'number' }, visual: { type: 'string' }, motion: { type: 'string' }, tail: { type: 'string' }, cam: { type: 'string' }, start: { type: 'string' }, seg: { type: 'string' }, characters: { type: 'array', items: { type: 'string' } }, scene: { type: 'string' }, props: { type: 'array', items: { type: 'string' } } } } } }, required: ['ok', 'text'] },
             render: (args, value) => [{ type: 'text', text: String(value.text || '') }],
           },
           timeoutMs: 30000,
@@ -2560,8 +2836,11 @@ export function apply(ctx) {
               lines.push('镜头清单（' + shots.length + ' 镜，总时长 ' + shots.reduce((a, x) => a + (Number(x.duration) || 0), 0) + 's）——视频提示词的镜头序列以此为准:');
               shots.forEach((sh) => {
                 const dl = (sh.dialogue || []).map((d) => d.role + '：' + d.line).join('；');
-                lines.push(sh.index + '. ' + sh.title + '（' + sh.duration + 's）角色:' + (sh.characters.join('/') || '-') + '｜场景:' + (sh.scene || '-') + '｜道具:' + (sh.props.join('/') || '-')
+                lines.push(sh.index + '. ' + sh.title + '（' + sh.duration + 's）' + (sh.seg ? '[' + sh.seg + '] ' : '') + '角色:' + (sh.characters.join('/') || '-') + '｜场景:' + (sh.scene || '-') + '｜道具:' + (sh.props.join('/') || '-')
                   + '\n   画面: ' + sh.visual + '\n   动作: ' + sh.motion
+                  + (sh.tail ? '\n   接点尾态(应写进下一镜起始态): ' + sh.tail : '')
+                  + (sh.cam ? '\n   运镜延续: ' + sh.cam : '')
+                  + (sh.start ? '\n   起始态: ' + sh.start : '')
                   + (dl ? '\n   台词: ' + dl : '')
                   + (sh.sfx ? '\n   音效: ' + sh.sfx : ''));
               });
@@ -2572,7 +2851,104 @@ export function apply(ctx) {
               lines.push('一致性告警（' + warnings.length + ' 条，须逐条 canvas_update_bible 补全，名称逐字一致）:');
               warnings.forEach((w) => lines.push(' · ' + w));
             }
-            return { ok: true, status: s.status, assetId: s.assetId || undefined, warnings: warnings.length ? warnings : undefined, shots: shots.length ? shots : undefined, text: lines.join('\n') };
+            // 生成节点的对话框提示词与参数：对话侧据此精准改写（canvas_update_node），不必删节点重建
+            if (s.prompt) lines.push('对话框提示词:\n' + s.prompt);
+            const params = [];
+            if (s.ratio) params.push('比例 ' + s.ratio);
+            if (s.size) params.push('清晰度 ' + s.size);
+            if (s.duration != null) params.push('时长 ' + s.duration + 's');
+            if (s.resolution) params.push('分辨率 ' + s.resolution);
+            if (s.frameMode) params.push('衔接 ' + s.frameMode);
+            if (s.count != null && s.count > 0) params.push('镜头数 ' + s.count);
+            if (s.imageModel) params.push('图片模型 ' + s.imageModel);
+            if (s.videoModel) params.push('视频模型 ' + s.videoModel);
+            if (params.length) lines.push('生成参数: ' + params.join(' · '));
+            if (s.historyAssetIds.length) lines.push('历史产物（' + s.historyAssetIds.length + ' 条，最新在最后）: ' + s.historyAssetIds.join(', '));
+            if (s.genWarn) lines.push('生成告警: ' + s.genWarn);
+            // 分镜衔接状态：续帧来源 + 接缝校验 + 最佳选帧（对话侧汇报成片质量时要一并说明）
+            if (s.chainFrom) lines.push('续帧: ' + (s.chainFrom === 'wired' ? '首帧来自 frame 连线（上一段尾帧）' : '自动取上一段视频的尾帧作首帧'));
+            if (s.seam) lines.push('接缝校验: ' + (s.seam.ok ? '通过' : '偏跳') + (s.seam.sim != null ? '（相似度 ' + s.seam.sim + '，阈值 ' + s.seam.thr + '）' : '') + (s.seam.note ? ' — ' + s.seam.note : ''));
+            if (s.tailPick && s.tailPickAssetId) lines.push('尾帧最佳选帧: ' + Number(s.tailPick.t || 0).toFixed(2) + 's 处（得分 ' + s.tailPick.score + '）资产 ' + s.tailPickAssetId);
+            return {
+              ok: true, status: s.status, assetId: s.assetId || undefined,
+              prompt: s.prompt || undefined, ratio: s.ratio || undefined, size: s.size || undefined,
+              duration: s.duration == null ? undefined : s.duration, resolution: s.resolution || undefined,
+              frameMode: s.frameMode || undefined, imageModel: s.imageModel || undefined, videoModel: s.videoModel || undefined,
+              genWarn: s.genWarn || undefined,
+              chainFrom: s.chainFrom || undefined, seam: s.seam || undefined,
+              tailPickAssetId: s.tailPickAssetId || undefined,
+              historyAssetIds: s.historyAssetIds.length ? s.historyAssetIds : undefined,
+              warnings: warnings.length ? warnings : undefined, shots: shots.length ? shots : undefined,
+              text: lines.join('\n'),
+            };
+          },
+        });
+        reg({
+          name: 'canvas_update_node',
+          description: '修改无限画布上**已有节点**的字段（改提示词、改比例/清晰度/时长/分辨率等参数）——"改节点"的唯一入口，改完不必删节点重建。可改字段：prompt（图片/视频节点的对话框提示词）、idea/output（剧本节点）、text（文本节点的正文）、script/requirement（分镜表的剧本来源与额外要求）、shots（分镜镜头清单，JSON 数组）、label（节点名）、ratio、size、duration、resolution、frameMode、count、imageModel、videoModel、model、cont（分镜表「分镜衔接」开关，默认 true；关掉后拆镜不写衔接字段、视频不自动续帧）。结构字段（id/type/坐标/宽高）不可改。改完用 canvas_generate_node 触发生成。**前提**：先用 canvas_node_status 读到当前内容，再只传要改的字段。**注意 shots 是整表替换**：只改一镜也要先把 canvas_node_status 返回的全部 shots 取回、改完再整体传回；否则其它镜的 tail/cam/seg 会被冲掉（服务端会按镜序兜底保留，但不要依赖它）。',
+          parameters: {
+            type: 'object',
+            properties: {
+              projectId: { type: 'string', description: '项目 id' },
+              nodeId: { type: 'string', description: '节点 id（来自 canvas_list_projects）' },
+              patch: {
+                type: 'object',
+                description: '要修改的字段（只传需要改的，其余保持不动）',
+                properties: {
+                  prompt: { type: 'string', description: '图片/视频生成节点的提示词（对话框内容）' },
+                  idea: { type: 'string', description: '剧本节点的创作意图' },
+                  output: { type: 'string', description: '剧本节点的成稿' },
+                  text: { type: 'string', description: '文本节点的正文' },
+                  script: { type: 'string', description: '分镜表的剧本来源' },
+                  requirement: { type: 'string', description: '分镜表的额外要求' },
+                  label: { type: 'string', description: '节点名（≤40 字）' },
+                  ratio: { type: 'string', description: '比例，如 16:9 / 9:16 / 1:1' },
+                  size: { type: 'string', description: '图片清晰度：1K / 2K / 4K' },
+                  duration: { type: 'number', description: '视频时长（秒，正数）' },
+                  resolution: { type: 'string', description: '视频分辨率，如 720P / 1080P / 2K' },
+                  frameMode: { type: 'string', description: '衔接模式：auto / hard / off' },
+                  count: { type: 'number', description: '分镜表镜头数（0=自动）' },
+                  imageModel: { type: 'string', description: '图片模型（供应商|模型引用）' },
+                  videoModel: { type: 'string', description: '视频模型（供应商|模型引用）' },
+                  model: { type: 'string', description: '文本模型（剧本/分镜节点）' },
+                  shots: { type: 'array', items: { type: 'object' }, description: '分镜镜头清单（整表替换）' },
+                },
+                additionalProperties: false,
+              },
+            },
+            required: ['projectId', 'nodeId', 'patch'],
+            additionalProperties: false,
+          },
+          output: textOutput,
+          timeoutMs: 30000,
+          async execute(args) {
+            const r = canvasUpdateNode(args);
+            const skipped = Array.isArray(r.skipped) && r.skipped.length ? '（已忽略不可改字段：' + r.skipped.join('、') + '）' : '';
+            return { ok: true, projectId: r.projectId, nodeId: r.nodeId, label: r.label || undefined, text: '✅ 已更新节点[' + r.type + ']「' + (r.label || r.nodeId) + '」字段：' + r.applied.join('、') + skipped + '。需要重新生成请调用 canvas_generate_node。' };
+          },
+        });
+        reg({
+          name: 'canvas_generate_node',
+          description: '触发节点执行并（可选）等到结束——"改完提示词 → 点生成 → 拿结果"的一站式入口（等价于点画布上的生成按钮）。执行由画布侧用节点上配置的模型真实运行，**画布页面必须处于打开状态**；等待超时不代表失败（任务仍在继续，可用 canvas_node_status 继续查）。waitSeconds=0 表示只触发不等待；图片通常 30–120s，视频数分钟。',
+          parameters: {
+            type: 'object',
+            properties: {
+              projectId: { type: 'string', description: '项目 id' },
+              nodeId: { type: 'string', description: '节点 id' },
+              waitSeconds: { type: 'number', description: '可选：等待秒数（0=只触发；上限 600）' },
+            },
+            required: ['projectId', 'nodeId'],
+            additionalProperties: false,
+          },
+          output: textOutput,
+          timeoutMs: 660000,
+          async execute(args) {
+            const r = await canvasGenerateNode(args);
+            const head = '🚀 已触发[' + r.type + ']「' + (r.label || r.nodeId) + '」';
+            const tail = r.finished
+              ? (r.ok ? '✅ 已完成（状态 ' + r.status + (r.assetId ? '，产物资产 ' + r.assetId : '') + '）' : '❌ 失败：' + (r.error || r.status))
+              : '⏳ ' + (r.note || '仍在进行');
+            return { ok: r.ok !== false, projectId: r.projectId, nodeId: r.nodeId, status: r.status || undefined, assetId: r.assetId || undefined, text: head + '。' + tail };
           },
         });
         reg({
@@ -2615,7 +2991,10 @@ export function apply(ctx) {
           timeoutMs: 30000,
           async execute(args) {
             const r = await canvasDeleteProject(args);
-            return { ok: true, projectId: r.projectId, text: '🗑 已删除项目「' + r.name + '」（id=' + r.projectId + '）。' };
+            // 磁盘清理失败必须可见：rmrf 部分失败（文件锁）时目录残留，同名重建会继承旧文件
+            const diskErrs = r.disk && Array.isArray(r.disk.errors) ? r.disk.errors : [];
+            const warn = diskErrs.length ? '⚠ 磁盘清理有 ' + diskErrs.length + ' 项失败：' + diskErrs.join('；') : '';
+            return { ok: diskErrs.length === 0, warning: diskErrs.length ? diskErrs : undefined, projectId: r.projectId, text: '🗑 已删除项目「' + r.name + '」（id=' + r.projectId + '）。' + (warn ? '\n' + warn : '') };
           },
         });
         reg({
@@ -2938,7 +3317,8 @@ export function apply(ctx) {
           }
         },
       }),
-      // CAS 对象库（0.18）：POST 上传（内容寻址去重）+ GET 读取（immutable + Range，远程访问与视频拖动友好）
+      // CAS 对象库读路径（0.18）：0.18.0–0.18.4 上传的媒体仍在 objects/ 里，必须继续可读。
+      // IC-08 起写路径已退役（POST/PUT 一律 405），只有 GET。
       ctx.webServer.register({
         kind: 'exact',
         path: `/${NAME}/api/object`,
@@ -2946,42 +3326,16 @@ export function apply(ctx) {
           try {
             const root = dataRoot();
             if (!root) throw new Error('未设置数据根目录');
-            if (req.method === 'POST' || req.method === 'PUT') {
-              const odir = objectsDirFor(root);
-              mkdirSync(odir, { recursive: true });
-              const tmp = path.join(odir, '.tmp-' + process.pid + '-' + Date.now());
-              const hash = createHash('sha256');
-              let size = 0;
-              const MAX_UPLOAD = 512 * 1024 * 1024;
-              await new Promise((resolve, reject) => {
-                const ws = createWriteStream(tmp);
-                const fail = (err) => {
-                  try { ws.destroy(); } catch { /* 忽略 */ }
-                  try { unlinkSync(tmp); } catch { /* 忽略 */ }
-                  reject(err);
-                };
-                req.on('data', (c) => { size += c.length; hash.update(c); if (size > MAX_UPLOAD) fail(new Error('文件过大（上限 512MB）')); });
-                req.on('error', fail);
-                req.on('aborted', () => fail(new Error('上传中断')));
-                ws.on('error', fail);
-                ws.on('finish', resolve);
-                req.pipe(ws);
-              });
-              const sha = hash.digest('hex');
-              const dest = objectAbsFor(root, sha);
-              let deduped = false;
-              if (existsSync(dest)) {
-                try { unlinkSync(tmp); } catch { /* 忽略 */ }
-                deduped = true; // 内容已存在：内容寻址天然去重
-              } else {
-                mkdirSync(path.dirname(dest), { recursive: true });
-                renameSync(tmp, dest);
-              }
+            // IC-08：写路径已退役——新上传一律经 /api/asset 落项目文件夹。
+            // 明确回 4xx 而不是静默接受：挂着旧版本 JS 的标签页 POST 过来时必须看得见失败。
+            if (req.method !== 'GET') {
+              res.statusCode = 405;
               res.setHeader('content-type', 'application/json; charset=utf-8');
-              res.end(JSON.stringify({ ok: true, sha, size, deduped }));
+              res.setHeader('allow', 'GET');
+              res.end(JSON.stringify({ error: '对象库写路径已退役（0.18.5 起新上传走 /api/asset 落项目文件夹）；本路由仅支持 GET 读取历史对象' }));
               return;
             }
-            if (req.method === 'GET') {
+            {
               const u = new URL(req.url, 'http://localhost');
               const sha = String(u.searchParams.get('sha') || '').toLowerCase();
               if (!/^[0-9a-f]{64}$/.test(sha)) { res.statusCode = 400; res.end('非法 sha256'); return; }
@@ -3014,9 +3368,6 @@ export function apply(ctx) {
               }
               return;
             }
-            res.statusCode = 405;
-            res.setHeader('content-type', 'application/json; charset=utf-8');
-            res.end(JSON.stringify({ error: '仅接受 GET/POST/PUT' }));
           } catch (e) {
             res.statusCode = 400;
             res.setHeader('content-type', 'application/json; charset=utf-8');