function installWorkbenchTestHooks() {
  if (!isLocalWorkbenchTestHost() || !new URLSearchParams(window.location.search).has("hwlab-test-hooks")) return;
  window.__hwlabWorkbenchTestHooks = {
    seedCompletedAgentMessage,
    seedTraceMessage,
    appendTraceEvents,
    reconcileTraceResultFixture,
    latestAgentMessageText,
    traceScrollMetrics,
    traceDomIdentity,
    traceBodyDomIdentity,
    traceRowTexts,
    setTraceBodyScrollTop,
    replaceTraceAssistantStream,
    setTraceScrollTop,
    setConversationScrollTop,
    resetProgrammaticScrollWriteCount
  };
}

function isLocalWorkbenchTestHost() {
  return ["127.0.0.1", "localhost", "::1", "[::1]"].includes(window.location.hostname);
}

function seedCompletedAgentMessage(options = {}) {
  state.chatMessages = [{
    id: options.messageId ?? "msg_markdown_contract",
    role: "agent",
    title: options.title ?? "Code Agent 回复",
    text: String(options.text ?? ""),
    status: options.status ?? "completed",
    traceId: options.traceId ?? "trc_markdown_contract",
    conversationId: options.conversationId ?? "cnv_markdown_contract",
    sessionId: options.sessionId ?? "ses_markdown_contract"
  }];
  renderConversation();
}

function seedTraceMessage(options = {}) {
  const traceId = options.traceId ?? "trc_scroll_contract";
  const messageId = options.messageId ?? "msg_scroll_contract";
  const count = Math.max(1, Number(options.count ?? 80));
  const events = Array.isArray(options.events)
    ? options.events.map((event, index) => normalizeTestTraceEvent(traceId, event, index + 1))
    : Array.from({ length: count }, (_, index) => testTraceEvent(traceId, index + 1));
  state.chatMessages = [{
    id: messageId,
    role: "agent",
    title: "Code Agent 处理中",
    text: "Trace scroll contract fixture",
    status: "running",
    traceId,
    runnerTrace: {
      traceId,
      events,
      assistantStreams: Array.isArray(options.assistantStreams) ? options.assistantStreams : [],
      eventCount: Number.isInteger(options.eventCount) ? options.eventCount : events.length,
      eventsCompacted: options.eventsCompacted === true,
      eventWindow: options.eventWindow ?? null,
      fullTraceLoaded: options.fullTraceLoaded === true,
      lastEvent: options.lastEvent ?? events.at(-1),
      waitingFor: "turn/completed"
    }
  }];
  renderConversation();
}

function normalizeTestTraceEvent(traceId, event, seq) {
  return {
    traceId,
    seq,
    createdAt: new Date(1779690000000 + seq * 1000).toISOString(),
    ...event,
    traceId: event?.traceId ?? traceId,
    seq: event?.seq ?? seq,
    createdAt: event?.createdAt ?? new Date(1779690000000 + seq * 1000).toISOString()
  };
}

function appendTraceEvents(count = 1) {
  const message = state.chatMessages.find((item) => item.runnerTrace?.traceId);
  if (!message) return;
  const trace = message.runnerTrace;
  const start = Array.isArray(trace.events) ? trace.events.length : 0;
  const additions = Array.from({ length: Math.max(1, Number(count)) }, (_, index) => testTraceEvent(trace.traceId, start + index + 1));
  trace.events = [...trace.events, ...additions];
  trace.eventCount = trace.events.length;
  trace.lastEvent = trace.events.at(-1);
  patchMessageTracePanel(message);
}

function replaceTraceAssistantStream(stream = {}) {
  const message = state.chatMessages.find((item) => item.runnerTrace?.traceId);
  if (!message) return null;
  const trace = message.runnerTrace;
  trace.assistantStreams = [{
    itemId: "assistant-message",
    chunkCount: Math.max(1, Number(stream.chunkCount ?? 1)),
    createdAt: stream.createdAt ?? new Date(1779699000000).toISOString(),
    updatedAt: stream.updatedAt ?? new Date(1779699001000 + Math.max(1, Number(stream.chunkCount ?? 1)) * 1000).toISOString(),
    waitingFor: stream.waitingFor ?? "turn/completed",
    text: String(stream.text ?? "assistant stream fixture")
  }];
  patchMessageTracePanel(message);
  return traceBodyDomIdentity();
}

async function reconcileTraceResultFixture(result) {
  const message = state.chatMessages.find((item) => item.runnerTrace?.traceId || item.traceId);
  if (!message) return null;
  applyCodeAgentResultToMessage(message.id, {
    ...(result && typeof result === "object" ? result : {}),
    traceId: message.traceId,
    conversationId: message.conversationId ?? "cnv_fixture",
    sessionId: message.sessionId ?? "ses_fixture",
    status: "completed",
    provider: "codex-stdio",
    model: "gpt-test",
    backend: "hwlab-cloud-api/codex-app-server-stdio",
    workspace: "/workspace/hwlab",
    sandbox: "workspace-write",
    capabilityLevel: "long-lived-codex-stdio-session",
    runner: {
      kind: "codex-app-server-stdio-runner",
      codexStdio: true,
      writeCapable: true,
      durableSession: true,
      workspace: "/workspace/hwlab",
      sandbox: "workspace-write",
      sessionMode: "codex-app-server-stdio-long-lived",
      implementationType: "repo-owned-codex-app-server-stdio-session",
      capabilityLevel: "long-lived-codex-stdio-session"
    },
    session: {
      sessionId: message.sessionId ?? "ses_fixture",
      status: "idle",
      idleTimeoutMs: 1800000,
      lastTraceId: message.traceId,
      longLivedSession: true,
      durableSession: true,
      codexStdio: true,
      writeCapable: true
    },
    sessionMode: "codex-app-server-stdio-long-lived",
    implementationType: "repo-owned-codex-app-server-stdio-session",
    sessionReuse: { reused: true, sessionId: message.sessionId ?? "ses_fixture" },
    longLivedSessionGate: { status: "pass", pass: true },
    toolCalls: [{ name: "codex-app-server.thread/resume+turn/start", status: "completed" }],
    skills: [],
    reply: {
      content: "fixture reconciled result",
      ...(result?.reply && typeof result.reply === "object" ? result.reply : {})
    },
    providerTrace: {
      protocol: "codex-app-server-jsonrpc-stdio",
      command: "codex app-server --listen stdio://",
      terminalStatus: "completed",
      ...(result?.providerTrace && typeof result.providerTrace === "object" ? result.providerTrace : {})
    },
    runnerTrace: message.runnerTrace,
    updatedAt: new Date().toISOString()
  }, {
    baseMessage: message,
    retryInput: message.retryInput,
    retryOf: message.retryOf
  });
  renderCodeAgentSummary();
  renderConversation();
  return latestAgentMessageText();
}

