made-bridge 0.3.5 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "made-bridge",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "码得（made）独立语音编程设备的电脑侧桥接器：工作台 API、设备接口、任务调度与插件运行时。一条命令启动，配合 ESP32 固件使用，源码在 github.com/jobop/made。",
   "type": "module",
   "license": "MIT",

package/public/app.js

@@ -297,6 +297,28 @@ import { t, m, getLocale, setLocale, supportedLocales, applyStaticTranslations,
           showToast(error.message || t('app.065'), true);
         } finally { state.busy.delete('rename-session'); render(); }
       }
+      /** 工具调用轨迹（仅桥接器网页端展示，不下发设备）：可折叠列表。 */
+      function toolTrace(job) {
+        const calls = Array.isArray(job.toolCalls) ? job.toolCalls.filter((call) => call && safeString(call.name)) : [];
+        if (!calls.length) return null;
+        const details = document.createElement('details');
+        details.className = 'tool-trace';
+        const summary = document.createElement('summary');
+        summary.textContent = t('app.231', { v0: calls.length });
+        details.append(summary);
+        const list = text('div', 'tool-trace-list');
+        for (const call of [...calls].reverse()) {
+          const line = text('div', `tool-trace-line ${call.state === 'completed' ? 'done' : 'active'}`);
+          line.append(
+            text('span', 'tool-trace-mark', call.state === 'completed' ? '✓' : '…'),
+            text('span', 'tool-trace-name', safeString(call.name)),
+          );
+          if (safeString(call.detail)) line.append(text('code', 'tool-trace-detail', safeString(call.detail)));
+          list.append(line);
+        }
+        details.append(list);
+        return details;
+      }
       function renderJobs() {
         if (!$('jobList')) return;
         const list = $('jobList'); list.replaceChildren();
@@ -319,6 +341,7 @@ import { t, m, getLocale, setLocale, supportedLocales, applyStaticTranslations,
         card.append(top, text('div', 'job-instruction', t('app.073', { v0: (job.instruction || t('app.072')) })));
         const answer = turnAnswer(job);
         card.append(text('p', `job-summary turn-answer ${job.error && !job.retryPending ? 'error' : ''}`, t('app.077', { v0: (providerName(job.provider)), v1: (safeString(answer)) })));
+        const trace = toolTrace(job); if (trace) card.append(trace);
         if (job.provider === 'codex' && job.retryPending) {
           card.append(text('p', 'job-retry-notice', t('app.078')));
         }
@@ -329,7 +352,7 @@ import { t, m, getLocale, setLocale, supportedLocales, applyStaticTranslations,
         if (actions.children.length) { const bottom = text('div', 'job-bottom'); bottom.append(actions); card.append(bottom); }
         list.append(card);
       }
-      /** 历史会话抽屉：当前任务的全部指令与回复，新的在上。数据来自 /api/state 的 jobs。 */
+      /** 历史会话抽屉：当前任务的全部指令与回复，从第一轮按时间往下排。数据来自 /api/state 的 jobs。 */
       function renderHistory() {
         const button = $('historyDrawerButton');
         const overlay = $('historyDrawerOverlay');
@@ -346,18 +369,20 @@ import { t, m, getLocale, setLocale, supportedLocales, applyStaticTranslations,
           list.append(text('p', 'history-empty', t('app.229')));
           return;
         }
+        // /api/state 的 jobs 是新→旧，反转成第一轮在最上面，编号也按时间顺序。
         [...jobs].reverse().forEach((job, index) => {
           const info = jobStatus(job);
           const turn = text('article', 'history-turn');
           const top = text('div', 'history-turn-top');
           top.append(
-            text('span', 'turn-number', t('app.228', { v0: jobs.length - index })),
+            text('span', 'turn-number', t('app.228', { v0: index + 1 })),
             text('span', 'history-turn-time', formatDateTime(job.createdAt)),
             text('span', `job-status ${info.css}`, info.label),
           );
           turn.append(top, text('div', 'history-turn-instruction', job.instruction || t('app.072')));
           const answer = turnAnswer(job);
           if (answer) turn.append(text('p', `history-turn-answer ${job.error && !job.retryPending ? 'error' : ''}`, answer));
+          const trace = toolTrace(job); if (trace) turn.append(trace);
           list.append(turn);
         });
       }

package/public/i18n-messages.js

@@ -905,8 +905,8 @@ export const messages = {
     "en": "History"
   },
   "app.227": {
-    "zh-CN": "这个任务的全部指令与回复，新的在上面。",
-    "en": "Every instruction and reply of this task, newest first."
+    "zh-CN": "这个任务的全部指令与回复，第一轮在最上面。",
+    "en": "Every instruction and reply of this task, oldest first."
   },
   "app.228": {
     "zh-CN": "第 {v0} 轮",
@@ -920,6 +920,14 @@ export const messages = {
     "zh-CN": "关闭",
     "en": "Close"
   },
+  "app.231": {
+    "zh-CN": "工具调用（{v0}）",
+    "en": "Tool calls ({v0})"
+  },
+  "app.232": {
+    "zh-CN": "进行中",
+    "en": "running"
+  },
   "tunnel.official.title": {
     "zh-CN": "官方入口",
     "en": "Official links"

package/public/styles.css

@@ -461,6 +461,26 @@
     .history-turn-instruction { margin: 9px 0 0; font-size: var(--font-body); font-weight: 600; line-height: 1.55; white-space: pre-wrap; overflow-wrap: anywhere; }
     .history-turn-answer { margin: 7px 0 0; color: var(--muted); font-size: var(--font-body); line-height: 1.6; white-space: pre-wrap; overflow-wrap: anywhere; }
     .history-turn-answer.error { color: var(--red); }
+
+    /* 工具调用轨迹：仅桥接器网页端展示，可折叠；设备端不携带该数据 */
+    .tool-trace { margin: 2px 0 12px; border: 1px dashed var(--line); border-radius: 12px; background: var(--panel); }
+    .tool-trace summary { padding: 9px 13px; color: var(--muted); font-size: var(--font-small); font-weight: 700; cursor: pointer; user-select: none; list-style: none; display: flex; align-items: center; gap: 7px; }
+    .tool-trace summary::-webkit-details-marker { display: none; }
+    .tool-trace summary::after { content: '+'; margin-left: auto; color: var(--dim); font-size: 16px; }
+    .tool-trace[open] summary::after { content: '–'; }
+    .tool-trace summary:hover { color: var(--green-deep); }
+    .tool-trace-list { display: grid; gap: 6px; max-height: 320px; overflow-y: auto; padding: 4px 13px 12px; }
+    .tool-trace-line { display: flex; align-items: baseline; gap: 8px; min-width: 0; font-size: var(--font-small); line-height: 1.5; }
+    .tool-trace-mark { flex: 0 0 auto; color: var(--green); font-weight: 700; }
+    .tool-trace-line.active .tool-trace-mark { color: var(--blue); animation: tool-trace-pulse 1.2s ease-in-out infinite; }
+    @keyframes tool-trace-pulse { 0%, 100% { opacity: 1; } 50% { opacity: .35; } }
+    .tool-trace-name { flex: 0 0 auto; color: var(--text); font-weight: 600; }
+    .tool-trace-detail { flex: 1; min-width: 0; overflow-x: auto; white-space: nowrap; color: var(--muted); background: var(--panel-2); border: 1px solid var(--line); border-radius: 8px; padding: 2px 8px; font-size: 13px; }
+    @media (max-width: 650px) {
+      .tool-trace-line { flex-wrap: wrap; }
+      .tool-trace-detail { flex-basis: 100%; white-space: normal; overflow-wrap: anywhere; }
+    }
+
     @media (max-width: 650px) {
       .history-head { padding: 18px 16px 13px; }
       .history-list { padding: 14px 16px 24px; }

package/src/agent-sprites.mjs

@@ -52,24 +52,81 @@ function readManifestFile(dir) {
   }
 }
 
+/**
+ * 整帧状态动画表（可选）。素材明说「每个状态播哪几帧、多快、眨眼怎么插」，
+ * 固件照表播放，不推断素材结构。有这张表时 layers 可以省略。
+ * 返回归一化的 { [state]: { frames: [...], ms } } 或 null（没声明）。
+ */
+function validateFramesTable(raw) {
+  if (raw.frames === undefined) return null;
+  const table = raw.frames;
+  if (!table || typeof table !== 'object' || Array.isArray(table)) {
+    throw new SpriteError('manifest.frames 必须是对象');
+  }
+  const allowed = new Set([...MOOD_NAMES, 'blink']);
+  const out = {};
+  let total = 0;
+  for (const [state, entry] of Object.entries(table)) {
+    if (!allowed.has(state)) throw new SpriteError(`frames 含未知状态：${state}`);
+    let files = null;
+    const extra = {};
+    if (Array.isArray(entry)) {
+      files = entry;
+    } else if (entry && typeof entry === 'object') {
+      const keys = Object.keys(entry);
+      if (keys.some((key) => !['frames', 'ms', 'period_ms', 'hold_ms'].includes(key))) {
+        throw new SpriteError(`frames.${state} 含不支持的字段`);
+      }
+      if (!Array.isArray(entry.frames)) throw new SpriteError(`frames.${state}.frames 必须是数组`);
+      files = entry.frames;
+      if (entry.ms !== undefined && !isInt(entry.ms, 30, 2000)) throw new SpriteError(`frames.${state}.ms 范围 30–2000`);
+      if (entry.ms !== undefined) extra.ms = entry.ms;
+      if (entry.period_ms !== undefined && !isInt(entry.period_ms, 500, 60000)) throw new SpriteError(`frames.${state}.period_ms 范围 500–60000`);
+      if (entry.period_ms !== undefined) extra.period_ms = entry.period_ms;
+      if (entry.hold_ms !== undefined && !isInt(entry.hold_ms, 30, 2000)) throw new SpriteError(`frames.${state}.hold_ms 范围 30–2000`);
+      if (entry.hold_ms !== undefined) extra.hold_ms = entry.hold_ms;
+    } else {
+      throw new SpriteError(`frames.${state} 必须是数组或对象`);
+    }
+    if (files.length < 1 || files.length > MAX_FRAMES ||
+        files.some((file) => typeof file !== 'string' || !FILE_NAME.test(file))) {
+      throw new SpriteError(`frames.${state} 需要 1–${MAX_FRAMES} 个 PNG 文件名`);
+    }
+    total += files.length;
+    if (total > 12) throw new SpriteError('frames 总帧数超过 12（设备内存上限）');
+    out[state] = { frames: [...files], ...extra };
+  }
+  if (Object.keys(out).length < 1 || !out.idle) throw new SpriteError('frames 至少要声明 idle 轨道');
+  if (raw.frame_ms !== undefined && !isInt(raw.frame_ms, 30, 2000)) {
+    throw new SpriteError('manifest.frame_ms 范围 30–2000');
+  }
+  return out;
+}
+
 function validateManifest(raw) {
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new SpriteError('manifest 必须是对象');
-  if (Object.keys(raw).some((key) => !['version', 'canvas', 'layers', 'motion', 'emotions', 'actions', 'commands'].includes(key))) {
+  if (Object.keys(raw).some((key) => !['version', 'canvas', 'layers', 'frames', 'frame_ms', 'motion', 'emotions', 'actions', 'commands'].includes(key))) {
     throw new SpriteError('manifest 包含不支持的字段');
   }
   if (!isInt(raw.version, 1, 2147483647)) throw new SpriteError('manifest.version 必须是正整数');
+  // 整帧状态动画（声明式）：有 frames 表就不再需要 layers。固件只照表播放，
+  // 不去推断素材结构；老素材（layers 分层叠加）行为不变。
+  const frameTracks = validateFramesTable(raw);
   const canvas = raw.canvas;
   if (!canvas || typeof canvas !== 'object' || Array.isArray(canvas) ||
       !isInt(canvas.w, 1, 512) || !isInt(canvas.h, 1, 512) ||
       Object.keys(canvas).some((key) => !['w', 'h'].includes(key))) {
     throw new SpriteError('manifest.canvas 必须是 {w, h}（各 1–512）');
   }
-  if (!Array.isArray(raw.layers) || raw.layers.length < 1 || raw.layers.length > MAX_LAYERS) {
-    throw new SpriteError(`manifest.layers 需要 1–${MAX_LAYERS} 层`);
+  // 整帧模式（frames 表）不需要 layers；分层模式 layers 必填。
+  if (!frameTracks) {
+    if (!Array.isArray(raw.layers) || raw.layers.length < 1 || raw.layers.length > MAX_LAYERS) {
+      throw new SpriteError(`manifest.layers 需要 1–${MAX_LAYERS} 层`);
+    }
   }
   const seen = new Set();
   const referenced = new Set();
-  for (const layer of raw.layers) {
+  if (Array.isArray(raw.layers)) for (const layer of raw.layers) {
     if (!layer || typeof layer !== 'object' || Array.isArray(layer)) throw new SpriteError('layers 条目必须是对象');
     const keys = Object.keys(layer);
     if (keys.some((key) => !['id', 'file', 'frames', 'x', 'y', 'z', 'blink', 'talk', 'alert'].includes(key))) {
@@ -225,6 +282,7 @@ function validateManifest(raw) {
   return {
     version: raw.version, canvas: canvas, layers: raw.layers, motion: raw.motion ?? null,
     emotions: raw.emotions ?? null, actions: raw.actions ?? null, commands: raw.commands ?? null,
+    frames: frameTracks ?? null, frame_ms: raw.frame_ms ?? null,
   };
 }
 
@@ -269,11 +327,19 @@ export function readSprite(packageDir) {
       if (action && typeof action.gif === 'string') gifReferencedHint.add(action.gif);
     }
   }
+  const declaredNames = new Set();
+  if (Array.isArray(manifest.layers)) {
+    for (const layer of manifest.layers) {
+      for (const file of layer.frames !== undefined ? layer.frames : [layer.file]) declaredNames.add(file);
+    }
+  }
+  if (manifest.frames) {
+    for (const track of Object.values(manifest.frames)) for (const file of track.frames) declaredNames.add(file);
+  }
   for (const name of fs.readdirSync(spriteDir)) {
     const lower = name.toLowerCase();
     if (lower.endsWith('.png')) {
-      const referenced = manifest.layers.some((layer) =>
-        (layer.frames !== undefined ? layer.frames : [layer.file]).includes(name));
+      const referenced = declaredNames.has(name);
       if (!referenced) {
         console.error(`[plugins] sprite 提示：${path.basename(spriteDir)}/${name} 未被 manifest 引用，不会被下发（建议删除旧素材省空间）`);
       }
@@ -283,8 +349,7 @@ export function readSprite(packageDir) {
   }
   let total = 0;
   const files = [];
-  for (const layer of manifest.layers) {
-    for (const file of layer.frames !== undefined ? layer.frames : [layer.file]) {
+  for (const file of declaredNames) {
       const target = path.join(spriteDir, file);
       let bytes;
       try {
@@ -297,7 +362,6 @@ export function readSprite(packageDir) {
       if (total > SPRITE_MAX_TOTAL_BYTES) throw new SpriteError(`sprite/ 整包超过 512 KB`);
       const data = fs.readFileSync(target);
       files.push({ file, bytes, sha256: createHash('sha256').update(data).digest('hex') });
-    }
   }
   // GIF 动作引用的动画文件（多个动作共用同一文件只下发一份）
   if (manifest.actions) {
@@ -321,6 +385,7 @@ export function readSprite(packageDir) {
   const value = Object.freeze({
     dir: spriteDir, version: manifest.version, canvas: manifest.canvas,
     layers: manifest.layers, motion: manifest.motion, emotions: manifest.emotions,
+    frames: manifest.frames, frame_ms: manifest.frame_ms,
     actions: manifest.actions, commands: manifest.commands,
     files: Object.freeze(files.map((file) => Object.freeze(file))),
   });

package/src/agents/events.mjs

@@ -36,19 +36,108 @@ export function streamActivity(event) {
   return '';
 }
 
+// 工具调用捕获：从 CLI 原始 JSONL 事件里抽 {name, detail, state}，只进桥接器
+// 任务记录（网页端折叠展示），绝不混入设备进度文本。codex 的 item.* 事件与
+// Claude 风格的 tool_call/assistant 事件都覆盖；认不出的形状安静返回 null。
+const TOOL_DETAIL_LIMIT = 600;
+
+function truncate(value, limit = TOOL_DETAIL_LIMIT) {
+  const text = String(value ?? '').trim();
+  return text.length <= limit ? text : `${text.slice(0, limit)}…（截断）`;
+}
+
+function toolDetail(parts) {
+  return truncate(parts.filter((part) => String(part || '').trim()).join('  '));
+}
+
+export function toolCallFromEvent(event) {
+  if (event.type === 'tool_call' && event.tool_call && typeof event.tool_call === 'object') {
+    const name = Object.keys(event.tool_call)[0] || '';
+    const args = event.tool_call[name];
+    return {
+      name: truncate(name, 120),
+      detail: toolDetail([name, typeof args === 'string' ? args : JSON.stringify(args)]),
+      state: event.subtype === 'completed' ? 'completed' : 'started',
+      key: '',
+    };
+  }
+  if (event.type === 'stream_event' && event.event?.type === 'content_block_start' &&
+      event.event.content_block?.type === 'tool_use') {
+    return {
+      name: truncate(event.event.content_block.name, 120),
+      detail: toolDetail([event.event.content_block.name,
+        JSON.stringify(event.event.content_block.input ?? '')]),
+      state: 'started', key: String(event.event.index ?? ''),
+    };
+  }
+  if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
+    const block = event.message.content.find((part) => part?.type === 'tool_use');
+    if (!block) return null;
+    return {
+      name: truncate(block.name, 120),
+      detail: toolDetail([block.name, JSON.stringify(block.input ?? '')]),
+      state: 'started', key: String(block.id ?? ''),
+    };
+  }
+  if (event.type !== 'item.started' && event.type !== 'item.completed') return null;
+  const item = event.item;
+  if (!item || typeof item !== 'object') return null;
+  const completed = event.type === 'item.completed';
+  switch (item.type) {
+    case 'command_execution':
+      return { name: '命令执行', detail: toolDetail([item.command, item.cwd]), state: completed ? 'completed' : 'started', key: String(item.id ?? '') };
+    case 'file_change':
+      return {
+        name: '文件修改',
+        detail: toolDetail(Array.isArray(item.changes)
+          ? item.changes.map((change) => `${change?.path || ''}${change?.kind ? ` (${change.kind})` : ''}`)
+          : []),
+        state: completed ? 'completed' : 'started', key: String(item.id ?? ''),
+      };
+    case 'mcp_tool_call': case 'collab_tool_call':
+      return { name: truncate(item.tool || '工具调用', 120), detail: toolDetail([item.tool, JSON.stringify(item.arguments ?? '')]), state: completed ? 'completed' : 'started', key: String(item.id ?? '') };
+    case 'web_search':
+      return { name: '网页搜索', detail: toolDetail([item.query]), state: completed ? 'completed' : 'started', key: String(item.id ?? '') };
+    case 'reasoning': case 'agent_message': case 'todo_list': case 'error':
+      return null;
+    default:
+      return null;
+  }
+}
+
 // Only categorical activity is emitted by builtin adapters; raw tool arguments
-// and reasoning never become the device progress text.
+// and reasoning never become the device progress text. Tool calls are drained
+// separately (takeToolCalls) for the bridge UI only.
 export function jsonLineEvents(interpret, onProgress = () => {}, onSession = () => {}) {
   let pending = '';
   let rawTail = '';
   let discardingOversized = false;
   let sawEvent = false;
   const state = { lastMessage: '', assistantDeltas: '', finalResult: '', terminalError: '' };
+  // 半开工具调用：key → 在 calls 里的引用。completed 事件来时把对应条目置为
+  // 完成；对不上号（CLI 没给 id 或乱序）就当作独立条目追加，宁可多一行。
+  const open = new Map();
+  const calls = [];
+  const record = (call) => {
+    if (!call || !call.name) return;
+    if (call.state === 'completed' && call.key && open.has(call.key)) {
+      const entry = open.get(call.key);
+      entry.state = 'completed';
+      if (call.detail && call.detail.length > entry.detail.length) entry.detail = call.detail;
+      open.delete(call.key);
+      return;
+    }
+    const entry = { name: call.name, detail: call.detail || '', state: call.state, at: new Date().toISOString() };
+    calls.push(entry);
+    if (calls.length > 80) calls.splice(0, calls.length - 80);
+    if (entry.state === 'started' && call.key) open.set(call.key, entry);
+  };
   const consume = (line) => {
     let event;
     try { event = JSON.parse(line); } catch { return; }
     if (!event || typeof event !== 'object' || typeof event.type !== 'string') return;
     sawEvent = true;
+    record(toolCallFromEvent(event));
     const update = interpret(event, state) || {};
     if (typeof update.sessionId === 'string') onSession(update.sessionId);
     if (update.activity) onProgress(update.activity);
@@ -69,12 +158,17 @@ export function jsonLineEvents(interpret, onProgress = () => {}, onSession = ()
     },
     finish() {
       if (!discardingOversized && pending.trim()) consume(pending);
+      for (const entry of open.values()) entry.state = 'completed';
+      open.clear();
       return {
         result: (state.finalResult || state.lastMessage || (sawEvent ? '任务已执行，未返回文字摘要。' : rawTail.trim())).slice(-8000),
         hasAssistantText: Boolean(state.finalResult || state.lastMessage || !sawEvent),
         error: state.terminalError, rawTail,
       };
     },
+    takeToolCalls() {
+      return calls.splice(0, calls.length);
+    },
   };
 }
 

package/src/agents/shared.mjs

@@ -109,7 +109,7 @@ function changeFooter(state, message) {
   return state.changed ? `${message('改动文件：')}\n${state.changed}` : message('没有检测到代码改动。');
 }
 
-export function runCli({ job, project, signal, onProgress, onSession, config, model }, adapter) {
+export function runCli({ job, project, signal, onProgress, onSession, onTool, config, model }, adapter) {
   const startingGitSnapshot = repositorySnapshot(project.path);
   const message = (value) => translateKnownMessage(value, config.locale);
   // 每轮都拼上权限边界：用户原文一字不改，边界文案按界面语言翻译。
@@ -139,8 +139,10 @@ export function runCli({ job, project, signal, onProgress, onSession, config, mo
     let timer;
     // 卡死看门狗：编程工具进程连续 idleMs 没有任何输出（进度、流式、stderr 都算）
     // 视为卡死，杀掉进程树并把错误标记为可自动重跑，由任务车道决定是否重试。
+    // 默认跟 config.mjs 对齐到 15 分钟：CLI 工具的 stdout/stderr 都算活动，但素材
+    // 管线里外部生图是异步轮询，单张上限 300s 且期间不吐字，5 分钟会误杀。
     const idleMs = Number(config?.stuckIdleMs)
-      || Math.max(1, Number(config?.stuckIdleMinutes) || 5) * 60 * 1000;
+      || Math.max(1, Number(config?.stuckIdleMinutes) || 15) * 60 * 1000;
     let idleTimer;
     const bumpIdle = () => {
       clearTimeout(idleTimer);
@@ -189,6 +191,9 @@ export function runCli({ job, project, signal, onProgress, onSession, config, mo
     child.stdout.on('data', (chunk) => {
       bumpIdle();
       events.write(chunk);
+      // 工具调用只走 onTool（桥接器任务记录，网页端折叠展示），不进设备进度文本。
+      const forwarded = events.takeToolCalls?.() || [];
+      for (const call of forwarded) onTool?.(call);
     });
     child.stderr.on('data', (chunk) => {
       bumpIdle();

package/src/config.mjs

@@ -128,9 +128,11 @@ export function loadConfig(env = process.env) {
     };
   });
   const defaultProject = raw.defaultProject || projects[0].id;
-  const defaultProvider = raw.defaultProvider || 'codex';
-  if (!seen.has(defaultProject) || !PLUGIN_ID.test(defaultProvider)) {
-    throw new Error('默认项目或默认编程工具不在配置中');
+  // 默认编程助手只是可选偏好（未指定 provider 时兜底），不再是必须存在的"主力"：
+  // 可以留空——没有助手享有特权，入口处没指定就明确报错让用户选。
+  const defaultProvider = typeof raw.defaultProvider === 'string' && PLUGIN_ID.test(raw.defaultProvider) ? raw.defaultProvider : '';
+  if (!seen.has(defaultProject)) {
+    throw new Error('默认项目不在配置中');
   }
   const port = Number(raw.port || 8787);
   const devicePort = Number(raw.devicePort || 8788);
@@ -147,7 +149,11 @@ export function loadConfig(env = process.env) {
   }
   // 卡死自愈：任务连续 N 分钟没有任何输出（进度/流式/stderr 都算）视为卡死，
   // 桥接器杀掉编程工具进程并自动重跑，最多 maxAutoRetries 次。
-  const stuckIdleMinutes = Number(env.VIBE_STUCK_IDLE_MINUTES ?? raw.stuckIdleMinutes ?? 5);
+  // 默认 15 分钟而不是 5 分钟：素材管线里一次外部生图是「提交异步任务 + 每 6s
+  // 轮询」，单张最长 300s（body 240s + sheet 300s ≈ 9 分钟），且轮询期间工具
+  // 不吐字。5 分钟会把一条正在正常跑的长任务当成卡死杀掉（2026-10-24 雪球
+  // jojo 任务被自己的看门狗反复打断实锤）。
+  const stuckIdleMinutes = Number(env.VIBE_STUCK_IDLE_MINUTES ?? raw.stuckIdleMinutes ?? 15);
   if (!Number.isInteger(stuckIdleMinutes) || stuckIdleMinutes < 1 || stuckIdleMinutes > 60) {
     throw new Error('卡死判定时长必须是 1 到 60 之间的整数（分钟）');
   }

package/src/i18n.mjs

@@ -59,8 +59,9 @@ const messages = new Map([
   ['插件状态检查必须同步返回', 'The plugin status check must return synchronously'],
   ['任务已取消', 'Task cancelled'],
   ['默认编程助手未安装或已禁用', 'The default assistant is not installed or is disabled'],
-  ['这是默认编程助手，不能停用；请先在设置里把默认编程助手切换为其他助手', 'This is the default assistant and cannot be disabled; switch the default assistant to another one in settings first'],
-  ['这是默认编程助手，不能删除；请先在设置里把默认编程助手切换为其他助手', 'This is the default assistant and cannot be removed; switch the default assistant to another one in settings first'],
+  ['请先选择编程助手', 'Choose an assistant first'],
+  ['请先在电脑桥接器里选择编程助手', 'Choose an assistant in the desktop bridge first'],
+  ['请指定编程助手（createTask 需要显式 agentId）', 'Specify an assistant (createTask requires an explicit agentId)'],
   ['配对请求格式无效', 'Invalid pairing request'],
   ['设备名称无效', 'Invalid device name'],
   ['电脑配对窗口未开启', 'Pairing is not open on the computer'],

package/src/installed.mjs

@@ -189,11 +189,12 @@ export async function setPluginEnabled(config, id, enabled) {
   if (!PLUGIN_ID.test(id || '')) throw fail('插件不存在');
   const installed = (await listInstalled(config)).plugins;
   if (!installed.some((plugin) => plugin.id === id)) throw fail('插件不存在');
-  // 默认编程助手不能停用：loadConfiguredPlugins 会守卫 defaultProvider，
-  // 但那里的报错不含操作指引，用户只会看到一句没头没尾的「未安装或已禁用」。
-  // 在动作入口给出可操作的前置报错。
-  if (!enabled && id === config.defaultProvider) {
-    throw fail('这是默认编程助手，不能停用；请先在设置里把默认编程助手切换为其他助手');
+  // 默认助手只是可选偏好，不再是"主力"：停用它时直接清掉默认指向，不拦人。
+  const previousDefault = config.defaultProvider || '';
+  let defaultCleared = false;
+  if (!enabled && id === previousDefault) {
+    config.defaultProvider = '';
+    defaultCleared = true;
   }
   const previous = [...(config.disabledPlugins || [])];
   const next = new Set(previous);
@@ -204,12 +205,17 @@ export async function setPluginEnabled(config, id, enabled) {
     await reload(config);
   } catch (error) {
     config.disabledPlugins = previous;
+    if (defaultCleared) config.defaultProvider = previousDefault;
     throw error;
   }
   try {
-    writeConfig(config, (raw) => { raw.disabledPlugins = config.disabledPlugins; });
+    writeConfig(config, (raw) => {
+      raw.disabledPlugins = config.disabledPlugins;
+      if (defaultCleared) raw.defaultProvider = '';
+    });
   } catch (error) {
     config.disabledPlugins = previous;
+    if (defaultCleared) config.defaultProvider = previousDefault;
     await reload(config);
     throw error;
   }
@@ -252,11 +258,10 @@ export async function removePlugin(config, { id = '', file = '' } = {}) {
   target = removalTarget(config, target);
   const described = await describeModule(target, config);
   const ids = described.map((plugin) => plugin.id).filter((item) => PLUGIN_ID.test(item));
-  // 同 setPluginEnabled：删默认助手会被 defaultProvider 守卫拦下但报错没有指引，
-  // 在动作入口就说清楚（2026-10-18 实锤：删除 codex 后桥接器重启都起不来）。
-  if (ids.includes(config.defaultProvider)) {
-    throw fail('这是默认编程助手，不能删除；请先在设置里把默认编程助手切换为其他助手');
-  }
+  // 默认助手只是可选偏好，不再是"主力"：删的就是默认助手时清掉指向，不拦人。
+  const previousDefault = config.defaultProvider || '';
+  const removesDefault = ids.includes(previousDefault);
+  if (removesDefault) config.defaultProvider = '';
   const previousDisabled = [...(config.disabledPlugins || [])];
   const previousPlugins = [...(config.plugins || [])];
   config.disabledPlugins = [...new Set([...previousDisabled, ...ids])];
@@ -266,10 +271,12 @@ export async function removePlugin(config, { id = '', file = '' } = {}) {
     writeConfig(config, (raw) => {
       raw.disabledPlugins = config.disabledPlugins;
       if (Array.isArray(raw.plugins)) raw.plugins = config.plugins;
+      if (removesDefault) raw.defaultProvider = '';
     });
   } catch (error) {
     config.disabledPlugins = previousDisabled;
     config.plugins = previousPlugins;
+    if (removesDefault) config.defaultProvider = previousDefault;
     await reload(config).catch(() => {});
     throw error;
   }

package/src/jobs.mjs

@@ -383,6 +383,34 @@ export class JobStore {
         job.updatedAt = now();
         this.save();
         this.hooks?.notify('started', job);
+        // —— 插件型助手的卡死看门狗 ——
+        // CLI 型插件由 agents/shared.mjs 的子进程 idle 看门狗覆盖；插件型（自带
+        // run() 与工具环的助手）此前完全没有超时：模型请求/工具调用不返回就永久
+        // 挂着，任务永远停在 running（2026-10-24 雪球 jojo 任务挂 15 分钟零输出
+        // 零产物实锤）。这里按「多久没有任何进展」判定，中止后交给车道自动重跑。
+        // 阈值必须大于素材管线的合法最长静默时长：外部生图是异步任务轮询，单张
+        // 上限 300s（body 240s + sheet 300s ≈ 9 分钟），期间完全没有文本进度。
+        // 默认 15 分钟（见 config.mjs）。
+        let lastActivity = Date.now();
+        const touchActivity = () => { lastActivity = Date.now(); };
+        const stallMs = Math.max(1, Number(this.stuckIdleMinutes) || 15) * 60_000;
+        let stalled = false;
+        const stallTimer = setInterval(() => {
+          if (job.status !== 'running') return;
+          const idle = Date.now() - lastActivity;
+          if (idle < stallMs) return;
+          stalled = true;
+          controller.abort(new Error(`任务 ${Math.round(idle / 60_000)} 分钟没有任何进展，疑似卡死`));
+        }, 15_000);
+        if (stallTimer.unref) stallTimer.unref();
+        // 单轮硬上限 30 分钟：素材管线一次从零生成（body + sheet）最坏约 10 分钟，
+        // 加上模型侧重试仍有余量。
+        const hardTimer = setTimeout(() => {
+          if (job.status !== 'running') return;
+          stalled = true;
+          controller.abort(new Error('任务单轮运行超过 30 分钟，已停止'));
+        }, 30 * 60_000);
+        if (hardTimer.unref) hardTimer.unref();
         try {
           this.ensureWorkspace(job.vibeSessionId);
           const project = this.projectFor(job);
@@ -395,6 +423,7 @@ export class JobStore {
               if (!progress || progress === job.progress) return;
               job.progress = progress;
               job.progressAt = now();
+              touchActivity();
               job.updatedAt = job.progressAt;
               const current = Date.now();
               if (current - (this.progressSavedAt.get(job.id) || 0) >= 750) {
@@ -413,6 +442,34 @@ export class JobStore {
               job.updatedAt = now();
               this.save();
             }
+          }, (tool) => {
+            // 工具调用轨迹：仅存任务记录给桥接器网页端折叠展示，设备端
+            // /device/tasks 是字段白名单，天然带不出去。
+            if (job.status !== 'running') return;
+            const name = String(tool?.name || '').trim();
+            if (!name) return;
+            const entry = {
+              name: name.slice(0, 120),
+              detail: String(tool?.detail || '').slice(0, 600),
+              state: tool?.state === 'completed' ? 'completed' : 'started',
+              at: now(),
+            };
+            const calls = Array.isArray(job.toolCalls) ? job.toolCalls : [];
+            // 同名同参数的 completed 覆盖前一条 started，避免每个工具占两行。
+            const previous = calls.length - 1 >= 0 ? calls[calls.length - 1] : null;
+            if (previous && previous.state === 'started' && previous.name === entry.name &&
+                previous.detail === entry.detail) {
+              previous.state = 'completed';
+            } else {
+              calls.push(entry);
+            }
+            job.toolCalls = calls.slice(-40);
+            touchActivity();
+            const current = Date.now();
+            if (current - (this.progressSavedAt.get(job.id) || 0) >= 750) {
+              this.progressSavedAt.set(job.id, current);
+              this.save();
+            }
           });
           if (job.status === 'running') {
             if (!outcome || !['completed', 'handed_off'].includes(outcome.status || 'completed')) {
@@ -434,6 +491,13 @@ export class JobStore {
             this.hooks?.notify(job.status, job);
           }
         } catch (error) {
+          if (stalled && job.status === 'running') {
+            // 看门狗中止（插件型助手）：按 CLI 型同样的语义交给车道自动重跑。
+            error = Object.assign(
+              new Error(`任务 ${Math.round(stallMs / 60_000)} 分钟没有任何进展，疑似卡死：已终止`),
+              { retryable: true, autoRetry: true },
+            );
+          }
           if (job.status === 'running') {
             // 卡死自愈：看门狗杀掉无输出的编程工具进程后，同车道自动重跑，
             // 最多 maxAutoRetries 次；重跑的是同一条指令（native 会话会 resume 同一 CLI 线程）。
@@ -462,6 +526,8 @@ export class JobStore {
             this.hooks?.notify('failed', job);
           }
         } finally {
+          clearInterval(stallTimer);
+          clearTimeout(hardTimer);
           this.controllers.delete(job.id);
           this.progressSavedAt.delete(job.id);
         }

package/src/plugins/enhance.mjs

@@ -91,6 +91,7 @@ export function createEnhancement(config) {
         if (!wired.jobs) throw new Error('桥接器尚未就绪');
         createTaskGuard();
         const provider = agentId || config.defaultProvider;
+        if (!provider) throw new Error('请指定编程助手（createTask 需要显式 agentId）');
         const project = projectId || wired.jobs.defaultProject;
         const session = wired.jobs.createSession({ provider, projectId: project, title });
         const job = wired.jobs.submit({ instruction, sessionId: session.id, provider, projectId: project, source: 'plugin' });

package/src/plugins/hot-reload.mjs

@@ -92,6 +92,14 @@ export async function reloadConfiguredPlugins(config) {
 }
 
 const RELOAD_DELAY_MS = 300;
+// 热加载单次超时：reloadConfiguredPlugins 一旦挂起（插件 import 死锁/网络
+// 等待），reloading 会永远停在 true，之后所有变更只排队、不再加载也
+// 不打日志——表现为「桥接器对素材改动完全无反应」（2026-10-24 实锤）。
+// 超时后强制解锁并记账，下一轮变更还能再试。
+const RELOAD_TIMEOUT_MS = 30000;
+// fs.watch 在 macOS 长跑进程里会静默失效（事件流断掉，无错误、无回调）。
+// 轮询兜底：按 mtime 快照比对，watch 哑了也能热加载。
+const POLL_INTERVAL_MS = 3000;
 
 function relevantChange(filename) {
   if (!filename) return true;
@@ -137,6 +145,12 @@ export function watchPlugins(config, { onReload } = {}) {
     if (closed) return;
     if (reloading) { pending = true; return; }
     reloading = true;
+    let timedOut = false;
+    const guard = setTimeout(() => {
+      timedOut = true;
+      console.error(`[plugins] 热加载超过 ${RELOAD_TIMEOUT_MS}ms 未返回，强制解锁`
+        + '（保留上一份插件；下一轮变更会再试）');
+    }, RELOAD_TIMEOUT_MS);
     try {
       await reloadConfiguredPlugins(config);
       const ids = config.pluginsRuntime?.agents?.().map((plugin) => plugin.id) ?? [];
@@ -146,7 +160,11 @@ export function watchPlugins(config, { onReload } = {}) {
       console.error(`[plugins] 热加载失败，继续使用上一份：${error.message}`);
       onReload?.(error);
     } finally {
+      clearTimeout(guard);
       reloading = false;
+      // 无论成败都刷新快照：否则轮询兜底会把同一次改动再触发一遍
+      // （fs.watch 与轮询双通道各来一次）。
+      snapshotMtimes();
       if (pending && !closed) {
         pending = false;
         schedule();
@@ -173,13 +191,58 @@ export function watchPlugins(config, { onReload } = {}) {
     arm(filename, false);
     arm(dir, false);
   }
-  if (watchers.length) console.error('[plugins] 正在监视插件变更');
+  // ---- 轮询兜底（fs.watch 静默失效时仍能热加载）----
+  const mtimes = new Map();
+
+  function collect(dir, depth, out) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (depth <= 0 || entry.name === 'node_modules') continue;
+        collect(path.join(dir, entry.name), depth - 1, out);
+        continue;
+      }
+      if (!relevantChange(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      try { out.set(full, fs.statSync(full).mtimeMs); } catch { /* 文件刚被删。 */ }
+    }
+  }
+
+  function scan() {
+    const out = new Map();
+    for (const root of pluginWatchRoots(config)) collect(root, 4, out);
+    return out;
+  }
+
+  function snapshotMtimes() {
+    mtimes.clear();
+    for (const [file, ms] of scan()) mtimes.set(file, ms);
+  }
+
+  function poll() {
+    if (closed || reloading) return;
+    const current = scan();
+    let changed = false;
+    for (const [file, ms] of current) {
+      if (mtimes.get(file) !== ms) { changed = true; break; }
+    }
+    if (!changed && current.size !== mtimes.size) changed = true;
+    mtimes.clear();
+    for (const [file, ms] of current) mtimes.set(file, ms);
+    if (changed && mtimes.size) schedule();
+  }
+
+  snapshotMtimes();
+  const pollTimer = setInterval(poll, POLL_INTERVAL_MS);
+  if (watchers.length) console.error('[plugins] 正在监视插件变更（含轮询兜底）');
 
   return {
     close() {
       closed = true;
       if (timer) clearTimeout(timer);
       timer = null;
+      clearInterval(pollTimer);
       for (const watcher of watchers) {
         try { watcher.close(); } catch { /* 已经关掉。 */ }
       }

package/src/plugins/registry.mjs

@@ -156,6 +156,7 @@ export async function loadConfiguredPlugins(config) {
     await loadFile(filename, label);
   }
   const registry = createPluginRegistry(plugins);
-  if (!registry.hasAgent(config.defaultProvider)) throw new Error('默认编程助手未安装或已禁用');
+  // 默认助手是可选偏好：配置了才校验存在性；留空表示没有兜底助手。
+  if (config.defaultProvider && !registry.hasAgent(config.defaultProvider)) throw new Error('默认编程助手未安装或已禁用');
   return registry;
 }

package/src/providers.mjs

@@ -60,7 +60,7 @@ export function providerStates(config, locale = config.locale) {
 }
 
 export function createRunner(config) {
-  const runner = async (job, project, signal, onProgress = () => {}, onSession = () => {}) => {
+  const runner = async (job, project, signal, onProgress = () => {}, onSession = () => {}, onTool = () => {}) => {
     const plugin = agentFor(config, job.provider);
     if (!plugin) throw new Error('编程工具插件未加载，请先安装或启用对应插件');
     if (signal.aborted) throw new Error('任务已取消');
@@ -71,6 +71,9 @@ export function createRunner(config) {
       job, project, signal, config, model,
       onProgress: plugin.capabilities.progress ? onProgress : () => {},
       onSession: plugin.capabilities.session === 'native' ? onSession : () => {},
+      // 工具调用轨迹（仅桥接器网页端展示）：CLI 型插件的 runCli 会自动消费，
+      // 不认识该字段的旧插件安全忽略。
+      onTool,
     });
   };
   runner.agent = (id) => agentFor(config, id);

package/src/server.mjs

@@ -251,7 +251,7 @@ export function createApp(config, { run, transcribe, tunnel: providedTunnel, ena
   const publicTunnel = (value = tunnel.summary()) => localizeStatus(value, config.locale);
   if (!config.pluginsRuntime && (config.plugins?.length || config.disabledPlugins?.length)) throw new Error('请先 await loadConfiguredPlugins(config) 并赋值 config.pluginsRuntime');
   config.pluginsRuntime ||= createPluginRegistry();
-  if (!config.pluginsRuntime.hasAgent(config.defaultProvider)) throw new Error('默认编程助手未安装或已禁用');
+  if (config.defaultProvider && !config.pluginsRuntime.hasAgent(config.defaultProvider)) throw new Error('默认编程助手未安装或已禁用');
   if (!config.speech) initializeSpeechSettings(config);
   config.models = { ...Object.fromEntries(config.pluginsRuntime.agents().filter(p => p.capabilities.model).map(p => [p.id, p.model?.default || ''])), ...(config.codexModel ? {codex: config.codexModel} : {}), ...config.models };
   validateModelSettings(Object.fromEntries(Object.entries(publicModels(config)).filter(([, value]) => value !== null)), config.pluginsRuntime);
@@ -909,6 +909,7 @@ export function createApp(config, { run, transcribe, tunnel: providedTunnel, ena
       }
       if (req.method === 'POST' && url.pathname === '/device/sessions') {
         const provider = url.searchParams.get('provider') || config.defaultProvider;
+        if (!provider) throw new Error('请先在电脑桥接器里选择编程助手');
         const projectId = url.searchParams.get('projectId') || config.defaultProject;
         if (!config.pluginsRuntime.hasAgent(provider)) throw new Error('未知编程工具');
         const payload = await body(req);
@@ -966,6 +967,9 @@ export function createApp(config, { run, transcribe, tunnel: providedTunnel, ena
           deviceSend(res, 200, {
             version: plugin.sprite.version, canvas: plugin.sprite.canvas,
             layers: plugin.sprite.layers, ...(plugin.sprite.motion ? { motion: plugin.sprite.motion } : {}),
+            // 整帧状态动画（声明式，固件照表播）；老素材没有这两项，照旧走分层叠加
+            ...(plugin.sprite.frames ? { frames: plugin.sprite.frames } : {}),
+            ...(plugin.sprite.frame_ms ? { frame_ms: plugin.sprite.frame_ms } : {}),
             ...(plugin.sprite.emotions ? { emotions: plugin.sprite.emotions } : {}),
             ...(plugin.sprite.actions ? { actions: plugin.sprite.actions } : {}),
             ...(plugin.sprite.commands ? { commands: plugin.sprite.commands } : {}),
@@ -1045,7 +1049,10 @@ export function createApp(config, { run, transcribe, tunnel: providedTunnel, ena
       }
       const match = url.pathname.match(/^\/device\/tasks\/([a-z0-9-]+)\/(confirm|cancel)$/);
       if (req.method === 'POST' && match) {
-        deviceSend(res, 200, publicJob(match[2] === 'confirm' ? store.confirm(match[1]) : store.cancel(match[1]), deviceLocale));
+        const confirmed = publicJob(match[2] === 'confirm' ? store.confirm(match[1]) : store.cancel(match[1]), deviceLocale);
+        // 工具调用轨迹只给桥接器网页端，任何设备回包都不携带。
+        const { toolCalls, ...deviceJob } = confirmed;
+        deviceSend(res, 200, deviceJob);
         return;
       }
       // 板端截屏回传：固件把当前画面以 RGB565 裸帧 POST 上来（tools/shot.mjs 触发）。

package/src/sessions.mjs

@@ -65,6 +65,7 @@ export class SessionStore {
 
   create({ provider, projectId, title, legacy = false, cliSessionId = '' } = {}) {
     const selectedProvider = provider || this.defaultProvider;
+    if (!selectedProvider) throw new Error('请先选择编程助手');
     const selectedProject = projectId || this.defaultProject;
     const plugin = this.agent(selectedProvider);
     if (!plugin && !(legacy && PROVIDER_ID.test(selectedProvider))) throw new Error('不支持的编程工具');