openclaw-openagent 1.0.0

package/src/plugin-ui/modules/remote-agent/render-hooks.js

@@ -0,0 +1,1609 @@
+// ── OpenAgent Render Hook v2 — 单一数据源 + 纯渲染 ──
+//
+// 架构：
+//   __cl_toolStates: 当前页面生命周期内的 DOM/phase 状态
+//   _clRemoteAgentProgressStore: 可替换存储层，保存卡片快照参数
+//   正常流式渲染只读写 __cl_toolStates；store 只是旁路记录，刷新后才用于恢复
+
+// ═══════════════════════════════════════════════════════════════
+// 单一数据源
+// ═══════════════════════════════════════════════════════════════
+
+var __cl_toolStates = new Map();
+// 每个 entry: { steps: [], phase: 'active'|'completed', cardNode: null, args: {} }
+
+var __cl_lastCallModel = null;   // 同一 render cycle 里 call card 的 model（供 result card 读取 agent 身份）
+var __cl_outputCardCache = new Map();  // toolCallId → cached output DOM
+var __cl_cardUiStates = new Map();     // execution/output 展开状态，避免 OpenClaw rerender 覆盖用户操作
+
+var CL_REMOTE_AGENT_PROGRESS_MODE_TRAVEL_TITLE = 'travel-title';
+var CL_REMOTE_AGENT_PROGRESS_MODE_GENERIC_STREAM = 'generic-stream';
+var CL_TRAVEL_TITLE_AGENT_IDS = {
+  '82bc858c-5021-4bda-83bc-1badd7f49049': true
+};
+var CL_TRAVEL_TITLE_AGENT_NAMES = {
+  '旅游梦想家': true
+};
+
+window.__openagentOwnsToolCards = function(cards) {
+  if (!Array.isArray(cards)) return false;
+  for (var i = 0; i < cards.length; i++) {
+    var card = cards[i] || {};
+    var name = String(card.name || '').toLowerCase();
+    var tcid = card.toolCallId || '';
+    var kind = typeof _clInferToolCardKind === 'function' ? _clInferToolCardKind(card) : (card.kind || '');
+    if (name.includes('call_remote_agent') || name.includes('openagent_delegate')) {
+      return true;
+    }
+    if (kind === 'result' && tcid && __cl_lastCallModel && tcid === __cl_lastCallModel.tcid) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// ═══════════════════════════════════════════════════════════════
+// WS 流式事件处理器 — 只写 __cl_toolStates
+// ═══════════════════════════════════════════════════════════════
+
+window.__cl_handleStreamEvent = function(msg) {
+  if (!msg || msg.stream !== 'tool') return;
+
+  var d = msg.data || {};
+  var phase = d.phase;
+  var toolCallId = d.toolCallId || '';
+  if (!toolCallId) return;
+
+  // ── start ──
+  if (phase === 'start') {
+    var name = d.name || (d.call && d.call.name) || '';
+    if (!_cl_isRemoteToolEvent(d, null)) return;
+
+    var wsArgs = _cl_getStreamArgs(d);
+    var existingState = __cl_toolStates.get(toolCallId);
+    if (existingState) {
+      existingState.args = _cl_mergeArgs(existingState.args, wsArgs);
+      existingState.progressMode = _cl_getRemoteAgentProgressMode(existingState.args, existingState.progressMode);
+      if (existingState.thinkChunks && existingState.thinkChunks.length > 0) {
+        _cl_rebuildThinkStepsByAgentMode(existingState);
+      }
+      existingState.phase = 'active';
+      if (typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore) {
+        _clRemoteAgentProgressStore.recordStart(toolCallId, { name: name, args: existingState.args || wsArgs });
+      }
+      return;
+    }
+
+    var state = _cl_createToolState(wsArgs);
+    __cl_toolStates.set(toolCallId, state);
+    if (typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore) {
+      _clRemoteAgentProgressStore.recordStart(toolCallId, { name: name, args: wsArgs });
+    }
+    console.log('[cl-stream] 🚀 start tcid=' + toolCallId.substring(0, 8));
+    return;
+  }
+
+  // ── update ──
+  if (phase === 'update') {
+    var rawText = _cl_extractText(d.partialResult || d.content);
+    if (!rawText) return;
+
+    _cl_logRawSseUpdate(toolCallId, rawText);
+
+    var chunks = _cl_parseLiveUpdateChunks(rawText, { toolCallId: toolCallId, rawText: rawText });
+    if (!chunks.length) {
+      console.log('[cl-stream] update without think chunks tcid=' + toolCallId.substring(0, 8)
+        + ' rawLen=' + rawText.length);
+      return;
+    }
+
+    var state = _cl_ensureRemoteToolState(toolCallId, d, rawText);
+    if (!state) return;
+
+    var changed = false;
+    var lastChunk = null;
+    var wasCompleted = state.phase === 'completed';
+    for (var ci = 0; ci < chunks.length; ci++) {
+      var chunk = chunks[ci];
+      lastChunk = chunk;
+
+      // 正常流程只用内存 state 驱动 UI；store 只是旁路记录，避免影响直播路径。
+      if (_cl_applyThinkChunkToLiveState(state, chunk)) changed = true;
+      if (typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore) {
+        _clRemoteAgentProgressStore.recordChunk(toolCallId, chunk);
+      }
+    }
+
+    console.log('[cl-diag][step] tcid=' + toolCallId.substring(0, 8)
+      + ' chunks=' + chunks.length
+      + ' lastIndex=' + (lastChunk && lastChunk.index !== undefined ? lastChunk.index : '')
+      + ' lastType=' + (lastChunk && lastChunk.thinkType || '')
+      + ' changed=' + changed
+      + ' steps=' + state.steps.length);
+
+    // 直接更新已渲染的 DOM（replay 进行中不直接更新，tick 会自然追上）
+    if (changed && state.cardNode && !state._replayActive) {
+      _cl_updateCardSteps(state.cardNode, state.steps);
+      if (wasCompleted) {
+        _cl_finalizeCard(state.cardNode, state.steps);
+      }
+    }
+    return;
+  }
+
+  // ── result ──
+  if (phase === 'result') {
+    var state = _cl_ensureRemoteToolState(toolCallId, d, null);
+    if (!state) return;
+
+    state.phase = 'completed';
+    if (typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore) {
+      _clRemoteAgentProgressStore.recordResult(toolCallId);
+    }
+    console.log('[cl-stream] ✅ result: steps=' + state.steps.length
+      + ' tcid=' + toolCallId.substring(0, 8)
+      + ' hasCard=' + !!state.cardNode
+      + ' replayActive=' + !!state._replayActive);
+
+    // 如果 replay 未完成或 cardNode 未创建，延迟 finalize
+    if (state._replayActive || !state.cardNode) {
+      state.pendingFinalize = true;
+      console.log('[cl-playback] finalize deferred tcid=' + toolCallId.substring(0, 8));
+    } else {
+      _cl_finalizeCard(state.cardNode, state.steps);
+      console.log('[cl-playback] finalize now tcid=' + toolCallId.substring(0, 8));
+    }
+    return;
+  }
+};
+
+function _cl_logRawSseUpdate(toolCallId, rawText) {
+  try {
+    if (!_cl_isRawSseDebugEnabled()) return;
+    var entry = {
+      ts: new Date().toISOString(),
+      toolCallId: toolCallId || '',
+      rawText: rawText || ''
+    };
+    window.__openagentRawSseLog = window.__openagentRawSseLog || [];
+    window.__openagentRawSseLog.push(entry);
+    if (window.__openagentRawSseLog.length > 200) {
+      window.__openagentRawSseLog.splice(0, window.__openagentRawSseLog.length - 200);
+    }
+    _cl_persistRawDebugLog('openagent.rawSseLog.v1', 'openagent-raw-sse-log', window.__openagentRawSseLog);
+    console.log('[cl-raw-sse] tcid=' + String(toolCallId || '').substring(0, 8) + ' raw=' + rawText);
+  } catch (err) {}
+}
+
+function _cl_isRawSseDebugEnabled() {
+  try {
+    return window.localStorage && window.localStorage.getItem('openagent.debug.rawSse') === '1';
+  } catch (err) {
+    return false;
+  }
+}
+
+function _cl_persistRawDebugLog(storageKey, elementId, entries) {
+  try {
+    var json = JSON.stringify(entries || []);
+    try {
+      window.localStorage && window.localStorage.setItem(storageKey, json);
+    } catch (storageErr) {}
+
+    var doc = window.document;
+    if (!doc || !doc.body) return;
+    var node = doc.getElementById(elementId);
+    if (!node) {
+      node = doc.createElement('pre');
+      node.id = elementId;
+      node.style.display = 'none';
+      doc.body.appendChild(node);
+    }
+    node.textContent = json;
+  } catch (err) {}
+}
+
+function _cl_isRemoteToolEvent(data, rawText) {
+  data = data || {};
+  var name = String(data.name || (data.call && data.call.name) || '').toLowerCase();
+  if (name.includes('call_remote_agent') || name.includes('openagent_delegate')) return true;
+
+  var args = _cl_getStreamArgs(data);
+  var agentId = args.agent_id || args.agentId || '';
+  var agentName = args.agent_name || args.agentName || '';
+  if (agentId || agentName) return true;
+
+  if (rawText && /openagent_call_remote_agent|openagent_delegate|call_remote_agent/.test(rawText)) return true;
+  if (rawText && rawText.indexOf('"dataType"') !== -1 && rawText.indexOf('"thinkType"') !== -1) return true;
+  if (rawText && rawText.indexOf('"dataType"') !== -1 && rawText.indexOf('"msgType"') !== -1) return true;
+  return false;
+}
+
+function _cl_getStreamArgs(data) {
+  data = data || {};
+  return data.args || (data.call && (data.call.args || data.call.arguments)) || {};
+}
+
+function _cl_mergeArgs(current, incoming) {
+  current = current && typeof current === 'object' ? current : {};
+  incoming = incoming && typeof incoming === 'object' ? incoming : {};
+  var merged = {};
+  var k;
+  for (k in current) {
+    if (Object.prototype.hasOwnProperty.call(current, k)) merged[k] = current[k];
+  }
+  for (k in incoming) {
+    if (Object.prototype.hasOwnProperty.call(incoming, k) && merged[k] === undefined) {
+      merged[k] = incoming[k];
+    }
+  }
+  return merged;
+}
+
+function _cl_getRemoteAgentProgressMode(args, currentMode) {
+  args = args && typeof args === 'object' ? args : {};
+  currentMode = currentMode || '';
+
+  var agentId = String(args.agent_id || args.agentId || '').trim();
+  var agentName = String(args.agent_name || args.agentName || '').trim();
+
+  if (agentId && CL_TRAVEL_TITLE_AGENT_IDS[agentId]) {
+    return CL_REMOTE_AGENT_PROGRESS_MODE_TRAVEL_TITLE;
+  }
+  if (agentName && CL_TRAVEL_TITLE_AGENT_NAMES[agentName]) {
+    return CL_REMOTE_AGENT_PROGRESS_MODE_TRAVEL_TITLE;
+  }
+  if (currentMode === CL_REMOTE_AGENT_PROGRESS_MODE_TRAVEL_TITLE) {
+    return currentMode;
+  }
+  return CL_REMOTE_AGENT_PROGRESS_MODE_GENERIC_STREAM;
+}
+
+function _cl_createToolState(args) {
+  var normalizedArgs = args || {};
+  return {
+    steps: [],
+    phase: 'active',
+    progressMode: _cl_getRemoteAgentProgressMode(normalizedArgs, ''),
+    thinkChunks: [],
+    lastThinkType: '',
+    lastTitleIndex: -1,
+    seenChunkKeys: Object.create(null),
+    unindexedSeq: 0,
+    cardNode: null,
+    args: normalizedArgs,
+    // ── 播放控制 ──
+    _replayActive: false,
+    _replayTimer: null,
+    pendingFinalize: false
+  };
+}
+
+function _cl_ensureRemoteToolState(toolCallId, data, rawText) {
+  var state = __cl_toolStates.get(toolCallId);
+  if (state) {
+    state.args = _cl_mergeArgs(state.args, _cl_getStreamArgs(data));
+    state.progressMode = _cl_getRemoteAgentProgressMode(state.args, state.progressMode);
+    if (state.thinkChunks && state.thinkChunks.length > 0) {
+      _cl_rebuildThinkStepsByAgentMode(state);
+    }
+    return state;
+  }
+
+  if (!_cl_isRemoteToolEvent(data, rawText)) return null;
+
+  var name = data && (data.name || (data.call && data.call.name)) || '';
+  var args = _cl_getStreamArgs(data);
+  state = _cl_createToolState(args);
+  __cl_toolStates.set(toolCallId, state);
+
+  if (typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore) {
+    _clRemoteAgentProgressStore.recordStart(toolCallId, { name: name, args: args });
+  }
+  console.log('[cl-stream] 🧩 recovered missing start tcid=' + toolCallId.substring(0, 8)
+    + ' phase=' + ((data && data.phase) || ''));
+  return state;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 渲染入口 — 只读 __cl_toolStates
+// ═══════════════════════════════════════════════════════════════
+
+window.__openagentRenderToolCard = function(card, onOpenSidebar) {
+  var n = (card && card.name || '').toLowerCase();
+  var cardTcid = card && (card.toolCallId || '');
+  var cardKind = typeof _clInferToolCardKind === 'function' ? _clInferToolCardKind(card) : (card && card.kind || '');
+  var liveState = cardTcid ? __cl_toolStates.get(cardTcid) : null;
+  if (cardKind === 'result' && liveState && liveState.phase === 'active' && card && card.inputText) {
+    cardKind = 'call';
+  }
+  var isRemoteName = n.includes('call_remote_agent') || n.includes('openagent_delegate');
+  var isLinkedRemoteResult = card && cardKind === 'result' && cardTcid
+    && __cl_lastCallModel && cardTcid === __cl_lastCallModel.tcid;
+  if (!isRemoteName && !isLinkedRemoteResult) return null;
+
+  // Phase 2: lazy 采样原生 ToolCard 尺寸变量
+  if (typeof _clEnsureNativeToolStyleVars === 'function') {
+    _clEnsureNativeToolStyleVars();
+  }
+
+  var model = _clParseToolCardModel(card);
+
+  try {
+    if (cardKind === 'call') {
+      var tcid = card.toolCallId || '';
+      var state = liveState || (tcid ? __cl_toolStates.get(tcid) : null);
+
+      // 保存 call card 的 model，供同一 message 的 result card 使用
+      __cl_lastCallModel = { tcid: tcid, agentId: model.agentId, agentName: model.agentName };
+
+      console.log('[cl-render] 🔍 call: tcid=' + tcid.substring(0, 8)
+        + ' hasState=' + !!state
+        + (state ? ' phase=' + state.phase + ' steps=' + state.steps.length + ' hasCard=' + !!state.cardNode : ''));
+
+      if (state) {
+        if (state.args) {
+          _cl_applyStoredRecordToModel(model, { args: state.args });
+        }
+        if (state.phase === 'active') {
+          model.status = 'executing';
+        }
+        // 有 streaming 状态 — 复用或新建
+        if (state.cardNode) {
+          // Lit 重复调用会复用同一个 DOM 节点；但 OpenClaw 外层 native
+          // <details> 可能被 rerender 成 closed。这里重新打开的是外层原生
+          // details，不影响卡片内部的“思考中/思考完成”折叠状态。
+          _cl_applyCardUiState(state.cardNode, { toolCallId: tcid, cardKind: 'call' });
+          if (state.phase === 'active') {
+            _cl_autoOpenStepsIfUncontrolled(state.cardNode);
+          }
+          _cl_forceOpenNativeToolDetails(state.cardNode, 'execution-cache', tcid);
+          if (typeof _cl_scheduleHostShellMark === 'function') _cl_scheduleHostShellMark(state.cardNode);
+          _cl_hideHostRawText(state.cardNode);
+          return state.cardNode;
+        }
+
+        // 首次渲染：创建卡片
+        model.toolCallId = tcid;
+        model.cardKind = 'call';
+        // 不直接灌 bufferedSteps，由 replay 逐条展示
+        model._bufferedSteps = [];
+        var node = _clRenderExecutionCard(model);
+        state.cardNode = node;
+        _cl_forceOpenNativeToolDetails(node, 'execution', tcid);
+        if (typeof _cl_scheduleHostShellMark === 'function') _cl_scheduleHostShellMark(node);
+        _cl_hideHostRawText(node);
+
+        if (state.phase === 'completed') {
+          // result 已到 — 如果有积压步骤，replay 后 finalize
+          if (state.steps.length > 0) {
+            state.pendingFinalize = true;
+            _cl_replayBufferedSteps(tcid, state);
+          } else {
+            _cl_finalizeCard(node, state.steps);
+          }
+          console.log('[cl-render] 🆕 built completed card, tcid=' + tcid.substring(0, 8)
+            + ' steps=' + state.steps.length);
+        } else {
+          // 仍在活跃 — replay 积压步骤（如有）
+          if (state.steps.length > 0) {
+            _cl_replayBufferedSteps(tcid, state);
+          }
+          console.log('[cl-render] 📥 bound active card, tcid=' + tcid.substring(0, 8)
+            + ' buffered=' + state.steps.length);
+        }
+        return node;
+      }
+
+      // 无状态 → 刷新/历史态。前端 store 如果有同一 toolCallId 的卡片快照，
+      // 就用快照参数重建 steps；没有 store 时仍展示完成态外壳。
+      var storedCallRecord = tcid && typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore
+        ? _clRemoteAgentProgressStore.get(tcid)
+        : null;
+      if (storedCallRecord) {
+        _cl_applyStoredRecordToModel(model, storedCallRecord);
+        model._bufferedSteps = _clRemoteAgentProgressStore.rebuildSteps(storedCallRecord);
+        console.log('[cl-store] restore call model tcid=' + tcid.substring(0, 8)
+          + ' steps=' + model._bufferedSteps.length
+          + ' agent=' + JSON.stringify(model.agentName));
+      } else {
+        console.log('[cl-store] historical call has no frontend progress record: tcid=' + tcid.substring(0, 8));
+      }
+      model.toolCallId = tcid;
+      model.cardKind = 'call';
+      model.status = 'completed';
+      var historyNode = _clRenderExecutionCard(model);
+      _cl_finalizeCard(historyNode, model._bufferedSteps || []);
+      _cl_forceOpenNativeToolDetails(historyNode, 'execution-history', tcid);
+      if (typeof _cl_scheduleHostShellMark === 'function') _cl_scheduleHostShellMark(historyNode);
+      _cl_hideHostRawText(historyNode);
+      console.log('[cl-render] 🗂️ built historical call card, tcid=' + tcid.substring(0, 8));
+      return historyNode;
+    }
+
+    if (cardKind === 'result') {
+      var resTcid = card.toolCallId || '';
+
+      // 从 toolState 合并 agent 身份信息（live 场景）
+      var resState = resTcid ? __cl_toolStates.get(resTcid) : null;
+      if (resState && resState.args) {
+        var ra = resState.args;
+        if (!model.agentId && (ra.agent_id || ra.agentId)) {
+          model.agentId = ra.agent_id || ra.agentId;
+        }
+        if (model.agentName === 'Remote Agent') {
+          model.agentName = ra.agent_name || ra.agentName || model.agentName;
+        }
+      }
+      var storedResultRecord = resTcid && typeof _clRemoteAgentProgressStore !== 'undefined' && _clRemoteAgentProgressStore
+        ? _clRemoteAgentProgressStore.get(resTcid)
+        : null;
+      if (storedResultRecord) {
+        _cl_applyStoredRecordToModel(model, storedResultRecord);
+        console.log('[cl-store] apply result model tcid=' + resTcid.substring(0, 8)
+          + ' agent=' + JSON.stringify(model.agentName));
+      }
+
+      // 从同一 message 的 call card 复制 agent 身份（历史场景 / WS 漏接）
+      // 仅当 toolCallId 匹配时才使用，防止跨消息串身份
+      if (model.agentName === 'Remote Agent' && __cl_lastCallModel
+          && resTcid && resTcid === __cl_lastCallModel.tcid) {
+        model.agentId = model.agentId || __cl_lastCallModel.agentId;
+        model.agentName = __cl_lastCallModel.agentName || model.agentName;
+      }
+
+      var chunkCounts = _cl_countChunkTypes(model.chunks || []);
+      console.log('[cl-diag][result] render tcid=' + resTcid.substring(0, 8)
+        + ' rawLen=' + ((model.rawText || '').length)
+        + ' chunks=' + (model.chunks || []).length
+        + ' steps=' + chunkCounts.step
+        + ' text=' + chunkCounts.text
+        + ' result=' + chunkCounts.result
+        + ' hasState=' + !!resState
+        + ' agent=' + JSON.stringify(model.agentName));
+
+      model.toolCallId = resTcid;
+      model.cardKind = 'result';
+
+      // 缓存：同一 toolCallId 的 output card 只创建一次，Lit 重复调用时复用
+      var cachedOutput = resTcid ? __cl_outputCardCache.get(resTcid) : null;
+      if (cachedOutput && cachedOutput.isConnected) {
+        _cl_applyCardUiState(cachedOutput, { toolCallId: resTcid, cardKind: 'result' });
+        _cl_forceOpenNativeToolDetails(cachedOutput, 'output-cache', resTcid);
+        if (typeof _cl_scheduleHostShellMark === 'function') _cl_scheduleHostShellMark(cachedOutput);
+        _cl_hideHostRawText(cachedOutput);
+        return cachedOutput;
+      }
+
+      var outputNode = _clRenderOutputCard(model, onOpenSidebar);
+      if (!outputNode.__clEmptyOutput) {
+        _cl_forceOpenNativeToolDetails(outputNode, 'output', resTcid);
+        if (typeof _cl_scheduleHostShellMark === 'function') _cl_scheduleHostShellMark(outputNode);
+        if (resTcid) {
+          __cl_outputCardCache.set(resTcid, outputNode);
+        }
+      }
+      _cl_hideHostRawText(outputNode);
+      return outputNode;
+    }
+  } catch (err) {
+    console.error('[cl-render] 💥', err.message);
+  }
+
+  return null;
+};
+
+// ═══════════════════════════════════════════════════════════════
+// Buffered Step Replay — cardNode 创建前积压的 steps 逐条展示
+// ═══════════════════════════════════════════════════════════════
+
+function _cl_replayBufferedSteps(toolCallId, state) {
+  if (!state || !state.cardNode || state._replayActive) return;
+
+  var totalSteps = state.steps.length;
+  if (totalSteps === 0) return;
+
+  state._replayActive = true;
+  var revealed = 0;
+
+  console.log('[cl-playback] start replay tcid=' + String(toolCallId || '').substring(0, 8)
+    + ' steps=' + totalSteps);
+
+  function tick() {
+    state._replayTimer = null;
+
+    if (!state.cardNode) {
+      state._replayActive = false;
+      return;
+    }
+
+    revealed++;
+    // 展示前 revealed 步（从 canonical state 切片）
+    var visibleSteps = state.steps.slice(0, revealed);
+    _cl_updateCardSteps(state.cardNode, visibleSteps);
+
+    console.log('[cl-playback] tick tcid=' + String(toolCallId || '').substring(0, 8)
+      + ' revealed=' + revealed + '/' + state.steps.length);
+
+    if (revealed < state.steps.length) {
+      // 还有步骤未展示
+      state._replayTimer = setTimeout(tick, 120);
+    } else {
+      // 播放完毕
+      state._replayActive = false;
+      console.log('[cl-playback] done tcid=' + String(toolCallId || '').substring(0, 8)
+        + ' steps=' + state.steps.length);
+
+      if (state.pendingFinalize) {
+        state.pendingFinalize = false;
+        _cl_finalizeCard(state.cardNode, state.steps);
+        console.log('[cl-playback] finalize after replay tcid=' + String(toolCallId || '').substring(0, 8));
+      }
+    }
+  }
+
+  // 第一步立即展示，后续逐条
+  tick();
+}
+
+// ═══════════════════════════════════════════════════════════════
+// DOM 操作
+// ═══════════════════════════════════════════════════════════════
+
+// ── Phase A: 主动隐藏宿主 raw text ──
+
+function _cl_hideHostRawText(cardNode) {
+  if (!cardNode) return;
+  function hide() {
+    var hosts = _cl_collectRawTextHosts(cardNode);
+    for (var h = 0; h < hosts.length; h++) {
+      _cl_hideRawTextInHost(hosts[h]);
+    }
+  }
+  hide();
+  if (typeof requestAnimationFrame === 'function') requestAnimationFrame(hide);
+  setTimeout(hide, 0);
+  setTimeout(hide, 80);
+  setTimeout(hide, 250);
+  setTimeout(hide, 800);
+  setTimeout(hide, 2000);
+}
+
+function _cl_isRemoteToolNameText(text) {
+  var value = String(text || '').toLowerCase();
+  return value.indexOf('call_remote_agent') !== -1 || value.indexOf('openagent_delegate') !== -1;
+}
+
+function _cl_isRemoteRawTextContent(text) {
+  var value = String(text || '');
+  if (!value) return false;
+  if (/"msgType"\s*:/.test(value) && /"dataType"\s*:/.test(value)) return true;
+  if (/"itineraryId"\s*:/.test(value) && /"unitList"\s*:/.test(value)) return true;
+  if (/"dayList"\s*:/.test(value) && /"unitContexts"\s*:/.test(value)) return true;
+  if (/(?:<|&lt;)(?:sh_card|tr_card|i_card|bg_card|fr_card|time_data_card)(?:>|&gt;)/.test(value)) return true;
+  if (value.indexOf('[TRIP_CARDS_READY]') !== -1) return true;
+  return false;
+}
+
+function _cl_collectRawTextHosts(node) {
+  var hosts = [];
+  function add(host) {
+    if (!host || hosts.indexOf(host) !== -1) return;
+    hosts.push(host);
+  }
+  add(node.parentElement);
+  if (node.closest) {
+    add(node.closest('.chat-tools-collapse__body'));
+    add(node.closest('.chat-tool-msg-body'));
+    add(node.closest('.chat-tool-card__detail'));
+    add(node.closest('.chat-bubble'));
+  }
+  return hosts;
+}
+
+function _cl_hideRawTextInHost(host) {
+  if (!host || !host.querySelectorAll) return;
+  host.classList.add('cl-remote-agent-raw-hidden');
+  if (host.classList.contains('chat-tools-collapse__body') || host.classList.contains('chat-tool-msg-body')) {
+    host.classList.add('cl-remote-agent-host-shell');
+  }
+  var texts = host.querySelectorAll(':scope > .chat-text');
+  for (var i = 0; i < texts.length; i++) {
+    texts[i].style.display = 'none';
+    texts[i].dataset.openagentRawHidden = '1';
+  }
+}
+
+function _cl_findRemoteNativeToolShell(node) {
+  var cur = node && (node.nodeType === 1 ? node : node.parentElement);
+  var hops = 0;
+  while (cur && cur !== document.body && hops < 12) {
+    if (cur.matches && cur.matches(
+      'details.chat-tools-collapse,' +
+      'details.chat-tool-msg-collapse,' +
+      '.chat-tools-collapse,' +
+      '.chat-tool-msg-collapse,' +
+      '.chat-tool-card'
+    )) {
+      if (_cl_isRemoteNativeToolShell(cur)) return cur;
+    }
+    cur = cur.parentElement;
+    hops++;
+  }
+  return null;
+}
+
+function _cl_isRemoteNativeToolShell(shell) {
+  if (!shell) return false;
+  var summaryText = '';
+  var summary = shell.querySelector && shell.querySelector(
+    ':scope > summary,' +
+    ':scope > .chat-tools-summary,' +
+    ':scope > .chat-tool-msg-summary,' +
+    '.chat-tools-summary,' +
+    '.chat-tool-msg-summary'
+  );
+  if (summary) summaryText = summary.textContent || '';
+  if (_cl_isRemoteToolNameText(summaryText)) return true;
+
+  var ownText = shell.textContent || '';
+  // Limit the expensive fallback to the beginning of the host text so huge
+  // raw JSON payloads do not become a broad "contains" matcher.
+  return _cl_isRemoteToolNameText(ownText.slice(0, 800));
+}
+
+function _cl_tryHideRemoteRawTextNode(node) {
+  if (!node) return;
+  if (node.nodeType !== 1) {
+    node = node.parentElement;
+  }
+  if (!node || node.nodeType !== 1) return;
+  var textNodes = [];
+  if (node.matches && node.matches('.chat-text')) {
+    textNodes.push(node);
+  }
+  if (node.querySelectorAll) {
+    var found = node.querySelectorAll('.chat-text');
+    for (var i = 0; i < found.length; i++) textNodes.push(found[i]);
+  }
+  for (var j = 0; j < textNodes.length; j++) {
+    var textNode = textNodes[j];
+    var shell = _cl_findRemoteNativeToolShell(textNode);
+    if (!shell && _cl_isRemoteRawTextContent(textNode.textContent || '')) {
+      shell = _cl_findNearestToolLikeShell(textNode);
+    }
+    if (shell && _cl_isRemoteRawTextContent(textNode.textContent || '')) {
+      _cl_hideRawTextInHost(textNode.parentElement);
+      continue;
+    }
+    if (!shell) continue;
+    var host = textNode.parentElement;
+    _cl_hideRawTextInHost(host);
+  }
+
+  var shell = _cl_findRemoteNativeToolShell(node);
+  if (shell && shell.querySelectorAll) {
+    var hosts = shell.querySelectorAll('.chat-tools-collapse__body, .chat-tool-msg-body, .chat-tool-card__detail, .chat-bubble');
+    for (var h = 0; h < hosts.length; h++) {
+      _cl_hideRawTextInHost(hosts[h]);
+    }
+  }
+}
+
+function _cl_findNearestToolLikeShell(node) {
+  var cur = node && (node.nodeType === 1 ? node : node.parentElement);
+  var hops = 0;
+  while (cur && cur !== document.body && hops < 12) {
+    if (cur.matches && cur.matches(
+      'details.chat-tools-collapse,' +
+      'details.chat-tool-msg-collapse,' +
+      '.chat-tools-collapse,' +
+      '.chat-tool-msg-collapse,' +
+      '.chat-tool-card,' +
+      '.chat-tools-collapse__body,' +
+      '.chat-tool-msg-body,' +
+      '.chat-tool-card__detail'
+    )) {
+      return cur;
+    }
+    cur = cur.parentElement;
+    hops++;
+  }
+  return null;
+}
+
+function _cl_installRemoteRawTextObserver() {
+  if (window.__clRemoteRawTextObserverInstalled) return;
+  if (!document.body) {
+    setTimeout(_cl_installRemoteRawTextObserver, 0);
+    if (document.addEventListener) {
+      document.addEventListener('DOMContentLoaded', _cl_installRemoteRawTextObserver, { once: true });
+    }
+    return;
+  }
+  window.__clRemoteRawTextObserverInstalled = true;
+  function scanExisting() {
+    if (!document.querySelectorAll) return;
+    var texts = document.querySelectorAll('.chat-text');
+    for (var i = 0; i < texts.length; i++) {
+      _cl_tryHideRemoteRawTextNode(texts[i]);
+    }
+  }
+  scanExisting();
+  if (typeof MutationObserver !== 'function' || !document.body) return;
+  var observer = new MutationObserver(function(records) {
+    for (var i = 0; i < records.length; i++) {
+      var record = records[i];
+      for (var j = 0; j < record.addedNodes.length; j++) {
+        var added = record.addedNodes[j];
+        _cl_tryHideRemoteRawTextNode(added.nodeType === 1 ? added : added.parentElement);
+      }
+      if (record.type === 'characterData') {
+        _cl_tryHideRemoteRawTextNode(record.target && record.target.parentElement);
+      }
+    }
+  });
+  observer.observe(document.body, { childList: true, subtree: true, characterData: true });
+  window.__clRemoteRawTextObserver = observer;
+}
+
+_cl_installRemoteRawTextObserver();
+
+// ── 局部打开最近宿主 wrapper（不做全局扫描）──
+
+function _cl_findNearestNativeToolShell(node) {
+  var cur = node && node.parentElement;
+  var hops = 0;
+  while (cur && cur !== document.body && hops < 10) {
+    if (cur.matches && cur.matches(
+      'details.chat-tools-collapse,' +
+      'details.chat-tool-msg-collapse,' +
+      '.chat-tools-collapse,' +
+      '.chat-tool-msg-collapse'
+    )) {
+      return cur;
+    }
+    cur = cur.parentElement;
+    hops++;
+  }
+  return null;
+}
+
+function _cl_forceOpenNativeToolDetails(node, source, tcid) {
+  if (!node) return;
+
+  function openNearest() {
+    var shell = _cl_findNearestNativeToolShell(node);
+    if (!shell) return false;
+
+    if (shell.tagName && shell.tagName.toLowerCase() === 'details') {
+      if (!shell.open) {
+        shell.open = true;
+        shell.setAttribute('open', '');
+        console.log('[cl-render] 🔓 opened native details source=' + source
+          + ' tcid=' + String(tcid || '').substring(0, 8));
+      }
+      return true;
+    }
+
+    if (shell.classList && !shell.classList.contains('is-open')) {
+      shell.classList.add('is-open');
+      var header = shell.querySelector('.chat-tool-msg-summary, .chat-tools-summary');
+      if (header) header.setAttribute('aria-expanded', 'true');
+      console.log('[cl-render] 🔓 opened native collapse source=' + source
+        + ' tcid=' + String(tcid || '').substring(0, 8));
+    }
+    return true;
+  }
+
+  // Lit 先拿 DOM node，稍后才插入 OpenClaw details body，所以需要延迟重试。
+  // openNearest 是幂等的（已 open 不重复操作），不需要防抖。
+  openNearest();
+  if (typeof requestAnimationFrame === 'function') requestAnimationFrame(openNearest);
+  setTimeout(openNearest, 0);
+  setTimeout(openNearest, 80);
+  setTimeout(openNearest, 300);  // 兜底：慢速 Lit render / 异步 wrapper 挂载
+}
+
+function _cl_cardUiKey(modelOrNode) {
+  if (!modelOrNode) return '';
+
+  var tcid = '';
+  var kind = '';
+
+  if (modelOrNode.nodeType === 1) {
+    tcid = modelOrNode.dataset && (modelOrNode.dataset.clCardTcid || '');
+    kind = modelOrNode.dataset && (modelOrNode.dataset.clCardSource || '');
+  } else {
+    tcid = modelOrNode.toolCallId || modelOrNode.tcid || '';
+    kind = modelOrNode.cardKind || modelOrNode.kind || '';
+  }
+
+  if (!tcid) return '';
+  if (kind === 'call') kind = 'execution';
+  if (kind === 'result') kind = 'output';
+  if (!kind) kind = 'card';
+  return kind + ':' + tcid;
+}
+
+function _cl_getCardUiState(modelOrNode) {
+  var key = _cl_cardUiKey(modelOrNode);
+  if (!key) return null;
+  return __cl_cardUiStates.get(key) || null;
+}
+
+function _cl_setCardUiState(modelOrNode, patch) {
+  var key = _cl_cardUiKey(modelOrNode);
+  if (!key || !patch) return;
+
+  var current = __cl_cardUiStates.get(key) || {};
+  var next = {};
+  for (var k in current) {
+    if (Object.prototype.hasOwnProperty.call(current, k)) next[k] = current[k];
+  }
+  for (var p in patch) {
+    if (Object.prototype.hasOwnProperty.call(patch, p)) next[p] = patch[p];
+  }
+  __cl_cardUiStates.set(key, next);
+  console.log('[cl-ui-state] save key=' + key
+    + ' contentCollapsed=' + (next.contentCollapsed === undefined ? '' : next.contentCollapsed)
+    + ' stepsExpanded=' + (next.stepsExpanded === undefined ? '' : next.stepsExpanded));
+}
+
+function _cl_applyCardUiState(container, modelOrNode) {
+  if (!container) return;
+
+  var state = _cl_getCardUiState(modelOrNode || container);
+  if (!state) return;
+
+  var content = container.querySelector('.cl-thought-chain-content');
+  var caret = container.querySelector('.cl-openagent-header-caret');
+  if (content && state.contentCollapsed !== undefined) {
+    if (state.contentCollapsed) {
+      content.classList.add('cl-content-collapsed');
+      if (caret) caret.textContent = '▶';
+    } else {
+      content.classList.remove('cl-content-collapsed');
+      if (caret) caret.textContent = '▼';
+    }
+  }
+
+  var body = container.querySelector('.cl-tools-collapse-body');
+  var stepIcon = container.querySelector('.cl-tools-collapse-header-icon');
+  if (body && state.stepsExpanded !== undefined) {
+    if (state.stepsExpanded) {
+      body.classList.remove('cl-collapsed');
+      body.classList.add('cl-expanded');
+      if (stepIcon) stepIcon.classList.remove('cl-collapsed');
+    } else {
+      body.classList.remove('cl-expanded');
+      body.classList.add('cl-collapsed');
+      if (stepIcon) stepIcon.classList.add('cl-collapsed');
+    }
+  }
+}
+
+function _cl_applyStoredRecordToModel(model, record) {
+  if (!model || !record) return;
+  var args = record.args || {};
+  if (!model.agentId && (args.agent_id || args.agentId)) {
+    model.agentId = args.agent_id || args.agentId;
+  }
+  if (model.agentName === 'Remote Agent' || !model.agentName) {
+    model.agentName = args.agent_name || args.agentName || model.agentId || 'Remote Agent';
+  }
+  if (!model.agentAvatar) {
+    model.agentAvatar = args.agent_avatar || args.agentAvatar || args.avatar || args.avatar_url || args.avatarUrl || null;
+  }
+  var identity = CL && typeof CL.getAgentIdentity === 'function'
+    ? CL.getAgentIdentity(model.agentId, model.agentName)
+    : null;
+  if (identity) {
+    model.agentId = model.agentId || identity.id || identity.agent_id;
+    model.agentName = (model.agentName && model.agentName !== 'Remote Agent') ? model.agentName : (identity.name || model.agentName);
+    model.agentAvatar = model.agentAvatar || identity.avatar || null;
+  }
+  model.taskText = model.taskText || args.task || args.message || args.instruction || '';
+}
+
+function _cl_applyThinkChunkToLiveState(state, chunk) {
+  if (!state || !chunk || chunk.dataType !== 'think') return false;
+
+  if (chunk._clProgressStep) {
+    var beforeProgressSig = _cl_stepsSignature(state.steps);
+    var stepIndex = Number(chunk.stepIndex);
+    if (!Number.isFinite(stepIndex) || stepIndex < 0) return false;
+    stepIndex = Math.floor(stepIndex);
+
+    if (chunk._clTripProgressRoot) {
+      state.steps = _cl_pruneGenericProgressSteps(state.steps);
+      stepIndex = 0;
+    }
+
+    while (state.steps.length <= stepIndex) {
+      state.steps.push({ title: '', detail: '' });
+    }
+
+    var progressStep = state.steps[stepIndex];
+    var progressTitle = _cl_normalizeStepTitle(chunk.text || '');
+    var progressChanged = false;
+
+    if (progressTitle && progressStep.title !== progressTitle) {
+      progressStep.title = progressTitle;
+      progressChanged = true;
+    }
+    if (progressStep.detail) progressStep.detail = '';
+
+    state.steps = _cl_compactThoughtSteps(state.steps);
+    var afterProgressSig = _cl_stepsSignature(state.steps);
+    if (!_cl_isGenericProgressTitle(progressTitle)) {
+      state.lastThinkType = 'progress-step';
+    }
+    return progressChanged || beforeProgressSig !== afterProgressSig;
+  }
+
+  var key = _cl_getLiveChunkKey(state, chunk);
+  if (key && state.seenChunkKeys && state.seenChunkKeys[key]) {
+    return false;
+  }
+  if (key) {
+    if (!state.seenChunkKeys) state.seenChunkKeys = Object.create(null);
+    state.seenChunkKeys[key] = true;
+  }
+
+  var type = chunk.thinkType || '';
+  var changed = _cl_applyThinkChunkByAgentMode(state, chunk);
+  state.lastThinkType = type;
+  return changed;
+}
+
+function _cl_applyThinkChunkByAgentMode(target, chunk) {
+  if (!target || !chunk || chunk.dataType !== 'think') return false;
+
+  var beforeSig = _cl_stepsSignature(target.steps);
+  _cl_storeThinkChunk(target, chunk);
+  _cl_rebuildThinkStepsByAgentMode(target);
+
+  return beforeSig !== _cl_stepsSignature(target.steps);
+}
+
+function _cl_rebuildThinkStepsByAgentMode(target) {
+  if (!target) return;
+  target.progressMode = _cl_getRemoteAgentProgressMode(target.args, target.progressMode);
+  if (target.progressMode === CL_REMOTE_AGENT_PROGRESS_MODE_TRAVEL_TITLE) {
+    target.steps = _cl_rebuildTravelTitleSteps(target.thinkChunks || []);
+  } else {
+    target.steps = _cl_rebuildGenericStreamSteps(target.thinkChunks || []);
+  }
+}
+
+function _cl_storeThinkChunk(target, chunk) {
+  if (!target.thinkChunks) target.thinkChunks = [];
+
+  var text = typeof chunk.text === 'string' ? chunk.text : '';
+  var item = {
+    dataType: chunk.dataType,
+    thinkType: chunk.thinkType || '',
+    text: text,
+    index: chunk.index,
+    _clPlainTextUpdate: !!chunk._clPlainTextUpdate,
+    _clLiveUpdateFallback: !!chunk._clLiveUpdateFallback,
+    _clSeq: target.unindexedSeq || 0
+  };
+  target.unindexedSeq = (target.unindexedSeq || 0) + 1;
+
+  var idx = _cl_getChunkIndex(item);
+  if (idx >= 0) {
+    for (var i = 0; i < target.thinkChunks.length; i++) {
+      var existing = target.thinkChunks[i];
+      if (!existing || _cl_getChunkIndex(existing) !== idx || (existing.thinkType || '') !== item.thinkType) {
+        continue;
+      }
+      var existingText = typeof existing.text === 'string' ? existing.text : '';
+      if (item.text && existingText && item.text.indexOf(existingText) === 0) {
+        existing.text = item.text;
+        existing._clSeq = item._clSeq;
+        return;
+      }
+      if (existingText && item.text && existingText.indexOf(item.text) === 0) {
+        return;
+      }
+    }
+  }
+
+  target.thinkChunks.push(item);
+}
+
+function _cl_sortThinkChunks(chunks) {
+  var sorted = (chunks || []).slice();
+  sorted.sort(function(a, b) {
+    var ai = _cl_getChunkIndex(a);
+    var bi = _cl_getChunkIndex(b);
+    if (ai >= 0 && bi >= 0 && ai !== bi) return ai - bi;
+    if (ai >= 0 && bi < 0) return -1;
+    if (ai < 0 && bi >= 0) return 1;
+    return ((a && a._clSeq) || 0) - ((b && b._clSeq) || 0);
+  });
+  return sorted;
+}
+
+function _cl_rebuildTravelTitleSteps(chunks) {
+  var sorted = _cl_sortThinkChunks(chunks);
+  var steps = [];
+  var pendingTitle = '';
+
+  function flushPending() {
+    var title = _cl_normalizeStepTitle(pendingTitle);
+    if (title) steps.push({ title: title, detail: '' });
+    pendingTitle = '';
+  }
+
+  for (var i = 0; i < sorted.length; i++) {
+    var chunk = sorted[i] || {};
+    var type = chunk.thinkType || '';
+    var text = _cl_normalizeStepTitle(chunk.text || '');
+
+    if (type === 'title') {
+      if (text) pendingTitle = _cl_mergeStepTitle(pendingTitle, text);
+      continue;
+    }
+
+    // 旅游梦想家的 content 是 title 之间的过程说明，只作为 title 分组边界。
+    flushPending();
+  }
+
+  flushPending();
+  return _cl_compactThoughtSteps(steps);
+}
+
+function _cl_rebuildGenericStreamSteps(chunks) {
+  var sorted = _cl_sortThinkChunks(chunks);
+  var text = '';
+  var shortPlainSteps = [];
+  var allShortPlain = sorted.length > 0 && sorted.length <= 20;
+  var hasFallbackUpdates = false;
+
+  for (var i = 0; i < sorted.length; i++) {
+    var chunk = sorted[i] || {};
+    var part = typeof chunk.text === 'string' ? chunk.text : '';
+    if (!part) continue;
+    var normalizedPart = _cl_normalizeStepTitle(part);
+    if (chunk._clLiveUpdateFallback) {
+      hasFallbackUpdates = true;
+    }
+    if (!chunk._clPlainTextUpdate || !normalizedPart || normalizedPart.length > 20) {
+      allShortPlain = false;
+    } else if (shortPlainSteps.length === 0 || shortPlainSteps[shortPlainSteps.length - 1].title !== normalizedPart) {
+      shortPlainSteps.push({ title: normalizedPart, detail: '' });
+    }
+    text = _cl_mergeStepTitle(text, part);
+  }
+
+  if (hasFallbackUpdates) {
+    return _cl_rebuildFallbackUpdateSteps(sorted);
+  }
+
+  if (allShortPlain && shortPlainSteps.length > 0) {
+    return shortPlainSteps;
+  }
+
+  text = _cl_normalizeStepTitle(text);
+  return text ? [{ title: text, detail: '' }] : [];
+}
+
+function _cl_rebuildFallbackUpdateSteps(chunks) {
+  var steps = [];
+  for (var i = 0; i < chunks.length; i++) {
+    var chunk = chunks[i] || {};
+    var parts = _cl_splitKnownFallbackStatusLine(chunk.text || '');
+    for (var j = 0; j < parts.length; j++) {
+      var part = _cl_normalizeStepTitle(parts[j] || '');
+      if (!part) continue;
+      if (steps.length > 0 && steps[steps.length - 1].title === part) continue;
+      steps.push({ title: part, detail: '', _clKeepSeparate: true });
+    }
+  }
+  return steps;
+}
+
+function _cl_getLiveChunkKey(state, chunk) {
+  if (chunk && chunk._clProgressStep) {
+    return 'p:' + String(chunk.stepIndex) + ':' + (chunk.text || '') + ':' + (chunk.detail || '');
+  }
+  if (chunk && Object.prototype.hasOwnProperty.call(chunk, 'index')
+      && chunk.index !== null && chunk.index !== undefined && chunk.index !== '') {
+    // 去重 key 包含完整内容：同 index 不同 text 是累计更新，不应跳过
+    return 'i:' + String(chunk.index) + ':' + (chunk.thinkType || '') + ':' + (chunk.text || '');
+  }
+  return 'u:' + (chunk.thinkType || '') + ':' + (chunk.text || '');
+}
+
+function _cl_getChunkIndex(chunk) {
+  if (!chunk || chunk.index === null || chunk.index === undefined || chunk.index === '') return -1;
+  var n = Number(chunk.index);
+  if (!Number.isFinite(n) || n < 0) return -1;
+  return Math.floor(n);
+}
+
+function _cl_normalizeStepTitle(text) {
+  return String(text || '').replace(/[\u2705\u2611\uFE0F\u2714\uFE0F]/g, '').trim();
+}
+
+function _cl_stepsSignature(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) return '';
+  return steps.map(function(step) {
+    return _cl_normalizeStepTitle(step && step.title || '');
+  }).join('|');
+}
+
+function _cl_isGenericProgressTitle(title) {
+  title = _cl_normalizeStepTitle(title);
+  if (!title) return true;
+  var genericTitles = {
+    '正在整理行程卡片': true,
+    '远端 Agent 已开始生成': true,
+    '远端 Agent 正在回复': true,
+    '远端 Agent 正在思考': true,
+    '远端 Agent 正在生成回复': true,
+    '正在生成回复内容': true,
+    '远端 Agent 已完成结果生成': true
+  };
+  return !!genericTitles[title];
+}
+
+function _cl_isShortTitleFragment(title) {
+  title = _cl_normalizeStepTitle(title).replace(/\s+/g, '');
+  if (!title) return false;
+  if (_cl_normalizeKnownTitlePhrase(title) !== title) return false;
+  if (title.indexOf('查找') !== -1
+      && (title.indexOf('目的地') !== -1 || title.indexOf('信息') !== -1)
+      && !(title.indexOf('目的地') !== -1 && title.indexOf('信息') !== -1)
+      && title.length <= 6) {
+    return true;
+  }
+  return title.length <= 3;
+}
+
+function _cl_shouldMergeStepTitle(current, incoming) {
+  current = _cl_normalizeStepTitle(current);
+  incoming = _cl_normalizeStepTitle(incoming);
+  if (!current || !incoming) return false;
+  if (incoming.length > current.length && incoming.indexOf(current) === 0) return true;
+  return _cl_isShortTitleFragment(current) && _cl_isShortTitleFragment(incoming);
+}
+
+function _cl_normalizeKnownTitlePhrase(title) {
+  var compact = _cl_normalizeStepTitle(title).replace(/\s+/g, '');
+  if (!compact) return '';
+
+  // 远端有时会把同一个 title 拆成乱序短片段：查找 / 信息 / 目的地。
+  // UI 只展示 title 时，需要把这个产品语义还原成一句话。
+  if (compact.indexOf('了解') !== -1
+      && compact.indexOf('你的') !== -1
+      && compact.indexOf('需求') !== -1
+      && compact.length <= 6) {
+    return '了解你的需求';
+  }
+
+  if (compact.indexOf('查找') !== -1
+      && compact.indexOf('目的地') !== -1
+      && compact.indexOf('信息') !== -1
+      && compact.length <= 8) {
+    return '查找目的地信息';
+  }
+
+  return compact;
+}
+
+function _cl_compactThoughtSteps(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) return [];
+
+  var compacted = [];
+  var pendingTitle = '';
+
+  function flushPending() {
+    var normalized = _cl_normalizeKnownTitlePhrase(pendingTitle);
+    if (normalized) compacted.push({ title: normalized, detail: '' });
+    pendingTitle = '';
+  }
+
+  for (var i = 0; i < steps.length; i++) {
+    var title = _cl_normalizeStepTitle(steps[i] && steps[i].title || '');
+    if (!title || _cl_isGenericProgressTitle(title)) continue;
+
+    if (steps[i] && steps[i]._clKeepSeparate) {
+      flushPending();
+      compacted.push({ title: title, detail: steps[i].detail || '', _clKeepSeparate: true });
+      continue;
+    }
+
+    var knownTitle = _cl_normalizeKnownTitlePhrase(title);
+    if (knownTitle && knownTitle !== title) {
+      flushPending();
+      compacted.push({ title: knownTitle, detail: '' });
+      continue;
+    }
+
+    if (_cl_isShortTitleFragment(title)) {
+      pendingTitle = _cl_mergeStepTitle(pendingTitle, title);
+      continue;
+    }
+
+    flushPending();
+    compacted.push({ title: title, detail: '' });
+  }
+
+  flushPending();
+  return compacted;
+}
+
+function _cl_pruneGenericProgressSteps(steps) {
+  if (!Array.isArray(steps) || steps.length === 0) return [];
+  return steps.filter(function(step) {
+    var title = _cl_normalizeStepTitle(step && step.title || '');
+    return !_cl_isGenericProgressTitle(title);
+  });
+}
+
+function _cl_mergeStepTitle(current, incoming) {
+  current = current || '';
+  incoming = incoming || '';
+  if (!incoming) return current;
+  if (!current) return incoming;
+  if (incoming.length > current.length && incoming.indexOf(current) === 0) return incoming;
+
+  var maxOverlap = Math.min(current.length, incoming.length);
+  for (var len = maxOverlap; len > 0; len--) {
+    if (current.slice(current.length - len) === incoming.slice(0, len)) {
+      return current + incoming.slice(len);
+    }
+  }
+  return current + incoming;
+}
+
+function _cl_updateCardSteps(card, steps) {
+  var body = card.querySelector('.cl-tools-collapse-body');
+  var header = card.querySelector('.cl-tools-collapse-header-title');
+  if (!body || !header) return;
+
+  steps = _cl_compactThoughtSteps(steps || []);
+
+  header.textContent = '思考中...';
+
+  // 默认产品行为：SSE 传输时步骤应自动展开展示。
+  // 只有用户明确点过“思考中/思考完成”后，才尊重用户保存的折叠状态。
+  _cl_autoOpenStepsIfUncontrolled(card);
+
+  var existing = body.querySelectorAll('.cl-tools-collapse-step');
+
+  // 已存在步骤可能继续收到 title/content token，逐个刷新文本和详情。
+  var updateCount = Math.min(existing.length, steps.length);
+  for (var ei = 0; ei < updateCount; ei++) {
+    _cl_updateStepElement(existing[ei], steps[ei], ei === steps.length - 1);
+  }
+
+  // 合并/过滤后 steps 可能变少，旧 DOM 行必须删除，否则页面会残留错误断句。
+  for (var ri = existing.length - 1; ri >= steps.length; ri--) {
+    existing[ri].remove();
+  }
+  existing = body.querySelectorAll('.cl-tools-collapse-step');
+
+  // 差量添加新步骤
+  for (var i = existing.length; i < steps.length; i++) {
+    if (i > 0) {
+      var prev = body.querySelectorAll('.cl-tools-collapse-step')[i - 1];
+      if (prev) {
+        var prevDot = prev.querySelector('.cl-tools-collapse-step-dot');
+        if (prevDot) prevDot.className = 'cl-tools-collapse-step-check';
+      }
+    }
+    var stepEl = _clCreateStepElement(steps[i], i === steps.length - 1);
+    body.appendChild(stepEl);
+  }
+
+  _cl_forceOpenNativeToolDetails(card, 'steps-update', card.dataset && card.dataset.clCardTcid || '');
+}
+
+function _cl_autoOpenStepsIfUncontrolled(card) {
+  if (!card) return;
+  var uiState = _cl_getCardUiState(card);
+  if (uiState && uiState.stepsExpanded !== undefined) return;
+
+  var body = card.querySelector('.cl-tools-collapse-body');
+  if (!body) return;
+
+  body.classList.remove('cl-collapsed');
+  body.classList.add('cl-expanded');
+
+  var headerIcon = card.querySelector('.cl-tools-collapse-header-icon');
+  if (headerIcon) headerIcon.classList.remove('cl-collapsed');
+}
+
+function _cl_updateStepElement(stepEl, step, isLatest) {
+  if (!stepEl || !step) return;
+
+  var titleEl = stepEl.querySelector('.cl-tools-collapse-step-title');
+  if (titleEl) {
+    titleEl.textContent = (step.title || '').replace(/[\u2705\u2611\uFE0F\u2714\uFE0F]/g, '').trim();
+  }
+  var detailEl = stepEl.querySelector('.cl-tools-collapse-step-detail');
+  if (detailEl) {
+    detailEl.remove();
+  }
+
+  var iconWrap = stepEl.querySelector('.cl-tools-collapse-step-icon');
+  if (iconWrap) {
+    var activeDot = iconWrap.querySelector('.cl-tools-collapse-step-dot');
+    var check = iconWrap.querySelector('.cl-tools-collapse-step-check');
+    if (isLatest) {
+      if (check) {
+        iconWrap.innerHTML = '';
+        var dot = document.createElement('div');
+        dot.className = 'cl-tools-collapse-step-dot cl-active';
+        iconWrap.appendChild(dot);
+      } else if (activeDot) {
+        activeDot.className = 'cl-tools-collapse-step-dot cl-active';
+      }
+    } else if (activeDot) {
+      iconWrap.innerHTML = '';
+      var done = document.createElement('div');
+      done.className = 'cl-tools-collapse-step-check';
+      iconWrap.appendChild(done);
+    }
+  }
+}
+
+function _cl_countChunkTypes(chunks) {
+  var counts = { step: 0, text: 0, result: 0, content: 0, error: 0, data: 0, other: 0 };
+  for (var i = 0; i < chunks.length; i++) {
+    var type = chunks[i] && chunks[i].type;
+    if (Object.prototype.hasOwnProperty.call(counts, type)) counts[type]++;
+    else counts.other++;
+  }
+  return counts;
+}
+
+function _cl_finalizeCard(card, steps) {
+  var header = card.querySelector('.cl-tools-collapse-header-title');
+  if (header) {
+    header.textContent = '思考完成';
+  }
+
+  var dots = card.querySelectorAll('.cl-tools-collapse-step-dot');
+  for (var i = 0; i < dots.length; i++) {
+    dots[i].className = 'cl-tools-collapse-step-check';
+  }
+
+  // Finalize 只负责把 execution card 标记为完成态。
+  // 不在这里强制折叠 steps：OpenClaw 会周期性 rerender，若 finalize 每次都
+  // 写 cl-collapsed，会覆盖用户手动展开后的状态。
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 解析
+// ═══════════════════════════════════════════════════════════════
+
+function _cl_extractText(value) {
+  if (typeof value === 'string') return value;
+  if (!value) return '';
+  if (Array.isArray(value.content)) {
+    return value.content
+      .filter(function(c) { return c.type === 'text'; })
+      .map(function(c) { return c.text || ''; })
+      .join('\n');
+  }
+  if (typeof value.text === 'string') return value.text;
+  try { return JSON.stringify(value, null, 2); } catch(e) { return String(value); }
+}
+
+function _cl_parseThinkChunks(rawText, scope) {
+  var chunks = [];
+  if (!rawText || typeof rawText !== 'string') return chunks;
+  var lines = rawText.trim().split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (!line) continue;
+    try {
+      var obj = JSON.parse(line);
+      _cl_ingestTripCardData(obj, scope);
+      if (obj && obj.dataType === 'think') chunks.push(obj);
+    } catch (e) {}
+  }
+  return chunks;
+}
+
+function _cl_parseLiveUpdateChunks(rawText, scope) {
+  _cl_ingestLiveUpdateData(rawText, scope);
+  var chunks = _cl_parseThinkChunks(rawText, scope);
+  if (chunks.length > 0) return chunks;
+  return _cl_extractLiveUpdateFallbackChunks(rawText);
+}
+
+function _cl_extractLiveUpdateFallbackChunks(rawText) {
+  var value = String(rawText || '').trim();
+  if (!value) return [];
+
+  var parts = value.split(/\r?\n/).map(function(line) {
+    return String(line || '').trim();
+  }).filter(Boolean);
+  if (parts.length === 0) parts = [value];
+
+  var chunks = [];
+  for (var i = 0; i < parts.length; i++) {
+    var splitParts = _cl_splitKnownFallbackStatusLine(parts[i]);
+    for (var j = 0; j < splitParts.length; j++) {
+      var text = splitParts[j];
+      if (!text) continue;
+      chunks.push({
+        dataType: 'think',
+        thinkType: 'content',
+        text: text,
+        _clPlainTextUpdate: _cl_isPlainLiveUpdateText(text),
+        _clLiveUpdateFallback: true
+      });
+    }
+  }
+  return chunks;
+}
+
+function _cl_splitKnownFallbackStatusLine(line) {
+  line = String(line || '').trim();
+  if (!line) return [];
+
+  var compact = line.replace(/\s+/g, '');
+  var statuses = ['已提交', '生成中', '已完成'];
+  var rest = compact;
+  var pieces = [];
+
+  while (rest) {
+    var matched = '';
+    for (var i = 0; i < statuses.length; i++) {
+      if (rest.indexOf(statuses[i]) === 0) {
+        matched = statuses[i];
+        break;
+      }
+    }
+    if (!matched) return [line];
+    pieces.push(matched);
+    rest = rest.slice(matched.length);
+  }
+
+  return pieces.length > 1 ? pieces : [line];
+}
+
+function _cl_isPlainLiveUpdateText(value) {
+  value = String(value || '').trim();
+  if (!value) return false;
+  return value.charAt(0) !== '{' && value.charAt(0) !== '[';
+}
+
+function _cl_ingestLiveUpdateData(rawText, scope) {
+  if (!rawText || typeof rawText !== 'string') return;
+  var lines = rawText.trim().split('\n');
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    if (!line) continue;
+    try {
+      var obj = JSON.parse(line);
+      if (obj && typeof obj === 'object') _cl_ingestTripCardData(obj, scope);
+    } catch (e) {}
+  }
+}
+
+function _cl_ingestTripCardData(obj, scope) {
+  if (!obj || typeof obj !== 'object') return;
+
+  function ensureTripCardData() {
+    if (CL && typeof CL.ensureTripCardData === 'function') {
+      return CL.ensureTripCardData();
+    }
+    if (!CL.tripCardData) {
+      CL.tripCardData = { unitContexts: {}, dayList: [], foodData: null, budgetData: null };
+    }
+    if (!CL.tripCardData.unitContexts) CL.tripCardData.unitContexts = {};
+    if (!Array.isArray(CL.tripCardData.dayList)) CL.tripCardData.dayList = [];
+    return CL.tripCardData;
+  }
+
+  function mergeTripCardData(data) {
+    if (!data || typeof data !== 'object') return false;
+    if (CL && typeof CL.mergeTripCardData === 'function') {
+      return CL.mergeTripCardData(data, { replaceDayList: true, scope: scope });
+    }
+
+    var changed = false;
+    var target = ensureTripCardData();
+
+    if (data.unitContexts && typeof data.unitContexts === 'object') {
+      var ids = Object.keys(data.unitContexts);
+      for (var i = 0; i < ids.length; i++) {
+        target.unitContexts[ids[i]] = data.unitContexts[ids[i]];
+      }
+      if (ids.length > 0) changed = true;
+    }
+
+    if (data.unitContext && data.unitContext.id) {
+      target.unitContexts[data.unitContext.id] = data.unitContext;
+      changed = true;
+    }
+
+    if (Array.isArray(data.dayList)) {
+      target.dayList = data.dayList;
+      changed = true;
+    }
+
+    if (data.foodData) {
+      target.foodData = data.foodData;
+      changed = true;
+    }
+
+    var incomingBudget = data.budgetData
+      || data.budget
+      || (data.result && (data.result.budgetData || data.result.budget));
+    if (incomingBudget) {
+      target.budgetData = incomingBudget;
+      changed = true;
+    }
+
+    return changed;
+  }
+
+  function persistTripCardData() {
+    try {
+      if (CL && CL.tripCardData) {
+        localStorage.setItem('openagent_tripCardData', JSON.stringify(CL.tripCardData));
+      }
+    } catch (e) {}
+  }
+
+  var changed = false;
+
+  if (obj.fullJson && typeof obj.fullJson === 'string') {
+    try {
+      var parsedData = JSON.parse(obj.fullJson);
+      changed = mergeTripCardData(parsedData) || changed;
+    } catch (e) {}
+  } else if (obj.fullJson && typeof obj.fullJson === 'object') {
+    changed = mergeTripCardData(obj.fullJson) || changed;
+  }
+
+  if (obj.tripCardData && typeof obj.tripCardData === 'object') {
+    changed = mergeTripCardData(obj.tripCardData) || changed;
+  }
+
+  if (obj.itineraryVersionInfo && typeof obj.itineraryVersionInfo === 'object') {
+    changed = mergeTripCardData(obj.itineraryVersionInfo) || changed;
+  }
+
+  if (obj.itinerary && typeof obj.itinerary === 'object') {
+    changed = mergeTripCardData(obj.itinerary) || changed;
+  }
+
+  var nestedFields = ['data', 'text', 'content', 'result', 'output'];
+  for (var fi = 0; fi < nestedFields.length; fi++) {
+    var nested = obj[nestedFields[fi]];
+    if (!nested) continue;
+    if (typeof nested === 'object') {
+      changed = mergeTripCardData(nested) || changed;
+      continue;
+    }
+    if (typeof nested === 'string'
+        && nested.charAt(0) === '{'
+        && /"unitContexts"|"dayList"|"foodData"|"budgetData"|"budget"/.test(nested)) {
+      try {
+        changed = mergeTripCardData(JSON.parse(nested)) || changed;
+      } catch (e) {}
+    }
+  }
+
+  changed = mergeTripCardData(obj) || changed;
+
+  if (changed) {
+    CL.tripCardDataFetchFailed = false;
+    persistTripCardData();
+  }
+}
+
+
+
+console.log('[openagent] ✅ render hook v2 registered');