function latestAgentMessageText() {
  const message = [...state.chatMessages].reverse().find((item) => item.role === "agent");
  return message ? {
    title: message.title,
    text: message.text,
    status: message.status,
    traceId: message.traceId,
    providerTrace: message.providerTrace ?? null,
    sourceKind: message.sourceKind ?? null,
    capabilityLevel: message.capabilityLevel ?? null,
    error: message.error ?? null
  } : null;
}

function traceRowTexts() {
  return [...el.conversationList.querySelectorAll(".message-trace-events[data-trace-ui-key] .message-trace-row")]
    .map((row, index) => ({
      index,
      rowId: row.dataset.traceRowId ?? null,
      text: row.textContent ?? ""
    }));
}

function testTraceEvent(traceId, seq) {
  return {
    traceId,
    label: "trace:scroll-contract",
    type: "trace",
    status: "observed",
    createdAt: new Date(1779690000000 + seq * 1000).toISOString(),
    message: `trace scroll contract event ${seq}\n${"payload ".repeat(18)}`,
    waitingFor: "turn/completed"
  };
}

function traceScrollMetrics() {
  const conversation = el.conversationList;
  const list = conversation.querySelector(".message-trace-events[data-trace-ui-key]");
  return {
    conversationTop: conversation.scrollTop,
    conversationBottomGap: scrollBottomGap(conversation),
    traceTop: list?.scrollTop ?? null,
    traceBottomGap: list ? scrollBottomGap(list) : null,
    traceScrollHeight: list?.scrollHeight ?? null,
    traceClientHeight: list?.clientHeight ?? null,
    traceRowCount: list?.querySelectorAll(".message-trace-row").length ?? 0
  };
}

function traceDomIdentity() {
  const conversation = el.conversationList;
  const panel = conversation.querySelector(".message-trace[data-trace-ui-key]");
  const list = conversation.querySelector(".message-trace-events[data-trace-ui-key]");
  const firstRow = list?.querySelector(".message-trace-row") ?? null;
  if (panel && !panel.__hwlabTraceIdentity) panel.__hwlabTraceIdentity = `panel-${Date.now()}-${Math.random()}`;
  if (list && !list.__hwlabTraceIdentity) list.__hwlabTraceIdentity = `list-${Date.now()}-${Math.random()}`;
  if (firstRow && !firstRow.__hwlabTraceIdentity) firstRow.__hwlabTraceIdentity = `row-${Date.now()}-${Math.random()}`;
  return {
    panel: panel?.__hwlabTraceIdentity ?? null,
    list: list?.__hwlabTraceIdentity ?? null,
    firstRow: firstRow?.__hwlabTraceIdentity ?? null,
    rowCount: list?.querySelectorAll(".message-trace-row").length ?? 0,
    programmaticScrollWrites: state.traceProgrammaticScrollWrites
  };
}

function traceBodyDomIdentity(selector = ".message-trace-events[data-trace-ui-key] li:last-child .message-trace-body") {
  const body = el.conversationList.querySelector(selector);
  const row = body?.closest(".message-trace-row") ?? null;
  if (body && !body.__hwlabTraceIdentity) body.__hwlabTraceIdentity = `body-${Date.now()}-${Math.random()}`;
  if (row && !row.__hwlabTraceIdentity) row.__hwlabTraceIdentity = `row-${Date.now()}-${Math.random()}`;
  return {
    selector,
    body: body?.__hwlabTraceIdentity ?? null,
    row: row?.__hwlabTraceIdentity ?? null,
    rowId: row?.dataset.traceRowId ?? null,
    top: body?.scrollTop ?? null,
    left: body?.scrollLeft ?? null,
    scrollHeight: body?.scrollHeight ?? null,
    clientHeight: body?.clientHeight ?? null,
    text: body?.textContent ?? null
  };
}

function resetProgrammaticScrollWriteCount() {
  state.traceProgrammaticScrollWrites = 0;
  return state.traceProgrammaticScrollWrites;
}

function setTraceScrollTop(top, { user = true } = {}) {
  const list = el.conversationList.querySelector(".message-trace-events[data-trace-ui-key]");
  if (!list) return traceScrollMetrics();
  if (user) markTraceScrollIntent(list.dataset.traceUiKey);
  list.scrollTop = top;
  rememberTraceScrollPosition(list.dataset.traceUiKey, list);
  return traceScrollMetrics();
}

function setTraceBodyScrollTop(selector, top, { user = true } = {}) {
  const body = el.conversationList.querySelector(selector);
  if (!body) return traceBodyDomIdentity(selector);
  if (user) markTraceBodyScrollIntent(body);
  body.scrollTop = top;
  rememberTraceBodyScrollPosition(body);
  return traceBodyDomIdentity(selector);
}

function setConversationScrollTop(top, { user = true } = {}) {
  if (user) markConversationScrollIntent();
  el.conversationList.scrollTop = top;
  captureConversationScrollPosition();
  return traceScrollMetrics();
}

export function traceDisplayRows(trace, events) {
  const rows = [];
  const commandGroups = traceCommandExecutionGroups(events);
  const requestEvent = tracePrimaryRequestEvent(events);
  const hasTerminalAssistant = events.some((event) => isTerminalAssistantTraceEvent(event));
  const renderedCommands = new Set();
  let requestRendered = false;
  let setupRendered = false;
  let completionRendered = false;
  let assistantIndex = 0;
  for (const event of events) {
    if (!event) continue;
    if (isToolOutputChunkTraceEvent(event)) continue;
    if (isCommandExecutionTraceEvent(event)) {
      const groupKey = traceCommandGroupKey(event);
      const group = commandGroups.get(groupKey) ?? { key: groupKey, started: event, completed: event, outputs: [] };
      const renderHere = event.label === "item/commandExecution:started" || group.started === event;
      if (renderHere && !renderedCommands.has(groupKey)) {
        const row = traceCommandSummaryRow(trace, group);
        if (row) rows.push(row);
        renderedCommands.add(groupKey);
      }
      continue;
    }
    if (isAssistantMessageTraceEvent(event)) {
      const row = traceAssistantSummaryRow(trace, event, assistantIndex);
      assistantIndex += 1;
      if (row) rows.push(row);
      continue;
    }
    if (isRequestTraceEvent(event)) {
      if (!requestRendered) {
        const row = traceRequestSummaryRow(trace, event, requestEvent ?? event);
        if (row) rows.push(row);
        requestRendered = true;
      }
      continue;
    }
    if (isSetupTraceEvent(event)) {
      if (!setupRendered) {
        const row = traceSetupSummaryRow(trace, events, event);
        if (row) rows.push(row);
        setupRendered = true;
      }
      continue;
    }
    if (isCompletionTraceEvent(event)) {
      if (!completionRendered && !hasTerminalAssistant) {
        const row = traceCompletionSummaryRow(trace, event);
        if (row) rows.push(row);
        completionRendered = true;
      }
      continue;
    }
    if (isNoisyTraceEvent(event)) continue;
    const row = traceDisplayRow(trace, event);
    if (row) rows.push(row);
  }
  return rows.length > 0 ? rows : events.map((event) => traceDisplayRow(trace, event, { includeNoise: true })).filter(Boolean);
}

