@xfxstudio/claworld 2026.7.9-testing.3 → 2026.7.13-testing.2

package/src/openclaw/runtime/transcript-report.js

@@ -1,1898 +1,933 @@
-import { execFile } from 'node:child_process';
-import crypto from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { promisify } from 'node:util';
-import { deflateSync } from 'node:zlib';
-import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
-import {
-  appendClaworldJournalEvent,
-  CLAWORLD_REPORTS_DIR,
-  CLAWORLD_WORKING_MEMORY_DIR,
-  ensureClaworldWorkingMemory,
-  readClaworldSessionDirectory,
-} from './working-memory.js';
-
-const execFileAsync = promisify(execFile);
 
-export const CLAWORLD_TRANSCRIPT_REPORT_TOOL_NAME = 'claworld_render_transcript_report';
-export const CLAWORLD_TRANSCRIPT_REPORT_STYLE = 'claworld-comic-grid';
-export const CLAWORLD_TRANSCRIPT_REPORT_STYLES = Object.freeze([
-  CLAWORLD_TRANSCRIPT_REPORT_STYLE,
-]);
+import {
+  CLAWORLD_TRANSCRIPT_STYLE_NAME,
+  measureTranscriptItem,
+  paginateTranscriptItems,
+  renderTranscriptPageSvg,
+} from './transcript-report-comic-grid.js';
+import { displayCols } from './transcript-report-stylekit.js';
+import { appendClaworldJournalEvent } from './working-memory.js';
 
 const DEFAULT_WIDTH = 720;
 const DEFAULT_MAX_PAGE_HEIGHT = 2600;
-const MIN_PAGE_HEIGHT = 900;
-const MAX_PAGE_HEIGHT = 8000;
+const TIME_SPLIT_SECONDS = 5 * 60;
+const SESSION_INDEX_RELATIVE_PATH = path.join('.claworld', 'sessions', 'index.json');
+
 const TOP_LEVEL_RENDER_FIELDS = new Set(['mode', 'stored', 'manual', 'style', 'maxPageHeight']);
 const MANUAL_RENDER_FIELDS = new Set(['messages', 'title', 'peerProfile', 'localLabel', 'peerLabel']);
+const STORED_RENDER_FIELDS = new Set(['chatRequestId', 'title', 'peerProfile', 'localLabel', 'peerLabel']);
 const MANUAL_MESSAGE_FIELDS = new Set(['from', 'text', 'createdAt']);
-const TIME_SPLIT_SECONDS = 5 * 60;
-const SEGMENT_GAP_SECONDS = 4 * 60 * 60;
-const ARTIFACT_SCHEMA = 'claworld.transcript_report.v1';
-const CANVAS_MARGIN = 24;
-const FRAME_MARGIN = 16;
-const HEADER_Y = 48;
-const HEADER_CARD_HEIGHT_ONE_LINE = 92;
-const HEADER_CARD_HEIGHT_TWO_LINES = 110;
-const HEADER_BOTTOM_PAD = 20;
-const BODY_TOP_GAP = 24;
-const PAGE_BOTTOM = 54;
-const ITEM_GAP = 22;
-const TIME_ROW_HEIGHT = 42;
-const ELLIPSIS_HEIGHT = 34;
-const BUBBLE_PAD_X = 32;
-const BUBBLE_PAD_Y = 22;
-const LABEL_HEIGHT = 30;
-const LABEL_OVERLAP = 18;
-const LABEL_RAISE = 9;
-const LABEL_MAX_COLS = 14;
-const BUBBLE_MAX_RATIO = 0.64;
-const BUBBLE_MIN_WIDTH = 200;
-const FONT_SIZE = 18;
-const SMALL_FONT_SIZE = 12;
-const LABEL_FONT_SIZE = 15;
-const TITLE_FONT_SIZE = 34;
-const LINE_HEIGHT = 29;
-const HEADER_SUBTITLE_MAX_UNITS = 33;
-const HEADER_SUBTITLE_MAX_LINES = 2;
-const HEADER_SUBTITLE_LINE_HEIGHT = 19;
-const TAG_HEIGHT = 58;
-const TAG_ICON_SIZE = 30;
-const TAG_ICON_GAP = 12;
-const TAG_ICON_TOP_GAP = 8;
-const TAG_FALLBACK_MAX_COLS = 10;
-const TEXT_UNIT_PX = 18;
-const BLACK = '#090909';
-const COMIC_THEME = Object.freeze({
-  paper: '#FBF8EF',
-  paperWarm: '#FFFDF7',
-  headerFill: '#FEF5D8',
-  gridMinor: '#BED1D8',
-  gridMajor: '#AABFC8',
-  ink: BLACK,
-  muted: '#222222',
-  leftFill: '#EFFFF5',
-  leftLabel: '#62E69D',
-  leftAccentA: '#58E58F',
-  leftAccentB: '#47B6FF',
-  rightFill: '#EFE0FF',
-  rightLabel: '#B785FF',
-  rightAccentA: '#A871FF',
-  rightAccentB: '#FF4EB4',
-  timeFill: '#FFFDF7',
-  timeAccentLeft: '#FF62DE',
-  timeAccentRight: '#50D995',
-});
-const TAG_ICON_THEMES = Object.freeze({
-  like: ['#D8F4FF', '#58B7FF'],
-  dislike: ['#FFE0EA', '#FF6A9A'],
-  'request end': ['#FFF0A8', '#FF9F2F'],
-});
-const COMIC_FONT_FAMILY = [
-  "'PingFang SC'",
-  "'Hiragino Sans GB'",
-  "'Microsoft YaHei'",
-  "'WenQuanYi Zen Hei'",
-  "'Noto Sans CJK SC'",
-  "'Noto Sans SC'",
-  "'Source Han Sans SC'",
-  "'IPA P Gothic'",
-  "'AR PL UMing CN'",
-  "'Arial Unicode MS'",
-  '-apple-system',
-  'BlinkMacSystemFont',
-  "'Segoe UI'",
-  'Arial',
-  'sans-serif',
-].join(', ');
 
