kiku-agent 1.0.11 → 1.2.0

package/server/agent/ui.js

@@ -2,15 +2,15 @@ import readline from 'node:readline';
 import { stdin as input, stdout as output } from 'node:process';
 import { eventBus, Events } from './eventBus.js';
 import { AgentStates } from './agentState.js';
-import { ansiBackground, ansiForeground, getThemePalette } from './theme.js';
+import { ansiBackground, ansiForeground, getThemePalette, isColorDisabled } from './theme.js';
 
 
 export const C = Object.freeze({
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  italic: '\x1b[3m',
-  underline: '\x1b[4m',
+  get reset() { return isColorDisabled() ? '' : '\x1b[0m'; },
+  get bold() { return isColorDisabled() ? '' : '\x1b[1m'; },
+  get dim() { return isColorDisabled() ? '' : '\x1b[2m'; },
+  get italic() { return isColorDisabled() ? '' : '\x1b[3m'; },
+  get underline() { return isColorDisabled() ? '' : '\x1b[4m'; },
 
   get sakura() { return ansiForeground(getThemePalette().primary); },
   get roseGlow() { return ansiForeground(getThemePalette().secondary); },
@@ -221,6 +221,105 @@ export function sliceLineForDisplay(str, cursor, maxWidth) {
   return { displayLine, cursorVisualOffset };
 }
 
+export function getMultilinePromptLayout(text, cursor = 0, maxWidth = 80, maxRows = 6) {
+  const safeWidth = Math.max(10, Number(maxWidth) || 80);
+  const safeMaxRows = Math.max(1, Math.min(10, Number(maxRows) || 6));
+  const rawParagraphs = String(text || '').split('\n');
+  const lines = [];
+  let cursorRow = 0;
+  let cursorCol = 0;
+  let runningCharCount = 0;
+
+  for (let pIdx = 0; pIdx < rawParagraphs.length; pIdx++) {
+    const paragraph = rawParagraphs[pIdx];
+    const segments = getGraphemeSegments(paragraph);
+    let currentLineSegments = [];
+    let currentLineWidth = 0;
+    let lineStartIndex = runningCharCount;
+
+    for (let sIdx = 0; sIdx < segments.length; sIdx++) {
+      const seg = segments[sIdx];
+      const segWidth = getStringDisplayWidth(seg.segment);
+
+      if (currentLineWidth + segWidth > safeWidth && currentLineSegments.length > 0) {
+        const lineText = currentLineSegments.map(s => s.segment).join('');
+        lines.push({
+          text: lineText,
+          width: currentLineWidth,
+          start: lineStartIndex,
+          end: lineStartIndex + lineText.length,
+        });
+        lineStartIndex += lineText.length;
+        currentLineSegments = [];
+        currentLineWidth = 0;
+      }
+
+      currentLineSegments.push(seg);
+      currentLineWidth += segWidth;
+    }
+
+    const lineText = currentLineSegments.map(s => s.segment).join('');
+    lines.push({
+      text: lineText,
+      width: currentLineWidth,
+      start: lineStartIndex,
+      end: lineStartIndex + lineText.length,
+    });
+
+    runningCharCount += paragraph.length;
+    if (pIdx < rawParagraphs.length - 1) {
+      runningCharCount += 1;
+    }
+  }
+
+  const safeCursor = Math.max(0, Math.min((text || '').length, cursor));
+  let foundCursor = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isLastLine = i === lines.length - 1;
+    if (safeCursor >= line.start && (safeCursor <= line.end || isLastLine)) {
+      cursorRow = i;
+      const textBeforeCursorInLine = (text || '').slice(line.start, safeCursor);
+      cursorCol = getStringDisplayWidth(textBeforeCursorInLine);
+      foundCursor = true;
+      break;
+    }
+  }
+
+  if (!foundCursor) {
+    cursorRow = Math.max(0, lines.length - 1);
+    cursorCol = lines[cursorRow] ? lines[cursorRow].width : 0;
+  }
+
+  let visibleStart = 0;
+  let visibleEnd = lines.length;
+
+  if (lines.length > safeMaxRows) {
+    if (cursorRow >= safeMaxRows) {
+      visibleStart = cursorRow - safeMaxRows + 1;
+      visibleEnd = cursorRow + 1;
+    } else {
+      visibleStart = 0;
+      visibleEnd = safeMaxRows;
+    }
+  }
+
+  const visibleLines = lines.slice(visibleStart, visibleEnd);
+  const displayCursorRow = cursorRow - visibleStart;
+
+  return {
+    lines,
+    visibleLines: visibleLines.map(l => l.text),
+    visibleStart,
+    totalLines: lines.length,
+    cursorRow: displayCursorRow,
+    cursorCol,
+    hasMoreAbove: visibleStart > 0,
+    hasMoreBelow: visibleEnd < lines.length,
+  };
+}
+
 export function getFullWidth() {
   return process.stdout.columns || 80;
 }
@@ -232,61 +331,86 @@ export function wrapText(text, maxWidth = 72) {
   const lines = [];
   const rawParagraphs = text.split('\n');
 
-  const tokenize = para => {
-    const raw = para.split(/\s+/).filter(Boolean);
-    const tokens = [];
-    for (let i = 0; i < raw.length; i++) {
-      if (raw[i] === '•' && i + 1 < raw.length) {
-        tokens.push('• ' + raw[i + 1]);
-        i++;
-      } else {
-        tokens.push(raw[i]);
-      }
-    }
-    return tokens;
-  };
-
   for (const para of rawParagraphs) {
     if (!para.trim()) {
       lines.push('');
       continue;
     }
 
-    const words = tokenize(para);
+    const plainPara = stripAnsi(para);
+    const spaceMatch = plainPara.match(/^(\s+)/);
+    const initialIndent = spaceMatch ? spaceMatch[1] : '';
+
+    let continuationIndent = initialIndent;
+    const bulletMatch = plainPara.match(/^(\s*)([↳•\-\*]|\[\d+\])\s+/);
+    if (bulletMatch) {
+      continuationIndent = ' '.repeat(Math.min(12, getStringDisplayWidth(bulletMatch[0])));
+    } else if (initialIndent) {
+      continuationIndent = initialIndent;
+    }
+
+    const rawWords = para.trim().split(/\s+/).filter(Boolean);
+    const words = [];
+    for (let i = 0; i < rawWords.length; i++) {
+      if (rawWords[i] === '•' && i + 1 < rawWords.length) {
+        words.push('• ' + rawWords[i + 1]);
+        i++;
+      } else {
+        words.push(rawWords[i]);
+      }
+    }
+
     const paraLines = [];
-    let currentLine = '';
+    let currentLine = initialIndent;
+    let activeAnsi = '';
 
     for (const word of words) {
       if (!word) continue;
-      const testLine = currentLine ? (currentLine + ' ' + word) : word;
+      const testLine = currentLine.trim() ? (currentLine + ' ' + word) : (currentLine + word);
       const testWidth = getStringDisplayWidth(testLine);
 
       if (testWidth <= maxWidth) {
         currentLine = testLine;
       } else {
-        if (currentLine) {
-          paraLines.push(currentLine);
-          currentLine = word;
+        if (currentLine.trim()) {
+          paraLines.push(currentLine + (activeAnsi && !currentLine.endsWith('\x1b[0m') ? '\x1b[0m' : ''));
+          currentLine = continuationIndent + activeAnsi + word;
         } else {
-          let chunk = '';
+          let chunk = continuationIndent + activeAnsi;
           for (const ch of word) {
             if (getStringDisplayWidth(chunk + ch) <= maxWidth) {
               chunk += ch;
             } else {
-              paraLines.push(chunk);
-              chunk = ch;
+              if (chunk.trim()) {
+                paraLines.push(chunk + (activeAnsi && !chunk.endsWith('\x1b[0m') ? '\x1b[0m' : ''));
+              }
+              chunk = continuationIndent + activeAnsi + ch;
             }
           }
           currentLine = chunk;
         }
       }
+
+      const ansiMatches = word.match(/\x1b\[[0-9;]*[a-zA-Z]/g);
+      if (ansiMatches) {
+        for (const m of ansiMatches) {
+          if (m === '\x1b[0m' || m === '\x1b[m') {
+            activeAnsi = '';
+          } else {
+            activeAnsi += m;
+          }
+        }
+      }
+    }
+
+    if (currentLine.trim()) {
+      paraLines.push(currentLine);
     }
-    if (currentLine) paraLines.push(currentLine);
 
-    if (paraLines.length >= 2 && !/\s/.test(paraLines[paraLines.length - 1].trim())) {
+    if (paraLines.length >= 2 && !/\s/.test(stripAnsi(paraLines[paraLines.length - 1]).trim())) {
       const last = paraLines[paraLines.length - 1];
       const prev = paraLines[paraLines.length - 2];
-      const candidate = prev + ' ' + last;
+      const candidate = prev + ' ' + last.trim();
       if (getStringDisplayWidth(candidate) <= maxWidth) {
         paraLines[paraLines.length - 2] = candidate;
         paraLines.pop();
@@ -300,6 +424,7 @@ export function wrapText(text, maxWidth = 72) {
 
 
 
+
 export function stripAnsi(str) {
   return String(str ?? '').replace(/\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1b\\))/g, '');
 }
@@ -340,13 +465,13 @@ export function fitStyledText(styledText, maxWidth) {
 
 export function printSolidBannerRow(styledText, targetWidth, requestedBg = C.bgPanel, indent = '') {
   const terminalWidth = getFullWidth();
-  const rowWidth = Math.max(1, Math.min(targetWidth || terminalWidth, terminalWidth) - 1);
-  const contentWidth = Math.max(0, rowWidth - getStringDisplayWidth(indent));
-  const fitted = fitStyledText(styledText, contentWidth);
-  const background = requestedBg === C.bgPanelHeader ? C.bgPanelHeader : C.bgPanel;
+  const rowWidth = Math.max(1, (targetWidth || terminalWidth) - getStringDisplayWidth(indent));
+  const fitted = fitStyledText(styledText, rowWidth);
+  const pad = Math.max(0, rowWidth - getStringDisplayWidth(fitted));
+  const background = requestedBg === C.bgPanelHeader ? C.bgPanelHeader : (requestedBg || C.bgPanel);
   const fixedStyled = fitted.replace(/\x1b\[0m/g, C.reset + background + C.white);
 
-  console.log(indent + background + C.white + fixedStyled + '\x1b[0K' + C.reset);
+  console.log(indent + background + C.white + fixedStyled + ' '.repeat(pad) + C.reset);
 }
 
 let activeTuiPrompt = null;
@@ -464,11 +589,11 @@ export function formatSolidPanelLines({ title, lines, width, indent = '', header
     const text = typeof raw === 'string' ? raw : (raw?.text ?? '');
     const sublines = String(text).split('\n');
     for (const subline of sublines) {
-      const isBoxTable = /^\s*[\x1b\[0-9;]*[┌├└│]/.test(subline);
+      const isBoxTable = /^\s*(\x1b\[[0-9;]*[a-zA-Z])*[┌├└│]/.test(subline) || /^[┌├└│]/.test(stripAnsi(subline).trimStart());
       const wrappedSublines = isBoxTable ? [subline] : wrapText(subline, maxContentWidth);
       for (const wrapped of (wrappedSublines.length > 0 ? wrappedSublines : [''])) {
         const rowText = isBoxTable ? (wrapped.startsWith(indent) ? wrapped : `${indent}${wrapped}`) : `${indent}  ${wrapped}`;
-        const fitted = fitStyledText(rowText, w);
+        const fitted = isBoxTable ? rowText : fitStyledText(rowText, w);
         const pad = Math.max(0, w - getStringDisplayWidth(fitted));
         const themed = fitted.replace(/\x1b\[0m/g, C.reset + bodyBg + C.white);
         rows.push(`${bodyBg}${C.white}${themed}${' '.repeat(pad)}${C.reset}`);
@@ -642,7 +767,7 @@ export function formatRichCardLines({
   const normStatus = String(status || 'info').toLowerCase();
   const st = STATUS_THEMES[normStatus] || STATUS_THEMES.info;
   const termWidth = width || getFullWidth();
-  const blockWidth = Math.max(30, Math.min(84, termWidth - getStringDisplayWidth(indent) - 2));
+  const blockWidth = Math.max(30, termWidth - (indent ? getStringDisplayWidth(indent) : 0));
   const rows = [];
 
   const icon = st.icon;
@@ -695,15 +820,32 @@ export function printRichStatusCard({ status, title, lines = [], footer = '', wi
   console.log(`\n${rows.join('\n')}\n`);
 }
 
+export function cleanTableCell(raw) {
+  if (!raw) return '';
+  return String(raw)
+    .replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g, (m, text, url) => {
+      const t = text.trim();
+      const u = url.trim();
+      return t === u ? u : `${t} (${u})`;
+    })
+    .replace(/\*\*/g, '')
+    .replace(/`/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
 export function formatRichTable(headers = [], rows = [], maxWidth = getFullWidth() - 4) {
   if (!headers.length && !rows.length) return [];
   const colCount = Math.max(headers.length, ...rows.map(r => r.length));
-  const colWidths = new Array(colCount).fill(3);
+  const colWidths = new Array(colCount).fill(4);
+
+  const cleanHeaders = headers.map(cleanTableCell);
+  const cleanRows = rows.map(r => r.map(cleanTableCell));
 
   for (let c = 0; c < colCount; c++) {
-    const headerLen = getStringDisplayWidth(headers[c] || '');
+    const headerLen = getStringDisplayWidth(cleanHeaders[c] || '');
     colWidths[c] = Math.max(colWidths[c], headerLen);
-    for (const row of rows) {
+    for (const row of cleanRows) {
       const cellLen = getStringDisplayWidth(row[c] || '');
       colWidths[c] = Math.max(colWidths[c], cellLen);
     }
@@ -725,10 +867,14 @@ export function formatRichTable(headers = [], rows = [], maxWidth = getFullWidth
 
   output.push(`${C.slate}${topBorder}${C.reset}`);
 
-  if (headers.length > 0) {
+  if (cleanHeaders.length > 0) {
     const headerCells = [];
     for (let c = 0; c < colCount; c++) {
-      const text = fitStyledText(headers[c] || '', colWidths[c]);
+      const rawText = cleanHeaders[c] || '';
+      const textLen = getStringDisplayWidth(rawText);
+      const text = textLen > colWidths[c] && colWidths[c] > 3
+        ? fitStyledText(rawText, colWidths[c] - 1) + '…'
+        : fitStyledText(rawText, colWidths[c]);
       const pad = Math.max(0, colWidths[c] - getStringDisplayWidth(text));
       headerCells.push(`${C.bold}${C.gold}${text}${C.reset}${' '.repeat(pad)}`);
     }
@@ -736,11 +882,14 @@ export function formatRichTable(headers = [], rows = [], maxWidth = getFullWidth
     output.push(`${C.slate}${midBorder}${C.reset}`);
   }
 
-  for (const row of rows) {
+  for (const row of cleanRows) {
     const rowCells = [];
     for (let c = 0; c < colCount; c++) {
       const cellRaw = row[c] || '—';
-      const text = fitStyledText(cellRaw, colWidths[c]);
+      const cellLen = getStringDisplayWidth(cellRaw);
+      const text = cellLen > colWidths[c] && colWidths[c] > 3
+        ? fitStyledText(cellRaw, colWidths[c] - 1) + '…'
+        : fitStyledText(cellRaw, colWidths[c]);
       const pad = Math.max(0, colWidths[c] - getStringDisplayWidth(text));
       rowCells.push(`${C.white}${text}${C.reset}${' '.repeat(pad)}`);
     }
@@ -754,6 +903,8 @@ export function formatRichTable(headers = [], rows = [], maxWidth = getFullWidth
 export function formatTerminalMarkdown(text) {
   if (!text) return '';
   return text
+    .replace(/^#####?\s*(.+)$/gm, `  ${C.bold}${C.lavender}• $1${C.reset}`)
+    .replace(/^####\s*(.+)$/gm, `${C.bold}${C.cyberCyan}▸ $1${C.reset}`)
     .replace(/^###\s*(.+)$/gm, `${C.bold}${C.gold}✦ $1${C.reset}`)
     .replace(/^##\s*(.+)$/gm, `${C.bold}${C.roseGlow}■ $1${C.reset}`)
     .replace(/^#\s*(.+)$/gm, `${C.bold}${C.sakura}━━━ $1 ━━━${C.reset}`)
@@ -763,7 +914,8 @@ export function formatTerminalMarkdown(text) {
     .replace(/\*\*([^*]+)\*\*/g, `${C.bold}${C.white}$1${C.reset}`)
     .replace(/(?<!\*)\*([^\*\n]+)\*(?!\*)/g, `${C.italic}${C.white}$1${C.reset}`)
     .replace(/`([^`]+)`/g, `${C.cyberCyan}$1${C.reset}`)
-    .replace(/^(\s*)[*•-]\s+/gm, `$1  ${C.sakura}•${C.reset} `)
+    .replace(/^(\s*)(\d+)\.\s+/gm, `$1  ${C.gold}$2.${C.reset} `)
+    .replace(/^(\s*)[*•+-]\s+/gm, `$1  ${C.sakura}•${C.reset} `)
     .replace(/^\s*[-*_]{3,}\s*$/gm, `  ${C.slate}${'─'.repeat(Math.max(20, getFullWidth() - 6))}${C.reset}`);
 }
 
@@ -784,7 +936,7 @@ export function parseMarkdownTableRow(text) {
 export function isMarkdownTableSeparator(cells) {
   return Array.isArray(cells)
     && cells.length > 0
-    && cells.every(cell => /^:?-{3,}:?$/.test(cell.replace(/\s+/g, '')));
+    && cells.every(cell => /^:?-+:?$/.test(cell.replace(/\s+/g, '')));
 }
 
 export function expandMarkdownLinks(text) {
@@ -821,8 +973,8 @@ export function formatMarkdownLines(text, maxWidth = getFullWidth() - 8) {
     const cells = parseMarkdownTableRow(rawLine);
 
     if (pendingHeader) {
-      if (cells && cells.length === pendingHeader.length && isMarkdownTableSeparator(cells)) {
-        tableHeaders = pendingHeader.map(c => c.replace(/\*\*/g, '').replace(/`/g, ''));
+      if (cells && isMarkdownTableSeparator(cells)) {
+        tableHeaders = pendingHeader.map(cleanTableCell);
         pendingHeader = null;
         tableRows = [];
         continue;
@@ -833,8 +985,12 @@ export function formatMarkdownLines(text, maxWidth = getFullWidth() - 8) {
     }
 
     if (tableHeaders) {
-      if (cells && cells.length === tableHeaders.length && !isMarkdownTableSeparator(cells)) {
-        tableRows.push(cells.map(c => c.replace(/\*\*/g, '').replace(/`/g, '')));
+      if (cells && !isMarkdownTableSeparator(cells)) {
+        const normalizedRow = new Array(tableHeaders.length).fill('');
+        for (let c = 0; c < tableHeaders.length; c++) {
+          normalizedRow[c] = cleanTableCell(cells[c] || '');
+        }
+        tableRows.push(normalizedRow);
         continue;
       } else {
         flushTable();
@@ -914,7 +1070,7 @@ export function getWelcomeHeroLines() {
     padItem(c + '◆', 'Music & OST', '"OSTs from In Blossom & Ruyi Pavilion, /play Ginkgo"'),
     padItem(e + '◆', 'Endorsements', '"Versace Global Ambassador & fashion partnerships"'),
     padItem(l + '◆', 'Tools / MCP', '"@search_works 2026, /mcp list, /stats, /help"'),
-    `  ${s}╰${'─'.repeat(boxWidth)}╯${rst}`,
+    `  ${s}╰${'─'.repeat(innerWidth)}╯${rst}`,
     '',
     ...shortcutLines,
     '',
@@ -961,12 +1117,11 @@ export function setupOutputInterception(tuiPrompt, _isProcessingFn) {
     if (tuiPrompt && tuiPrompt.screenBuffer && !tuiPrompt.isDisposed && !isTuiWriting) {
       const str = String(chunk);
       if (
-        str.startsWith('\x1b[H') ||
         str.startsWith('\x1b[?1049') ||
-        str.startsWith('\x1b[?25') ||
         str.startsWith('\x1b[?1000') ||
         str.startsWith('\x1b[?1002') ||
-        str.startsWith('\x1b[?1006')
+        str.startsWith('\x1b[?1006') ||
+        str.startsWith('\x1b[?1015')
       ) {
         return _rawStdoutWrite(chunk, encoding, callback);
       }
@@ -1025,7 +1180,7 @@ export function formatTaskPlanBanner(plan) {
   const barEmpty = 10 - barFilled;
   const progressBar = `[${'█'.repeat(barFilled)}${'░'.repeat(barEmpty)}] ${pct}%`;
 
-  const termWidth = Math.min(80, Math.max(20, getFullWidth() - 2));
+  const termWidth = Math.max(20, getFullWidth());
   const bg = C.bgPanel;
   const bgHeader = C.bgPanelHeader;
 
@@ -1077,6 +1232,7 @@ export function formatTaskPlanBanner(plan) {
 let isAlternateScreenActive = false;
 
 export function enterAlternateScreen() {
+  if (isColorDisabled()) return;
   if (process.stdout.isTTY && !isAlternateScreenActive) {
     isAlternateScreenActive = true;
     _rawStdoutWrite('\x1b[?1049h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l\x1b[?25l\x1b[H\x1b[2J');
@@ -1090,20 +1246,27 @@ export function exitAlternateScreen() {
   }
 }
 
-export function getTuiViewportLayout(termRows = 24) {
+export function getTuiViewportLayout(termRows = 24, promptLinesCount = 1) {
   const parsedRows = Number(termRows);
   const rows = Math.max(10, Number.isFinite(parsedRows) ? Math.floor(parsedRows) : 24);
-  const viewportStartRow = 1;
-  const statusBarRow = rows - 4;
-  const promptRow = rows - 2;
+  const extraPromptRows = Math.max(0, Math.min(Math.floor(rows / 3), (Number(promptLinesCount) || 1) - 1));
+  const promptHeight = 1 + extraPromptRows;
   const separatorRow = rows - 1;
+  const promptStartRow = (rows - 2) - extraPromptRows;
+  const promptEndRow = promptStartRow + promptHeight - 1;
+  const statusBarRow = (rows - 4) - extraPromptRows;
+  const viewportStartRow = 1;
+  const viewportHeight = Math.max(1, statusBarRow - viewportStartRow);
 
   return {
     termRows: rows,
     viewportStartRow,
-    viewportHeight: Math.max(1, statusBarRow - viewportStartRow),
+    viewportHeight,
     statusBarRow,
-    promptRow,
+    promptRow: promptStartRow,
+    promptStartRow,
+    promptEndRow,
+    promptHeight,
     separatorRow,
   };
 }
@@ -1215,4 +1378,263 @@ export class VirtualScreenBuffer {
   }
 }
 
+function getMilestonePalette(era = '', year = '') {
+  if (isColorDisabled()) {
+    return {
+      yearBg: '',
+      yearFg: '',
+      badgeBg: '',
+      badgeFg: '',
+      tagBg: '',
+      tagFg: '',
+    };
+  }
+
+  const eraLower = String(era || '').toLowerCase();
+  const yearNum = parseInt(year, 10) || 0;
+
+
+  if (eraLower.includes('snh') || (yearNum >= 2013 && yearNum <= 2017)) {
+    return {
+      yearBg: '\x1b[48;2;180;36;85m',
+      yearFg: '\x1b[38;2;255;255;255m',
+      badgeBg: '\x1b[48;2;60;25;40m',
+      badgeFg: '\x1b[38;2;255;185;210m',
+      tagBg: '\x1b[48;2;40;22;32m',
+      tagFg: '\x1b[38;2;230;170;190m',
+    };
+  }
+
+
+  if (eraLower.includes('solo') || eraLower.includes('star48') || (yearNum >= 2018 && yearNum <= 2023)) {
+    return {
+      yearBg: '\x1b[48;2;115;45;160m',
+      yearFg: '\x1b[38;2;255;255;255m',
+      badgeBg: '\x1b[48;2;55;30;70m',
+      badgeFg: '\x1b[38;2;225;175;255m',
+      tagBg: '\x1b[48;2;38;22;48m',
+      tagFg: '\x1b[38;2;200;160;230m',
+    };
+  }
+
+ 
+  return {
+    yearBg: '\x1b[48;2;18;110;120m',
+    yearFg: '\x1b[38;2;255;255;255m',
+    badgeBg: '\x1b[48;2;20;50;55m',
+    badgeFg: '\x1b[38;2;130;240;250m',
+    tagBg: '\x1b[48;2;16;35;40m',
+    tagFg: '\x1b[38;2;110;200;210m',
+  };
+}
+
+export function formatCareerTimelineGraphic(items = [], width = getFullWidth()) {
+  const termWidth = Math.max(40, width);
+  const rows = [];
+
+  const headerBg = isColorDisabled() ? '' : '\x1b[48;2;65;20;42m';
+  const headerFg = isColorDisabled() ? '' : '\x1b[38;2;255;220;235m';
+
+  rows.push(`${headerBg}${headerFg}${C.bold}  ◆ JU JINGYI • 鞠婧祎 CAREER MILESTONES TIMELINE  ${C.reset}`);
+  rows.push(`${C.dim}  Artistic eras, breakthrough performances, and landmark milestones${C.reset}`);
+  rows.push('');
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const pal = getMilestonePalette(item.era, item.year);
+
+    const yearStr = item.year ? ` ${item.year} ` : ' ERA ';
+    const yearBadge = `${pal.yearBg}${pal.yearFg}${C.bold}${yearStr}${C.reset}`;
+
+    const titleText = `${C.white}${C.bold}${item.title || item.titleEn || ''}${C.reset}`;
+    const cnText = item.titleCn ? ` ${C.slate}(${item.titleCn})${C.reset}` : '';
+    const badgeText = item.badge
+      ? ` ${pal.badgeBg}${pal.badgeFg}${C.bold} ✨ ${item.badge} ${C.reset}`
+      : '';
+
+    rows.push(`  ${yearBadge}  ${titleText}${cnText}${badgeText}`);
+
+    const metaParts = [];
+    if (item.category) metaParts.push(item.category);
+    if (item.date) metaParts.push(item.date);
+    if (metaParts.length > 0) {
+      const metaText = metaParts.join('  •  ');
+      rows.push(`    ${pal.tagBg}${pal.tagFg} ${metaText} ${C.reset}`);
+    }
+
+    if (item.summary) {
+      const wrapped = wrapText(item.summary, termWidth - 8);
+      for (const wLine of wrapped) {
+        rows.push(`    ${C.slate}${wLine}${C.reset}`);
+      }
+    }
+
+    if (Array.isArray(item.highlights) && item.highlights.length > 0) {
+      for (const h of item.highlights) {
+        const cleanH = String(h || '').replace(/^[•\-\*]\s*/, '');
+        const wrappedH = wrapText(cleanH, termWidth - 10);
+        for (let hi = 0; hi < wrappedH.length; hi++) {
+          if (hi === 0) {
+            rows.push(`    ${C.sakura}•${C.reset} ${C.white}${wrappedH[hi]}${C.reset}`);
+          } else {
+            rows.push(`      ${C.slate}${wrappedH[hi]}${C.reset}`);
+          }
+        }
+      }
+    }
+
+    if (i < items.length - 1) {
+      rows.push('');
+    }
+  }
+
+  return rows;
+}
+
+
+export function formatDebateMatrix(debateResult, width = getFullWidth()) {
+  const termWidth = Math.max(40, width);
+  const rows = [];
+  const r = debateResult || {};
+
+  rows.push(`${C.bold}${C.sakura}◆ MULTI-AGENT ADVERSARIAL DEBATE MATRIX${C.reset}`);
+  rows.push(`${C.slate}${'═'.repeat(Math.min(termWidth - 2, 70))}${C.reset}`);
+  rows.push(`${C.bold}${C.gold}Topic / Claim:${C.reset} ${C.white}${r.topic || 'N/A'}${C.reset}`);
+  rows.push('');
+
+  rows.push(`${C.bold}${C.emerald}┌── ADVOCATE (Corroborating Primary Evidence) ────────────────────┐${C.reset}`);
+  const advLines = formatMarkdownLines(r.advocate || 'No evidence provided.', termWidth - 8);
+  for (const al of advLines) {
+    rows.push(`  ${C.slate}│${C.reset} ${al}`);
+  }
+  rows.push(`${C.bold}${C.emerald}└──${'─'.repeat(Math.min(termWidth - 6, 62))}┘${C.reset}`);
+  rows.push('');
+
+  rows.push(`${C.bold}${C.roseGlow}┌── CRITIC (Counter-Evidence & Skeptic Findings) ─────────────────┐${C.reset}`);
+  const critLines = formatMarkdownLines(r.critic || 'No counter-evidence provided.', termWidth - 8);
+  for (const cl of critLines) {
+    rows.push(`  ${C.slate}│${C.reset} ${cl}`);
+  }
+  rows.push(`${C.bold}${C.roseGlow}└──${'─'.repeat(Math.min(termWidth - 6, 62))}┘${C.reset}`);
+  rows.push('');
+
+  rows.push(`${C.bold}${C.cyberCyan}┌── NEUTRAL JUDGE SYNTHESIS & VERDICT ────────────────────────────┐${C.reset}`);
+  const judgeLines = formatMarkdownLines(r.verdict || 'Synthesis unavailable.', termWidth - 8);
+  for (const jl of judgeLines) {
+    rows.push(`  ${C.slate}│${C.reset} ${jl}`);
+  }
+  rows.push(`${C.bold}${C.cyberCyan}└──${'─'.repeat(Math.min(termWidth - 6, 62))}┘${C.reset}`);
+
+  return rows;
+}
+
+export function getCategoryBadge(category = '') {
+  const norm = String(category || '').trim().toUpperCase();
+  switch (norm) {
+    case 'DRAMA':
+      return { icon: '🌸', label: 'DRAMA', color: C.lavender, bg: '\x1b[48;2;48;32;72m' };
+    case 'MUSIC':
+      return { icon: '🎵', label: 'MUSIC', color: C.sakura, bg: '\x1b[48;2;72;32;56m' };
+    case 'FASHION':
+      return { icon: '✨', label: 'FASHION', color: C.cyberCyan, bg: '\x1b[48;2;24;48;64m' };
+    case 'MILESTONE':
+    case 'AWARDS':
+      return { icon: '🌸', label: 'AWARDS', color: C.gold, bg: '\x1b[48;2;64;52;24m' };
+    case 'ANALYSIS':
+      return { icon: '📖', label: 'ANALYSIS', color: C.emerald, bg: '\x1b[48;2;24;56;36m' };
+    case 'TRIVIA':
+      return { icon: '💬', label: 'TRIVIA', color: C.amber, bg: '\x1b[48;2;64;40;20m' };
+    default:
+      return { icon: '✨', label: norm || 'TOPIC', color: C.white, bg: '\x1b[48;2;40;40;48m' };
+  }
+}
+
+export function formatWorkerProgressMatrix({ workers = [], batchId = '', elapsed = '0.0', termWidth = getFullWidth() } = {}) {
+  const rows = [];
+  const headerBg = isColorDisabled() ? '' : '\x1b[48;2;65;20;42m';
+  const headerFg = isColorDisabled() ? '' : '\x1b[38;2;255;220;235m';
+
+  rows.push(`  ${headerBg}${headerFg}${C.bold}  🌸 CONCURRENT RESEARCH SUBAGENTS [${workers.length} Workers • ${elapsed}s]  ${C.reset}`);
+  rows.push('');
+
+  for (const w of workers) {
+    const badge = getCategoryBadge(w.category);
+    let statePill = '';
+    let stateText = 'Working';
+    if (w.state === 'complete' || w.state === 'done') {
+      stateText = 'Done';
+      statePill = isColorDisabled() ? '[Done]' : '\x1b[48;2;20;65;35m\x1b[38;2;80;240;140m\x1b[1m  Done  \x1b[0m';
+    } else if (w.state === 'error' || w.state === 'failed') {
+      stateText = 'Error';
+      statePill = isColorDisabled() ? '[Error]' : '\x1b[48;2;70;20;25m\x1b[38;2;255;120;120m\x1b[1m  Error  \x1b[0m';
+    } else {
+      stateText = 'Working';
+      statePill = isColorDisabled() ? '[Working]' : '\x1b[48;2;20;45;65m\x1b[38;2;80;210;255m\x1b[1m Working \x1b[0m';
+    }
+
+    const catPill = isColorDisabled()
+      ? `[${badge.icon} ${badge.label}]`
+      : `${badge.bg}${badge.color}${C.bold} ${badge.icon} ${badge.label} ${C.reset}`;
+    const toolLabel = w.currentTool ? `> ${w.currentTool}` : (w.statusMessage || w.question || '');
+    const cleanTool = stripAnsi(toolLabel).slice(0, 32);
+
+    rows.push(`  ${statePill}  ${C.bold}W${w.index || 1} [${badge.icon} ${badge.label}]${C.reset}  ${C.white}${cleanTool}${C.reset}  ${C.dim}${stateText}${C.reset}`);
+  }
+
+  rows.push('');
+  return rows;
+}
+
+export function formatExecutiveFindings({ batchResult, termWidth = getFullWidth() } = {}) {
+  const width = Math.max(50, termWidth - 4);
+  const rows = [];
+  const results = batchResult?.results || [];
+  const total = batchResult?.tasksCount || results.length;
+  const succeeded = batchResult?.successfulCount ?? results.filter(r => Boolean(r.answer)).length;
+  const elapsed = batchResult?.elapsed || '0.0';
+
+  const headerBg = isColorDisabled() ? '' : '\x1b[48;2;65;20;42m';
+  const headerFg = isColorDisabled() ? '' : '\x1b[38;2;255;220;235m';
+
+  rows.push('');
+  rows.push(`  ${headerBg}${headerFg}${C.bold}  🌸 KIKU EXECUTIVE RESEARCH FINDINGS [${succeeded}/${total} Succeeded • ${elapsed}s]  ${C.reset}`);
+  rows.push('');
+
+  for (const r of results) {
+    const badge = getCategoryBadge(r.category);
+    const catPill = isColorDisabled()
+      ? `[${badge.icon} ${badge.label}]`
+      : `${badge.bg}${badge.color}${C.bold} ${badge.icon} ${badge.label} ${C.reset}`;
+    const workerTag = isColorDisabled()
+      ? `[Worker ${r.index || 1}]`
+      : `\x1b[48;2;38;30;46m\x1b[38;2;220;200;240m [Worker ${r.index || 1}] \x1b[0m`;
+
+    rows.push(`  ${workerTag} ${catPill} ${C.bold}${C.white}[Worker ${r.index || 1}] ${badge.label}: ${r.question}${C.reset}`);
+
+    if (r.answer) {
+      const formattedLines = formatMarkdownLines(r.answer, width - 8);
+      for (const line of formattedLines) {
+        rows.push(`    ${line}`);
+      }
+      if (r.toolCalls?.length > 0) {
+        const evidencePill = isColorDisabled()
+          ? '📖 Grounded Evidence:'
+          : '\x1b[48;2;22;42;30m\x1b[38;2;120;230;160m 📖 Grounded Evidence \x1b[0m';
+        rows.push(`    ${evidencePill} ${C.dim}Grounded Evidence: ${r.toolCalls.length} tool calls executed successfully.${C.reset}`);
+      }
+    } else {
+      const errorPill = isColorDisabled()
+        ? '[x] Research failed:'
+        : '\x1b[48;2;60;18;22m\x1b[38;2;255;120;120m [x] Research failed \x1b[0m';
+      rows.push(`    ${errorPill} ${C.red}${r.error || 'No answer generated'}${C.reset}`);
+    }
+
+    rows.push('');
+  }
+
+  rows.push(`  ${C.dim}Tips: Use /sources to review citations • Type /session export to save report as markdown/HTML${C.reset}`);
+  return rows;
+}
+
 export { _rawStdoutWrite as rawWrite, _rawConsoleLog as rawLog };
+