function compactTraceTextTail(text, maxLength) {
  const clean = cleanTraceText(text);
  if (clean.length <= maxLength) return clean;
  return `...${clean.slice(-maxLength)}`;
}

function traceCommandExecutionGroups(events) {
  const groups = new Map();
  let activeKey = null;
  const ensureGroup = (key, event) => {
    const groupKey = key || traceCommandGroupKey(event);
    if (!groups.has(groupKey)) groups.set(groupKey, { key: groupKey, started: null, completed: null, outputs: [] });
    return groups.get(groupKey);
  };
  for (const event of events) {
    if (isCommandExecutionTraceEvent(event)) {
      const key = traceCommandGroupKey(event, activeKey);
      const group = ensureGroup(key, event);
      if (event.label === "item/commandExecution:started") {
        group.started = group.started ?? event;
        activeKey = key;
      } else {
        group.completed = event;
        group.started = group.started ?? event;
        if (activeKey === key) activeKey = null;
      }
      continue;
    }
    if (isToolOutputChunkTraceEvent(event)) {
      const key = traceCommandGroupKey(event, activeKey);
      ensureGroup(key, event).outputs.push(event);
    }
  }
  return groups;
}

function traceCommandGroupKey(event, fallback = null) {
  return traceNonEmptyString(event?.itemId ?? event?.callId ?? event?.commandId ?? event?.id) || fallback || `cmd:${event?.seq ?? event?.createdAt ?? Math.random()}`;
}

function traceCommandSummaryRow(trace, group) {
  const start = group.started ?? group.completed ?? group.outputs?.[0];
  const completed = group.completed ?? null;
  if (!start) return null;
  const command = displayTraceCommand(completed?.command ?? start.command ?? "");
  const clock = traceClock(start.createdAt);
  const title = traceCommandTitle(command);
  const ok = !completed ? false : traceStatusToken(completed) === "ok" && (!Number.isInteger(completed.exitCode) || completed.exitCode === 0);
  return {
    rowId: `tool-summary:${group.key}`,
    seq: start.seq ?? null,
    tone: completed ? (ok ? "ok" : "blocked") : "warn",
    header: `${clock}  🔧 工具调用：${title}`,
    body: traceCommandSummaryBody(group, command)
  };
}

function traceCommandSummaryBody(group, command) {
  const completed = group.completed ?? null;
  const result = traceCommandResultSummary(group, command);
  return [
    command ? `命令：${command}` : null,
    completed ? `结果：${result}` : "结果：等待命令完成"
  ].filter(Boolean).join("\n");
}

function traceCommandResultSummary(group, command) {
  const completed = group.completed ?? {};
  const output = traceCommandCombinedOutput(group);
  const fields = traceOutputFields(output);
  const success = fields.hostSuccess ?? fields.success ?? commandSuccessFromEvent(completed);
  const duration = traceCommandDurationSuffix(group);
  if (fields.content && /read-after-launch-flash/u.test(command)) {
    return `\n${traceStartupLogSummary(fields.content)}${duration}`;
  }
  if (fields.hostJobId) {
    return [`hostJobId=${fields.hostJobId}`, `success=${success}`].join(", ") + duration;
  }
  if (fields.logTail && /Flash Load finished/iu.test(fields.logTail)) {
    const ticks = fields.content ? traceTickRange(fields.content) : null;
    const capture = ticks ? ` 捕获的部分串口：tick ${ticks}` : "";
    return `success=${success}, Flash Load finished.${capture}${duration}`;
  }
  if (fields.logTail) {
    return `success=${success}, logTail: "${traceLogTailSummary(fields.logTail)}"${duration}`;
  }
  if (fields.content) {
    const ticks = traceTickRange(fields.content);
    const content = ticks ? `捕获的串口：tick ${ticks}` : compactTraceOneLine(fields.content, 180);
    return `success=${success}, ${content}${duration}`;
  }
  const compact = compactTraceOneLine(output || completed.errorMessage || completed.message || "", 220);
  return `${success !== null ? `success=${success}` : traceStatusToken(completed)}${compact ? `, ${compact}` : ""}${duration}`;
}

function traceCommandCombinedOutput(group) {
  return [
    ...(Array.isArray(group.outputs) ? group.outputs.map((event) => rawTraceOutputText(event)) : []),
    group.completed?.stdoutSummary,
    group.completed?.outputSummary,
    group.completed?.stderrSummary
  ].filter(Boolean).join("\n");
}

function commandSuccessFromEvent(event) {
  if (!event) return null;
  if (Number.isInteger(event.exitCode)) return event.exitCode === 0;
  const status = String(event.status ?? "");
  if (["completed", "succeeded", "success"].includes(status)) return true;
  if (["failed", "error", "timeout", "canceled"].includes(status)) return false;
  return null;
}

function traceCommandDurationSuffix(group) {
  const completed = group.completed ?? null;
  if (!completed) return "";
  let seconds = null;
  if (typeof completed.durationMs === "number") {
    seconds = completed.durationMs / 1000;
  } else if (group.started?.createdAt && completed.createdAt) {
    const start = Date.parse(group.started.createdAt);
    const end = Date.parse(completed.createdAt);
    if (Number.isFinite(start) && Number.isFinite(end) && end >= start) seconds = (end - start) / 1000;
  }
  return seconds === null ? "" : `   (耗时 ${seconds.toFixed(1)}s)`;
}

function traceCommandTitle(command) {
  if (/build\s+start/iu.test(command)) return "启动编译";
  if (/build\s+status/iu.test(command)) return "等待编译并获取状态";
  if (/download\s+start/iu.test(command)) return "启动下载（含串口捕获）";
  if (/download\s+status/iu.test(command)) return "等待下载并获取状态";
  if (/read-after-launch-flash/iu.test(command)) return "读取完整启动日志";
  return "命令执行";
}