-function isObject(value) {
-  return value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function normalizeText(value, fallback = null) {
+const OPERATIONAL_NOTICE_PATTERNS = [
+  /^🧭\s*New session:\s+\S+/iu,
+  /^🧹\s*Auto-compaction complete(?:\s*\(count \d+\))?\.$/iu,
+  /^↪️?\s*Model Fallback:/iu,
+  /^↪️?\s*Model Fallback cleared:/iu,
+  /^⚠️?\s*Agent failed before reply:/iu,
+  /^Sent the (?:reply|opener|Claworld reply)\.?$/iu,
+  /^◐\s*Session automatically reset\b/iu,
+];
+const RUNTIME_ERROR_PATTERNS = [
+  /^⚠️?\s*Agent failed before reply:/iu,
+  /^LLM request failed:/iu,
+  /^LLM request timed out\.$/iu,
+  /^LLM request unauthorized\.$/iu,
+  /^The AI service is temporarily overloaded\.$/iu,
+  /^The AI service returned an error\.$/iu,
+  /^⚠️?\s*API rate limit reached\.$/iu,
+  /^⚠️?\s*.+\s+returned a billing error\b/iu,
+];
+const OPERATIONAL_SUFFIX_PATTERNS = [
+  /^Usage:\s+.+\s+in\s+\/\s+.+\s+out(?:\s+·\s+est\s+.+)?$/iu,
+];
+
+function text(value, fallback = null) {
   if (value == null) return fallback;
   const normalized = String(value).trim();
   return normalized || fallback;
 }
 
-function inputError(field, message) {
-  throw createRuntimeBoundaryError({
-    code: 'tool_input_invalid',
-    category: 'input',
-    status: 400,
-    message,
-    publicMessage: message,
-    recoverable: true,
-    context: { field },
-  });
+function isObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
 
-function assertObject(value, field) {
-  if (!isObject(value)) inputError(field, `${field} must be an object`);
-  return value;
+function compactObject(value = {}) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => (
+    entry != null && entry !== '' && (!Array.isArray(entry) || entry.length > 0)
+  )));
 }
 
-function assertNoUnknownFields(value, allowedFields, field) {
-  const source = assertObject(value, field);
-  for (const key of Object.keys(source)) {
-    if (!allowedFields.has(key)) inputError(`${field}.${key}`, `${field}.${key} is not supported`);
-  }
+function isoNow() {
+  return new Date().toISOString();
 }
 
-function validateRenderArgs(args = {}) {
-  const params = assertObject(args, 'parameters');
-  assertNoUnknownFields(params, TOP_LEVEL_RENDER_FIELDS, 'parameters');
-  const mode = normalizeText(params.mode, null);
-  if (!mode) inputError('mode', 'mode is required');
-  if (!['stored', 'manual'].includes(mode)) inputError('mode', 'mode must be stored or manual');
-  const style = normalizeText(params.style, CLAWORLD_TRANSCRIPT_REPORT_STYLE);
-  if (!CLAWORLD_TRANSCRIPT_REPORT_STYLES.includes(style)) {
-    inputError('style', `style must be ${CLAWORLD_TRANSCRIPT_REPORT_STYLE}`);
-  }
-  const maxPageHeight = Number.isInteger(params.maxPageHeight)
-    ? params.maxPageHeight
-    : DEFAULT_MAX_PAGE_HEIGHT;
-  if (maxPageHeight < MIN_PAGE_HEIGHT || maxPageHeight > MAX_PAGE_HEIGHT) {
-    inputError('maxPageHeight', `maxPageHeight must be between ${MIN_PAGE_HEIGHT} and ${MAX_PAGE_HEIGHT}`);
-  }
-
-  if (mode === 'stored') {
-    const stored = assertObject(params.stored, 'stored');
-    assertNoUnknownFields(stored, new Set(['chatRequestId']), 'stored');
-    const chatRequestId = normalizeText(stored.chatRequestId, null);
-    if (!chatRequestId) inputError('stored.chatRequestId', 'stored.chatRequestId is required');
-    return { mode, style, maxPageHeight, stored: { chatRequestId } };
+async function readJsonObject(filePath, fallback = {}) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(filePath, 'utf8'));
+    return isObject(parsed) ? parsed : fallback;
+  } catch {
+    return fallback;
   }
+}
 
-  const manual = assertObject(params.manual, 'manual');
-  assertNoUnknownFields(manual, MANUAL_RENDER_FIELDS, 'manual');
-  for (const field of MANUAL_RENDER_FIELDS) {
-    if (!Object.prototype.hasOwnProperty.call(manual, field)) {
-      inputError(`manual.${field}`, `manual.${field} is required`);
-    }
-  }
-  if (!Array.isArray(manual.messages) || manual.messages.length === 0) {
-    inputError('manual.messages', 'manual.messages must contain at least one message');
+async function atomicWriteText(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const temporaryPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${randomUUID()}.tmp`);
+  try {
+    await fs.writeFile(temporaryPath, content.endsWith('\n') ? content : `${content}\n`, 'utf8');
+    await fs.rename(temporaryPath, filePath);
+  } finally {
+    await fs.rm(temporaryPath, { force: true }).catch(() => {});
   }
-  const messages = manual.messages.map((message, index) => {
-    if (!isObject(message)) inputError(`manual.messages.${index}`, 'manual message must be an object');
-    assertNoUnknownFields(message, MANUAL_MESSAGE_FIELDS, `manual.messages.${index}`);
-    const from = normalizeText(message.from, null);
-    if (!['peer', 'local'].includes(from)) {
-      inputError(`manual.messages.${index}.from`, 'manual message from must be peer or local');
-    }
-    const text = normalizeText(message.text, null);
-    if (!text) inputError(`manual.messages.${index}.text`, 'manual message text is required');
-    const createdAt = normalizeText(message.createdAt, null);
-    if (!createdAt) inputError(`manual.messages.${index}.createdAt`, 'manual message createdAt is required');
-    if (!parseTimestampMs(createdAt)) {
-      inputError(`manual.messages.${index}.createdAt`, 'manual message createdAt must be a parseable timestamp');
-    }
-    return { from, text, createdAt };
-  });
-  return {
-    mode,
-    style,
-    maxPageHeight,
-    manual: {
-      messages,
-      title: normalizeText(manual.title, null) || inputError('manual.title', 'manual.title is required'),
-      peerProfile: normalizeText(manual.peerProfile, null) || inputError('manual.peerProfile', 'manual.peerProfile is required'),
-      localLabel: normalizeText(manual.localLabel, null) || inputError('manual.localLabel', 'manual.localLabel is required'),
-      peerLabel: normalizeText(manual.peerLabel, null) || inputError('manual.peerLabel', 'manual.peerLabel is required'),
-    },
-  };
 }
 
-function resolveWorkspaceRoot(workspaceRoot = null) {
-  return path.resolve(normalizeText(workspaceRoot, null) || process.cwd());
+async function atomicWriteJson(filePath, payload) {
+  await atomicWriteText(filePath, JSON.stringify(payload, null, 2));
 }
 
-function stableJson(value) {
-  return JSON.stringify(value, Object.keys(value || {}).sort());
+function sessionIndexPath(workspaceRoot) {
+  return path.join(workspaceRoot, SESSION_INDEX_RELATIVE_PATH);
 }
 
-function sha256Buffer(buffer) {
-  return crypto.createHash('sha256').update(buffer).digest('hex');
+function emptySessionIndex() {
+  const now = isoNow();
+  return {
+    schema: 'claworld.sessions.v1',
+    version: 1,
+    createdAt: now,
+    updatedAt: now,
+    main: {},
+    management: {},
+    conversationSessions: {},
+    conversationEpisodes: {},
+  };
 }
 
-async function hashFile(filePath) {
-  return sha256Buffer(await fs.readFile(filePath));
+async function readSessionIndex(workspaceRoot) {
+  const index = await readJsonObject(sessionIndexPath(workspaceRoot), emptySessionIndex());
+  if (!isObject(index.main)) index.main = {};
+  if (!isObject(index.management)) index.management = {};
+  if (!isObject(index.conversationSessions)) index.conversationSessions = {};
+  if (!isObject(index.conversationEpisodes)) index.conversationEpisodes = {};
+  return index;
 }
 
-function safeFileStem(value) {
-  const text = normalizeText(value, 'report') || 'report';
-  return text.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'report';
-}
+function appendUniqueDelivery(deliveries, delivery) {
+  const deliveryId = text(delivery?.deliveryId, null);
+  if (!deliveryId || (!text(delivery?.commandText, null) && !text(delivery?.contextText, null))) return deliveries;
+  const next = Array.isArray(deliveries) ? [...deliveries] : [];
+  const existingIndex = next.findIndex((item) => text(item?.deliveryId, null) === deliveryId);
+  if (existingIndex >= 0) {
+    next[existingIndex] = compactObject({ ...next[existingIndex], ...delivery });
+  } else {
+    next.push(compactObject(delivery));
+  }
+  return next;
+}
+
+export async function recordClaworldTranscriptEpisode(workspaceRoot, input = {}) {
+  const chatRequestId = text(input.chatRequestId, null);
+  const deliveryId = text(input.deliveryId, null);
+  const commandText = text(input.commandText, null);
+  const contextText = text(input.contextText, null);
+  if (!workspaceRoot || !chatRequestId || !deliveryId || (!commandText && !contextText)) {
+    return { ok: false, updated: false, reason: 'missing_transcript_identity' };
+  }
+
+  const index = await readSessionIndex(workspaceRoot);
+  const previous = isObject(index.conversationEpisodes[chatRequestId])
+    ? index.conversationEpisodes[chatRequestId]
+    : {};
+  let deliveries = appendUniqueDelivery(previous.deliveries, {
+    deliveryId,
+    direction: 'inbound',
+    fromAgentId: text(input.fromAgentId, null),
+    fromAgentCode: text(input.fromAgentCode, null),
+    fromDisplayIdentity: text(input.fromDisplayIdentity, null),
+    deliveryType: text(input.deliveryType, null),
+    commandText,
+    contextText,
+    untrustedContext: text(input.untrustedContext, null),
+    createdAt: text(input.createdAt, null),
+    turnCreatedAt: text(input.turnCreatedAt, null),
+  });
+  const replyText = text(input.replyText, null);
+  if (replyText) {
+    deliveries = appendUniqueDelivery(deliveries, {
+      deliveryId: `${deliveryId}:reply`,
+      direction: 'outbound',
+      deliveryType: 'reply',
+      fromAgentId: text(input.localAgentId, null),
+      commandText: replyText,
+      createdAt: text(input.replyCreatedAt, isoNow()),
+      turnCreatedAt: text(input.replyCreatedAt, isoNow()),
+    });
+  }
 
-async function atomicWriteText(filePath, text) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await fs.writeFile(tempPath, text, 'utf8');
-  await fs.rename(tempPath, filePath);
+  const now = isoNow();
+  const deliveryIds = deliveries.map((entry) => text(entry?.deliveryId, null)).filter(Boolean);
+  index.conversationEpisodes[chatRequestId] = compactObject({
+    ...previous,
+    chatRequestId,
+    chatId: text(input.chatId, previous.chatId),
+    lastActiveSessionKey: text(input.localSessionKey, previous.lastActiveSessionKey),
+    relaySessionKey: text(input.relaySessionKey, previous.relaySessionKey),
+    conversationKey: text(input.conversationKey, previous.conversationKey),
+    worldId: text(input.worldId, previous.worldId),
+    targetAgentId: text(input.targetAgentId, previous.targetAgentId),
+    fromAgentCode: text(input.fromAgentCode, previous.fromAgentCode),
+    fromDisplayIdentity: text(input.fromDisplayIdentity, previous.fromDisplayIdentity),
+    firstSeenAt: text(previous.firstSeenAt, text(input.createdAt, now)),
+    lastSeenAt: replyText
+      ? text(input.replyCreatedAt, now)
+      : text(input.turnCreatedAt, text(input.createdAt, now)),
+    deliveryIds,
+    deliveryCount: deliveryIds.length,
+    deliveries,
+    updatedAt: now,
+  });
+  index.updatedAt = now;
+  await atomicWriteJson(sessionIndexPath(workspaceRoot), index);
+  return { ok: true, updated: true, chatRequestId, deliveryCount: deliveryIds.length };
 }
 
-async function atomicWriteBuffer(filePath, buffer) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await fs.writeFile(tempPath, buffer);
-  await fs.rename(tempPath, filePath);
+function stripOperationalSuffix(content) {
+  const lines = String(content ?? '').split(/\r?\n/);
+  while (lines.length) {
+    const lastLine = String(lines.at(-1) ?? '').trim();
+    if (!lastLine) {
+      lines.pop();
+      continue;
+    }
+    if (!OPERATIONAL_SUFFIX_PATTERNS.some((pattern) => pattern.test(lastLine))) break;
+    lines.pop();
+  }
+  return lines.join('\n').trim();
+}
+
+function classifyReplyContent(content) {
+  const rawText = String(content ?? '');
+  const normalized = stripOperationalSuffix(rawText);
+  if (!normalized) return { text: '', silenceReason: rawText.trim() ? 'operational_notice_only' : 'empty_reply' };
+  if (normalized === 'NO_REPLY') return { text: '', silenceReason: 'no_reply' };
+  if (RUNTIME_ERROR_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { text: '', silenceReason: 'runtime_failed_before_reply' };
+  }
+  if (OPERATIONAL_NOTICE_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { text: '', silenceReason: 'operational_notice_only' };
+  }
+  return { text: normalized, silenceReason: null };
+}
+
+function renderableTranscriptDelivery(delivery) {
+  if (!isObject(delivery) || text(delivery.deliveryType, null) === 'kickoff') return false;
+  const commandText = text(delivery.commandText, null);
+  return Boolean(commandText && !classifyReplyContent(commandText).silenceReason);
+}
+
+function episodeSummary(chatRequestId, entry) {
+  const deliveries = Array.isArray(entry.deliveries) ? entry.deliveries : [];
+  const renderable = deliveries.filter(renderableTranscriptDelivery);
+  const peerMessages = renderable.filter((delivery) => text(delivery.direction, null) !== 'outbound').length;
+  return compactObject({
+    chatRequestId: text(entry.chatRequestId, chatRequestId),
+    chatId: entry.chatId,
+    conversationKey: entry.conversationKey,
+    relaySessionKey: entry.relaySessionKey,
+    lastActiveSessionKey: entry.lastActiveSessionKey,
+    worldId: entry.worldId,
+    targetAgentId: entry.targetAgentId,
+    fromAgentCode: entry.fromAgentCode,
+    fromDisplayIdentity: entry.fromDisplayIdentity,
+    firstSeenAt: entry.firstSeenAt,
+    lastSeenAt: entry.lastSeenAt,
+    deliveryCount: entry.deliveryCount,
+    renderableMessages: renderable.length,
+    peerMessages,
+    localMessages: renderable.length - peerMessages,
+  });
 }
 
-function resolveArtifactDirs(workspaceRoot) {
-  const baseDir = path.join(
-    workspaceRoot,
-    CLAWORLD_WORKING_MEMORY_DIR,
-    CLAWORLD_REPORTS_DIR,
-    'transcripts',
-  );
-  return {
-    baseDir,
-    imageDir: path.join(baseDir, 'images'),
-    documentDir: path.join(baseDir, 'documents'),
-  };
+function localEpisodeSummaries(index) {
+  return Object.entries(isObject(index.conversationEpisodes) ? index.conversationEpisodes : {})
+    .filter(([, entry]) => isObject(entry))
+    .map(([chatRequestId, entry]) => episodeSummary(chatRequestId, entry))
+    .sort((left, right) => String(right.lastSeenAt || right.firstSeenAt || '')
+      .localeCompare(String(left.lastSeenAt || left.firstSeenAt || '')));
 }
 
-function parseTimestampMs(value) {
-  if (value == null || value === '') return null;
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return value > 1_000_000_000_000 ? Math.trunc(value) : Math.trunc(value * 1000);
-  }
-  const text = String(value).trim();
-  if (!text) return null;
-  if (/^-?\d+(\.\d+)?$/.test(text)) return parseTimestampMs(Number(text));
-  const parsed = Date.parse(text);
-  return Number.isFinite(parsed) ? parsed : null;
+function matchesEpisodeFilters(episode, filters = {}) {
+  const checks = {
+    chatRequestId: 'chatRequestId',
+    conversationKey: 'conversationKey',
+    localSessionKey: 'relaySessionKey',
+    counterpartyAgentId: 'targetAgentId',
+    worldId: 'worldId',
+  };
+  return Object.entries(checks).every(([filterKey, episodeKey]) => {
+    const expected = text(filters[filterKey], null);
+    return !expected || text(episode[episodeKey], null) === expected;
+  });
 }
 
-function toIsoTimestamp(value) {
-  const ms = parseTimestampMs(value);
-  if (!ms) return null;
-  return new Date(ms).toISOString();
+function filterLocalEpisodes(episodes, filters = {}) {
+  return episodes.filter((episode) => matchesEpisodeFilters(episode, filters)).slice(0, 25);
 }
 
-function formatTimestampLabel(value) {
-  const ms = parseTimestampMs(value);
-  if (!ms) return '';
-  const date = new Date(ms);
-  const pad = (part) => String(part).padStart(2, '0');
-  return [
-    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`,
-    `${pad(date.getHours())}:${pad(date.getMinutes())}`,
-  ].join(' ');
+function conversationItemFilters(item = {}) {
+  const related = isObject(item.relatedObjects) ? item.relatedObjects : {};
+  return compactObject({
+    chatRequestId: text(item.chatRequestId, text(related.chatRequestId, null)),
+    conversationKey: text(item.conversationKey, text(related.conversationKey, null)),
+    localSessionKey: text(item.localSessionKey, text(related.localSessionKey, null)),
+    counterpartyAgentId: text(item.counterpartyAgentId, text(related.counterpartyAgentId, null)),
+    worldId: text(item.worldId, text(related.worldId, null)),
+  });
 }
 
-function flattenContent(value) {
-  if (value == null) return '';
-  if (typeof value === 'string') return value;
-  if (Array.isArray(value)) {
-    return value.map(flattenContent).filter(Boolean).join('\n');
+export async function augmentConversationPayloadWithLocalTranscriptIndex({
+  workspaceRoot,
+  payload,
+  filters = {},
+} = {}) {
+  if (!workspaceRoot || !isObject(payload)) return payload;
+  const index = await readSessionIndex(workspaceRoot);
+  const episodes = localEpisodeSummaries(index);
+  const matching = filterLocalEpisodes(episodes, filters);
+  const result = { ...payload };
+  if (matching.length) {
+    result.localTranscriptEpisodes = matching;
+    result.localTranscriptSummary = {
+      episodeCount: matching.length,
+      chatRequestIds: matching.map((item) => item.chatRequestId).filter(Boolean),
+    };
   }
-  if (isObject(value)) {
-    for (const key of ['text', 'input_text', 'output_text', 'content', 'body', 'message']) {
-      if (value[key] != null) {
-        const text = flattenContent(value[key]);
-        if (text) return text;
-      }
-    }
-    return '';
+  if (Array.isArray(result.items)) {
+    result.items = result.items.map((item) => {
+      if (!isObject(item)) return item;
+      const itemFilters = conversationItemFilters(item);
+      if (!Object.keys(itemFilters).length) return item;
+      const itemMatches = filterLocalEpisodes(episodes, itemFilters);
+      if (!itemMatches.length) return item;
+      return {
+        ...item,
+        localTranscriptEpisodes: itemMatches,
+        localTranscriptSummary: {
+          episodeCount: itemMatches.length,
+          chatRequestIds: itemMatches.map((match) => match.chatRequestId).filter(Boolean),
+        },
+      };
+    });
   }
-  return String(value);
+  return result;
 }
 
-function extractFencedBlockAfter(text, marker) {
-  const source = String(text || '');
-  const index = source.indexOf(marker);
-  if (index < 0) return null;
-  const afterMarker = source.slice(index + marker.length).trimStart();
-  const fenceMatch = afterMarker.match(/^```[^\n]*\n([\s\S]*?)\n```/);
-  if (fenceMatch) return fenceMatch[1].trim();
-  const nextSection = afterMarker.search(/\n(?:Routing metadata|Backend-authored Claworld|Relay untrusted context|Claworld live conversation rules):/);
-  return (nextSection >= 0 ? afterMarker.slice(0, nextSection) : afterMarker).trim();
+function rejectUnknown(name, value, allowed) {
+  const extra = Object.keys(value).filter((key) => !allowed.has(key)).sort();
+  if (extra.length) throw new Error(`unsupported ${name} parameter(s): ${extra.join(', ')}`);
 }
 
-function stripInternalEnvelopeSections(text) {
-  let output = String(text || '');
-  const markers = [
-    'Routing metadata:',
-    'Backend-authored Claworld context:',
-    'Backend-authored Claworld command:',
-    'Relay untrusted context:',
-    'Claworld live conversation rules:',
-  ];
-  for (const marker of markers) {
-    const index = output.indexOf(marker);
-    if (index >= 0) output = output.slice(0, index);
+function normalizeRenderRequest(args = {}) {
+  if (!isObject(args)) throw new Error('render arguments must be an object');
+  rejectUnknown('transcript render', args, TOP_LEVEL_RENDER_FIELDS);
+  const mode = text(args.mode, null);
+  if (!['stored', 'manual'].includes(mode)) {
+    throw new Error('mode is required and must be one of stored or manual');
   }
-  output = output.replace(/```[a-zA-Z0-9_-]*\n([\s\S]*?)\n```/g, '$1');
-  return output.trim();
-}
-
-function stripOpenClawSpeakerPrefix(text) {
-  const source = String(text || '').trim();
-  const match = source.match(/^([^\n:]{1,80}):\s+([\s\S]+)$/);
-  if (!match) return { text: source, speaker: null };
-  const label = match[1].trim();
-  if (/^(https?|file|data)$/i.test(label)) return { text: source, speaker: null };
-  return { text: match[2].trim(), speaker: label };
-}
-
-function redactSensitiveText(text) {
-  let output = String(text || '');
-  output = output.replace(
-    /\bauthorization\b\s*[:=]\s*(?:bearer\s+)?`?[^`\s,;]+`?/gi,
-    'authorization=[REDACTED]',
-  );
-  output = output.replace(
-    /\b(api[_-]?key|app[_-]?token|access[_-]?token|refresh[_-]?token|secret|password)\b\s*[:=]\s*`?[^`\s,;]+`?/gi,
-    '$1=[REDACTED]',
-  );
-  output = output.replace(/\bbearer\s+[a-zA-Z0-9._~+/=-]{12,}/gi, 'bearer [REDACTED]');
-  output = output.replace(/\bsk-[a-zA-Z0-9_-]{12,}\b/g, '[REDACTED_TOKEN]');
-  output = output.replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '[REDACTED_EMAIL]');
-  output = output.replace(/\+?\d[\d ()-]{8,}\d/g, '[REDACTED_PHONE]');
-  return output.trim();
-}
-
-function normalizeTagLabel(value) {
-  const tag = normalizeText(value, null);
-  if (!tag) return null;
-  const compact = tag.toLowerCase().replace(/\s+/g, '_');
-  if (compact === 'request_conversation_end' || compact === 'request_end' || compact === 'end') {
-    return 'request end';
+  const style = text(args.style, CLAWORLD_TRANSCRIPT_STYLE_NAME);
+  if (style !== CLAWORLD_TRANSCRIPT_STYLE_NAME) {
+    throw new Error(`unsupported transcript report style: ${style}; expected ${CLAWORLD_TRANSCRIPT_STYLE_NAME}`);
   }
-  if (compact === 'like') return 'like';
-  if (compact === 'dislike') return 'dislike';
-  return tag.replace(/_/g, ' ').trim().toLowerCase();
+  const renderArgs = { mode, style, maxPageHeight: args.maxPageHeight };
+  if (mode === 'stored') {
+    if (args.manual != null) throw new Error('manual must not be provided when mode=stored');
+    if (!isObject(args.stored)) throw new Error('stored must be an object when mode=stored');
+    rejectUnknown('stored', args.stored, STORED_RENDER_FIELDS);
+    const chatRequestId = text(args.stored.chatRequestId, null);
+    if (!chatRequestId) throw new Error('stored.chatRequestId is required when mode=stored');
+    for (const key of ['title', 'peerProfile', 'localLabel', 'peerLabel']) {
+      renderArgs[key] = args.stored[key];
+    }
+    return { mode, chatRequestId, renderArgs };
+  }
+  if (args.stored != null) throw new Error('stored must not be provided when mode=manual');
+  if (!isObject(args.manual)) throw new Error('manual must be an object when mode=manual');
+  rejectUnknown('manual', args.manual, MANUAL_RENDER_FIELDS);
+  for (const key of ['title', 'peerProfile', 'localLabel', 'peerLabel']) {
+    if (!text(args.manual[key], null)) throw new Error(`manual.${key} is required when mode=manual`);
+    renderArgs[key] = args.manual[key];
+  }
+  if (!Array.isArray(args.manual.messages) || !args.manual.messages.length) {
+    throw new Error('manual.messages must be a non-empty array when mode=manual');
+  }
+  args.manual.messages.forEach((message, index) => {
+    const position = index + 1;
+    if (!isObject(message)) throw new Error(`manual.messages[${position}] must be an object`);
+    rejectUnknown(`manual.messages[${position}]`, message, MANUAL_MESSAGE_FIELDS);
+    if (!['peer', 'local'].includes(text(message.from, null))) {
+      throw new Error(`manual.messages[${position}].from must be peer or local`);
+    }
+    if (!text(message.text, null)) throw new Error(`manual.messages[${position}].text is required`);
+    if (!text(message.createdAt, null)) throw new Error(`manual.messages[${position}].createdAt is required`);
+  });
+  return { mode, messages: args.manual.messages, renderArgs };
 }
 
-function extractControlTags(text) {
-  const source = String(text || '');
-  const matches = [];
-  const claimedSpans = [];
-  const tags = [];
-  const record = (start, end, label) => {
-    if (!label) return;
-    if (claimedSpans.some(([claimedStart, claimedEnd]) => start < claimedEnd && end > claimedStart)) return;
-    matches.push([start, end, label]);
-    claimedSpans.push([start, end]);
-  };
-  const controlPatterns = [
-    { pattern: /\[\[?\s*request[_\s-]*(?:conversation[_\s-]*)?end\s*\]?\]?/gi, label: 'request end' },
-    { pattern: /\[\s*requeset\s+end\s*\]/gi, label: 'request end' },
-    { pattern: /\[\[?\s*end\s*\]?\]?/gi, label: 'request end' },
-    { pattern: /\[\[?\s*like\s*\]?\]?/gi, label: 'like' },
-    { pattern: /\[\[?\s*dislike\s*\]?\]?/gi, label: 'dislike' },
-  ];
-  for (const { pattern, label } of controlPatterns) {
-    for (const match of source.matchAll(pattern)) record(match.index, match.index + match[0].length, label);
+async function loadSourceMessages(request, workspaceRoot) {
+  if (request.mode === 'manual') {
+    return { messages: request.messages, summary: { kind: 'manual', messageCount: request.messages.length } };
   }
-  for (const match of source.matchAll(/\[\[\s*([A-Za-z0-9][A-Za-z0-9 _-]{0,24})\s*\]\]/g)) {
-    record(match.index, match.index + match[0].length, normalizeTagLabel(match[1]));
+  const index = await readSessionIndex(workspaceRoot);
+  const episode = isObject(index.conversationEpisodes?.[request.chatRequestId])
+    ? index.conversationEpisodes[request.chatRequestId]
+    : null;
+  if (!episode) {
+    throw new Error(`chatRequestId was not found in local Claworld transcript index: ${request.chatRequestId}`);
   }
-  let cleaned = '';
-  let cursor = 0;
-  for (const [start, end, label] of matches.sort((left, right) => left[0] - right[0])) {
-    cleaned += source.slice(cursor, start);
-    cursor = Math.max(cursor, end);
-    if (!tags.includes(label)) tags.push(label);
-  }
-  cleaned += source.slice(cursor);
-  return {
-    text: cleaned.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim(),
-    tags,
-  };
-}
-
-function extractEpisodeIds(...values) {
-  const ids = new Set();
-  const source = values.map((value) => String(value || '')).join('\n');
-  const patterns = [
-    /(?:Chat Request ID|chatRequestId|requestId|Intent ID|intentId)\s*[:=]\s*`?([a-zA-Z0-9._:-]+)/gi,
-    /\b(?:chatRequestId|requestId|intentId)\b["']?\s*[:=]\s*["']?([a-zA-Z0-9._:-]+)/gi,
-  ];
-  for (const pattern of patterns) {
-    for (const match of source.matchAll(pattern)) {
-      const id = normalizeText(match[1], null);
-      if (id) ids.add(id.replace(/[`,.;)\]}]+$/g, ''));
-    }
+  const deliveries = Array.isArray(episode.deliveries) ? episode.deliveries : [];
+  if (!deliveries.length) {
+    throw new Error(`chatRequestId was found but no deliveries were indexed: ${request.chatRequestId}`);
   }
-  return [...ids];
-}
-
-function getMessageText(record) {
-  if (record?.text != null) return flattenContent(record.text);
-  if (record?.body != null) return flattenContent(record.body);
-  if (record?.content != null) return flattenContent(record.content);
-  if (record?.message?.content != null) return flattenContent(record.message.content);
-  if (record?.payload?.content != null) return flattenContent(record.payload.content);
-  return '';
-}
-
-function getMessageRole(record) {
-  return normalizeText(
-    record?.role
-      ?? record?.from
-      ?? record?.message?.role
-      ?? record?.payload?.role,
-    null,
-  );
-}
-
-function getMessageTimestamp(record) {
-  return record?.createdAt
-    ?? record?.created_at
-    ?? record?.timestamp
-    ?? record?.message?.createdAt
-    ?? record?.message?.timestamp
-    ?? record?.payload?.createdAt
-    ?? record?.payload?.timestamp
-    ?? record?.__openclaw?.recordTimestampMs
-    ?? record?.__openclaw?.recordTimestamp
-    ?? null;
-}
-
-function normalizeManualMessage(raw, index) {
-  const tagsResult = extractControlTags(raw.text);
   return {
-    id: `manual-${index + 1}`,
-    side: raw.from === 'peer' ? 'peer' : 'local',
-    speaker: null,
-    text: redactSensitiveText(tagsResult.text),
-    tags: tagsResult.tags,
-    createdAt: toIsoTimestamp(raw.createdAt),
-    createdAtLabel: formatTimestampLabel(raw.createdAt),
-    timestampMs: parseTimestampMs(raw.createdAt),
-    episodeIds: [],
-    sourceRole: raw.from,
+    messages: deliveries,
+    summary: compactObject({
+      kind: 'chatRequestId',
+      chatRequestId: request.chatRequestId,
+      chatId: episode.chatId,
+      conversationKey: episode.conversationKey,
+      relaySessionKey: episode.relaySessionKey,
+      lastActiveSessionKey: episode.lastActiveSessionKey,
+      firstSeenAt: episode.firstSeenAt,
+      lastSeenAt: episode.lastSeenAt,
+      indexSource: 'conversationEpisodes',
+    }),
   };
 }
 
-function normalizeStoredMessage(record, index) {
-  const role = getMessageRole(record);
-  if (['system', 'developer', 'tool', 'tool_call'].includes(role)) return null;
-
-  const side = role === 'assistant' || role === 'local' || role === 'me' || role === 'right'
-    ? 'local'
-    : 'peer';
-  let text = getMessageText(record);
-  const rawText = text;
-  const episodeIds = extractEpisodeIds(
-    rawText,
-    record?.id,
-    record?.message?.id,
-    record?.__openclaw?.id,
-  );
-
-  if (side === 'peer') {
-    const peerVisible = extractFencedBlockAfter(text, 'Peer-visible Claworld message:');
-    const hasBackendCommand = text.includes('Backend-authored Claworld command:');
-    if (peerVisible != null) {
-      text = peerVisible;
-    } else if (hasBackendCommand) {
-      return null;
+function markdownSection(value, title, level) {
+  const hashes = '#'.repeat(level);
+  const pattern = new RegExp(`^${hashes}\\s+${title}\\s*$`, 'imu');
+  const match = pattern.exec(value);
+  if (!match) return '';
+  const start = match.index + match[0].length;
+  const remainder = value.slice(start);
+  const nextHeading = new RegExp(`^#{1,${level}}\\s+`, 'mu').exec(remainder);
+  return remainder.slice(0, nextHeading?.index ?? remainder.length).trim();
+}
+
+function markdownNamedCodeBlock(value, title, level) {
+  const section = markdownSection(value, title, level);
+  if (!section) return '';
+  const fenced = /```[^\n]*\n([\s\S]*?)\n```/u.exec(section);
+  if (fenced) return fenced[1].trim();
+  return section.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith('#')).join('\n');
+}
+
+function squashWhitespace(value) {
+  const lines = String(value ?? '').split(/\r?\n/).map((line) => line.replace(/[ \t]+/gu, ' ').trim());
+  const compact = [];
+  let blank = false;
+  for (const line of lines) {
+    if (!line) {
+      if (!blank && compact.length) compact.push('');
+      blank = true;
     } else {
-      text = stripInternalEnvelopeSections(text);
+      compact.push(line);
+      blank = false;
     }
-  } else {
-    text = stripInternalEnvelopeSections(text);
-    if (/^NO_REPLY$/i.test(text.trim())) return null;
   }
-
-  const speakerResult = side === 'peer' ? stripOpenClawSpeakerPrefix(text) : { text: text.trim(), speaker: null };
-  const tagsResult = extractControlTags(speakerResult.text);
-  const redactedText = redactSensitiveText(tagsResult.text);
-  if (!redactedText && tagsResult.tags.length === 0) return null;
-  const timestamp = getMessageTimestamp(record) || new Date(0).toISOString();
-  return {
-    id: normalizeText(record?.id ?? record?.message?.id ?? record?.__openclaw?.id, `message-${index + 1}`),
-    side,
-    speaker: speakerResult.speaker,
-    text: redactedText,
-    tags: tagsResult.tags,
-    createdAt: toIsoTimestamp(timestamp),
-    createdAtLabel: formatTimestampLabel(timestamp),
-    timestampMs: parseTimestampMs(timestamp) || 0,
-    episodeIds,
-    sourceRole: role,
-  };
-}
-
-function normalizeTranscriptMessages(records, { mode } = {}) {
-  const messages = records
-    .map((record, index) => (
-      mode === 'manual'
-        ? normalizeManualMessage(record, index)
-        : normalizeStoredMessage(record, index)
-    ))
-    .filter(Boolean)
-    .filter((message) => message.text || message.tags.length > 0)
-    .sort((left, right) => (left.timestampMs || 0) - (right.timestampMs || 0));
-  return messages;
-}
-
-function episodeSetsIntersect(left = [], right = []) {
-  if (!left.length || !right.length) return true;
-  const rightSet = new Set(right);
-  return left.some((id) => rightSet.has(id));
-}
-
-function segmentTranscriptMessages(messages = []) {
-  const segments = [];
-  let current = null;
-  for (const message of messages) {
-    const previous = current?.messages?.[current.messages.length - 1] || null;
-    const gapSeconds = previous && message.timestampMs && previous.timestampMs
-      ? Math.abs(message.timestampMs - previous.timestampMs) / 1000
-      : 0;
-    const currentEpisodeIds = current ? [...current.episodeIds] : [];
-    const startsNewEpisode = current
-      && message.episodeIds.length > 0
-      && currentEpisodeIds.length > 0
-      && !episodeSetsIntersect(message.episodeIds, currentEpisodeIds);
-    const startsAfterCompletion = previous
-      && current?.endedSides?.size >= 2
-      && message.side === 'peer';
-    if (!current || gapSeconds > SEGMENT_GAP_SECONDS || startsNewEpisode || startsAfterCompletion) {
-      current = {
-        messages: [],
-        episodeIds: new Set(),
-        endedSides: new Set(),
-      };
-      segments.push(current);
+  return compact.join('\n').trim();
+}
+
+function parseHeaderContextCandidate(value, source) {
+  const content = String(value ?? '').trim();
+  if (!content) return {};
+  const parsed = {};
+  const modeMatch = /^\s*-\s*Mode:\s*`?([A-Za-z_-]+)`?\s*$/imu.exec(content)
+    || /\bconversation[_\s-]*mode\b\s*[:=]\s*`?([A-Za-z_-]+)`?/iu.exec(content);
+  const mode = text(modeMatch?.[1]?.toLowerCase(), null);
+  if (['world', 'direct'].includes(mode)) parsed.conversationMode = mode;
+  const worldMatch = /^\s*-\s*World:\s*([^\n(`]+?)\s*(?:\(`([^`]+)`\))?\s*$/imu.exec(content);
+  if (worldMatch) {
+    parsed.worldName = text(worldMatch[1], null);
+    parsed.worldId = text(worldMatch[2], null);
+  }
+  const localSection = markdownSection(content, 'You', 2);
+  const peerSection = markdownSection(content, 'Peer', 2);
+  const identity = (section) => text(/^\s*-\s*Identity:\s*`?([^`\n]+)`?\s*$/imu.exec(section)?.[1], null);
+  if (localSection) parsed.localIdentity = identity(localSection);
+  if (peerSection) {
+    parsed.peerIdentity = identity(peerSection);
+    const globalProfile = markdownNamedCodeBlock(peerSection, 'Global Profile', 3);
+    const worldProfile = markdownNamedCodeBlock(peerSection, 'World Membership Profile', 3);
+    if (globalProfile) {
+      parsed.globalProfile = squashWhitespace(globalProfile);
+      parsed.globalProfileSource = source;
     }
-    current.messages.push(message);
-    for (const id of message.episodeIds) current.episodeIds.add(id);
-    if (message.tags.includes('request end')) current.endedSides.add(message.side);
-  }
-  return segments;
-}
-
-function selectStoredMessages(messages, chatRequestId) {
-  const targetId = normalizeText(chatRequestId, null);
-  if (!targetId) return messages;
-  const segments = segmentTranscriptMessages(messages);
-  const segment = segments.find((candidate) => candidate.episodeIds.has(targetId));
-  if (segment) return segment.messages;
-  const tagged = messages.filter((message) => message.episodeIds.includes(targetId));
-  return tagged.length > 0 ? tagged : messages;
-}
-
-function parseJsonLine(line) {
-  try {
-    const parsed = JSON.parse(line);
-    return isObject(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function extractTranscriptRecordsFromJson(value, fallbackId = 'json') {
-  if (Array.isArray(value)) return value;
-  if (!isObject(value)) return [];
-  for (const key of ['entries', 'records', 'messages', 'items', 'transcript']) {
-    if (Array.isArray(value[key])) return value[key];
-  }
-  if (Array.isArray(value.conversation?.messages)) return value.conversation.messages;
-  if (Array.isArray(value.session?.messages)) return value.session.messages;
-  if (isObject(value.message) || value.role || value.content || value.text) {
-    return [{ ...value, id: value.id ?? fallbackId }];
-  }
-  return [];
-}
-
-async function loadTranscriptRecords(transcriptPath) {
-  const content = await fs.readFile(transcriptPath, 'utf8');
-  const trimmed = content.trim();
-  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
-    try {
-      return extractTranscriptRecordsFromJson(JSON.parse(trimmed), path.basename(transcriptPath));
-    } catch {
-      // Fall back to line-oriented parsing below.
+    if (worldProfile) {
+      parsed.worldProfile = squashWhitespace(worldProfile);
+      parsed.worldProfileSource = source;
     }
   }
-  const records = [];
-  let index = 0;
-  for (const line of content.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    index += 1;
-    const parsed = parseJsonLine(line);
-    if (!parsed) continue;
-    if (isObject(parsed.message)) {
-      records.push({
-        ...parsed.message,
-        id: parsed.message.id ?? parsed.id ?? `line-${index}`,
-        timestamp: parsed.message.timestamp ?? parsed.timestamp ?? parsed.createdAt ?? null,
-        __openclaw: {
-          id: parsed.id ?? null,
-          recordTimestamp: parsed.timestamp ?? null,
-          seq: index,
-        },
-      });
-      continue;
-    }
-    if (parsed.type === 'response_item' && isObject(parsed.payload) && parsed.payload.type === 'message') {
-      records.push({
-        ...parsed.payload,
-        id: parsed.payload.id ?? parsed.id ?? `line-${index}`,
-        timestamp: parsed.payload.timestamp ?? parsed.timestamp ?? null,
-        __openclaw: {
-          id: parsed.id ?? null,
-          recordTimestamp: parsed.timestamp ?? null,
-          seq: index,
-        },
-      });
-      continue;
-    }
-    if (parsed.type === 'message' || parsed.role || parsed.content || parsed.text) {
-      records.push({
-        ...parsed,
-        id: parsed.id ?? `line-${index}`,
-        timestamp: parsed.timestamp ?? parsed.createdAt ?? null,
-        __openclaw: {
-          id: parsed.id ?? null,
-          recordTimestamp: parsed.timestamp ?? null,
-          seq: index,
-        },
-      });
+  if (!localSection && !peerSection && source === 'untrustedContext') {
+    const plainProfile = plainProfileCandidate(content);
+    if (plainProfile) {
+      parsed.globalProfile = plainProfile;
+      parsed.globalProfileSource = source;
     }
   }
-  return records;
+  return compactObject(parsed);
 }
 
-async function pathExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
+function plainProfileCandidate(value) {
+  const candidate = squashWhitespace(value);
+  if (!candidate || candidate.includes('# ') || candidate.includes('```')) return '';
+  return displayCols(candidate) <= 420 ? candidate : '';
 }
 
-function artifactPathCandidates(artifact = {}) {
-  return [
-    normalizeText(artifact.transcriptPath, null),
-    normalizeText(artifact.sessionFile, null),
-  ].filter(Boolean);
+function headerProfileSourcePriority(source) {
+  return { contextText: 4, untrustedContext: 3, rawKickoffText: 2, transcript: 1 }[source] || 0;
 }
 
-async function chooseReadableArtifact(artifacts = []) {
-  const ordered = [...artifacts].reverse();
-  for (const artifact of ordered) {
-    for (const candidatePath of artifactPathCandidates(artifact)) {
-      if (await pathExists(candidatePath)) {
-        return {
-          artifact,
-          transcriptPath: candidatePath,
-        };
+function mergeHeaderContextCandidate(merged, candidate, source) {
+  if (!candidate) return;
+  const parsed = parseHeaderContextCandidate(candidate, source);
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!text(value, null)) continue;
+    const sourceKey = {
+      globalProfile: 'globalProfileSource',
+      worldProfile: 'worldProfileSource',
+      globalProfileSource: 'globalProfileSource',
+      worldProfileSource: 'worldProfileSource',
+    }[key];
+    if (!sourceKey) {
+      merged[key] = value;
+    } else {
+      const incomingSource = key.endsWith('Source') ? value : parsed[sourceKey];
+      if (headerProfileSourcePriority(incomingSource) >= headerProfileSourcePriority(merged[sourceKey])) {
+        merged[key] = value;
       }
     }
   }
-  const fallback = ordered.find((artifact) => artifactPathCandidates(artifact).length > 0);
-  if (!fallback) return null;
-  return {
-    artifact: fallback,
-    transcriptPath: artifactPathCandidates(fallback)[0],
-  };
-}
-
-function summarizeDirectoryRequest({
-  chatRequestId,
-  localSessionKey,
-  session = {},
-  request = {},
-  artifact = {},
-  transcriptPath = null,
-} = {}) {
-  return {
-    chatRequestId,
-    localSessionKey,
-    relaySessionKey: normalizeText(session.relaySessionKey, null),
-    conversationKey: normalizeText(session.conversationKey, null),
-    worldId: normalizeText(session.worldId, null),
-    localAgentId: normalizeText(session.localAgentId, null),
-    firstSeenAt: normalizeText(request.firstSeenAt, null),
-    lastSeenAt: normalizeText(request.lastSeenAt, null),
-    artifactCount: Array.isArray(request.artifacts) ? request.artifacts.length : 0,
-    sessionId: normalizeText(artifact.sessionId, null),
-    sessionFile: normalizeText(artifact.sessionFile, null),
-    transcriptPath: normalizeText(transcriptPath || artifact.transcriptPath, null),
-    deliveryId: normalizeText(artifact.deliveryId, null),
-    sourceEventId: normalizeText(artifact.sourceEventId, null),
-  };
 }
 
-async function resolveStoredTranscriptSource(workspaceRoot, chatRequestId) {
-  const sessionDirectory = await readClaworldSessionDirectory(workspaceRoot);
-  const conversationSessions = sessionDirectory.directory?.conversationSessions || {};
-  for (const [localSessionKey, session] of Object.entries(conversationSessions)) {
-    const request = session?.chatRequests?.[chatRequestId];
-    if (!request) continue;
-    const artifacts = Array.isArray(request.artifacts) ? request.artifacts : [];
-    const readable = await chooseReadableArtifact(artifacts);
-    if (!readable?.transcriptPath) {
-      inputError('stored.chatRequestId', `No local transcript artifact is indexed for chatRequestId=${chatRequestId}`);
+function extractTranscriptHeaderContext(rawMessages) {
+  const merged = {};
+  for (const raw of rawMessages) {
+    if (!isObject(raw)) continue;
+    mergeHeaderContextCandidate(merged, text(raw.contextText, null), 'contextText');
+    mergeHeaderContextCandidate(merged, text(raw.untrustedContext, null), 'untrustedContext');
+    if (text(raw.deliveryType, null) === 'kickoff') {
+      mergeHeaderContextCandidate(merged, text(raw.commandText, null), 'rawKickoffText');
+    }
+    if (!merged.peerIdentity && text(raw.fromDisplayIdentity, null)) {
+      merged.peerIdentity = text(raw.fromDisplayIdentity, null);
     }
-    return {
-      mode: 'stored',
-      chatRequestId,
-      transcriptPath: readable.transcriptPath,
-      sessionDirectoryPath: sessionDirectory.sessionDirectoryPath,
-      summary: summarizeDirectoryRequest({
-        chatRequestId,
-        localSessionKey,
-        session,
-        request,
-        artifact: readable.artifact,
-        transcriptPath: readable.transcriptPath,
-      }),
-    };
-  }
-  inputError('stored.chatRequestId', `chatRequestId=${chatRequestId} was not found in .claworld/sessions/index.json`);
-}
-
-function normalizeHeaderContext({ mode, manual = null, source = null, messages = [] } = {}) {
-  if (mode === 'manual') {
-    return {
-      title: manual.title,
-      subtitle: manual.peerProfile,
-      peerLabel: manual.peerLabel,
-      localLabel: manual.localLabel,
-    };
   }
-  const firstPeer = messages.find((message) => message.side === 'peer');
-  const peerLabel = firstPeer?.speaker
-    || normalizeText(source?.summary?.counterpartyAgentId, null)
-    || normalizeText(source?.summary?.relaySessionKey, null)
-    || 'Peer';
-  const title = normalizeText(firstPeer?.speaker, null)
-    || normalizeText(source?.summary?.conversationKey, null)
-    || normalizeText(source?.chatRequestId, null)
-    || 'Claworld conversation';
-  const subtitleParts = [
-    normalizeText(source?.summary?.worldId, null) ? `world ${source.summary.worldId}` : null,
-    normalizeText(source?.chatRequestId, null) ? `chat request ${source.chatRequestId}` : null,
-  ].filter(Boolean);
-  return {
-    title,
-    subtitle: subtitleParts.join(' · ') || 'Claworld transcript',
-    peerLabel,
-    localLabel: 'You',
-  };
-}
-
-function isWideChar(char) {
-  const code = char.codePointAt(0) || 0;
-  return (
-    (code >= 0x1100 && code <= 0x115f)
-    || code === 0x2329
-    || code === 0x232a
-    || (code >= 0x2e80 && code <= 0xa4cf)
-    || (code >= 0xac00 && code <= 0xd7a3)
-    || (code >= 0xf900 && code <= 0xfaff)
-    || (code >= 0xfe10 && code <= 0xfe19)
-    || (code >= 0xfe30 && code <= 0xfe6f)
-    || (code >= 0xff00 && code <= 0xff60)
-    || (code >= 0xffe0 && code <= 0xffe6)
-    || (code >= 0x1f300 && code <= 0x1faff)
-    || (code >= 0x20000 && code <= 0x3fffd)
-  );
-}
-
-function charColumns(char) {
-  if (char === '\n') return 0;
-  return isWideChar(char) ? 2 : 1;
-}
-
-function displayColumns(text) {
-  let columns = 0;
-  for (const char of String(text || '')) columns += charColumns(char);
-  return columns;
-}
-
-function clipDisplay(text, maxColumns) {
-  const value = String(text || '');
-  if (displayColumns(value) <= maxColumns) return value;
-  const suffix = '...';
-  const target = Math.max(0, maxColumns - suffix.length);
-  let kept = '';
-  let used = 0;
-  for (const char of value) {
-    const columns = charColumns(char);
-    if (used + columns > target) break;
-    kept += char;
-    used += columns;
+  let peerProfile = '';
+  let profileSource = '';
+  if (merged.conversationMode === 'world' && merged.worldProfile) {
+    peerProfile = merged.worldProfile;
+    profileSource = merged.worldProfileSource || 'transcript';
+  } else if (merged.conversationMode === 'direct' && merged.globalProfile) {
+    peerProfile = merged.globalProfile;
+    profileSource = merged.globalProfileSource || 'transcript';
+  } else if (merged.worldProfile) {
+    peerProfile = merged.worldProfile;
+    profileSource = merged.worldProfileSource || 'transcript';
+  } else if (merged.globalProfile) {
+    peerProfile = merged.globalProfile;
+    profileSource = merged.globalProfileSource || 'transcript';
+  }
+  return compactObject({ ...merged, peerProfile, profileSource });
+}
+
+function formatTimestamp(value) {
+  if (value == null || value === '') return '';
+  let date = null;
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    date = new Date(value * 1000);
+  } else {
+    const parsed = new Date(String(value).trim());
+    if (!Number.isNaN(parsed.getTime())) date = parsed;
   }
-  return `${kept.trimEnd()}${suffix}`;
-}
-
-function charUnits(char) {
-  if (char === '\n') return 0;
-  if (/\s/u.test(char)) return 0.35;
-  return isWideChar(char) ? 1 : 0.55;
-}
-
-function textUnits(text) {
-  let units = 0;
-  for (const char of String(text || '')) units += charUnits(char);
-  return units;
+  if (!date) return String(value).trim();
+  const pad = (part) => String(part).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
 }
 
-function ellipsizeText(text, maxUnits, { suffix = '...' } = {}) {
-  const value = String(text || '');
-  if (textUnits(value) <= maxUnits) return value;
-  const allowed = Math.max(0, maxUnits - textUnits(suffix));
-  let kept = '';
-  let used = 0;
-  for (const char of value) {
-    const units = charUnits(char);
-    if (used + units > allowed) break;
-    kept += char;
-    used += units;
-  }
-  return `${kept.trimEnd()}${suffix}`;
+function parseTimeish(value) {
+  if (value == null || value === '') return null;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (/^\d+(?:\.\d+)?$/u.test(String(value).trim())) return Number(value);
+  const timestamp = Date.parse(String(value).trim());
+  return Number.isNaN(timestamp) ? null : timestamp / 1000;
 }
 
-function wrapTokens(paragraph) {
-  const tokens = [];
-  let current = '';
-  const flush = () => {
-    if (current) {
-      tokens.push(current);
-      current = '';
-    }
+function extractControlTags(value) {
+  const matches = [];
+  const claimed = [];
+  const patterns = [
+    [/\[\[?\s*request[_\s-]*(?:conversation[_\s-]*)?end\s*\]?\]?/giu, 'request end'],
+    [/\[\s*requeset\s+end\s*\]/giu, 'request end'],
+    [/\[\[?\s*end\s*\]?\]?/giu, 'request end'],
+    [/\[\[?\s*like\s*\]?\]?/giu, 'like'],
+    [/\[\[?\s*dislike\s*\]?\]?/giu, 'dislike'],
+  ];
+  const record = (start, end, label) => {
+    if (claimed.some(([claimedStart, claimedEnd]) => start < claimedEnd && end > claimedStart)) return;
+    claimed.push([start, end]);
+    matches.push([start, end, label]);
   };
-  for (const char of String(paragraph || '')) {
-    if (/\s/u.test(char)) {
-      flush();
-      tokens.push(' ');
-    } else if (isWideChar(char)) {
-      flush();
-      tokens.push(char);
-    } else {
-      current += char;
-    }
-  }
-  flush();
-  return tokens;
-}
-
-function wrapText(text, maxUnits) {
-  const lines = [];
-  const paragraphs = String(text || '').replace(/\r/g, '').split('\n');
-  for (const paragraph of paragraphs.length ? paragraphs : ['']) {
-    let current = '';
-    let currentUnits = 0;
-    let paragraphHasLine = false;
-    for (const token of wrapTokens(paragraph)) {
-      const tokenUnits = textUnits(token);
-      if (/^\s+$/u.test(token)) {
-        if (current && currentUnits + tokenUnits <= maxUnits) {
-          current += token;
-          currentUnits += tokenUnits;
-        }
-        continue;
-      }
-      if (current && currentUnits + tokenUnits > maxUnits) {
-        lines.push(current.trimEnd());
-        paragraphHasLine = true;
-        current = '';
-        currentUnits = 0;
-      }
-      if (tokenUnits > maxUnits) {
-        for (const char of token) {
-          const units = charUnits(char);
-          if (current && currentUnits + units > maxUnits) {
-            lines.push(current.trimEnd());
-            paragraphHasLine = true;
-            current = '';
-            currentUnits = 0;
-          }
-          current += char;
-          currentUnits += units;
-        }
-      } else {
-        current += token;
-        currentUnits += tokenUnits;
-      }
-    }
-    if (current || !paragraphHasLine) lines.push(current.trimEnd());
+  const source = String(value ?? '');
+  for (const [pattern, label] of patterns) {
+    for (const match of source.matchAll(pattern)) record(match.index, match.index + match[0].length, label);
   }
-  return lines.length > 0 ? lines : [''];
-}
-
-function formatCompactTimestamp(value) {
-  const ms = parseTimestampMs(value);
-  if (ms) {
-    const date = new Date(ms);
-    const pad = (part) => String(part).padStart(2, '0');
-    return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+  for (const match of source.matchAll(/\[\[\s*([A-Za-z0-9][A-Za-z0-9 _-]{0,24})\s*\]\]/gu)) {
+    const label = squashWhitespace(match[1].replaceAll('_', ' ').replaceAll('-', ' ')).toLowerCase().slice(0, 24).trim();
+    if (label) record(match.index, match.index + match[0].length, label);
   }
-  const text = String(value || '').trim();
-  const match = text.match(/(?:(\d{4})[-/])?(\d{1,2})[-/](\d{1,2})[ T](\d{1,2}):(\d{2})/);
-  if (match) {
-    return `${String(Number(match[2])).padStart(2, '0')}-${String(Number(match[3])).padStart(2, '0')} ${String(Number(match[4])).padStart(2, '0')}:${match[5]}`;
+  const sorted = matches.sort((left, right) => left[0] - right[0]);
+  const tags = [...new Set(sorted.map(([, , label]) => label))];
+  let cursor = 0;
+  const pieces = [];
+  for (const [start, end] of sorted) {
+    pieces.push(source.slice(cursor, start));
+    cursor = Math.max(cursor, end);
   }
-  return '';
+  pieces.push(source.slice(cursor));
+  return { text: squashWhitespace(pieces.join('')), tags };
 }
 
-function timeLabelForMessage(message) {
-  return formatCompactTimestamp(message.createdAt || message.timestampMs || message.createdAtLabel)
-    || message.createdAtLabel
-    || '';
+function redactText(value) {
+  return String(value ?? '')
+    .replace(/\b(api[_-]?key|app[_-]?token|access[_-]?token|refresh[_-]?token|secret|password|authorization|bearer)\b\s*[:=]\s*[^\s,;]+/giu, '$1=[redacted]')
+    .replace(/\b(?:sk|rk|pk|ghp|glpat)-[A-Za-z0-9_-]{12,}\b/gu, '[redacted-token]')
+    .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/gu, '[redacted-email]')
+    .replace(/(?<!\d)(?:\+?\d[\d\s().-]{8,}\d)(?!\d)/gu, '[redacted-phone]');
 }
 
-function buildRenderItems(messages = []) {
-  const items = [];
-  let previousMessage = null;
-  for (const message of messages) {
-    const gapSeconds = previousMessage && message.timestampMs && previousMessage.timestampMs
-      ? Math.abs(message.timestampMs - previousMessage.timestampMs) / 1000
-      : Number.POSITIVE_INFINITY;
-    if (!previousMessage || gapSeconds > TIME_SPLIT_SECONDS) {
-      items.push({
-        kind: 'time',
-        label: timeLabelForMessage(message),
-      });
+function stripInternalMarkup(value) {
+  let cleaned = String(value ?? '').replace(/```(?:json|text|markdown)?/giu, '').replaceAll('```', '');
+  for (const marker of [
+    'Routing metadata:',
+    'Claworld live conversation rules:',
+    'Backend-authored Claworld context:',
+    'Backend-authored Claworld command:',
+    'Relay untrusted context:',
+  ]) {
+    if (cleaned.includes(marker)) cleaned = cleaned.split(marker, 1)[0];
+  }
+  return squashWhitespace(cleaned);
+}
+
+function normalizeMessages(rawMessages, localAgentId, args, headerContext = {}) {
+  const localIdentity = text(headerContext.localIdentity, null);
+  const peerIdentity = text(headerContext.peerIdentity, text(headerContext.peerId, null));
+  const localId = text(localIdentity, text(localAgentId, 'local-agent'));
+  const peerId = text(peerIdentity, 'peer-agent');
+  const localLabel = publicHeaderValue(args.localLabel) || publicHeaderValue(localIdentity) || 'Me';
+  const peerLabel = publicHeaderValue(args.peerLabel) || publicHeaderValue(peerIdentity) || 'Peer';
+  const normalized = [];
+  rawMessages.forEach((raw, index) => {
+    if (!isObject(raw)) return;
+    let side;
+    let messageText;
+    let createdAt;
+    let messageId;
+    let participantId;
+    let participantLabel;
+    if (['peer', 'local'].includes(raw.from)) {
+      side = raw.from === 'peer' ? 'left' : 'right';
+      messageText = text(raw.text, null);
+      createdAt = formatTimestamp(raw.createdAt);
+      messageId = text(raw.id, `msg-${index + 1}`);
+      participantId = side === 'left' ? peerId : localId;
+      participantLabel = side === 'left' ? peerLabel : localLabel;
+    } else {
+      if (text(raw.deliveryType, null) === 'kickoff') return;
+      const classification = classifyReplyContent(text(raw.commandText, ''));
+      if (classification.silenceReason) return;
+      messageText = classification.text;
+      createdAt = formatTimestamp(raw.turnCreatedAt || raw.createdAt);
+      messageId = text(raw.deliveryId, `msg-${index + 1}`);
+      side = text(raw.direction, null) === 'outbound'
+        || (!text(raw.direction, null) && text(raw.fromAgentId, null) === text(localAgentId, null))
+        ? 'right'
+        : 'left';
+      participantId = side === 'left' ? peerId : localId;
+      participantLabel = side === 'left' ? peerLabel : localLabel;
     }
-    items.push({
-      kind: 'message',
-      message,
+    if (!messageText) return;
+    const extracted = extractControlTags(messageText);
+    const cleanedText = stripInternalMarkup(redactText(extracted.text));
+    if (!cleanedText && !extracted.tags.length) return;
+    normalized.push({
+      id: messageId,
+      side,
+      participantId,
+      participantLabel,
+      text: cleanedText,
+      createdAt,
+      tags: extracted.tags,
+      sourceIndex: index,
     });
-    previousMessage = message;
-  }
-  return items;
-}
-
-function renderSide(message = {}) {
-  return message.side === 'local' || message.side === 'right' || message.side === 'me'
-    ? 'right'
-    : 'left';
-}
-
-function participantLabel(message = {}, header = {}) {
-  if (renderSide(message) === 'right') return header.localLabel || 'You';
-  return message.speaker || header.peerLabel || 'Peer';
-}
-
-function messageTags(message = {}) {
-  return Array.isArray(message.tags) ? message.tags : [];
-}
-
-function measureRenderItem(item, width, header) {
-  const contentWidth = Math.max(270, Math.trunc(width * BUBBLE_MAX_RATIO));
-  if (item.kind === 'ellipsis') {
-    return {
-      kind: 'ellipsis',
-      message: null,
-      lines: [],
-      width: contentWidth,
-      height: ELLIPSIS_HEIGHT,
-      omittedCount: item.omitted || 0,
-      label: item.label || '',
-    };
-  }
-  if (item.kind === 'time') {
-    return {
-      kind: 'time',
-      message: null,
-      lines: [],
-      width: contentWidth,
-      height: TIME_ROW_HEIGHT,
-      label: item.label || '',
-    };
-  }
-
-  const side = renderSide(item.message);
-  const label = participantLabel(item.message, header);
-  const maxUnits = Math.max(18, (contentWidth - BUBBLE_PAD_X * 2) / TEXT_UNIT_PX);
-  const lines = wrapText(item.message.text, maxUnits);
-  const labelUnits = textUnits(labelText(label)) + 4;
-  const contentUnits = Math.max(
-    ...lines.map((line) => textUnits(line)),
-    tagRowUnits(messageTags(item.message)),
-    labelUnits,
-    10,
-  );
-  const bubbleWidth = Math.trunc(Math.min(
-    contentWidth,
-    Math.max(BUBBLE_MIN_WIDTH, contentUnits * TEXT_UNIT_PX + BUBBLE_PAD_X * 2),
-  ));
-  const textHeight = lines.length * LINE_HEIGHT;
-  const tagHeight = messageTags(item.message).length ? TAG_HEIGHT : 0;
-  const bubbleHeight = BUBBLE_PAD_Y * 2 + textHeight + tagHeight;
-  const rowHeight = LABEL_HEIGHT - LABEL_OVERLAP + bubbleHeight + 10;
-  return {
-    kind: 'message',
-    message: item.message,
-    side,
-    participantLabel: label,
-    lines,
-    width: bubbleWidth,
-    height: rowHeight,
-    tagHeight,
-    textHeight,
-  };
-}
-
-function layoutPages({ messages, header, maxPageHeight }) {
-  const width = DEFAULT_WIDTH;
-  const maxHeight = maxPageHeight || DEFAULT_MAX_PAGE_HEIGHT;
-  const measuredItems = buildRenderItems(messages).map((item) => measureRenderItem(item, width, header));
-  const pageBuckets = [[]];
-  const headerHeight = headerHeightForSubtitle(header.subtitle);
-  let used = headerHeight + BODY_TOP_GAP + PAGE_BOTTOM;
-
-  measuredItems.forEach((item, index) => {
-    const itemHeight = item.height + ITEM_GAP;
-    let neededHeight = itemHeight;
-    if (item.kind === 'time' && index + 1 < measuredItems.length) {
-      neededHeight += measuredItems[index + 1].height + ITEM_GAP;
-    }
-    const currentPage = pageBuckets[pageBuckets.length - 1];
-    if (currentPage.length > 0 && used + neededHeight > maxHeight) {
-      pageBuckets.push([]);
-      used = headerHeight + BODY_TOP_GAP + PAGE_BOTTOM;
-    }
-    pageBuckets[pageBuckets.length - 1].push(item);
-    used += itemHeight;
-  });
-
-  const pages = pageBuckets.map((pageItems, pageIndex) => {
-    let y = headerHeight + BODY_TOP_GAP;
-    const elements = [];
-    for (const item of pageItems) {
-      if (item.kind === 'ellipsis') {
-        elements.push({
-          kind: 'ellipsis',
-          y,
-          height: item.height,
-          label: item.label,
-        });
-        y += item.height + ITEM_GAP;
-        continue;
-      }
-      if (item.kind === 'time') {
-        elements.push({
-          kind: 'time',
-          y,
-          height: item.height,
-          label: item.label,
-        });
-        y += item.height + ITEM_GAP;
-        continue;
-      }
-      const label = labelText(item.participantLabel);
-      const position = positions(width, item.width, label, item.side);
-      const bubbleY = y + LABEL_HEIGHT - LABEL_OVERLAP;
-      const bubbleHeight = BUBBLE_PAD_Y * 2 + item.textHeight + item.tagHeight;
-      elements.push({
-        kind: 'message',
-        y,
-        x: position.bubbleX,
-        bubbleX: position.bubbleX,
-        bubbleY,
-        labelX: position.labelX,
-        labelY: y - LABEL_RAISE,
-        labelWidth: position.labelWidth,
-        label,
-        align: position.align,
-        width: item.width,
-        height: bubbleHeight,
-        bubbleHeight,
-        lines: item.lines,
-        message: item.message,
-        side: item.side,
-        participantLabel: item.participantLabel,
-        tagHeight: item.tagHeight,
-        textHeight: item.textHeight,
-      });
-      y += item.height + ITEM_GAP;
-    }
-    return {
-      page: pageIndex + 1,
-      width,
-      height: Math.max(520, Math.min(maxHeight, Math.ceil(y + PAGE_BOTTOM))),
-      elements,
-      title: header.title,
-      subtitle: header.subtitle,
-      footer: 'visit claworld.love',
-    };
   });
-
-  return {
-    width,
-    header,
-    pages,
-  };
+  return normalized;
 }
 
-function escapeXml(value) {
-  return String(value ?? '')
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
+function selectionSummary(request, messageCount) {
+  return compactObject({
+    mode: request.mode,
+    chatRequestId: request.mode === 'stored' ? request.chatRequestId : null,
+    messageCount,
+    omittedBefore: 0,
+    omittedAfter: 0,
+  });
 }
 
-function renderSvgPage({ page }) {
-  const titleId = `claworld-report-title-${page.page}`;
-  const descId = `claworld-report-desc-${page.page}`;
-  const desc = `${page.title}. ${page.subtitle}. ${page.elements.length} transcript rows.`;
-  const parts = [
-    `<svg class="comic-grid" xmlns="http://www.w3.org/2000/svg" width="${page.width}" height="${page.height}" viewBox="0 0 ${page.width} ${page.height}" role="img" aria-labelledby="${titleId} ${descId}">`,
-    `<title id="${titleId}">${escapeXml(page.title)}</title>`,
-    `<desc id="${descId}">${escapeXml(desc)}</desc>`,
-    svgDefs(),
-    `<rect x="0" y="0" width="${page.width}" height="${page.height}" fill="${COMIC_THEME.paper}"/>`,
-    `<rect x="0" y="0" width="${page.width}" height="${page.height}" fill="url(#comicGridMinor)"/>`,
-    `<rect x="0" y="0" width="${page.width}" height="${page.height}" fill="url(#comicGridMajor)" opacity="0.46"/>`,
-    `<rect x="${FRAME_MARGIN}" y="${FRAME_MARGIN}" width="${page.width - FRAME_MARGIN * 2}" height="${page.height - FRAME_MARGIN * 2}" rx="46" fill="none" stroke="${BLACK}" stroke-width="6"/>`,
-    renderHeaderSvg(page),
-    '<g role="list">',
-  ];
-  for (const item of page.elements) {
-    if (item.kind === 'ellipsis') {
-      parts.push(renderEllipsisSvg(page, item));
-      continue;
-    }
-    if (item.kind === 'time') {
-      parts.push(renderTimeSvg(page, item));
-      continue;
+function formatTimeMarker(value) {
+  const timestamp = parseTimeish(value);
+  if (timestamp != null) {
+    const date = new Date(timestamp * 1000);
+    if (!Number.isNaN(date.getTime())) {
+      const pad = (part) => String(part).padStart(2, '0');
+      return `${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
     }
-    parts.push(renderMessageSvg(item));
-  }
-  parts.push('</g>');
-  if (page.footer) {
-    parts.push(`<text x="${(page.width / 2).toFixed(1)}" y="${page.height - 24}" text-anchor="middle" font-size="${SMALL_FONT_SIZE}" fill="#444444">${escapeXml(page.footer)}</text>`);
   }
-  parts.push('</svg>');
-  return parts.join('\n');
+  const match = /(?:(\d{4})[-/])?(\d{1,2})[-/](\d{1,2})[ T](\d{1,2}):(\d{2})/u.exec(String(value ?? '').trim());
+  return match ? `${String(Number(match[2])).padStart(2, '0')}-${String(Number(match[3])).padStart(2, '0')} ${String(Number(match[4])).padStart(2, '0')}:${match[5]}` : '';
 }
 
-function positions(width, bubbleWidth, label, side) {
-  const labelWidth = labelWidthForText(label);
-  const inset = CANVAS_MARGIN + 38;
-  if (side === 'right') {
-    const bubbleX = width - inset - bubbleWidth;
-    const labelX = bubbleX + bubbleWidth - labelWidth - 16;
-    return { bubbleX, labelX, labelWidth, align: 'right' };
+function decorateSelection(messages, selection) {
+  const items = [];
+  let previousTimestamp = null;
+  messages.forEach((message, index) => {
+    const timestamp = parseTimeish(message.createdAt);
+    if (message.createdAt && (index === 0 || (
+      previousTimestamp != null && timestamp != null && timestamp - previousTimestamp > TIME_SPLIT_SECONDS
+    ))) {
+      const label = formatTimeMarker(message.createdAt);
+      if (label) items.push({ kind: 'time', label, timestamp: message.createdAt });
+    }
+    items.push({ kind: 'message', message });
+    previousTimestamp = timestamp ?? previousTimestamp;
+  });
+  if (selection.omittedAfter > 0) {
+    items.push({ kind: 'ellipsis', omitted: selection.omittedAfter, label: `${selection.omittedAfter} later messages omitted` });
   }
-  const bubbleX = inset;
-  const labelX = bubbleX + 16;
-  return { bubbleX, labelX, labelWidth, align: 'left' };
-}
-
-function renderHeaderSvg(page) {
-  const x = CANVAS_MARGIN + 26;
-  const y = HEADER_Y;
-  const width = page.width - (CANVAS_MARGIN + 26) * 2;
-  const height = headerCardHeight(page.subtitle);
-  const title = clipDisplay(headerTitle(page.title), 32);
-  return [
-    `<rect x="${x + 11}" y="${y + 6}" width="${width + 2}" height="${height + 10}" rx="22" fill="${BLACK}"/>`,
-    `<rect x="${x + 7}" y="${y + 6}" width="${width}" height="${height + 4}" rx="22" fill="url(#headerAccent)"/>`,
-    `<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="22" fill="${COMIC_THEME.headerFill}" stroke="${BLACK}" stroke-width="4"/>`,
-    `<text x="${x + 28}" y="${y + 43}" font-size="${TITLE_FONT_SIZE}" font-weight="900" fill="${BLACK}">${escapeXml(title)}</text>`,
-    renderHeaderSubtitleSvg(x + 35, y + 70, headerSubtitleLines(page.subtitle)),
-    decorativeStarSvg(x + width - 62, y + 34, 22, '#FFFFFF', 'url(#headerAccent)'),
-    `<circle cx="${x + width - 23}" cy="${y + 55}" r="9" fill="#72E3C0" stroke="${BLACK}" stroke-width="3"/>`,
-    `<circle cx="${x + width - 25}" cy="${y + 53}" r="9" fill="#72E3C0" stroke="${BLACK}" stroke-width="3"/>`,
-  ].join('\n');
-}
-
-function headerSubtitleLines(subtitle) {
-  const lines = wrapText(String(subtitle || '').trim(), HEADER_SUBTITLE_MAX_UNITS);
-  if (lines.length <= HEADER_SUBTITLE_MAX_LINES) return lines;
-  const visible = lines.slice(0, HEADER_SUBTITLE_MAX_LINES - 1);
-  const remainder = lines.slice(HEADER_SUBTITLE_MAX_LINES - 1).map((line) => line.trim()).filter(Boolean).join(' ');
-  visible.push(ellipsizeText(remainder, HEADER_SUBTITLE_MAX_UNITS));
-  return visible;
-}
-
-function headerCardHeight(subtitle) {
-  return headerSubtitleLines(subtitle).length > 1
-    ? HEADER_CARD_HEIGHT_TWO_LINES
-    : HEADER_CARD_HEIGHT_ONE_LINE;
-}
-
-function headerHeightForSubtitle(subtitle) {
-  return HEADER_Y + headerCardHeight(subtitle) + HEADER_BOTTOM_PAD;
-}
-
-function renderHeaderSubtitleSvg(x, y, lines) {
-  return lines.map((line, index) => (
-    `<text class="header-subtitle-line" x="${x.toFixed(1)}" y="${(y + index * HEADER_SUBTITLE_LINE_HEIGHT).toFixed(1)}" font-size="15" font-weight="600" fill="${COMIC_THEME.muted}">${escapeXml(line)}</text>`
-  )).join('\n');
-}
-
-function renderEllipsisSvg(page, item) {
-  const y = item.y + 7;
-  return `<text x="${(page.width / 2).toFixed(1)}" y="${y + 14}" text-anchor="middle" font-size="${SMALL_FONT_SIZE}" fill="#555555">${escapeXml(item.label)}</text>`;
-}
-
-function renderTimeSvg(page, item) {
-  const label = clipDisplay(item.label, 22);
-  const labelWidth = Math.max(150, displayColumns(label) * 8 + 44);
-  const x = page.width / 2 - labelWidth / 2;
-  const y = item.y + 4;
-  return [
-    '<g class="time-row">',
-    diamondSvg(x - 28, y + 16, 13, COMIC_THEME.timeAccentLeft),
-    `<rect x="${(x + 3).toFixed(1)}" y="${y + 4}" width="${labelWidth}" height="30" rx="15" fill="${BLACK}"/>`,
-    `<rect x="${x.toFixed(1)}" y="${y}" width="${labelWidth}" height="30" rx="15" fill="${COMIC_THEME.timeFill}" stroke="${BLACK}" stroke-width="3"/>`,
-    `<text x="${(page.width / 2).toFixed(1)}" y="${y + 21}" text-anchor="middle" font-size="${FONT_SIZE}" font-weight="700" fill="${BLACK}">${escapeXml(label)}</text>`,
-    diamondSvg(x + labelWidth + 28, y + 16, 13, COMIC_THEME.timeAccentRight),
-    '</g>',
-  ].join('\n');
+  return items;
 }
 
-function renderMessageSvg(item) {
-  const colors = sideColors(item.side);
-  const messageText = item.message?.text || '';
-  const titleText = escapeXml(`${item.participantLabel}: ${ellipsizeText(messageText, 42)}`);
-  const parts = [
-    `<g class="message-row ${item.side}" role="listitem" aria-label="${titleText}">`,
-    `<title>${titleText}</title>`,
-    bubbleLayersSvg(item, colors),
-    `<rect x="${item.labelX}" y="${item.labelY}" width="${item.labelWidth}" height="${LABEL_HEIGHT}" rx="9" fill="${colors.label}" stroke="${BLACK}" stroke-width="3"/>`,
-    `<text x="${(item.labelX + item.labelWidth / 2).toFixed(1)}" y="${item.labelY + 21}" text-anchor="middle" font-size="${LABEL_FONT_SIZE}" font-weight="900" fill="${BLACK}">${escapeXml(item.label)}</text>`,
-  ];
-  const textX = item.bubbleX + BUBBLE_PAD_X;
-  let textY = item.bubbleY + BUBBLE_PAD_Y + 17;
-  for (const line of item.lines) {
-    parts.push(`<text x="${textX}" y="${textY}" font-size="${FONT_SIZE}" font-weight="800" fill="${BLACK}">${escapeXml(line)}</text>`);
-    textY += LINE_HEIGHT;
+function participants(messages) {
+  const seen = new Map();
+  for (const message of messages) {
+    if (!seen.has(message.participantId)) seen.set(message.participantId, message);
   }
-  const tags = messageTags(item.message);
-  if (tags.length) parts.push(renderTagIconsSvg(tags, textX, textY + TAG_ICON_TOP_GAP));
-  parts.push('</g>');
-  return parts.join('\n');
-}
-
-function bubbleLayersSvg(item, colors) {
-  const x = item.bubbleX;
-  const y = item.bubbleY;
-  const width = item.width;
-  const height = item.bubbleHeight;
-  return [
-    `<rect x="${x + 11}" y="${y + 9}" width="${width + 2}" height="${height + 4}" rx="17" fill="${BLACK}"/>`,
-    `<rect x="${x + 11}" y="${y + 9}" width="${width - 3}" height="${height}" rx="17" fill="${colors.accent}" stroke="${BLACK}" stroke-width="3"/>`,
-    `<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="17" fill="${colors.fill}" stroke="${BLACK}" stroke-width="4"/>`,
-  ].join('\n');
+  return [...seen.entries()].map(([participantId, message]) => ({
+    id: participantId,
+    name: message.participantLabel,
+    side: message.side,
+    avatar: String(message.participantLabel || 'A').replace(/[^A-Za-z0-9]/gu, '').slice(0, 2).toUpperCase() || 'A',
+  }));
 }
 
-function sideColors(side) {
-  if (side === 'right') {
-    return {
-      fill: COMIC_THEME.rightFill,
-      label: COMIC_THEME.rightLabel,
-      accent: 'url(#rightAccent)',
-    };
-  }
+function bubbleMessagePayload(item) {
+  if (item.kind === 'time') return { kind: 'time', label: item.label, timestamp: item.timestamp || '' };
+  if (item.kind === 'ellipsis') return { kind: 'ellipsis', omitted: item.omitted, label: item.label };
+  const { message } = item;
   return {
-    fill: COMIC_THEME.leftFill,
-    label: COMIC_THEME.leftLabel,
-    accent: 'url(#leftAccent)',
+    id: message.id,
+    kind: 'text',
+    from: message.participantId,
+    side: message.side,
+    speaker: message.participantLabel,
+    text: message.text,
+    createdAt: message.createdAt,
+    tags: [...message.tags],
   };
 }
 
-function headerTitle(title) {
-  const clean = String(title || '').trim();
-  if (clean.startsWith('@')) return clean;
-  return clean ? `@${clean}` : '@claworld';
-}
-
-function labelText(label) {
-  return clipDisplay(String(label || 'AGENT').toUpperCase(), LABEL_MAX_COLS);
-}
-
-function labelWidthForText(label) {
-  return Math.max(86, Math.min(158, displayColumns(label) * 11 + 30));
-}
-
-function tagRowUnits(tags) {
-  if (!tags.length) return 0;
-  const width = tags.reduce((sum, tag) => sum + tagWidth(tag), 0) + Math.max(0, tags.length - 1) * TAG_ICON_GAP;
-  return width / TEXT_UNIT_PX;
-}
-
-function renderTagIconsSvg(tags, x, y) {
-  const parts = [`<g class="tag-icons" transform="translate(${x.toFixed(1)} ${y.toFixed(1)})">`];
-  let cursor = 0;
-  for (const tag of tags) {
-    parts.push(tagIconSvg(tag, cursor, 0));
-    cursor += tagWidth(tag) + TAG_ICON_GAP;
+function publicHeaderValue(value) {
+  const normalized = text(value, '') || '';
+  if (/(?:^|[\s(])(?:agt|req|wld|dlv|conversation|management)[_:-][a-z0-9]/iu.test(normalized)) {
+    return '';
   }
-  parts.push('</g>');
-  return parts.join('\n');
-}
-
-function tagWidth(tag) {
-  const normalized = tagName(tag);
-  if (['like', 'dislike', 'request end'].includes(normalized)) return TAG_ICON_SIZE;
-  return Math.max(58, Math.min(126, displayColumns(fallbackTagLabel(normalized)) * 8 + 24));
-}
-
-function tagIconSvg(tag, x, y) {
-  const normalized = tagName(tag);
-  if (!['like', 'dislike', 'request end'].includes(normalized)) return fallbackTagSvg(normalized, x, y);
-  const [fill, accent] = TAG_ICON_THEMES[normalized] || ['#FFFFFF', '#7DD7FF'];
-  const icon = normalized === 'request end'
-    ? requestEndIconSvg(x, y, accent)
-    : thumbIconSvg(x, y, accent, { down: normalized === 'dislike' });
-  return [
-    `<g class="tag-icon tag-${safeClassToken(normalized)}" role="img" aria-label="${escapeXml(normalized)}">`,
-    `<title>${escapeXml(normalized)}</title>`,
-    `<rect x="${(x + 3).toFixed(1)}" y="${(y + 4).toFixed(1)}" width="${TAG_ICON_SIZE}" height="${TAG_ICON_SIZE}" rx="9" fill="${BLACK}"/>`,
-    `<rect x="${x.toFixed(1)}" y="${y.toFixed(1)}" width="${TAG_ICON_SIZE}" height="${TAG_ICON_SIZE}" rx="9" fill="${fill}" stroke="${BLACK}" stroke-width="2.5"/>`,
-    icon,
-    '</g>',
-  ].join('\n');
-}
-
-function tagName(tag) {
-  return String(tag || '').trim().toLowerCase();
-}
-
-function fallbackTagLabel(tag) {
-  return clipDisplay(String(tag || 'tag'), TAG_FALLBACK_MAX_COLS);
-}
-
-function fallbackTagSvg(tag, x, y) {
-  const label = fallbackTagLabel(tag);
-  const width = tagWidth(tag);
-  return [
-    `<g class="tag-icon tag-fallback" role="img" aria-label="${escapeXml(label)}">`,
-    `<title>${escapeXml(label)}</title>`,
-    `<rect x="${(x + 3).toFixed(1)}" y="${(y + 4).toFixed(1)}" width="${width}" height="${TAG_ICON_SIZE}" rx="9" fill="${BLACK}"/>`,
-    `<rect x="${x.toFixed(1)}" y="${y.toFixed(1)}" width="${width}" height="${TAG_ICON_SIZE}" rx="9" fill="#F6F1FF" stroke="${BLACK}" stroke-width="2.5"/>`,
-    `<text x="${(x + width / 2).toFixed(1)}" y="${(y + 20.5).toFixed(1)}" text-anchor="middle" font-size="${LABEL_FONT_SIZE}" font-weight="900" fill="${BLACK}">${escapeXml(label)}</text>`,
-    '</g>',
-  ].join('\n');
-}
-
-function thumbIconSvg(x, y, accent, { down = false } = {}) {
-  const paths = [
-    `<path d="M${(x + 7.8).toFixed(1)} ${(y + 13.3).toFixed(1)} H${(x + 12).toFixed(1)} V${(y + 24).toFixed(1)} H${(x + 7.8).toFixed(1)} Z" fill="#FFFFFF" stroke="${BLACK}" stroke-width="2" stroke-linejoin="round"/>`,
-    `<path d="M${(x + 12).toFixed(1)} ${(y + 23.6).toFixed(1)} H${(x + 21.2).toFixed(1)} C${(x + 23).toFixed(1)} ${(y + 23.6).toFixed(1)} ${(x + 24).toFixed(1)} ${(y + 22.5).toFixed(1)} ${(x + 24.4).toFixed(1)} ${(y + 20.9).toFixed(1)} L${(x + 25.4).toFixed(1)} ${(y + 15.6).toFixed(1)} C${(x + 25.8).toFixed(1)} ${(y + 13.9).toFixed(1)} ${(x + 24.5).toFixed(1)} ${(y + 12.2).toFixed(1)} ${(x + 22.7).toFixed(1)} ${(y + 12.2).toFixed(1)} H${(x + 18.6).toFixed(1)} L${(x + 19.2).toFixed(1)} ${(y + 9.1).toFixed(1)} C${(x + 19.5).toFixed(1)} ${(y + 7.4).toFixed(1)} ${(x + 18.4).toFixed(1)} ${(y + 5.7).toFixed(1)} ${(x + 16.7).toFixed(1)} ${(y + 5.4).toFixed(1)} L${(x + 15.8).toFixed(1)} ${(y + 5.3).toFixed(1)} L${(x + 12).toFixed(1)} ${(y + 12.9).toFixed(1)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="2" stroke-linejoin="round"/>`,
-  ].join('\n');
-  if (!down) return paths;
-  const cx = x + TAG_ICON_SIZE / 2;
-  const cy = y + TAG_ICON_SIZE / 2;
-  return `<g transform="rotate(180 ${cx.toFixed(1)} ${cy.toFixed(1)})">\n${paths}\n</g>`;
+  return normalized;
 }
 
-function requestEndIconSvg(x, y, accent) {
-  return [
-    `<path d="M${(x + 22).toFixed(1)} ${(y + 4).toFixed(1)} C${(x + 25.2).toFixed(1)} ${(y + 5.4).toFixed(1)} ${(x + 26.6).toFixed(1)} ${(y + 7.8).toFixed(1)} ${(x + 26.5).toFixed(1)} ${(y + 10.6).toFixed(1)}" fill="none" stroke="${BLACK}" stroke-width="2" stroke-linecap="round"/>`,
-    `<path d="M${(x + 9.215).toFixed(3)} ${(y + 18.117).toFixed(3)} C${(x + 10.043).toFixed(3)} ${(y + 22.457).toFixed(3)} ${(x + 13.384).toFixed(3)} ${(y + 25.036).toFixed(3)} ${(x + 17.132).toFixed(3)} ${(y + 23.961).toFixed(3)} L${(x + 19.44).toFixed(3)} ${(y + 23.3).toFixed(3)} C${(x + 22.323).toFixed(3)} ${(y + 22.473).toFixed(3)} ${(x + 23.488).toFixed(3)} ${(y + 19.642).toFixed(3)} ${(x + 22.538).toFixed(3)} ${(y + 16.69).toFixed(3)} L${(x + 21.435).toFixed(3)} ${(y + 12.845).toFixed(3)} L${(x + 9.227).toFixed(3)} ${(y + 16.345).toFixed(3)} L${(x + 9.215).toFixed(3)} ${(y + 18.117).toFixed(3)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="2" stroke-linejoin="round"/>`,
-    `<path d="M${(x + 9.665).toFixed(3)} ${(y + 7.897).toFixed(3)} L${(x + 9.473).toFixed(3)} ${(y + 7.952).toFixed(3)} C${(x + 8.756).toFixed(3)} ${(y + 8.158).toFixed(3)} ${(x + 8.286).toFixed(3)} ${(y + 8.709).toFixed(3)} ${(x + 8.422).toFixed(3)} ${(y + 9.184).toFixed(3)} L${(x + 10.192).toFixed(3)} ${(y + 15.356).toFixed(3)} C${(x + 10.328).toFixed(3)} ${(y + 15.831).toFixed(3)} ${(x + 11.019).toFixed(3)} ${(y + 16.049).toFixed(3)} ${(x + 11.736).toFixed(3)} ${(y + 15.843).toFixed(3)} L${(x + 11.928).toFixed(3)} ${(y + 15.788).toFixed(3)} C${(x + 12.645).toFixed(3)} ${(y + 15.583).toFixed(3)} ${(x + 13.115).toFixed(3)} ${(y + 15.031).toFixed(3)} ${(x + 12.979).toFixed(3)} ${(y + 14.557).toFixed(3)} L${(x + 11.209).toFixed(3)} ${(y + 8.384).toFixed(3)} C${(x + 11.073).toFixed(3)} ${(y + 7.91).toFixed(3)} ${(x + 10.382).toFixed(3)} ${(y + 7.692).toFixed(3)} ${(x + 9.665).toFixed(3)} ${(y + 7.897).toFixed(3)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="1.8"/>`,
-    `<path d="M${(x + 11.93).toFixed(3)} ${(y + 5.999).toFixed(3)} L${(x + 11.738).toFixed(3)} ${(y + 6.055).toFixed(3)} C${(x + 11.021).toFixed(3)} ${(y + 6.26).toFixed(3)} ${(x + 10.553).toFixed(3)} ${(y + 6.82).toFixed(3)} ${(x + 10.692).toFixed(3)} ${(y + 7.306).toFixed(3)} L${(x + 12.729).toFixed(3)} ${(y + 14.408).toFixed(3)} C${(x + 12.868).toFixed(3)} ${(y + 14.894).toFixed(3)} ${(x + 13.562).toFixed(3)} ${(y + 15.122).toFixed(3)} ${(x + 14.279).toFixed(3)} ${(y + 14.916).toFixed(3)} L${(x + 14.471).toFixed(3)} ${(y + 14.861).toFixed(3)} C${(x + 15.188).toFixed(3)} ${(y + 14.655).toFixed(3)} ${(x + 15.656).toFixed(3)} ${(y + 14.095).toFixed(3)} ${(x + 15.516).toFixed(3)} ${(y + 13.609).toFixed(3)} L${(x + 13.48).toFixed(3)} ${(y + 6.507).toFixed(3)} C${(x + 13.341).toFixed(3)} ${(y + 6.021).toFixed(3)} ${(x + 12.647).toFixed(3)} ${(y + 5.794).toFixed(3)} ${(x + 11.93).toFixed(3)} ${(y + 5.999).toFixed(3)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="1.8"/>`,
-    `<path d="M${(x + 14.636).toFixed(3)} ${(y + 5.64).toFixed(3)} L${(x + 14.443).toFixed(3)} ${(y + 5.695).toFixed(3)} C${(x + 13.727).toFixed(3)} ${(y + 5.9).toFixed(3)} ${(x + 13.258).toFixed(3)} ${(y + 6.457).toFixed(3)} ${(x + 13.396).toFixed(3)} ${(y + 6.938).toFixed(3)} L${(x + 15.338).toFixed(3)} ${(y + 13.714).toFixed(3)} C${(x + 15.476).toFixed(3)} ${(y + 14.195).toFixed(3)} ${(x + 16.169).toFixed(3)} ${(y + 14.418).toFixed(3)} ${(x + 16.886).toFixed(3)} ${(y + 14.213).toFixed(3)} L${(x + 17.078).toFixed(3)} ${(y + 14.157).toFixed(3)} C${(x + 17.795).toFixed(3)} ${(y + 13.952).toFixed(3)} ${(x + 18.264).toFixed(3)} ${(y + 13.395).toFixed(3)} ${(x + 18.126).toFixed(3)} ${(y + 12.914).toFixed(3)} L${(x + 16.183).toFixed(3)} ${(y + 6.139).toFixed(3)} C${(x + 16.045).toFixed(3)} ${(y + 5.658).toFixed(3)} ${(x + 15.352).toFixed(3)} ${(y + 5.434).toFixed(3)} ${(x + 14.636).toFixed(3)} ${(y + 5.64).toFixed(3)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="1.8"/>`,
-    `<path d="M${(x + 17.8).toFixed(3)} ${(y + 6.085).toFixed(3)} L${(x + 17.702).toFixed(3)} ${(y + 6.113).toFixed(3)} C${(x + 16.971).toFixed(3)} ${(y + 6.322).toFixed(3)} ${(x + 16.482).toFixed(3)} ${(y + 6.851).toFixed(3)} ${(x + 16.609).toFixed(3)} ${(y + 7.294).toFixed(3)} L${(x + 18.176).toFixed(3)} ${(y + 12.759).toFixed(3)} C${(x + 18.303).toFixed(3)} ${(y + 13.202).toFixed(3)} ${(x + 18.998).toFixed(3)} ${(y + 13.391).toFixed(3)} ${(x + 19.729).toFixed(3)} ${(y + 13.182).toFixed(3)} L${(x + 19.827).toFixed(3)} ${(y + 13.154).toFixed(3)} C${(x + 20.557).toFixed(3)} ${(y + 12.944).toFixed(3)} ${(x + 21.046).toFixed(3)} ${(y + 12.415).toFixed(3)} ${(x + 20.919).toFixed(3)} ${(y + 11.972).toFixed(3)} L${(x + 19.352).toFixed(3)} ${(y + 6.507).toFixed(3)} C${(x + 19.225).toFixed(3)} ${(y + 6.065).toFixed(3)} ${(x + 18.53).toFixed(3)} ${(y + 5.875).toFixed(3)} ${(x + 17.8).toFixed(3)} ${(y + 6.085).toFixed(3)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="1.8"/>`,
-    `<path d="M${(x + 9.546).toFixed(3)} ${(y + 19.999).toFixed(3)} L${(x + 6).toFixed(3)} ${(y + 17.791).toFixed(3)} C${(x + 4.736).toFixed(3)} ${(y + 17.009).toFixed(3)} ${(x + 5.668).toFixed(3)} ${(y + 15.181).toFixed(3)} ${(x + 7.138).toFixed(3)} ${(y + 15.592).toFixed(3)} L${(x + 10.615).toFixed(3)} ${(y + 17.196).toFixed(3)} L${(x + 9.546).toFixed(3)} ${(y + 19.999).toFixed(3)} Z" fill="${accent}" stroke="${BLACK}" stroke-width="1.8" stroke-linejoin="round"/>`,
-    `<rect x="${(x + 10.887).toFixed(3)}" y="${(y + 14.834).toFixed(3)}" width="9.584" height="3.800" transform="rotate(-16.9438 ${(x + 10.887).toFixed(3)} ${(y + 14.834).toFixed(3)})" fill="${accent}"/>`,
-    `<path d="M${(x + 10.5).toFixed(1)} ${(y + 19.5).toFixed(1)} L${(x + 11).toFixed(1)} ${(y + 20).toFixed(1)} L${(x + 11.5).toFixed(1)} ${(y + 17).toFixed(1)} L${(x + 9.5).toFixed(1)} ${(y + 17.5).toFixed(1)} L${(x + 9).toFixed(1)} ${(y + 18.5).toFixed(1)} L${(x + 10.5).toFixed(1)} ${(y + 19.5).toFixed(1)} Z" fill="${accent}"/>`,
-  ].join('\n');
+function displayName(identity) {
+  return publicHeaderValue(String(identity || '').split('#', 1)[0]);
 }
 
-function decorativeStarSvg(cx, cy, radius, fill, accent) {
-  const backPath = starPoints(cx + 3, cy + 5, radius).map(([x, y]) => `${x.toFixed(1)},${y.toFixed(1)}`).join(' ');
-  const frontPath = starPoints(cx, cy, radius).map(([x, y]) => `${x.toFixed(1)},${y.toFixed(1)}`).join(' ');
-  return [
-    `<polygon points="${backPath}" fill="${accent}"/>`,
-    `<polygon points="${frontPath}" fill="${fill}" stroke="${BLACK}" stroke-width="3"/>`,
-  ].join('\n');
+function semanticHeaderTitle(peerName, worldName) {
+  if (peerName && worldName) return `${peerName} — ${worldName}`;
+  return peerName || worldName || 'Claworld conversation';
 }
 
-function diamondSvg(cx, cy, radius, fill) {
-  const shadow = `<polygon points="${(cx + 1).toFixed(1)},${(cy + 2 - radius).toFixed(1)} ${(cx + 1 + radius * 0.46).toFixed(1)},${(cy + 2).toFixed(1)} ${(cx + 1).toFixed(1)},${(cy + 2 + radius).toFixed(1)} ${(cx + 1 - radius * 0.46).toFixed(1)},${(cy + 2).toFixed(1)}" fill="${BLACK}" stroke="${BLACK}" stroke-width="2.5"/>`;
-  const front = `<polygon points="${cx.toFixed(1)},${(cy - radius).toFixed(1)} ${(cx + radius * 0.46).toFixed(1)},${cy.toFixed(1)} ${cx.toFixed(1)},${(cy + radius).toFixed(1)} ${(cx - radius * 0.46).toFixed(1)},${cy.toFixed(1)}" fill="${fill}" stroke="${BLACK}" stroke-width="2.5"/>`;
-  return `${shadow}\n${front}`;
-}
-
-function starPoints(cx, cy, radius) {
-  return [
-    [cx, cy - radius],
-    [cx + radius * 0.28, cy - radius * 0.28],
-    [cx + radius, cy],
-    [cx + radius * 0.28, cy + radius * 0.28],
-    [cx, cy + radius],
-    [cx - radius * 0.28, cy + radius * 0.28],
-    [cx - radius, cy],
-    [cx - radius * 0.28, cy - radius * 0.28],
-  ];
-}
-
-function safeClassToken(value) {
-  return String(value || 'tag').toLowerCase().replace(/[^a-z0-9_-]+/g, '-') || 'tag';
-}
-
-function svgDefs() {
-  return [
-    '<defs>',
-    `<style><![CDATA[text { font-family: ${COMIC_FONT_FAMILY}; letter-spacing: 0; } .message-row:hover rect:last-of-type { filter: url(#comicLift); }]]></style>`,
-    '<pattern id="comicGridMinor" width="32" height="32" patternUnits="userSpaceOnUse"><path d="M 32 0 L 0 0 0 32" fill="none" stroke="#BED1D8" stroke-width="1" stroke-opacity="0.62"/></pattern>',
-    '<pattern id="comicGridMajor" width="128" height="128" patternUnits="userSpaceOnUse"><path d="M 128 0 L 0 0 0 128" fill="none" stroke="#AABFC8" stroke-width="1.4" stroke-opacity="0.72"/></pattern>',
-    '<linearGradient id="headerAccent" x1="0" y1="0" x2="1" y2="0"><stop offset="0%" stop-color="#47B6FF"/><stop offset="52%" stop-color="#FF4EB4"/><stop offset="100%" stop-color="#FF8A2A"/></linearGradient>',
-    '<linearGradient id="leftAccent" x1="0" y1="0" x2="1" y2="0"><stop offset="0%" stop-color="#58E58F"/><stop offset="100%" stop-color="#47B6FF"/></linearGradient>',
-    '<linearGradient id="rightAccent" x1="0" y1="0" x2="1" y2="0"><stop offset="0%" stop-color="#A871FF"/><stop offset="100%" stop-color="#FF4EB4"/></linearGradient>',
-    '<filter id="comicLift" x="-6%" y="-16%" width="112%" height="132%"><feDropShadow dx="0" dy="2" stdDeviation="1.2" flood-color="#000000" flood-opacity="0.14"/></filter>',
-    '</defs>',
-  ].join('\n');
+function headerText(args, messages, headerContext) {
+  const explicitTitle = publicHeaderValue(args.title);
+  let peerIdentity = publicHeaderValue(headerContext.peerIdentity)
+    || publicHeaderValue(headerContext.peerId);
+  if (!peerIdentity) {
+    peerIdentity = publicHeaderValue(
+      messages.find((message) => message.side === 'left')?.participantLabel,
+    );
+  }
+  const peerName = displayName(peerIdentity);
+  const worldName = publicHeaderValue(headerContext.worldName);
+  const title = explicitTitle || semanticHeaderTitle(peerName, worldName);
+  const explicitProfile = publicHeaderValue(args.peerProfile);
+  if (explicitProfile) return { title, subtitle: explicitProfile };
+  const profile = publicHeaderValue(headerContext.peerProfile);
+  const subtitleParts = [peerIdentity, profile].filter(Boolean);
+  if (!subtitleParts.length && worldName) subtitleParts.push(worldName);
+  return { title, subtitle: subtitleParts.join(' · ') || 'Conversation transcript' };
 }
 
-function buildBubbleSpec({ mode, source, header, messages, layout, style }) {
-  return {
-    schema: ARTIFACT_SCHEMA,
-    format: 'bubblespec',
-    style,
-    width: layout.width,
-    mode,
-    chatRequestId: source?.chatRequestId || null,
-    source: {
-      mode,
-      transcriptPath: source?.transcriptPath || null,
-      sessionDirectoryPath: source?.sessionDirectoryPath || null,
-      summary: source?.summary || null,
-    },
-    header,
-    messages: messages.map((message) => ({
-      id: message.id,
-      side: message.side,
-      speaker: message.speaker,
-      text: message.text,
-      tags: message.tags,
-      createdAt: message.createdAt,
-      episodeIds: message.episodeIds,
-    })),
-    pages: layout.pages.map((page) => ({
-      page: page.page,
-      width: page.width,
-      height: page.height,
-      elementCount: page.elements.length,
-    })),
-  };
+function outputDirectories(workspaceRoot) {
+  const base = path.join(workspaceRoot, '.claworld', 'reports', 'transcripts');
+  return { images: path.join(base, 'images'), documents: path.join(base, 'documents') };
 }
 
-function makeCrcTable() {
-  const table = [];
-  for (let n = 0; n < 256; n += 1) {
-    let c = n;
-    for (let k = 0; k < 8; k += 1) {
-      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    }
-    table[n] = c >>> 0;
-  }
-  return table;
+function artifactId(source, selection, styleName) {
+  const now = new Date();
+  const pad = (part) => String(part).padStart(2, '0');
+  const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const styleSlug = styleName.toLowerCase().replace(/[^a-z0-9]+/gu, '-').replace(/^-|-$/gu, '') || 'style';
+  const digest = createHash('sha256').update(JSON.stringify({ source, selection, style: styleName, now: timestamp })).digest('hex').slice(0, 10);
+  return `claworld-transcript-${styleSlug}-${timestamp}-${digest}`;
 }
 
-const CRC_TABLE = makeCrcTable();
-
-function crc32(buffer) {
-  let crc = 0xffffffff;
-  for (const byte of buffer) {
-    crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
-  }
-  return (crc ^ 0xffffffff) >>> 0;
+async function sha256(filePath) {
+  return createHash('sha256').update(await fs.readFile(filePath)).digest('hex');
 }
 
-function pngChunk(type, data = Buffer.alloc(0)) {
-  const typeBuffer = Buffer.from(type, 'ascii');
-  const length = Buffer.alloc(4);
-  length.writeUInt32BE(data.length, 0);
-  const crcBuffer = Buffer.alloc(4);
-  crcBuffer.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0);
-  return Buffer.concat([length, typeBuffer, data, crcBuffer]);
+function intValue(value, fallback, minimum, maximum) {
+  const parsed = Number.parseInt(value, 10);
+  return Math.min(maximum, Math.max(minimum, Number.isFinite(parsed) ? parsed : fallback));
 }
 
-function writeRect(rgba, width, x, y, rectWidth, rectHeight, color) {
-  const [r, g, b, a] = color;
-  const left = Math.max(0, Math.floor(x));
-  const top = Math.max(0, Math.floor(y));
-  const right = Math.min(width, Math.ceil(x + rectWidth));
-  const bottom = Math.min(Math.floor(rgba.length / (width * 4)), Math.ceil(y + rectHeight));
-  for (let row = top; row < bottom; row += 1) {
-    for (let col = left; col < right; col += 1) {
-      const offset = (row * width + col) * 4;
-      rgba[offset] = r;
-      rgba[offset + 1] = g;
-      rgba[offset + 2] = b;
-      rgba[offset + 3] = a;
-    }
-  }
+async function writePng(svg, pngPath, page) {
+  const sharpModule = await import('sharp');
+  const sharp = sharpModule.default || sharpModule;
+  await sharp(Buffer.from(svg), { density: 192 })
+    .resize(page.width, page.height, { fit: 'fill' })
+    .png()
+    .toFile(pngPath);
+  return { renderer: 'sharp-svg' };
 }
 
-function buildFallbackPngBuffer(page) {
-  const width = page.width;
-  const height = page.height;
-  const rgba = Buffer.alloc(width * height * 4, 255);
-  writeRect(rgba, width, 0, 0, width, height, [251, 247, 239, 255]);
-  writeRect(rgba, width, 22, 18, width - 44, height - 36, [255, 253, 248, 255]);
-  writeRect(rgba, width, 40, 38, width - 80, 18, [22, 22, 22, 255]);
-  writeRect(rgba, width, 40, 68, width - 180, 10, [120, 112, 100, 255]);
-  for (const element of page.elements) {
-    if (element.kind !== 'message') continue;
-    const color = element.message.side === 'local' ? [223, 243, 229, 255] : [255, 255, 255, 255];
-    writeRect(rgba, width, element.x, element.y + 14, element.width, element.height, color);
-    writeRect(rgba, width, element.x + 16, element.y + 36, element.width - 32, 5, [45, 45, 45, 255]);
-    writeRect(rgba, width, element.x + 16, element.y + 54, Math.max(60, element.width - 90), 5, [80, 80, 80, 255]);
-  }
-  const raw = Buffer.alloc((width * 4 + 1) * height);
-  for (let row = 0; row < height; row += 1) {
-    const rawOffset = row * (width * 4 + 1);
-    raw[rawOffset] = 0;
-    rgba.copy(raw, rawOffset + 1, row * width * 4, (row + 1) * width * 4);
-  }
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8;
-  ihdr[9] = 6;
-  ihdr[10] = 0;
-  ihdr[11] = 0;
-  ihdr[12] = 0;
-  return Buffer.concat([
-    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
-    pngChunk('IHDR', ihdr),
-    pngChunk('IDAT', deflateSync(raw)),
-    pngChunk('IEND'),
-  ]);
+function artifactPage(item) {
+  return compactObject({
+    page: item.page,
+    format: item.format,
+    path: item.path,
+    width: item.width,
+    height: item.height,
+    sha256: item.sha256,
+    mediaRef: item.format === 'png' ? `MEDIA:${item.path}` : null,
+  });
 }
 
-async function tryConvertSvgToPng(svgPath, pngPath, page) {
-  const attempts = [
-    { renderer: 'rsvg-convert', cmd: 'rsvg-convert', args: ['--format', 'png', '--output', pngPath, svgPath] },
-    { renderer: 'resvg', cmd: 'resvg', args: [svgPath, pngPath] },
-    { renderer: 'magick', cmd: 'magick', args: [svgPath, pngPath] },
-    { renderer: 'convert', cmd: 'convert', args: [svgPath, pngPath] },
-    { renderer: 'sips', cmd: 'sips', args: ['-s', 'format', 'png', svgPath, '--out', pngPath] },
-  ];
-  for (const attempt of attempts) {
-    try {
-      await execFileAsync(attempt.cmd, attempt.args, { timeout: 15000, maxBuffer: 2 * 1024 * 1024 });
-      const stat = await fs.stat(pngPath);
-      if (stat.size > 64) return attempt.renderer;
-    } catch {
-      // Continue to the next local renderer.
-    }
-  }
-  await atomicWriteBuffer(pngPath, buildFallbackPngBuffer(page));
-  return 'fallback-png';
-}
+export async function renderTranscriptReport({ workspaceRoot, localAgentId = null, args = {} } = {}) {
+  if (!workspaceRoot) throw new Error('OpenClaw workspace root is required for transcript rendering');
+  const request = normalizeRenderRequest(args);
+  const source = await loadSourceMessages(request, workspaceRoot);
+  const headerContext = extractTranscriptHeaderContext(source.messages);
+  const normalized = normalizeMessages(source.messages, localAgentId, request.renderArgs, headerContext);
+  if (!normalized.length) throw new Error('no visible transcript messages were found for rendering');
 
-async function writeArtifacts({ workspaceRoot, artifactId, spec, layout }) {
-  const dirs = resolveArtifactDirs(workspaceRoot);
-  await fs.mkdir(dirs.imageDir, { recursive: true });
-  await fs.mkdir(dirs.documentDir, { recursive: true });
-  const bubbleSpecPath = path.join(dirs.documentDir, `${artifactId}.bubblespec.json`);
-  await atomicWriteText(bubbleSpecPath, `${JSON.stringify(spec, null, 2)}\n`);
-  const svgPages = [];
-  const pngPages = [];
-  for (const page of layout.pages) {
-    const pageStem = `${artifactId}-page-${String(page.page).padStart(2, '0')}`;
-    const svgPath = path.join(dirs.documentDir, `${pageStem}.svg`);
-    const pngPath = path.join(dirs.imageDir, `${pageStem}.png`);
-    await atomicWriteText(svgPath, renderSvgPage({ page, header: layout.header, pageCount: layout.pages.length }));
-    const renderer = await tryConvertSvgToPng(svgPath, pngPath, page);
-    svgPages.push({
-      page: page.page,
-      format: 'svg',
-      path: svgPath,
-      width: page.width,
-      height: page.height,
-      sha256: await hashFile(svgPath),
-    });
-    pngPages.push({
-      page: page.page,
-      format: 'png',
-      path: pngPath,
-      filePath: pngPath,
-      filename: path.basename(pngPath),
-      mimeType: 'image/png',
-      width: page.width,
-      height: page.height,
-      renderer,
-      sha256: await hashFile(pngPath),
-    });
-  }
-  return {
-    bubbleSpec: {
-      format: 'bubblespec',
-      path: bubbleSpecPath,
-      sha256: await hashFile(bubbleSpecPath),
+  const selection = selectionSummary(request, normalized.length);
+  const width = DEFAULT_WIDTH;
+  const maxPageHeight = intValue(request.renderArgs.maxPageHeight, DEFAULT_MAX_PAGE_HEIGHT, 900, 8000);
+  const header = headerText(request.renderArgs, normalized, headerContext);
+  const decorated = decorateSelection(normalized, selection);
+  const measured = decorated.map((item) => measureTranscriptItem(item, width));
+  const pages = paginateTranscriptItems(measured, width, maxPageHeight, header.title, header.subtitle);
+  const currentArtifactId = artifactId(source.summary, selection, CLAWORLD_TRANSCRIPT_STYLE_NAME);
+  const directories = outputDirectories(workspaceRoot);
+  await Promise.all([fs.mkdir(directories.images, { recursive: true }), fs.mkdir(directories.documents, { recursive: true })]);
+
+  const files = [];
+  for (const page of pages) {
+    const suffix = `p${String(page.page).padStart(2, '0')}`;
+    const svgPath = path.join(directories.documents, `${currentArtifactId}-${suffix}.svg`);
+    const pngPath = path.join(directories.images, `${currentArtifactId}-${suffix}.png`);
+    const svg = renderTranscriptPageSvg(page);
+    await atomicWriteText(svgPath, svg);
+    const pngResult = await writePng(svg, pngPath, page);
+    files.push({ page: page.page, format: 'svg', path: svgPath, width: page.width, height: page.height, sha256: await sha256(svgPath), role: 'source' });
+    files.push({ page: page.page, format: 'png', path: pngPath, width: page.width, height: page.height, sha256: await sha256(pngPath), role: 'primary', renderer: pngResult.renderer });
+  }
+
+  const bubbleSpec = {
+    version: '1',
+    kind: 'claworld.transcript_report',
+    scene: {
+      title: header.title,
+      subtitle: header.subtitle,
+      peerId: header.title,
+      peerProfile: header.subtitle,
+      peerProfileSource: publicHeaderValue(request.renderArgs.peerProfile)
+        ? 'explicit'
+        : headerContext.profileSource || 'fallback',
+      generatedAt: isoNow(),
+      source: source.summary,
+      selection,
     },
-    svgPages,
-    pngPages,
+    canvas: { width, style: CLAWORLD_TRANSCRIPT_STYLE_NAME, maxPageHeight },
+    participants: participants(normalized),
+    messages: decorated.map(bubbleMessagePayload),
   };
-}
-
-function buildOpenClawUploadArgs(page, message = null) {
-  if (!page?.path) return null;
-  return {
-    action: 'upload-file',
-    filePath: page.path,
-    path: page.path,
-    media: page.path,
-    filename: page.filename || path.basename(page.path),
-    mimeType: page.mimeType || 'image/png',
-    ...(message ? { message } : {}),
+  const specPath = path.join(directories.documents, `${currentArtifactId}.bubblespec.json`);
+  await atomicWriteJson(specPath, bubbleSpec);
+
+  const pngPages = files.filter((item) => item.format === 'png').map(artifactPage);
+  const svgPages = files.filter((item) => item.format === 'svg').map(artifactPage);
+  const stats = {
+    sourceMessages: source.messages.length,
+    normalizedMessages: normalized.length,
+    renderedMessages: normalized.length,
+    pages: pages.length,
+    omittedBefore: selection.omittedBefore || 0,
+    omittedAfter: selection.omittedAfter || 0,
   };
-}
-
-function buildDiagnostics({ sourceRecords, normalizedMessages, renderedMessages, source }) {
-  return {
-    source: {
-      mode: source.mode,
-      transcriptPath: source.transcriptPath || null,
-      sessionDirectoryPath: source.sessionDirectoryPath || null,
-    },
-    stats: {
-      sourceMessages: sourceRecords.length,
-      normalizedMessages: normalizedMessages.length,
-      renderedMessages: renderedMessages.length,
-      droppedMessages: Math.max(0, sourceRecords.length - normalizedMessages.length),
+  const result = compactObject({
+    status: 'ok',
+    mode: request.mode,
+    chatRequestId: request.mode === 'stored' ? request.chatRequestId : null,
+    artifactId: currentArtifactId,
+    messageCount: normalized.length,
+    pageCount: pages.length,
+    style: CLAWORLD_TRANSCRIPT_STYLE_NAME,
+    artifacts: {
+      bubbleSpec: { format: 'bubblespec', path: specPath, sha256: await sha256(specPath) },
+      pngPages,
+      svgPages,
     },
-  };
-}
-
-async function appendRenderJournalEvent(workspaceRoot, result) {
-  try {
-    await appendClaworldJournalEvent(workspaceRoot, {
-      source: 'claworld_runtime',
-      kind: 'transcript_report',
-      scope: 'conversation',
-      summary: `Rendered Claworld transcript report ${result.artifactId}.`,
-      refs: {
-        chatRequestId: result.chatRequestId || null,
-        artifactId: result.artifactId,
-      },
-      artifacts: {
-        bubbleSpec: result.artifacts?.bubbleSpec?.path || null,
-        pngPages: (result.artifacts?.pngPages || []).map((page) => page.path),
-        svgPages: (result.artifacts?.svgPages || []).map((page) => page.path),
-      },
-    }, { updateSessionDirectory: false });
-  } catch {
-    // Rendering should not fail because the journal is unavailable.
-  }
-}
-
-export async function renderClaworldTranscriptReport({
-  workspaceRoot = null,
-  agentId = null,
-  args = {},
-} = {}) {
-  const resolvedWorkspaceRoot = resolveWorkspaceRoot(workspaceRoot);
-  await ensureClaworldWorkingMemory(resolvedWorkspaceRoot);
-  const params = validateRenderArgs(args);
-  let source = { mode: params.mode };
-  let sourceRecords = [];
-  let normalizedMessages = [];
-  let renderedMessages = [];
-  if (params.mode === 'manual') {
-    sourceRecords = params.manual.messages;
-    normalizedMessages = normalizeTranscriptMessages(sourceRecords, { mode: 'manual' });
-    renderedMessages = normalizedMessages;
-    source = {
-      mode: 'manual',
-      summary: {
-        suppliedMessageCount: sourceRecords.length,
+    deliveryHint: {
+      primaryMedia: pngPages[0]?.mediaRef || null,
+      primaryMediaBatch: pngPages.map((item) => item.mediaRef).join('\n'),
+      sourceSvgDocument: svgPages[0] ? `[[as_document]]\nMEDIA:${svgPages[0].path}` : null,
+      reportOwnerArgs: {
+        media_path: pngPages[0]?.path || null,
+        media_paths: pngPages.map((item) => item.path),
+        send_source_svg: false,
       },
-    };
-  } else {
-    source = await resolveStoredTranscriptSource(resolvedWorkspaceRoot, params.stored.chatRequestId);
-    sourceRecords = await loadTranscriptRecords(source.transcriptPath);
-    normalizedMessages = normalizeTranscriptMessages(sourceRecords, { mode: 'stored' });
-    renderedMessages = selectStoredMessages(normalizedMessages, params.stored.chatRequestId);
-  }
-  if (renderedMessages.length === 0) {
-    inputError('messages', 'No renderable peer-visible transcript messages were found');
-  }
-
-  const header = normalizeHeaderContext({
-    mode: params.mode,
-    manual: params.manual || null,
-    source,
-    messages: renderedMessages,
-  });
-  const layout = layoutPages({
-    messages: renderedMessages,
-    header,
-    maxPageHeight: params.maxPageHeight,
-  });
-  const spec = buildBubbleSpec({
-    mode: params.mode,
-    source,
-    header,
-    messages: renderedMessages,
-    layout,
-    style: params.style,
+    },
+    diagnostics: { source: source.summary, stats },
   });
-  const seed = `${params.mode}:${source?.chatRequestId || header.title}:${renderedMessages.length}:${Date.now()}:${stableJson({ agentId })}`;
-  const artifactId = `claworld-transcript-${safeFileStem(source?.chatRequestId || header.title)}-${sha256Buffer(Buffer.from(seed)).slice(0, 10)}`;
-  const artifacts = await writeArtifacts({
-    workspaceRoot: resolvedWorkspaceRoot,
-    artifactId,
-    spec,
-    layout,
+  await appendClaworldJournalEvent(workspaceRoot, {
+    kind: 'transcript_report',
+    scope: request.mode === 'stored' ? 'conversation' : 'main',
+    summary: `Rendered ${normalized.length} visible Claworld transcript messages across ${pages.length} page(s).`,
+    refs: { chatRequestId: request.mode === 'stored' ? request.chatRequestId : null },
+    artifacts: { artifactId: currentArtifactId, bubbleSpec: specPath, pngPages: pngPages.map((item) => item.path), svgPages: svgPages.map((item) => item.path) },
+    maintenance: { selection, stats },
   });
-  const result = {
-    status: 'ok',
-    mode: params.mode,
-    chatRequestId: source.chatRequestId || null,
-    artifactId,
-    messageCount: renderedMessages.length,
-    pageCount: layout.pages.length,
-    style: params.style,
-    artifacts,
-    deliveryHint: {
-      primaryFilePath: artifacts.pngPages[0]?.path || null,
-      imageFilePaths: artifacts.pngPages.map((page) => page.path),
-      sourceSvgFilePaths: artifacts.svgPages.map((page) => page.path),
-      messageTool: buildOpenClawUploadArgs(
-        artifacts.pngPages[0],
-        source.chatRequestId
-          ? `Claworld transcript report for ${source.chatRequestId}`
-          : 'Claworld transcript report',
-      ),
-      messageToolBatch: artifacts.pngPages.map((page) => buildOpenClawUploadArgs(page)).filter(Boolean),
-    },
-    diagnostics: buildDiagnostics({
-      sourceRecords,
-      normalizedMessages,
-      renderedMessages,
-      source,
-    }),
-  };
-  await appendRenderJournalEvent(resolvedWorkspaceRoot, result);
   return result;
 }
-
-function buildEpisodeFilters(input = {}) {
-  const source = isObject(input.filters) ? input.filters : input;
-  return {
-    chatRequestId: normalizeText(source.chatRequestId, null),
-    conversationKey: normalizeText(source.conversationKey, null),
-    localSessionKey: normalizeText(source.localSessionKey, null),
-    worldId: normalizeText(source.worldId, null),
-    counterpartyAgentId: normalizeText(source.counterpartyAgentId, null),
-  };
-}
-
-function episodeMatchesFilters(summary, filters) {
-  if (filters.chatRequestId && summary.chatRequestId !== filters.chatRequestId) return false;
-  if (filters.localSessionKey && summary.localSessionKey !== filters.localSessionKey) return false;
-  if (filters.conversationKey && summary.conversationKey !== filters.conversationKey) return false;
-  if (filters.worldId && summary.worldId !== filters.worldId) return false;
-  if (
-    filters.counterpartyAgentId
-    && summary.relaySessionKey !== filters.counterpartyAgentId
-    && summary.conversationKey?.includes(filters.counterpartyAgentId) !== true
-  ) {
-    return false;
-  }
-  return true;
-}
-
-export async function listClaworldLocalTranscriptEpisodes({
-  workspaceRoot = null,
-  filters = {},
-} = {}) {
-  const resolvedWorkspaceRoot = resolveWorkspaceRoot(workspaceRoot);
-  const normalizedFilters = buildEpisodeFilters(filters);
-  const sessionDirectory = await readClaworldSessionDirectory(resolvedWorkspaceRoot);
-  const summaries = [];
-  const conversationSessions = sessionDirectory.directory?.conversationSessions || {};
-  for (const [localSessionKey, session] of Object.entries(conversationSessions)) {
-    const chatRequests = session?.chatRequests || {};
-    for (const [chatRequestId, request] of Object.entries(chatRequests)) {
-      const artifacts = Array.isArray(request?.artifacts) ? request.artifacts : [];
-      const latestArtifact = [...artifacts].reverse().find((artifact) => artifactPathCandidates(artifact).length > 0) || {};
-      const summary = summarizeDirectoryRequest({
-        chatRequestId,
-        localSessionKey,
-        session,
-        request,
-        artifact: latestArtifact,
-        transcriptPath: latestArtifact.transcriptPath || latestArtifact.sessionFile || null,
-      });
-      if (episodeMatchesFilters(summary, normalizedFilters)) summaries.push(summary);
-    }
-  }
-  return summaries.sort((left, right) => String(right.lastSeenAt || '').localeCompare(String(left.lastSeenAt || '')));
-}
-
-export async function summarizeClaworldChatRequestTranscript({
-  workspaceRoot = null,
-  chatRequestId,
-} = {}) {
-  const resolvedWorkspaceRoot = resolveWorkspaceRoot(workspaceRoot);
-  const id = normalizeText(chatRequestId, null);
-  if (!id) inputError('chatRequestId', 'chatRequestId is required');
-  const source = await resolveStoredTranscriptSource(resolvedWorkspaceRoot, id);
-  const sourceRecords = await loadTranscriptRecords(source.transcriptPath);
-  const normalizedMessages = normalizeTranscriptMessages(sourceRecords, { mode: 'stored' });
-  const renderedMessages = selectStoredMessages(normalizedMessages, id);
-  return {
-    chatRequestId: id,
-    transcriptPath: source.transcriptPath,
-    sourceMessageCount: sourceRecords.length,
-    renderableMessageCount: renderedMessages.length,
-    peerMessageCount: renderedMessages.filter((message) => message.side === 'peer').length,
-    localMessageCount: renderedMessages.filter((message) => message.side === 'local').length,
-    firstMessageAt: renderedMessages[0]?.createdAt || null,
-    lastMessageAt: renderedMessages[renderedMessages.length - 1]?.createdAt || null,
-  };
-}
-
-function buildLocalTranscriptSummary(episodes = []) {
-  return {
-    count: episodes.length,
-    chatRequestIds: episodes.map((episode) => episode.chatRequestId).filter(Boolean),
-    latestChatRequestId: episodes[0]?.chatRequestId || null,
-  };
-}
-
-export async function augmentConversationPayloadWithLocalTranscriptIndex(payload, {
-  workspaceRoot = null,
-  filters = {},
-} = {}) {
-  if (!isObject(payload)) return payload;
-  const episodes = await listClaworldLocalTranscriptEpisodes({ workspaceRoot, filters });
-  const addition = {
-    localTranscriptEpisodes: episodes,
-    localTranscriptSummary: buildLocalTranscriptSummary(episodes),
-  };
-  if (Array.isArray(payload.items)) {
-    return {
-      ...payload,
-      ...addition,
-      items: payload.items.map((item) => {
-        if (!isObject(item)) return item;
-        const itemFilters = buildEpisodeFilters({
-          chatRequestId: item.chatRequestId,
-          conversationKey: item.conversationKey,
-          localSessionKey: item.localSessionKey,
-          worldId: item.worldId,
-          counterpartyAgentId: item.counterpartyAgentId || item.targetAgentId || item.peerAgentId,
-        });
-        const itemEpisodes = episodes.filter((episode) => episodeMatchesFilters(episode, itemFilters));
-        if (itemEpisodes.length === 0) return item;
-        return {
-          ...item,
-          localTranscriptEpisodes: itemEpisodes,
-          localTranscriptSummary: buildLocalTranscriptSummary(itemEpisodes),
-        };
-      }),
-    };
-  }
-  return {
-    ...payload,
-    ...addition,
-  };
-}