ronds_ai 0.1.21 → 0.1.22

package/lib/analyze_transcript.js

@@ -0,0 +1,803 @@
+const fs = require('fs');
+const path = require('path');
+
+const MAX_PENDING_TASK_NOTIFICATIONS = 50;
+
+/**
+ * 创建新的会话增量读取状态。
+ */
+function createSessionState(value = {}) {
+  return {
+    offset: Number(value.offset || 0),
+    buffer: String(value.buffer || ''),
+    turnCount: Number(value.turnCount ?? value.turn_count ?? 0),
+    pendingAgentTurns: Array.isArray(value.pendingAgentTurns ?? value.pending_agent_turns)
+      ? (value.pendingAgentTurns ?? value.pending_agent_turns)
+      : [],
+    pendingTaskNotifications: Array.isArray(
+      value.pendingTaskNotifications ?? value.pending_task_notifications,
+    )
+      ? (value.pendingTaskNotifications ?? value.pending_task_notifications)
+      : [],
+  };
+}
+
+/**
+ * 从 transcript 行中读取消息内容。
+ */
+function getContentFromRow(row) {
+  if (!row || typeof row !== 'object' || Array.isArray(row)) {
+    return null;
+  }
+  return row.message && typeof row.message === 'object'
+    ? row.message.content
+    : row.content;
+}
+
+/**
+ * 从 transcript 行中解析 user 或 assistant 角色。
+ */
+function getRoleFromRow(row) {
+  if (!row || typeof row !== 'object') {
+    return null;
+  }
+  if (row.type === 'user' || row.type === 'assistant') {
+    return row.type;
+  }
+  const role = row.message && row.message.role;
+  return role === 'user' || role === 'assistant' ? role : null;
+}
+
+/**
+ * 获取 Claude 消息标识。
+ */
+function getMessageId(row) {
+  const messageId = row && row.message && row.message.id;
+  return typeof messageId === 'string' && messageId ? messageId : null;
+}
+
+/**
+ * 获取 Assistant 消息使用的模型名称。
+ */
+function getModel(row) {
+  const model = row && row.message && row.message.model;
+  return typeof model === 'string' && model ? model : 'claude';
+}
+
+/**
+ * 提取原插件支持的 Anthropic token usage 字段。
+ */
+function getUsageDetailsFromRow(row) {
+  const usage = row && row.message && row.message.usage;
+  if (!usage || typeof usage !== 'object' || Array.isArray(usage)) {
+    return null;
+  }
+
+  const mapping = [
+    ['input_tokens', 'input'],
+    ['output_tokens', 'output'],
+    ['cache_read_input_tokens', 'cache_read_input_tokens'],
+    ['cache_creation_input_tokens', 'cache_creation_input_tokens'],
+  ];
+  const details = {};
+  for (const [source, target] of mapping) {
+    if (Number.isInteger(usage[source]) && usage[source] > 0) {
+      details[target] = usage[source];
+    }
+  }
+  return Object.keys(details).length > 0 ? details : null;
+}
+
+/**
+ * 将 transcript 时间转换为 Date。
+ */
+function parseTimestamp(value) {
+  const raw = value && typeof value === 'object' ? value.timestamp : value;
+  if (typeof raw !== 'string' || !raw) {
+    return null;
+  }
+  const parsed = new Date(raw);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+/**
+ * 仅提取原 Python 插件采集的 text 内容，不采集 thinking。
+ */
+function extractTextFromContent(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return '';
+  }
+  return content
+    .map((block) => {
+      if (typeof block === 'string') {
+        return block;
+      }
+      return block && block.type === 'text' ? String(block.text || '') : '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+/**
+ * 截断过长文本并返回长度元数据。
+ */
+function truncateText(value, maxChars) {
+  const text = value == null ? '' : String(value);
+  if (text.length <= maxChars) {
+    return {
+      text,
+      metadata: { truncated: false, orig_len: text.length },
+    };
+  }
+  const crypto = require('crypto');
+  const kept = text.slice(0, maxChars);
+  return {
+    text: kept,
+    metadata: {
+      truncated: true,
+      orig_len: text.length,
+      kept_len: kept.length,
+      sha256: crypto.createHash('sha256').update(text, 'utf8').digest('hex'),
+    },
+  };
+}
+
+/**
+ * 取得内容中的 tool_use 块。
+ */
+function getToolUseBlocks(content) {
+  return Array.isArray(content)
+    ? content.filter((block) => block && typeof block === 'object' && block.type === 'tool_use')
+    : [];
+}
+
+/**
+ * 取得内容中的 tool_result 块。
+ */
+function getToolResultBlocks(content) {
+  return Array.isArray(content)
+    ? content.filter((block) => block && typeof block === 'object' && block.type === 'tool_result')
+    : [];
+}
+
+/**
+ * 判断当前行是否为工具返回消息。
+ */
+function isToolResultRow(row) {
+  return getRoleFromRow(row) === 'user'
+    && getToolResultBlocks(getContentFromRow(row)).length > 0;
+}
+
+/**
+ * 从上次 byte offset 开始读取新增 JSONL。
+ */
+function readNewJsonl(transcriptPath, sessionState) {
+  if (!fs.existsSync(transcriptPath)) {
+    return { rows: [], sessionState };
+  }
+
+  const fileSize = fs.statSync(transcriptPath).size;
+  if (fileSize < sessionState.offset) {
+    sessionState.offset = 0;
+    sessionState.buffer = '';
+  }
+
+  const length = fileSize - sessionState.offset;
+  if (length <= 0) {
+    return { rows: [], sessionState };
+  }
+
+  const descriptor = fs.openSync(transcriptPath, 'r');
+  let chunk;
+  try {
+    chunk = Buffer.alloc(length);
+    fs.readSync(descriptor, chunk, 0, length, sessionState.offset);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+
+  sessionState.offset = fileSize;
+  const combined = sessionState.buffer + chunk.toString('utf8');
+  const lines = combined.split('\n');
+  sessionState.buffer = lines.pop() || '';
+
+  const rows = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        rows.push(parsed);
+      }
+    } catch {
+      // 与原插件一致：忽略损坏的 JSONL 行。
+    }
+  }
+  return { rows, sessionState };
+}
+
+/**
+ * 从简单 XML 标记中提取内容。
+ */
+function extractXmlTagValue(text, tag) {
+  const start = `<${tag}>`;
+  const end = `</${tag}>`;
+  const startIndex = text.indexOf(start);
+  if (startIndex < 0) {
+    return null;
+  }
+  const endIndex = text.indexOf(end, startIndex + start.length);
+  return endIndex < 0 ? null : text.slice(startIndex + start.length, endIndex);
+}
+
+/**
+ * 判断是否为 Claude Code 的任务通知行。
+ */
+function isTaskNotificationRow(row) {
+  if (row && row.origin && row.origin.kind === 'task-notification') {
+    return true;
+  }
+  return extractTextFromContent(getContentFromRow(row))
+    .trimStart()
+    .startsWith('<task-notification>');
+}
+
+/**
+ * 从任务通知中获取 tool_use_id。
+ */
+function getToolUseIdFromTaskNotification(row) {
+  const value = extractXmlTagValue(
+    extractTextFromContent(getContentFromRow(row)),
+    'tool-use-id',
+  );
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+/**
+ * 从任务通知中获取 task_id。
+ */
+function getTaskIdFromTaskNotification(row) {
+  const value = extractXmlTagValue(
+    extractTextFromContent(getContentFromRow(row)),
+    'task-id',
+  );
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+/**
+ * 综合通知字段和子 Agent 映射解析 tool_use_id。
+ */
+function getToolUseIdForTaskNotification(row, taskIdToToolUseId = {}) {
+  if (!isTaskNotificationRow(row)) {
+    return null;
+  }
+  const direct = getToolUseIdFromTaskNotification(row);
+  if (direct) {
+    return direct;
+  }
+  const taskId = getTaskIdFromTaskNotification(row);
+  return taskId ? taskIdToToolUseId[taskId] || null : null;
+}
+
+/**
+ * 从任务通知中提取最终结果。
+ */
+function getResultFromTaskNotification(row) {
+  const text = extractTextFromContent(getContentFromRow(row));
+  const result = extractXmlTagValue(text, 'result');
+  return result == null ? text : result;
+}
+
+/**
+ * 查找正在等待指定异步工具的历史 Turn。
+ */
+function findPendingAgentTurn(sessionState, toolUseId) {
+  return sessionState.pendingAgentTurns.find((pendingTurn) => {
+    if (!pendingTurn || !Array.isArray(pendingTurn.rows)) {
+      return false;
+    }
+    return (Array.isArray(pendingTurn.pendingToolUseIds)
+      && pendingTurn.pendingToolUseIds.includes(toolUseId))
+      || (Array.isArray(pendingTurn.resolvedToolUseIds)
+        && pendingTurn.resolvedToolUseIds.includes(toolUseId));
+  }) || null;
+}
+
+/**
+ * 将异步任务通知路由到被延迟的 Turn。
+ */
+function resolveDeferredAgentTurns(rows, sessionState, taskIdToToolUseId = {}) {
+  const remainingRows = [];
+  const stashedNotifications = [];
+
+  /**
+   * 将单条通知追加到匹配的延迟 Turn。
+   */
+  function routeToPendingTurn(pendingTurn, row, toolUseId) {
+    pendingTurn.rows.push(row);
+    const pendingIds = pendingTurn.pendingToolUseIds;
+    if (Array.isArray(pendingIds) && pendingIds.includes(toolUseId)) {
+      pendingIds.splice(pendingIds.indexOf(toolUseId), 1);
+      pendingTurn.resolvedToolUseIds = pendingTurn.resolvedToolUseIds || [];
+      pendingTurn.resolvedToolUseIds.push(toolUseId);
+    }
+  }
+
+  const priorNotifications = sessionState.pendingTaskNotifications;
+  for (const row of priorNotifications) {
+    const toolUseId = getToolUseIdForTaskNotification(row, taskIdToToolUseId);
+    if (!toolUseId) {
+      stashedNotifications.push(row);
+      continue;
+    }
+    const pendingTurn = findPendingAgentTurn(sessionState, toolUseId);
+    if (pendingTurn) {
+      routeToPendingTurn(pendingTurn, row, toolUseId);
+    }
+  }
+
+  for (const row of rows) {
+    if (!isTaskNotificationRow(row)) {
+      remainingRows.push(row);
+      continue;
+    }
+    const toolUseId = getToolUseIdForTaskNotification(row, taskIdToToolUseId);
+    if (!toolUseId) {
+      stashedNotifications.push(row);
+      continue;
+    }
+    const pendingTurn = findPendingAgentTurn(sessionState, toolUseId);
+    if (!pendingTurn) {
+      remainingRows.push(row);
+      continue;
+    }
+    routeToPendingTurn(pendingTurn, row, toolUseId);
+  }
+
+  sessionState.pendingTaskNotifications = stashedNotifications
+    .slice(-MAX_PENDING_TASK_NOTIFICATIONS);
+  const resolvedTurnRows = [];
+  sessionState.pendingAgentTurns = sessionState.pendingAgentTurns.filter((pendingTurn) => {
+    if (!pendingTurn || !Array.isArray(pendingTurn.rows)) {
+      return false;
+    }
+    if (Array.isArray(pendingTurn.pendingToolUseIds)
+      && pendingTurn.pendingToolUseIds.length > 0) {
+      return true;
+    }
+    resolvedTurnRows.push(pendingTurn.rows);
+    return false;
+  });
+  return { resolvedTurnRows, remainingRows };
+}
+
+/**
+ * 取出所有仍未完成的异步 Agent Turn，供 SessionEnd 收尾。
+ */
+function popAllDeferredAgentTurnRows(sessionState) {
+  const rowLists = sessionState.pendingAgentTurns
+    .filter((entry) => entry && Array.isArray(entry.rows) && entry.rows.length > 0)
+    .map((entry) => entry.rows);
+  sessionState.pendingAgentTurns = [];
+  return rowLists;
+}
+
+/**
+ * 读取 tool_result 的文本形式。
+ */
+function getToolResultText(toolResultEntry) {
+  if (!toolResultEntry || typeof toolResultEntry !== 'object') {
+    return '';
+  }
+  return typeof toolResultEntry.content === 'string'
+    ? toolResultEntry.content
+    : JSON.stringify(toolResultEntry.content);
+}
+
+/**
+ * 获取 Claude Code 写入的结构化异步启动标记。
+ */
+function getAsyncLaunchFlagFromRow(row) {
+  const result = row && row.toolUseResult;
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    return null;
+  }
+  return result.status === 'async_launched' || result.isAsync === true;
+}
+
+/**
+ * 判断工具返回是否代表异步 Agent 已启动。
+ */
+function isAsyncAgentLaunchResult(toolResultEntry) {
+  if (!toolResultEntry || typeof toolResultEntry !== 'object') {
+    return false;
+  }
+  if (toolResultEntry.isAsyncLaunch != null) {
+    return Boolean(toolResultEntry.isAsyncLaunch);
+  }
+  const text = getToolResultText(toolResultEntry);
+  return text.includes('Async agent launched successfully')
+    || (text.includes('agentId:')
+      && text.includes('output_file:')
+      && text.includes('You will be notified automatically'));
+}
+
+/**
+ * 合并同一 message.id 的 Assistant 分片。
+ */
+function mergeAssistantRows(rows) {
+  const base = { ...rows[rows.length - 1] };
+  const finalMessage = rows[rows.length - 1].message;
+  const message = finalMessage && typeof finalMessage === 'object'
+    ? { ...finalMessage }
+    : {};
+  const content = [];
+  for (const row of rows) {
+    const rowContent = row && row.message && row.message.content;
+    if (Array.isArray(rowContent)) {
+      content.push(...rowContent);
+    } else if (typeof rowContent === 'string' && rowContent) {
+      content.push({ type: 'text', text: rowContent });
+    }
+  }
+  message.content = content;
+  base.message = message;
+  return base;
+}
+
+/**
+ * 创建 Turn 组装过程的临时状态。
+ */
+function createTurnAssemblyState() {
+  return {
+    currentUserRow: null,
+    assistantMessageIds: [],
+    assistantRowsByMessageId: {},
+    toolResultsById: {},
+    toolUseTimestampsById: {},
+    injectedByToolId: {},
+    currentRows: [],
+  };
+}
+
+/**
+ * 尝试把当前临时状态构造成完整 Turn。
+ */
+function buildTurnFromState(state) {
+  if (!state.currentUserRow || state.assistantMessageIds.length === 0) {
+    return null;
+  }
+  const assistantMessages = state.assistantMessageIds
+    .map((messageId) => state.assistantRowsByMessageId[messageId])
+    .filter((rows) => Array.isArray(rows) && rows.length > 0)
+    .map(mergeAssistantRows);
+  if (assistantMessages.length === 0) {
+    return null;
+  }
+  return {
+    userMsg: state.currentUserRow,
+    assistantMsgs: assistantMessages,
+    toolResultsById: { ...state.toolResultsById },
+    toolUseTimestampsById: { ...state.toolUseTimestampsById },
+    injectedByToolId: { ...state.injectedByToolId },
+    rows: state.currentRows.slice(),
+  };
+}
+
+/**
+ * 使用真实用户消息开始新的 Turn。
+ */
+function startNewTurn(row, state) {
+  state.currentUserRow = row;
+  state.assistantMessageIds = [];
+  state.assistantRowsByMessageId = {};
+  state.toolResultsById = {};
+  state.toolUseTimestampsById = {};
+  state.injectedByToolId = {};
+  state.currentRows = [row];
+}
+
+/**
+ * 向当前 Turn 添加 Assistant 分片及工具时间。
+ */
+function addAssistantRow(row, state) {
+  if (!state.currentUserRow) {
+    return;
+  }
+  const messageId = getMessageId(row) || `noid:${state.assistantMessageIds.length}`;
+  if (!state.assistantRowsByMessageId[messageId]) {
+    state.assistantMessageIds.push(messageId);
+    state.assistantRowsByMessageId[messageId] = [];
+  }
+  state.assistantRowsByMessageId[messageId].push(row);
+  for (const toolUse of getToolUseBlocks(getContentFromRow(row))) {
+    if (toolUse.id && state.toolUseTimestampsById[String(toolUse.id)] == null) {
+      state.toolUseTimestampsById[String(toolUse.id)] = row.timestamp;
+    }
+  }
+  state.currentRows.push(row);
+}
+
+/**
+ * 处理 Skill 等 isMeta 注入行。
+ */
+function addInjectedContextRow(row, state) {
+  if (!row || !row.isMeta) {
+    return false;
+  }
+  if (row.sourceToolUseID) {
+    const text = extractTextFromContent(getContentFromRow(row));
+    if (text) {
+      state.injectedByToolId[String(row.sourceToolUseID)] = text;
+      state.currentRows.push(row);
+    }
+  }
+  return true;
+}
+
+/**
+ * 处理普通 tool_result 行。
+ */
+function addToolResultRow(row, state) {
+  if (!isToolResultRow(row)) {
+    return false;
+  }
+  state.currentRows.push(row);
+  const asyncFlag = getAsyncLaunchFlagFromRow(row);
+  for (const result of getToolResultBlocks(getContentFromRow(row))) {
+    if (!result.tool_use_id) {
+      continue;
+    }
+    const entry = {
+      content: result.content,
+      timestamp: row.timestamp,
+    };
+    if (asyncFlag != null) {
+      entry.isAsyncLaunch = asyncFlag;
+    }
+    state.toolResultsById[String(result.tool_use_id)] = entry;
+  }
+  return true;
+}
+
+/**
+ * 处理已路由到当前 Turn 的任务通知。
+ */
+function addTaskNotificationRow(row, state, taskIdToToolUseId) {
+  if (!isTaskNotificationRow(row)) {
+    return false;
+  }
+  if (!state.currentUserRow) {
+    return true;
+  }
+  const toolUseId = getToolUseIdForTaskNotification(row, taskIdToToolUseId);
+  if (!toolUseId) {
+    state.currentRows.push(row);
+    return true;
+  }
+  const existing = state.toolResultsById[toolUseId];
+  if (existing && typeof existing === 'object') {
+    existing.finalContent = getResultFromTaskNotification(row);
+    existing.finalTimestamp = row.timestamp;
+  } else {
+    state.toolResultsById[toolUseId] = {
+      content: getResultFromTaskNotification(row),
+      timestamp: row.timestamp,
+    };
+  }
+  state.currentRows.push(row);
+  return true;
+}
+
+/**
+ * 将 transcript 行组装为对话 Turn。
+ */
+function buildTurns(rows, taskIdToToolUseId = {}) {
+  const turns = [];
+  const state = createTurnAssemblyState();
+  for (const row of rows) {
+    if (addInjectedContextRow(row, state)
+      || addToolResultRow(row, state)
+      || addTaskNotificationRow(row, state, taskIdToToolUseId)) {
+      continue;
+    }
+    const role = getRoleFromRow(row);
+    if (role === 'user') {
+      const turn = buildTurnFromState(state);
+      if (turn) {
+        turns.push(turn);
+      }
+      startNewTurn(row, state);
+    } else if (role === 'assistant') {
+      addAssistantRow(row, state);
+    }
+  }
+  const finalTurn = buildTurnFromState(state);
+  if (finalTurn) {
+    turns.push(finalTurn);
+  }
+  return turns;
+}
+
+/**
+ * 找出 Turn 中尚未收到最终通知的异步 Agent 工具。
+ */
+function getPendingAgentToolUseIds(turn) {
+  const pendingIds = [];
+  for (const assistantMessage of turn.assistantMsgs) {
+    for (const toolUse of getToolUseBlocks(getContentFromRow(assistantMessage))) {
+      if (toolUse.name !== 'Agent' && toolUse.name !== 'Task') {
+        continue;
+      }
+      const toolUseId = String(toolUse.id || '');
+      if (!toolUseId) {
+        continue;
+      }
+      const result = turn.toolResultsById[toolUseId];
+      if (result && result.finalContent != null) {
+        continue;
+      }
+      if (isAsyncAgentLaunchResult(result)) {
+        pendingIds.push(toolUseId);
+      }
+    }
+  }
+  return pendingIds;
+}
+
+/**
+ * 筛选当前可以导出的 Turn，并延迟异步 Agent Turn。
+ */
+function getTurnsToEmit(turns, sessionState, flushDeferredAgentTurns = false) {
+  const ready = [];
+  for (const turn of turns) {
+    const pendingIds = getPendingAgentToolUseIds(turn);
+    if (pendingIds.length === 0 || flushDeferredAgentTurns) {
+      ready.push(turn);
+      continue;
+    }
+    sessionState.pendingAgentTurns.push({
+      pendingToolUseIds: pendingIds,
+      rows: turn.rows,
+    });
+  }
+  return ready;
+}
+
+/**
+ * 发现主 transcript 对应的子 Agent transcript。
+ */
+function getSubagentTranscriptsByToolUseId(transcriptPath) {
+  const parsed = path.parse(transcriptPath);
+  const subagentDir = path.join(parsed.dir, parsed.name, 'subagents');
+  if (!fs.existsSync(subagentDir) || !fs.statSync(subagentDir).isDirectory()) {
+    return {};
+  }
+
+  const result = {};
+  for (const fileName of fs.readdirSync(subagentDir)) {
+    if (!fileName.endsWith('.meta.json')) {
+      continue;
+    }
+    const metaPath = path.join(subagentDir, fileName);
+    let metadata;
+    try {
+      metadata = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!metadata || typeof metadata.toolUseId !== 'string' || !metadata.toolUseId) {
+      continue;
+    }
+    const stem = fileName.slice(0, -'.meta.json'.length);
+    const jsonlPath = path.join(subagentDir, `${stem}.jsonl`);
+    if (!fs.existsSync(jsonlPath)) {
+      continue;
+    }
+    result[metadata.toolUseId] = {
+      path: jsonlPath,
+      agentId: stem.startsWith('agent-') ? stem.slice('agent-'.length) : stem,
+      agentType: metadata.agentType,
+      description: metadata.description,
+    };
+  }
+  return result;
+}
+
+/**
+ * 构造 task_id 到父级 tool_use_id 的映射。
+ */
+function getTaskIdToToolUseId(subagents) {
+  const result = {};
+  for (const [toolUseId, subagent] of Object.entries(subagents || {})) {
+    if (subagent && typeof subagent.agentId === 'string' && subagent.agentId) {
+      result[subagent.agentId] = toolUseId;
+    }
+  }
+  return result;
+}
+
+/**
+ * 读取完整子 Agent JSONL，忽略损坏行。
+ */
+function readSubagentJsonl(filePath) {
+  const rows = [];
+  const content = fs.readFileSync(filePath, 'utf8');
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    try {
+      const row = JSON.parse(line);
+      if (row && typeof row === 'object' && !Array.isArray(row)) {
+        rows.push(row);
+      }
+    } catch {
+      // 与原插件一致：损坏的子 Agent 行不阻断整条轨迹。
+    }
+  }
+  return rows;
+}
+
+/**
+ * 读取新增 transcript，并结合历史延迟状态生成 Turn。
+ */
+function getNewTurnsFromTranscript(
+  transcriptPath,
+  sessionState,
+  subagents,
+  flushDeferredAgentTurns = false,
+) {
+  const readResult = readNewJsonl(transcriptPath, sessionState);
+  const taskMap = getTaskIdToToolUseId(subagents);
+  const routed = resolveDeferredAgentTurns(readResult.rows, sessionState, taskMap);
+  let deferredRows = routed.resolvedTurnRows;
+
+  if (flushDeferredAgentTurns && sessionState.pendingAgentTurns.length > 0) {
+    deferredRows = deferredRows.concat(popAllDeferredAgentTurnRows(sessionState));
+  }
+  if (flushDeferredAgentTurns) {
+    sessionState.pendingTaskNotifications = [];
+  }
+
+  const turns = [];
+  for (const rows of deferredRows) {
+    turns.push(...buildTurns(rows, taskMap));
+  }
+  if (routed.remainingRows.length > 0) {
+    turns.push(...buildTurns(routed.remainingRows, taskMap));
+  }
+  return { turns, sessionState };
+}
+
+module.exports = {
+  MAX_PENDING_TASK_NOTIFICATIONS,
+  buildTurns,
+  createSessionState,
+  extractTextFromContent,
+  getContentFromRow,
+  getModel,
+  getNewTurnsFromTranscript,
+  getPendingAgentToolUseIds,
+  getSubagentTranscriptsByToolUseId,
+  getTaskIdToToolUseId,
+  getToolResultText,
+  getToolResultBlocks,
+  getToolUseBlocks,
+  getTurnsToEmit,
+  getUsageDetailsFromRow,
+  isAsyncAgentLaunchResult,
+  isTaskNotificationRow,
+  parseTimestamp,
+  readNewJsonl,
+  readSubagentJsonl,
+  resolveDeferredAgentTurns,
+  truncateText,
+};