function displayTraceCommand(command) {
  let text = cleanTraceOutputText(command);
  text = text.replace(/^\/?\s*bin\s*\/\s*bash\s+-lc\s+(["'])([\s\S]*)\1$/u, "$2");
  text = text.replace(/^bash\s+-lc\s+(["'])([\s\S]*)\1$/u, "$2");
  return normalizeTraceCommandSpacing(text);
}

function normalizeTraceCommandSpacing(text) {
  return String(text ?? "")
    .replace(/:\s+\/\s+/gu, ":/")
    .replace(/\s+\/\s+/gu, "/")
    .replace(/\s{2,}/gu, " ")
    .trim();
}

function traceOutputFields(text) {
  return {
    hostAction: traceOutputStringField(text, "hostAction"),
    hostJobId: traceOutputStringField(text, "hostJobId"),
    hostSuccess: traceOutputBooleanField(text, "hostSuccess"),
    success: traceOutputBooleanField(text, "success"),
    logTail: traceOutputStringField(text, "logTail"),
    content: traceOutputStringField(text, "content")
  };
}

function traceOutputStringField(text, name) {
  const pattern = new RegExp(`"${name}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)"`, "gu");
  let value = "";
  for (const match of String(text ?? "").matchAll(pattern)) {
    try {
      const parsed = JSON.parse(`"${match[1]}"`);
      if (parsed) value = parsed;
    } catch {
      if (match[1]) value = match[1];
    }
  }
  return value;
}

function traceOutputBooleanField(text, name) {
  const pattern = new RegExp(`"${name}"\\s*:\\s*(true|false)`, "giu");
  let value = null;
  for (const match of String(text ?? "").matchAll(pattern)) {
    value = match[1].toLowerCase() === "true";
  }
  return value;
}

function traceLogTailSummary(value) {
  const text = cleanSerialText(value);
  const build = text.match(/([^\n]*\b\d+ Error\(s\), \d+ Warning\(s\)\.[^\n]*)(?:\n([^\n]*Build Time Elapsed:[^\n]*))?/iu);
  if (build) return compactTraceOneLine(`... ${[build[1], build[2]].filter(Boolean).join(" ")}`, 220);
  const flash = text.match(/Flash Load finished[^\n]*/iu);
  if (flash) return flash[0];
  return compactTraceOneLine(text, 220);
}

function traceStartupLogSummary(value) {
  const lines = cleanSerialText(value)
    .split("\n")
    .map((line) => line.trim())
    .filter(Boolean);
  const selected = [];
  for (const line of lines) {
    if (/hello device-pod!/iu.test(line)) selected.push("hello device-pod!");
    else if (/STM32F103 USART1 baseline ready/iu.test(line)) selected.push("[01_baseline] STM32F103 USART1 baseline ready");
    else if (/baud=/iu.test(line)) selected.push(line.replace(/\s+\/\s+/gu, "/"));
    else if (/project=/iu.test(line)) selected.push(line.replace(/\s+\/\s+/gu, "/"));
    else if (/dap=.*idcode=/iu.test(line)) selected.push(line);
  }
  const ticks = traceTickRange(value);
  if (ticks) {
    const [first, last] = ticks.split("-");
    selected.push(last ? `tick=${first}, ..., tick=${last}` : `tick=${first}`);
  }
  return selected.slice(0, 8).join("\n");
}

function traceTickRange(value) {
  const ticks = [...String(value ?? "").matchAll(/tick=(\d+)/giu)].map((match) => Number(match[1])).filter(Number.isFinite);
  if (ticks.length === 0) return null;
  const first = ticks[0];
  const last = ticks.at(-1);
  return first === last ? String(first) : `${first}-${last}`;
}

function cleanSerialText(value) {
  return String(value ?? "")
    .replace(/\u0000/gu, "")
    .replace(/\r\n|\r/gu, "\n")
    .replace(/\n{3,}/gu, "\n\n")
    .trim();
}

function compactTraceOneLine(value, limit = 220) {
  const text = cleanSerialText(value).replace(/\s+/gu, " ").trim();
  return text.length <= limit ? text : `${text.slice(0, Math.max(0, limit - 3))}...`;
}

function tracePrimaryRequestEvent(events) {
  return events.find((event) => isRequestTraceEvent(event) && tracePromptText(event)) ?? events.find(isRequestTraceEvent) ?? null;
}

function traceRequestSummaryRow(trace, event, promptEvent = event) {
  const clock = traceClock(event.createdAt);
  const prompt = tracePromptText(promptEvent);
  return {
    rowId: `trace-request:${event.seq ?? "accepted"}`,
    seq: event.seq ?? null,
    tone: "warn",
    header: `${clock}  请求接受${prompt ? `，提示词："${compactTraceOneLine(prompt, 120)}"` : ""}`,
    body: null
  };
}

function traceSetupSummaryRow(trace, events, event) {
  const setupEvents = events.filter(isSetupTraceEvent);
  const sessionReused = setupEvents.some((item) => /session:reused/iu.test(String(item?.label ?? "")));
  const promptSent = setupEvents.some((item) => /prompt:sent|sent prompt/iu.test(String(item?.label ?? "")));
  const turnStarted = setupEvents.some((item) => /turn[:/]start|turn:started|turn\/start/iu.test(String(item?.label ?? "")));
  const parts = [
    sessionReused ? "会话复用" : "会话就绪",
    promptSent ? "提示词已发送" : null,
    turnStarted ? "轮次开始" : null
  ].filter(Boolean);
  return {
    rowId: "trace-setup:session-turn",
    seq: event.seq ?? null,
    tone: "source",
    header: `${traceClock(event.createdAt)}  ${parts.join("，") || "会话准备完成"}`,
    body: null
  };
}

function traceCompletionSummaryRow(trace, event) {
  return {
    rowId: `trace-completion:${event.seq ?? "turn"}`,
    seq: event.seq ?? null,
    tone: traceEventTone(event),
    header: `${traceClock(event.createdAt)}  轮次完成（总耗时 ${formatTraceDuration(traceRelativeMs(trace, event))}）`,
    body: null
  };
}

function traceAssistantSummaryRow(trace, event, index = 0) {
  const terminal = isTerminalAssistantTraceEvent(event);
  const text = traceAssistantTextForEvent(trace, event, index);
  if (!text && !terminal && traceHasLaterTerminalAssistant(trace, event)) return null;
  const elapsed = formatTraceDuration(traceRelativeMs(trace, event));
  return {
    rowId: `event:${event.seq ?? `${event.label ?? event.type ?? "assistant"}:${event.createdAt ?? "unknown"}`}`,
    seq: event.seq ?? null,
    tone: traceEventTone(event),
    header: terminal
      ? `${traceClock(event.createdAt)}  🤖 助手最后一条消息，轮次完成（总耗时 ${elapsed}）`
      : `${traceClock(event.createdAt)}  🤖 助手消息${index === 0 ? "（第一条）" : ""}`,
    body: text ? compactTraceAssistantMarkdown(text, terminal ? 5000 : 2200) : null,
    bodyFormat: "markdown"
  };
}

function traceAssistantTextForEvent(trace, event, index = 0) {
  const direct = normalizeTraceAssistantMarkdown(event.message ?? event.outputSummary ?? event.chunk ?? event.text ?? "");
  if (direct) return traceAssistantTextDuplicatesTerminal(trace, event, direct) ? "" : direct;
  const streams = traceAssistantStreams(trace);
  if (streams.length === 0) return "";
  const itemId = traceNonEmptyString(event.itemId ?? event.messageId ?? event.id);
  if (itemId) {
    const match = streams.find((stream) => stream.itemId === itemId || stream.messageId === itemId || stream.id === itemId);
    if (match?.text) {
      const text = normalizeTraceAssistantMarkdown(match.text);
      return traceAssistantTextDuplicatesTerminal(trace, event, text) ? "" : text;
    }
  }
  if (isTerminalAssistantTraceEvent(event)) return traceAssistantTerminalText(trace, event);
  return traceAssistantCumulativeSegment(trace, event, index);
}

function traceAssistantStreams(trace) {
  return Array.isArray(trace?.assistantStreams)
    ? trace.assistantStreams.filter((stream) => stream && typeof stream === "object" && normalizeTraceAssistantMarkdown(stream.text ?? ""))
    : [];
}

function traceAssistantEvents(trace) {
  return Array.isArray(trace?.events) ? trace.events.filter(isAssistantMessageTraceEvent) : [];
}

function traceAssistantTerminalText(trace, event = null) {
  const streams = traceAssistantStreams(trace);
  const itemId = traceNonEmptyString(event?.itemId ?? event?.messageId ?? event?.id);
  if (itemId) {
    const matched = streams.find((stream) => stream.itemId === itemId || stream.messageId === itemId || stream.id === itemId);
    if (matched?.text) return normalizeTraceAssistantMarkdown(matched.text);
  }
  return normalizeTraceAssistantMarkdown(streams.at(-1)?.text ?? "");
}

function traceAssistantTextDuplicatesTerminal(trace, event, text) {
  if (isTerminalAssistantTraceEvent(event) || !traceHasLaterTerminalAssistant(trace, event)) return false;
  const terminalText = traceAssistantTerminalText(trace);
  return Boolean(terminalText && traceAssistantComparableText(text) === traceAssistantComparableText(terminalText));
}

function traceHasLaterTerminalAssistant(trace, event) {
  const events = traceAssistantEvents(trace);
  const currentIndex = events.findIndex((item) => item === event || (item?.seq !== undefined && item.seq === event?.seq));
  if (currentIndex < 0) return events.some(isTerminalAssistantTraceEvent);
  return events.slice(currentIndex + 1).some(isTerminalAssistantTraceEvent);
}

function traceAssistantCumulativeSegment(trace, event, index = 0) {
  const assistantEvents = traceAssistantEvents(trace).filter((item) => !isTerminalAssistantTraceEvent(item));
  const eventIndex = assistantEvents.findIndex((item) => item === event || (item?.seq !== undefined && item.seq === event?.seq));
  const segmentIndex = eventIndex >= 0 ? eventIndex : index;
  if (segmentIndex < 0) return "";
  const stream = traceAssistantCumulativeStream(trace);
  if (!stream?.text) return "";
  const cumulative = normalizeTraceAssistantMarkdown(stream.text);
  const terminalText = traceAssistantTerminalText(trace);
  const nonTerminalText = traceAssistantRemoveTerminalSuffix(cumulative, terminalText);
  if (!nonTerminalText || traceAssistantComparableText(nonTerminalText) === traceAssistantComparableText(terminalText)) return "";
  const segments = traceAssistantSplitCumulativeText(nonTerminalText, assistantEvents.length);
  return normalizeTraceAssistantMarkdown(segments[segmentIndex] ?? "");
}

function traceAssistantCumulativeStream(trace) {
  const streams = traceAssistantStreams(trace);
  if (streams.length === 0) return null;
  const terminalIds = new Set(traceAssistantEvents(trace)
    .filter(isTerminalAssistantTraceEvent)
    .flatMap((event) => [event.itemId, event.messageId, event.id].map(traceNonEmptyString).filter(Boolean)));
  const candidates = streams.filter((stream) => {
    const streamId = traceNonEmptyString(stream.itemId ?? stream.messageId ?? stream.id);
    return !streamId || !terminalIds.has(streamId);
  });
  return [...(candidates.length > 0 ? candidates : streams)]
    .sort((left, right) => String(right.text ?? "").length - String(left.text ?? "").length)[0] ?? null;
}

function traceAssistantRemoveTerminalSuffix(text, terminalText) {
  const clean = normalizeTraceAssistantMarkdown(text);
  const terminal = normalizeTraceAssistantMarkdown(terminalText);
  if (!clean || !terminal) return clean;
  if (clean.endsWith(terminal)) return clean.slice(0, -terminal.length).trim();
  const index = traceAssistantCompactLastIndex(clean, terminal);
  if (index > 0) return clean.slice(0, index).trim();
  return clean;
}

function traceAssistantCompactLastIndex(text, needle) {
  const haystack = traceAssistantComparableWithMap(text);
  const target = traceAssistantComparableText(needle);
  if (!target) return -1;
  const compactIndex = haystack.text.lastIndexOf(target);
  return compactIndex >= 0 ? haystack.map[compactIndex] ?? -1 : -1;
}

function traceAssistantComparableWithMap(value) {
  const map = [];
  let text = "";
  const raw = String(value ?? "");
  for (let index = 0; index < raw.length; index += 1) {
    const char = raw[index];
    if (/\s/u.test(char)) continue;
    text += char.toLowerCase();
    map.push(index);
  }
  return { text, map };
}

function traceAssistantComparableText(value) {
  return traceAssistantComparableWithMap(normalizeTraceAssistantMarkdown(value)).text;
}

function traceAssistantSplitCumulativeText(text, count) {
  const targetCount = Math.max(1, Number(count) || 1);
  const clean = normalizeTraceAssistantMarkdown(text);
  if (!clean) return [];
  if (targetCount === 1) return [clean];
  const colonPieces = [];
  let remaining = clean;
  while (remaining && colonPieces.length < targetCount) {
    const match = /^([\s\S]*?[：:])(?=\s*[^\s])/u.exec(remaining);
    if (!match?.[1] || match[1].trim().length < 8) break;
    colonPieces.push(match[1].trim());
    remaining = remaining.slice(match[1].length).trim();
  }
  const pieces = colonPieces.length > 0 ? colonPieces : traceAssistantSentencePieces(clean);
  if (colonPieces.length > 0 && remaining) pieces.push(remaining);
  if (pieces.length <= targetCount) return [...pieces, ...Array.from({ length: targetCount - pieces.length }, () => "")];
  return traceAssistantPackPieces(pieces, targetCount);
}

function traceAssistantSentencePieces(text) {
  return String(text ?? "").match(/[^。！？.!?]+[。！？.!?]?/gu)?.map((item) => item.trim()).filter(Boolean) ?? [];
}

function traceAssistantPackPieces(pieces, count) {
  const packed = Array.from({ length: count }, () => "");
  pieces.forEach((piece, index) => {
    const slot = Math.min(count - 1, Math.floor(index * count / pieces.length));
    packed[slot] = [packed[slot], piece].filter(Boolean).join("");
  });
  return packed;
}

function compactTraceAssistantMarkdown(text, maxLength) {
  const clean = normalizeTraceAssistantMarkdown(text);
  if (clean.length <= maxLength) return clean;
  return `${clean.slice(0, Math.max(0, maxLength - 12)).trimEnd()}\n\n...内容已截断`;
}

function normalizeTraceAssistantMarkdown(value) {
  let text = String(value ?? "")
    .replace(/\u0000/gu, "")
    .replace(/\r\n|\r/gu, "\n")
    .replace(/[ \t]{2,}/gu, " ")
    .replace(/\n{3,}/gu, "\n\n")
    .trim();
  if (!text) return "";
  text = restoreTraceAssistantEnglishSpacing(text);
  text = restoreTraceAssistantMarkdownBreaks(text);
  return text;
}

function restoreTraceAssistantEnglishSpacing(value) {
  return String(value ?? "")
    .replace(/\bLetmecheckwhat/gu, "Let me check what ")
    .replace(/cloudAPI/giu, "Cloud API")
    .replace(/CloudAPI/gu, "Cloud API")
    .replace(/gatewaysessions/giu, "gateway sessions")
    .replace(/gatewaysession/giu, "gateway session")
    .replace(/gatewaysidecar/giu, "gateway sidecar")
    .replace(/Windows端/gu, "Windows 端")
    .replace(/gateway服务/giu, "gateway 服务")
    .replace(/gateway恢复/giu, "gateway 恢复")
    .replace(/device-podprofilesareavailable/giu, "device-pod profiles are available")
    .replace(/profilesareavailable/giu, "profiles are available")
    .replace(/\b([A-Za-z]+)areavailable\b/gu, "$1 are available")
    .replace(/(\d+)Error\(s\),\s*(\d+)Warning\(s\)/gu, "$1 Error(s), $2 Warning(s)")
    .replace(/所有(\d+)个/gu, "所有 $1 个")
    .replace(/(\d+)个device-pod/giu, "$1 个 device-pod")
    .replace(/个device-pod/giu, "个 device-pod")
    .replace(/(\*\*\d+)个/gu, "$1 个")
    .replace(/([\u4e00-\u9fff])`/gu, "$1 `")
    .replace(/`([^`]+)`([\u4e00-\u9fff])/gu, "`$1` $2")
    .replace(/([A-Za-z0-9_-])`/gu, "$1 `")
    .replace(/([\u4e00-\u9fff])\*\*/gu, "$1 **")
    .replace(/\*\*([\u4e00-\u9fff])/gu, "** $1")
    .replace(/([a-z])([\u4e00-\u9fff])/gu, "$1 $2")
    .replace(/([\u4e00-\u9fff])([A-Za-z][A-Za-z0-9_-]*)/gu, "$1 $2");
}

function restoreTraceAssistantMarkdownBreaks(value) {
  return String(value ?? "")
    .replace(/([：:。.!?])\s*(\|[^\n]+\|)/gu, "$1\n\n$2")
    .replace(/\|\s*\|(?=(?:---|:---|[^|\n]+\s*\|))/gu, "|\n|")
    .replace(/\s+-\s+(?=(?:\*\*|`|[\u4e00-\u9fffA-Za-z0-9]))/gu, "\n- ")
    .replace(/([^\n])\s+(想对哪个pod进行操作？)/gu, "$1\n\n$2")
    .replace(/([^\n])\s+(编译干净通过，无错误无警告。)/gu, "$1\n\n$2");
}

function traceDisplayRow(trace, event, options = {}) {
  if (!options.includeNoise && isNoisyTraceEvent(event)) return null;
  if (isCommandExecutionTraceEvent(event)) return traceCommandExecutionRow(trace, event);
  const clock = traceClock(event.createdAt);
  const total = formatTraceDuration(traceRelativeMs(trace, event));
  const status = traceStatusToken(event);
  const label = readableTraceLabel(event);
  const meta = [
    status,
    event.errorCode ? `error=${event.errorCode}` : null,
    typeof event.timeoutMs === "number" ? `timeout=${formatTraceDuration(event.timeoutMs)}` : null,
    typeof event.idleMs === "number" ? `idle=${formatTraceDuration(event.idleMs)}` : null,
    event.outputSummary ? `out=${compactTraceSize(event.outputSummary)}` : null
  ].filter(Boolean).join(" ");
  const body = traceDisplayBody(event);
  return {
    rowId: `event:${event.seq ?? `${event.label ?? event.type ?? "event"}:${event.createdAt ?? "unknown"}`}`,
    seq: event.seq ?? null,
    tone: traceEventTone(event),
    header: `${clock} total=${total}${meta ? ` ${meta}` : ""}${label ? ` ${label}` : ""}`,
    body
  };
}

function traceCommandExecutionRow(trace, event) {
  const clock = traceClock(event.createdAt);
  const total = formatTraceDuration(traceRelativeMs(trace, event));
  const status = traceStatusToken(event);
  const command = cleanTraceOutputText(event.command ?? "");
  const meta = [
    status,
    "tool cmd",
    command ? `:: ${compactTraceTextTail(command, 220)}` : null,
    Number.isInteger(event.exitCode) ? `exit=${event.exitCode}` : null,
    typeof event.durationMs === "number" ? `s=${(event.durationMs / 1000).toFixed(1)}` : null,
    typeof event.outputBytes === "number" ? `out=${formatTraceBytes(event.outputBytes)}` : null,
    event.itemId ? `item=${event.itemId}` : null
  ].filter(Boolean).join(" ");
  return {
    rowId: `event:${event.seq ?? `${event.label ?? event.type ?? "command"}:${event.createdAt ?? "unknown"}`}`,
    seq: event.seq ?? null,
    tone: traceEventTone(event),
    header: `${clock} total=${total} ${meta}`,
    body: traceCommandExecutionBody(event)
  };
}

function traceCommandExecutionBody(event) {
  const lines = [
    event.command ? `command=${compactTraceTextTail(cleanTraceOutputText(event.command), 900)}` : null,
    event.stdoutSummary ? `stdout:\n${compactTraceTextTail(cleanTraceOutputText(event.stdoutSummary), 1200)}` : null,
    event.stderrSummary ? `stderr:\n${compactTraceTextTail(cleanTraceOutputText(event.stderrSummary), 800)}` : null,
    event.waitingFor && event.status !== "completed" ? `waiting=${event.waitingFor}` : null
  ].filter(Boolean);
  return lines.join("\n");
}

function isCommandExecutionTraceEvent(event) {
  return event?.type === "tool_call" && event?.toolName === "commandExecution" &&
    (event?.label === "item/commandExecution:started" || event?.label === "item/commandExecution:completed");
}

function isAssistantMessageTraceEvent(event) {
  const label = String(event?.label ?? "");
  return event?.type === "assistant_message" || label.startsWith("assistant:");
}

function isTerminalAssistantTraceEvent(event) {
  const label = String(event?.label ?? "");
  return event?.terminal === true || label === "assistant:completed";
}

function isRequestTraceEvent(event) {
  const label = String(event?.label ?? "");
  return label === "request:accepted-short-connection" ||
    label === "request:accepted" ||
    label === "request:received";
}

function isSetupTraceEvent(event) {
  const label = String(event?.label ?? "");
  return /^session:|^stdio:|^prompt:|^thread:|^turn:started|^turn:start|turn\/start|codex turn|tool:codex-app-server/iu.test(label);
}

function isCompletionTraceEvent(event) {
  const label = String(event?.label ?? "");
  return label.startsWith("turn:completed") || label.startsWith("result:completed");
}

function tracePromptText(event) {
  return cleanTraceText(event?.promptSummary ?? event?.prompt ?? "");
}

function traceNonEmptyString(value) {
  const text = String(value ?? "").trim();
  return text ? text : null;
}

function isNoisyTraceEvent(event) {
  const label = String(event?.label ?? "");
  if (isToolOutputChunkTraceEvent(event)) return false;
  if (/token_count|outputDelta:chunk/iu.test(label)) return true;
  if (event?.type === "event" && !event.outputSummary && !event.message && !event.errorCode) return true;
  return false;
}

function isToolOutputChunkTraceEvent(event) {
  const label = String(event?.label ?? "");
  return label === "item/commandExecution/outputDelta" ||
    (event?.type === "tool_call" && event?.status === "output_chunk" && !String(event?.toolName ?? "").startsWith("codex-app-server"));
}

function readableTraceLabel(event) {
  const label = String(event?.label ?? `${event?.type ?? "event"}:${event?.status ?? "observed"}`);
  if (label === "request:accepted-short-connection") return "submit short-connection";
  if (label === "request:accepted") return "request accepted";
  if (label.startsWith("tool:codex-app-server.thread/start+turn/start")) return "codex turn start";
  if (label.startsWith("tool:codex-app-server.thread/resume+turn/start")) return "codex turn resume";
  if (label === "item/commandExecution:started") return "cmd started";
  if (label === "item/commandExecution:completed") return "cmd completed";
  if (label.startsWith("item/commandExecution/outputDelta")) return "cmd output";
  if (label === "turn:waiting:first_assistant_token") return "waiting first assistant token";
  if (label.startsWith("turn:completed")) return "turn completed";
  if (label.startsWith("result:completed")) return "result ready";
  if (label.startsWith("result:failed")) return "result failed";
  if (label.startsWith("timeout:")) return "timeout";
  if (label.startsWith("cancel:")) return "cancel";
  return label
    .replace(/^tool:/u, "")
    .replace(/^assistant:/u, "assistant ")
    .replace(/:completed:completed$/u, " completed")
    .replace(/:completed$/u, " completed")
    .replace(/:started$/u, " started");
}

function traceDisplayBody(event) {
  const lines = [
    event.promptSummary ? cleanTraceText(event.promptSummary) : null,
    event.outputSummary ? cleanTraceOutputText(event.outputSummary) : null,
    event.message ? cleanTraceText(event.message) : null,
    event.chunk && !isNoisyTraceEvent(event) ? cleanTraceOutputText(event.chunk) : null,
    event.waitingFor && event.status !== "completed" ? `waiting=${event.waitingFor}` : null
  ].filter(Boolean);
  return lines.join("\n").slice(0, 1400);
}

function rawTraceOutputText(event) {
  return String(event?.outputSummary ?? event?.chunk ?? event?.message ?? "");
}

function parseGatewayJsonRpcOutputs(text) {
  const payloads = parseJsonObjects(text);
  return payloads
    .filter((payload) => payload && payload.jsonrpc === "2.0" && payload.result && typeof payload.result === "object")
    .map((payload) => {
      const result = payload.result;
      const dispatch = result.dispatch && typeof result.dispatch === "object" ? result.dispatch : {};
      if (!("gatewaySessionId" in result) && !("capabilityId" in result) && !("shellExecuted" in dispatch)) return null;
      return { payload, result, dispatch };
    })
    .filter(Boolean);
}

function parseGatewayJsonRpcOutput(text) {
  return parseGatewayJsonRpcOutputs(text)[0] ?? null;
}

function parseJsonObjects(text) {
  const source = String(text ?? "");
  const values = [];
  let searchFrom = 0;
  while (searchFrom < source.length) {
    const start = source.indexOf("{", searchFrom);
    if (start < 0) break;
    const end = jsonObjectEnd(source, start);
    if (end < 0) break;
    try {
      values.push(JSON.parse(source.slice(start, end + 1)));
      searchFrom = end + 1;
    } catch {
      searchFrom = start + 1;
    }
  }
  return values;
}

function parseFirstJsonObject(text) {
  const source = String(text ?? "");
  const start = source.indexOf("{");
  if (start < 0) return null;
  const end = jsonObjectEnd(source, start);
  if (end < 0) return null;
  try {
    return JSON.parse(source.slice(start, end + 1));
  } catch {
    return null;
  }
}

function jsonObjectEnd(source, start) {
  let depth = 0;
  let inString = false;
  let escaped = false;
  for (let index = start; index < source.length; index += 1) {
    const char = source[index];
    if (inString) {
      if (escaped) {
        escaped = false;
      } else if (char === "\\") {
        escaped = true;
      } else if (char === "\"") {
        inString = false;
      }
      continue;
    }
    if (char === "\"") {
      inString = true;
      continue;
    }
    if (char === "{") depth += 1;
    if (char === "}") depth -= 1;
    if (depth === 0) {
      return index;
    }
  }
  return -1;
}

function gatewayJsonRpcDisplayBody({ payload, result, dispatch, raw }) {
  const stdout = cleanTraceOutputText(dispatch.stdout);
  const stderr = cleanTraceOutputText(dispatch.stderr);
  const error = dispatch.error?.message ?? dispatch.error ?? dispatch.message ?? result.message ?? null;
  return [
    `request=${payload.id ?? "unknown"}`,
    `gateway=${result.gatewaySessionId ?? "unknown"} resource=${result.resourceId ?? "unknown"} capability=${result.capabilityId ?? "unknown"}`,
    `dispatch=${dispatch.dispatchStatus ?? result.status ?? "unknown"} shellExecuted=${dispatch.shellExecuted === true ? "true" : "false"} timedOut=${dispatch.timedOut === true ? "true" : "false"}`,
    error ? `error=${compactTraceTextTail(cleanTraceOutputText(error), 600)}` : null,
    dispatch.command ? `command=${compactTraceTextTail(cleanTraceOutputText(dispatch.command), 420)}` : null,
    result.auditId ? `audit=${result.auditId}` : null,
    result.evidenceId ? `evidence=${result.evidenceId}` : null,
    dispatch.stdoutTruncated === true ? "stdoutTruncated=true" : null,
    stdout ? `stdout:\n${compactTraceTextTail(stdout, 1200)}` : null,
    stderr ? `stderr:\n${compactTraceTextTail(stderr, 800)}` : null,
    !stdout && !stderr && raw ? compactTraceTextTail(cleanTraceOutputText(raw), 900) : null
  ].filter(Boolean).join("\n");
}

function traceStatusToken(event) {
  const status = String(event?.status ?? "");
  if (status === "completed" || status === "succeeded") return "ok";
  if (["failed", "blocked", "error", "timeout", "canceled"].includes(status) || event?.errorCode) return "fail";
  if (["started", "running", "accepted"].includes(status)) return "run";
  return status || "event";
}

function traceEventTone(event) {
  const status = traceStatusToken(event);
  if (status === "ok") return "ok";
  if (status === "fail") return "blocked";
  if (status === "run") return "warn";
  return "source";
}

function traceClock(value) {
  const date = new Date(value);
  return Number.isNaN(date.getTime()) ? "--:--:--" : date.toISOString().slice(11, 19);
}

function traceRelativeMs(trace, event) {
  if (typeof event?.elapsedMs === "number") return event.elapsedMs;
  const start = Date.parse(trace?.startedAt ?? trace?.createdAt ?? "");
  const current = Date.parse(event?.createdAt ?? "");
  return Number.isNaN(start) || Number.isNaN(current) ? 0 : Math.max(0, current - start);
}

function formatTraceDuration(ms) {
  const total = Math.max(0, Math.floor(Number(ms) || 0));
  const seconds = Math.floor(total / 1000);
  const hh = String(Math.floor(seconds / 3600)).padStart(2, "0");
  const mm = String(Math.floor((seconds % 3600) / 60)).padStart(2, "0");
  const ss = String(seconds % 60).padStart(2, "0");
  return `${hh}:${mm}:${ss}`;
}

function compactTraceSize(value) {
  const length = String(value ?? "").length;
  if (length >= 1000) return `${(length / 1000).toFixed(length >= 10000 ? 0 : 1)}k`;
  return String(length);
}

function formatTraceBytes(value) {
  const bytes = Math.max(0, Number(value) || 0);
  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}MiB`;
  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)}KiB`;
  return `${bytes}B`;
}

function cleanTraceText(value) {
  const text = String(value ?? "").trim();
  if (!text) return "";
  return text
    .replace(/\s*\/\s*/gu, " / ")
    .replace(/[ \t]{2,}/gu, " ")
    .replace(/\n{3,}/gu, "\n\n");
}

function cleanTraceOutputText(value) {
  const text = String(value ?? "").trim();
  if (!text) return "";
  return text
    .replace(/[ \t]{2,}/gu, " ")
    .replace(/\n{3,}/gu, "\n\n");
}

function traceActionButton(label, onClick, title) {
  const button = document.createElement("button");
  button.type = "button";
  button.className = "message-trace-action";
  button.textContent = label;
  button.title = title;
  button.addEventListener("click", onClick);
  return button;
}

function messageTraceJson(message, trace, events) {
  return JSON.stringify({
    traceId: trace?.traceId ?? message.traceId ?? null,
    messageId: message.id ?? null,
    eventCount: Number.isInteger(trace?.eventCount) ? trace.eventCount : events.length,
    eventsCompacted: trace?.eventsCompacted === true,
    eventWindow: trace?.eventWindow ?? null,
    lastEvent: trace?.lastEvent ?? events.at(-1) ?? null,
    assistantStreams: Array.isArray(trace?.assistantStreams) ? trace.assistantStreams : [],
    events
  }, null, 2);
}

function downloadTraceJson(message, trace, events) {
  const traceId = String(trace?.traceId ?? message.traceId ?? "trace")
    .replace(/[^A-Za-z0-9_.-]+/gu, "-")
    .replace(/^-|-$/gu, "")
    .slice(0, 96) || "trace";
  const blob = new Blob([messageTraceJson(message, trace, events)], { type: "application/json" });
  const href = URL.createObjectURL(blob);
  const anchor = document.createElement("a");
  anchor.href = href;
  anchor.download = `${traceId}.json`;
  document.body.append(anchor);
  anchor.click();
  anchor.remove();
  window.setTimeout(() => URL.revokeObjectURL(href), 0);
}

function runnerTraceHeadline(message, trace) {
  const count = Number.isInteger(trace?.eventCount) ? trace.eventCount : Array.isArray(trace?.events) ? trace.events.length : 0;
  const last = trace?.lastEvent?.label ?? trace?.eventLabels?.at?.(-1) ?? "等待事件";
  const elapsed = typeof trace?.elapsedMs === "number" ? ` / ${trace.elapsedMs}ms` : "";
  const waiting = trace?.waitingFor ? ` / 等待 ${trace.waitingFor}` : "";
  const thread = trace?.threadId ?? message.threadId ? ` / thread=${trace?.threadId ?? message.threadId}` : "";
  return `运行 trace ${trace?.traceId ?? message.traceId ?? "pending"} / events=${count} / last=${last}${elapsed}${waiting}${thread}`;
}