work-ally 0.2.0-alpha.1

package/bridge/src/thread-sync.ts

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { WorkAllyConfig } from './config.ts';
+import { logInfo, logWarn } from './logger.ts';
+import type { WorkSessionMeta } from './types.ts';
+import { todayStamp, writeJsonFile } from './utils.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+
+interface RuntimeThreadReader {
+  readThreadWithTurns(threadId: string): Promise<{ id: string; status: { type: string; activeFlags?: string[] } | null; turns: any[] }>;
+}
+
+interface SyncTurnMessage {
+  schema_version: number;
+  at: string;
+  day: string;
+  thread_id: string;
+  turn_id: string;
+  role: 'user' | 'assistant';
+  text: string;
+  source: 'thread_read';
+}
+
+interface SyncSummary {
+  syncedAt: string;
+  threadId: string;
+  resolvedThreadId: string;
+  status: string | null;
+  dayFiles: string[];
+  messageCount: number;
+  turnCount: number;
+}
+
+const SCHEMA_VERSION = 1;
+
+function asText(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function toIsoOrNow(value: unknown): string {
+  const text = asText(value);
+  if (!text) {
+    return new Date().toISOString();
+  }
+  const date = new Date(text);
+  if (Number.isNaN(date.getTime())) {
+    return new Date().toISOString();
+  }
+  return date.toISOString();
+}
+
+function collectUserAssistantMessages(threadId: string, turns: any[], timezone: string): { byDay: Map<string, SyncTurnMessage[]>; messageCount: number } {
+  const byDay = new Map<string, SyncTurnMessage[]>();
+  let messageCount = 0;
+
+  for (const turn of turns) {
+    const turnId = asText(turn?.id) || 'unknown-turn';
+    const items = Array.isArray(turn?.items) ? turn.items : [];
+    for (const item of items) {
+      const itemType = asText(item?.type);
+      if (itemType !== 'userMessage' && itemType !== 'agentMessage') {
+        continue;
+      }
+      const text = asText(item?.text);
+      if (!text) {
+        continue;
+      }
+      const at = toIsoOrNow(item?.createdAt || turn?.createdAt);
+      const day = todayStamp(new Date(at), timezone);
+      const role: 'user' | 'assistant' = itemType === 'userMessage' ? 'user' : 'assistant';
+      const entry: SyncTurnMessage = {
+        schema_version: SCHEMA_VERSION,
+        at,
+        day,
+        thread_id: threadId,
+        turn_id: turnId,
+        role,
+        text,
+        source: 'thread_read',
+      };
+      if (!byDay.has(day)) {
+        byDay.set(day, []);
+      }
+      byDay.get(day)?.push(entry);
+      messageCount += 1;
+    }
+  }
+
+  return { byDay, messageCount };
+}
+
+function writeDayThreadFile(archiveRoot: string, day: string, threadId: string, entries: SyncTurnMessage[]): string {
+  const [year, month, date] = day.split('-');
+  const dayDir = path.join(archiveRoot, year, month, date);
+  fs.mkdirSync(dayDir, { recursive: true });
+  const filePath = path.join(dayDir, `${threadId}.ndjson`);
+  const content = entries
+    .sort((left, right) => String(left.at).localeCompare(String(right.at)))
+    .map((entry) => JSON.stringify(entry))
+    .join('\n');
+  fs.writeFileSync(filePath, content ? `${content}\n` : '', 'utf8');
+  return filePath;
+}
+
+function isSyncEligible(session: WorkSessionMeta): boolean {
+  return !session.archivedAt && session.activeSurface !== 'closed' && Boolean(asText(session.runtimeThreadId));
+}
+
+export async function syncThreadConversationById(
+  config: WorkAllyConfig,
+  runtime: RuntimeThreadReader,
+  threadId: string,
+): Promise<SyncSummary | null> {
+  const targetThreadId = asText(threadId);
+  if (!targetThreadId) {
+    return null;
+  }
+
+  const snapshot = await runtime.readThreadWithTurns(targetThreadId);
+  const resolvedThreadId = asText(snapshot.id) || targetThreadId;
+  const status = asText(snapshot.status?.type) || null;
+  const turns = Array.isArray(snapshot.turns) ? snapshot.turns : [];
+
+  const { byDay, messageCount } = collectUserAssistantMessages(resolvedThreadId, turns, config.timezone);
+  if (byDay.size === 0) {
+    logInfo('thread_sync', 'thread_without_messages', {
+      threadId: resolvedThreadId,
+      requestedThreadId: targetThreadId,
+    });
+    return {
+      syncedAt: new Date().toISOString(),
+      threadId: targetThreadId,
+      resolvedThreadId,
+      status,
+      dayFiles: [],
+      messageCount: 0,
+      turnCount: turns.length,
+    };
+  }
+
+  const dayFiles: string[] = [];
+  for (const [day, entries] of byDay.entries()) {
+    const filePath = writeDayThreadFile(config.paths.archiveDir, day, resolvedThreadId, entries);
+    dayFiles.push(filePath);
+  }
+
+  const summary: SyncSummary = {
+    syncedAt: new Date().toISOString(),
+    threadId: targetThreadId,
+    resolvedThreadId,
+    status,
+    dayFiles: dayFiles.sort(),
+    messageCount,
+    turnCount: turns.length,
+  };
+
+  const summaryPath = path.join(config.paths.runtimeDir, 'thread-sync', `${resolvedThreadId}.json`);
+  writeJsonFile(summaryPath, summary);
+
+  logInfo('thread_sync', 'thread_synced', {
+    threadId: resolvedThreadId,
+    messageCount,
+    turnCount: turns.length,
+    dayFileCount: dayFiles.length,
+  });
+
+  return summary;
+}
+
+export async function syncAllActiveWorkSessions(
+  config: WorkAllyConfig,
+  runtime: RuntimeThreadReader,
+  workSessionStore: WorkSessionStore,
+): Promise<{ synced: number; skipped: number; failed: number }> {
+  const sessions = workSessionStore.listWorkSessions().filter(isSyncEligible);
+  let synced = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const session of sessions) {
+    const threadId = asText(session.runtimeThreadId);
+    if (!threadId) {
+      skipped += 1;
+      continue;
+    }
+    try {
+      await syncThreadConversationById(config, runtime, threadId);
+      synced += 1;
+    } catch (error) {
+      failed += 1;
+      logWarn('thread_sync', 'thread_sync_failed', {
+        threadId,
+        workSessionId: session.workSessionId,
+        error: error instanceof Error ? (error.stack || error.message) : String(error),
+      });
+    }
+  }
+
+  return { synced, skipped, failed };
+}

package/bridge/src/translator.ts

@@ -0,0 +1,494 @@
+import type {ApprovalRequest, ConnectionLifecycleEvent, PendingUserInputRecord, RuntimeThreadStatus, SessionMeta, WorkSessionMeta} from './types.ts';
+
+interface ConnectionLifecycleMessageOptions {
+  hasActiveTurn?: boolean;
+}
+
+const SYSTEM_NOTICE_PREFIX_RE = /^\s*(?:\*\*)?【系统消息】(?:\*\*)?/;
+const WORKING_NOTICE_PREFIX_RE =
+    /^\s*(?:\*\*)?(?:【工作中】|⏳ 工作中)(?:\*\*)?/;
+
+export function systemNoticeMessage(text: string): string {
+  const trimmed = String(text || '').trim();
+  if (!trimmed) {
+    return '';
+  }
+  if (SYSTEM_NOTICE_PREFIX_RE.test(trimmed)) {
+    return trimmed;
+  }
+  return `**【系统消息】** ${trimmed}`;
+}
+
+export function workingNoticeMessage(text: string): string {
+  const trimmed = String(text || '').trim();
+  if (!trimmed) {
+    return '';
+  }
+  if (WORKING_NOTICE_PREFIX_RE.test(trimmed)) {
+    return trimmed;
+  }
+  return `**⏳ 工作中** ${trimmed}`;
+}
+
+function isMcpToolApprovalText(text: string|null|undefined): boolean {
+  return /MCP server wants to run the tool/i.test(text || '');
+}
+
+type WaitingUserInputSource =
+    Pick<PendingUserInputRecord, 'questions'|'elicitation'>;
+
+function isMcpToolApprovalRequest(request: WaitingUserInputSource): boolean {
+  if (isMcpToolApprovalText(request.elicitation?.message)) {
+    return true;
+  }
+  if (request.questions.length !== 1) {
+    return false;
+  }
+  return isMcpToolApprovalText(request.questions[0]?.question);
+}
+
+function markdownSection(title: string, lines: string[]): string {
+  return [`**${title}**`, ...lines.map((line) => `- ${line}`)].join('\n');
+}
+
+function approvalKindLabel(kind: ApprovalRequest['kind']): string {
+  return kind === 'file_change' ? '文件修改' : '命令执行';
+}
+
+export function approvalMessage(request: ApprovalRequest): string {
+  const lines = [
+    '**审批请求**',
+    '- 先说明：这一步超出了默认自决边界，需要你明确拍板。',
+    `- 审批编号：${request.approvalId}`,
+    `- 类型：${approvalKindLabel(request.kind)}`,
+  ];
+
+  if (request.boundaryReason) {
+    lines.push(`- 边界原因：${request.boundaryReason}`);
+  }
+  if (request.command) {
+    lines.push(`- 动作：\`${request.command}\``);
+  }
+  if (request.grantRoot) {
+    lines.push(`- 影响范围：\`${request.grantRoot}\``);
+  }
+  if (request.cwd) {
+    lines.push(`- 工作目录：\`${request.cwd}\``);
+  }
+  if (request.reason) {
+    lines.push(`- 运行时原因：${request.reason}`);
+  }
+
+  lines.push(
+      '',
+      '**你现在可以这样处理**',
+      '- 当前会话正在等审批：直接回复 `OK` / `同意`，或 `NO` / `拒绝`',
+      `- 命令兜底：\`/approve ${request.approvalId}\` / \`/deny ${
+          request.approvalId}\``,
+  );
+  return lines.join('\n').trim();
+}
+
+export function batchedApprovalMessage(requests: ApprovalRequest[]): string {
+  const lines = [
+    `**审批请求（共 ${requests.length} 项）**`,
+    '- 这一轮有多项审批待处理。',
+    '- 回复 `OK` / `同意` 可全部通过；回复 `NO` / `拒绝` 可全部拒绝。',
+    '',
+    '**审批条目**',
+  ];
+
+  requests.forEach((request, index) => {
+    const parts = [`${index + 1}. ${approvalKindLabel(request.kind)}`];
+    if (request.command) {
+      parts.push(`动作：\`${request.command}\``);
+    }
+    if (request.grantRoot) {
+      parts.push(`影响范围：\`${request.grantRoot}\``);
+    }
+    if (request.cwd) {
+      parts.push(`工作目录：\`${request.cwd}\``);
+    }
+    if (request.reason) {
+      parts.push(`运行时原因：${request.reason}`);
+    }
+    lines.push(`- ${parts.join('；')}`);
+  });
+
+  lines.push(
+      '',
+      '**你现在可以这样处理**',
+      '- 当前会话正在等审批：直接回复 `OK` / `同意`，或 `NO` / `拒绝`',
+  );
+
+  return lines.join('\n').trim();
+}
+
+function previewLine(label: string, value: string|null|undefined): string {
+  if (!value) {
+    return `${label}: none`;
+  }
+  const compact = value.replace(/\s+/g, ' ').trim();
+  if (compact.length <= 120) {
+    return `${label}: ${compact}`;
+  }
+  return `${label}: ${compact.slice(0, 120)}…`;
+}
+
+export function userInputMessage(request: PendingUserInputRecord): string {
+  const lines = [
+    isMcpToolApprovalRequest(request) ?
+        '需要你确认一次 MCP 工具调用后我才能继续。' :
+        '需要你补充信息后我才能继续。',
+    request.questions.length > 1 ? '请按 `问题ID: 回答` 的格式逐行回复。' :
+                                   '请直接回复答案即可。',
+  ];
+
+  for (const [index, question] of request.questions.entries()) {
+    lines.push('');
+    lines.push(`${index + 1}. ${question.header || question.id}`);
+    lines.push(`question_id: ${question.id}`);
+    lines.push(question.question);
+    if (question.options?.length) {
+      lines.push(`可选项：${
+          question.options.map((option) => option.label).join(' / ')}`);
+    }
+    if (question.isSecret) {
+      lines.push('如涉及敏感信息，请只回复必要部分。');
+    }
+  }
+
+  return lines.join('\n').trim();
+}
+
+export function connectionLifecycleMessage(
+    event: ConnectionLifecycleEvent,
+    options: ConnectionLifecycleMessageOptions = {}): string {
+  const sourceLabel =
+      event.source === 'runtime' ? 'Codex runtime' : 'Feishu 长连接';
+  const hasActiveTurn = Boolean(options.hasActiveTurn);
+
+  if (event.state === 'reconnected') {
+    if (event.source === 'runtime' && hasActiveTurn) {
+      return `${sourceLabel} 连接已恢复，继续确认这一轮结果。`;
+    }
+    return event.source === 'runtime' ? `${sourceLabel} 连接已恢复。` :
+                                        `${sourceLabel} 已恢复。`;
+  }
+
+  if (event.state === 'reconnecting') {
+    if (event.source === 'runtime') {
+      const attemptText = event.attempt ? `第 ${event.attempt} 次` : '本轮';
+      const delayText = event.nextRetryDelayMs ?
+          `，约 ${
+              Math.max(1, Math.ceil(event.nextRetryDelayMs / 1000))} 秒后重试` :
+          '';
+      if (hasActiveTurn) {
+        return `${sourceLabel} 正在重连，并继续确认这一轮结果（${attemptText}${
+            delayText}）。`;
+      }
+      return `${sourceLabel} 正在重连（${attemptText}${delayText}）。`;
+    }
+    return `${sourceLabel} 正在自动重连。`;
+  }
+
+  if (event.source === 'runtime' && hasActiveTurn) {
+    return `${sourceLabel} 已断开，正在继续确认这一轮结果。`;
+  }
+
+  const reason = String(event.reason || '').trim();
+  return reason ? `${sourceLabel} 已断开（${reason}）。` :
+                  `${sourceLabel} 已断开。`;
+}
+
+export function runtimeRecoveryRequiredMessage(): string {
+  return '系统暂时还没确认这一轮是否已完成。为避免漏掉结果，请重新发送上一条消息。';
+}
+
+export function runtimeFinalStateRecoveryRequiredMessage(): string {
+  return '系统暂时还没确认这一轮是否已完成。为避免漏掉结果，请重新发送上一条消息。';
+}
+
+export function runtimeInfrastructureErrorMessage(): string {
+  return '系统暂时还没确认这一轮是否已完成。若长时间无恢复，请重新发送上一条消息。';
+}
+
+export function pendingDeliveryIssueMessage(): string {
+  return '上一轮已有结果或状态产出，但消息当时没能稳定送达；我会先尝试补发上一轮结果，再继续处理你刚发的这条。';
+}
+
+export function contextCompactionStatusMessage(): string {
+  return systemNoticeMessage('Codex 正在压缩当前会话上下文。');
+}
+
+export function redeliveredPreviousTurnPrefixMessage(): string {
+  return '补发上一轮未稳定送达的结果：';
+}
+export function busyNewThreadControlMessage(): string {
+  return systemNoticeMessage(
+      '当前仍在处理上一条；如需新开会话，请先发送 /stop。');
+}
+
+export function newWorkSessionCreatedMessage(): string {
+  return '已新建并切换到新的工作线程；后续消息会继续这条新 thread。';
+}
+
+export function workSessionTakenOverMessage(): string {
+  return '已接回当前工作线程；后续消息会继续同一条 Codex thread。';
+}
+
+export function workSessionAlreadyOnChannelMessage(): string {
+  return systemNoticeMessage('当前工作线程已经在这里继续，无需重复接回。');
+}
+
+export function noLinkedWorkSessionMessage(): string {
+  return systemNoticeMessage(
+      '当前没有已链接的工作线程；如果你要接回官方 Codex 里已在跑的线程，请先在本机执行 `ally attach --assistant <assistant> --last`。');
+}
+
+export function noLinkedOrAttachedWorkSessionMessage(): string {
+  return systemNoticeMessage(
+      '当前没有已链接的工作线程；如果这条线程是你先在官方 Codex CLI 里开的，请先在本机执行 `ally attach --assistant <assistant> --last`，attach 成功后再回来发送 /takeover。');
+}
+
+function threadPreview(session: Pick<WorkSessionMeta, 'threadName' | 'lastPromptPreview' | 'lastReplyPreview'>): string {
+  const preview = [session.threadName, session.lastPromptPreview, session.lastReplyPreview]
+    .map((value) => String(value || '').trim())
+    .find((value) => value.length > 0);
+  if (!preview) {
+    return '无标题';
+  }
+  return preview.replace(/\s+/g, ' ').slice(0, 60);
+}
+
+export function workSessionThreadsMessage(
+  sessions: WorkSessionMeta[],
+  options: {
+    highlightedWorkSessionId?: string | null;
+  } = {},
+): string {
+  if (sessions.length === 0) {
+    return systemNoticeMessage('当前还没有可接回的受管线程。');
+  }
+
+  const lines = ['**当前可接回的线程**'];
+  for (const session of sessions) {
+    const badges = [];
+    if (options.highlightedWorkSessionId && session.workSessionId === options.highlightedWorkSessionId) {
+      badges.push('default');
+    }
+    if (session.origin === 'codex_cli_attach') {
+      badges.push('attach');
+    }
+    const suffix = badges.length ? ` (${badges.join(', ')})` : '';
+    lines.push(`- \`${session.threadHandle}\` ${threadPreview(session)}${suffix}`);
+    lines.push(`  surface: ${session.activeSurface}; updated: ${session.updatedAt}`);
+  }
+  return lines.join('\n');
+}
+
+export function ambiguousTakeoverMessage(sessions: WorkSessionMeta[]): string {
+  return systemNoticeMessage([
+    `当前有 ${sessions.length} 条可接回的受管线程，系统不会替你猜。`,
+    '先发送 `/threads` 查看 handle，再发送 `/takeover <thread-handle>`。',
+  ].join('\n'));
+}
+
+export function takeoverHandleNotFoundMessage(threadHandle: string): string {
+  return systemNoticeMessage(`找不到线程句柄 \`${threadHandle}\`；先发送 /threads 看当前可选项。`);
+}
+
+export function codexBindingRequiredMessage(): string {
+  return systemNoticeMessage('当前会话还没有绑定受管线程；先发普通消息、`/new`，或先 `/threads` 再 `/takeover <thread-handle>`。');
+}
+
+export function codexHandoffMessage(payload: {
+  status: 'ready'|'not_ready'|'not_found';
+  reason?: 'active_work_session_missing' | 'cli_resume_ref_missing';
+  assistantName: string;
+  workspaceRoot: string;
+  assistantCodexHome: string | null;
+  workSessionId: string | null;
+  runtimeThreadId: string | null;
+  cliResumeRef: string | null;
+  cliResumeRefType: 'session_id' | 'thread_name' | 'unknown' | 'null';
+  threadName: string | null;
+  activeSurface: string | null;
+  ownershipSource: string | null;
+  resumeCapability: 'ready' | 'not_ready';
+  command: string | null;
+  exportedAt: string;
+}): string {
+  const stablePayload = {
+    status: payload.status,
+    reason: payload.reason || null,
+    assistant: payload.assistantName,
+    workspace_root: payload.workspaceRoot,
+    assistant_codex_home: payload.assistantCodexHome,
+    work_session_id: payload.workSessionId,
+    runtime_thread_id: payload.runtimeThreadId,
+    cli_resume_ref: payload.cliResumeRef,
+    cli_resume_ref_type: payload.cliResumeRefType,
+    thread_name: payload.threadName,
+    active_surface: payload.activeSurface,
+    ownership_source: payload.ownershipSource,
+    resume_capability: payload.resumeCapability,
+    command: payload.command,
+    exported_at: payload.exportedAt,
+  };
+
+  if (payload.status === 'ready' && payload.command) {
+    return [
+      '在电脑的命令行执行下面命令，可以继续使用 codex-cli 进行当前会话：',
+      '```bash',
+      payload.command,
+      '```',
+    ].join('\n');
+  }
+
+  if (payload.status === 'not_found') {
+    return systemNoticeMessage([
+      '当前没有可接续的工作线程；/codex 只会导出当前工作线程，不会替你隐式新开会话。',
+      '',
+      '**handoff payload**',
+      '```json',
+      JSON.stringify(stablePayload, null, 2),
+      '```',
+    ].join('\n'));
+  }
+
+  return systemNoticeMessage([
+    '当前工作线程还没有官方 Codex CLI 可恢复句柄，所以现在只能确认 runtime thread 还在，但还不能给出 `codex resume ...`。',
+    '这不是新开会话失败，而是 `cliResumeRef` 还没准备好；系统不会拿 `runtimeThreadId` 冒充官方 CLI resume 句柄。',
+    '',
+    '**handoff payload**',
+    '```json',
+    JSON.stringify(stablePayload, null, 2),
+    '```',
+  ].join('\n'));
+}
+
+export function unsupportedHandoffCommandInGroupMessage(
+    command: '/takeover'|'/codex'): string {
+  return systemNoticeMessage(`群聊暂不支持 ${command}；请改用单聊入口继续。`);
+}
+
+export function workSessionOwnershipRejectedMessage(
+    surface: 'official_codex_cli'|'idle'|'closed'): string {
+  if (surface === 'official_codex_cli') {
+    return systemNoticeMessage(
+        '当前工作线程正在官方 Codex CLI 中继续；如需切回这里，请先发送 /takeover，或发送 /new 新开一条工作线程。');
+  }
+  if (surface === 'idle') {
+    return systemNoticeMessage(
+        '当前工作线程的 owner 尚未明确；请先发送 /takeover 接回，或发送 /new 新开一条工作线程。');
+  }
+  return systemNoticeMessage(
+      '当前工作线程已关闭，不能继续写入；如需继续，请发送 /new 新开一条工作线程。');
+}
+export function runningStatusMessage(): string {
+  return '正在处理，请稍候。';
+}
+
+export function completionWithoutReplyStatusMessage(): string {
+  return systemNoticeMessage(
+      '本轮已结束，当前没有更多动作；如需继续，请直接发下一条消息。');
+}
+
+export function waitingApprovalStatusMessage(): string {
+  return '当前已暂停，等待你审批后继续。';
+}
+
+export function waitingApprovalFollowUpMessage(): string {
+  return '当前有待处理审批。请回复 OK / 同意，或 NO / 拒绝。';
+}
+
+export function waitingUserInputStatusMessage(request: WaitingUserInputSource):
+    string {
+  return isMcpToolApprovalRequest(request) ? '当前已暂停，等待你确认后继续。' :
+                                             '当前已暂停，等待你回复后继续。';
+}
+
+export function waitingUserInputFollowUpMessage(): string {
+  return '当前这轮已暂停，正在等你补充信息；你刚发的这条我还没转给 Codex。先回答当前问题，再继续发下一条。';
+}
+
+export function activeTurnNotReadyFollowUpMessage(): string {
+  return '当前这一轮暂时还不能接收新消息；你刚发的这条我先没转给 Codex，请稍后再试。';
+}
+
+export function heartbeatMessage(session: SessionMeta): string {
+  if (session.pendingApprovalIds.length > 0) {
+    const firstApprovalId = session.pendingApprovalIds[0];
+    if (session.pendingApprovalIds.length === 1) {
+      return `仍在等待你的审批：直接回复 OK / 同意，或 NO / 拒绝；也可输入 /approve ${
+          firstApprovalId} / /deny ${firstApprovalId}`;
+    }
+    return `仍在等待你的审批，当前共有 ${
+        session.pendingApprovalIds
+            .length} 项。请直接回复 OK / 同意，或 NO / 拒绝。`;
+  }
+
+  if (session.pendingUserInputRequestId) {
+    return '仍在等待你的补充信息，请直接回复即可。';
+  }
+
+  return '正在思考中，请稍候…';
+}
+
+export function statusMessage(
+    session: SessionMeta,
+    runtimeStatus: RuntimeThreadStatus|null = null,
+    assistant?: {
+      mode: 'assistant'|'native';
+      name?: string;
+      assistantHome?: string;
+      codexHome?: string;
+    },
+    ): string {
+  const thread =
+      session.threadId ? `thread: ${session.threadId}` : 'thread: (none yet)';
+  const runtimeState = session.threadId ?
+      `runtime status: ${runtimeStatus?.type || 'unknown'}` :
+      'runtime status: (no thread)';
+  const runtimeFlags = runtimeStatus?.activeFlags?.length ?
+      `runtime flags: ${runtimeStatus.activeFlags.join(', ')}` :
+      'runtime flags: none';
+  const activeTurn = session.activeTurnId ?
+      `active turn: ${session.activeTurnId}` :
+      'active turn: none';
+  const lastTurn = session.lastTurnId ? `last turn: ${session.lastTurnId}` :
+                                        'last turn: none';
+  const approvals = session.pendingApprovalIds.length ?
+      `pending approvals: ${session.pendingApprovalIds.join(', ')}` :
+      'pending approvals: none';
+  const pendingUserInput = session.pendingUserInputRequestId ?
+      `pending user input: ${session.pendingUserInputRequestId}` :
+      'pending user input: none';
+  const updatedAt = `updated at: ${session.updatedAt}`;
+  const lastMessage = session.lastMessageId ?
+      `last message: ${session.lastMessageId}` :
+      'last message: none';
+
+  return [
+    markdownSection(
+        'Mode',
+        [
+          `mode: ${assistant?.mode || 'native'}`,
+          `assistant: ${assistant?.name || 'none'}`,
+          `assistant_home: ${assistant?.assistantHome || 'none'}`,
+          `codex_home: ${assistant?.codexHome || 'none'}`,
+        ]),
+    markdownSection('Thread', [thread, runtimeState, runtimeFlags]),
+    markdownSection('Turn', [activeTurn, lastTurn]),
+    markdownSection('Queue', [approvals, pendingUserInput]),
+    markdownSection(
+        'Recent',
+        [
+          lastMessage,
+          previewLine('last prompt', session.lastPromptPreview),
+          previewLine('last reply', session.lastReplyPreview),
+          updatedAt,
+        ]),
+  ].join('\n\n');
+}