feat (编辑器)：优化表格布局与会话管理，升级单元格缩放能力

· 新增会话历史追踪能力，提供SessionHistoryList组件与sessionService会话服务
· 优化列宽缩放逻辑：增加节流处理，依托tableUtils实现基于百分比的宽度归一化
· 新增tableUtils工具模块，提供宽度单位换算（百分比 ↔ 磅值）、百分比归一化工具方法
· 增强表格区块（TableBlock）功能：支持缩放实时视觉反馈、优化边界约束处理，新增ResizeState.currentSize尺寸跟踪
· 修复画布区块（BlockCanvas）与表格区块布局溢出问题，通过最大宽度、隐藏溢出约束实现管控
· 优化消息条目（MessageItem）文档预览逻辑，关联会话 ID，支持多文档会话场景
· 更新类型定义、区块操作与服务层，支撑基于会话的文档管理体系
· 重构表格单元格样式，在缩放操作过程中持续保持列宽约束

src/components/ChatPanel/MessageItem.tsx

@@ -142,14 +142,12 @@ const MessageItem: React.FC<MessageItemProps> = memo(
     /**
      * Handle preview document click
      * 
-     * This function ensures the document exists in the document management
-     * system before opening the editor. It implements smart deduplication:
-     * 
-     * Steps:
-     * 1. Check localStorage cache for existing documentId
-     * 2. If cached, verify document still exists
-     * 3. If not cached or deleted, create new document via POST
-     * 4. Cache the documentId and open editor
+     * 点击预览文档时的处理逻辑:
+     * 1. 检查本地缓存是否已有该导出记录对应的 documentId
+     * 2. 如果有缓存且文档仍然存在,直接使用
+     * 3. 如果没有缓存或文档已被删除,调用 POST /api/v1/documents 创建新文档
+     * 4. 创建文档时传递 sessionId,确保同一会话中的多个文档共用相同的 sessionId
+     * 5. 缓存 documentId 并打开编辑器
      */
     const handlePreviewClick = useCallback(async () => {
       if (!exportRecord || !onPreviewDocument || isCreatingDocument) return;
@@ -174,7 +172,8 @@ const MessageItem: React.FC<MessageItemProps> = memo(
             // Document no longer exists, clear cache and create new
             localStorage.removeItem(cacheKey);
             
-            // Create new document
+            // Create new document with sessionId
+            // 重要: 传递 sessionId 确保文档关联到当前会话
             const response = await createDocument({
               userId: 'default-user', // TODO: Get from auth context
               fileUrl: exportRecord.downloadUrl,
@@ -185,7 +184,9 @@ const MessageItem: React.FC<MessageItemProps> = memo(
             localStorage.setItem(cacheKey, documentId);
           }
         } else {
-          // Step 3: No cache, create new document
+          // Step 3: No cache, create new document with sessionId
+          // 重要: 每次生成新文档都会调用此API,传递相同的sessionId
+          // 这样在数据库中就会有多条记录,id不同但session_id相同
           const response = await createDocument({
             userId: 'default-user', // TODO: Get from auth context
             fileUrl: exportRecord.downloadUrl,

src/components/Editor/BlockCanvas.css

@@ -10,6 +10,7 @@
   background-color: #ffffff;
   min-height: 0; /* 修复flex子元素滚动问题 */
   height: 100%;
+  max-width: 100%;
 }
 
 /* 空状态 */
@@ -26,6 +27,8 @@
 .block-canvas .block-wrapper {
   margin-bottom: 16px;
   position: relative;
+  max-width: 100%;
+  overflow: hidden;
 }
 
 /* 滚动条样式 - Word风格 */

src/components/Editor/blocks/TableBlock.css

@@ -4,16 +4,18 @@
 
 .table-block-wrapper {
   margin-bottom: 16px;
+  overflow: hidden;
 }
 
 .table-container {
-  overflow-x: auto;
+  overflow: hidden;
   margin: 8px 0;
 }
 
 .table-block {
   border-collapse: collapse;
   width: 100%;
+  max-width: 100%;
   background-color: #ffffff;
 }
 

src/components/Editor/blocks/TableBlock.tsx

@@ -9,6 +9,7 @@ import type { TableBlock as TableBlockType, TableCell as TableCellType } from '.
 import { useEditorStore } from '../../../stores/editorStore';
 import { TableCell } from './TableCell';
 import { TableToolbar } from './TableToolbar';
+import { percentToPtWidths, ptToPercentWidths, pixelToPt, normalizePercents } from '../../../utils/tableUtils';
 import './TableBlock.css';
 
 // ══════════════════════════════════════════════════════════════════════════════
@@ -20,6 +21,7 @@ interface ResizeState {
   index: number;
   startPos: number;
   startSize: number;
+  currentSize?: number; // 当前尺寸(用于实时显示)
 }
 
 export interface TableBlockProps {
@@ -56,6 +58,9 @@ export const TableBlock: React.FC<TableBlockProps> = ({
   // 防抖计时器
   const saveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const lastContentRef = useRef<string>(JSON.stringify(block.content));
+  
+  // 节流标记 - 用于优化拖动性能
+  const updateThrottleRef = useRef<boolean>(false);
 
   // 处理单元格内容变更
   const handleCellChange = useCallback(
@@ -163,54 +168,97 @@ export const TableBlock: React.FC<TableBlockProps> = ({
     });
   }, [block.content.rows, readOnly]);
 
-  // 处理拖动
+  // 处理拖动 - 优化版本,使用节流和实时反馈
   const handleMouseMove = useCallback((e: MouseEvent) => {
     if (!resizeState || !tableRef.current) return;
 
-    if (resizeState.type === 'column') {
-      // 调整列宽
-      const deltaX = e.clientX - resizeState.startPos;
-      const tableWidth = tableRef.current.offsetWidth;
-      const deltaPercent = (deltaX / tableWidth) * 100;
-      
-      const newColWidths = [...block.metadata.col_widths];
-      const newWidth = Math.max(5, resizeState.startSize + deltaPercent); // 最小5%
+    // 节流处理 - 每16ms更新一次(约60fps)
+    if (updateThrottleRef.current) return;
+    updateThrottleRef.current = true;
+    
+    requestAnimationFrame(() => {
+      updateThrottleRef.current = false;
       
-      // 如果有下一列，调整下一列宽度以保持总宽度不变
-      if (resizeState.index < newColWidths.length - 1) {
-        const nextColWidth = newColWidths[resizeState.index + 1];
-        const widthDiff = newWidth - resizeState.startSize;
-        const newNextWidth = Math.max(5, nextColWidth - widthDiff);
+      if (!resizeState || !tableRef.current) return;
+
+      if (resizeState.type === 'column') {
+        // 调整列宽 - 基于百分比
+        const deltaX = e.clientX - resizeState.startPos;
+        const tableWidth = tableRef.current.offsetWidth;
+        const deltaPercent = (deltaX / tableWidth) * 100;
+        
+        const newColWidths = [...block.metadata.col_widths];
+        let newWidth = resizeState.startSize + deltaPercent;
+        
+        // 如果有下一列，调整下一列宽度以保持总宽度不变
+        if (resizeState.index < newColWidths.length - 1) {
+          const nextColWidth = newColWidths[resizeState.index + 1];
+          const widthDiff = newWidth - resizeState.startSize;
+          const newNextWidth = nextColWidth - widthDiff;
+          
+          // 确保两列都满足最小宽度5%
+          if (newWidth < 5) {
+            newWidth = 5;
+          } else if (newNextWidth < 5) {
+            newWidth = resizeState.startSize + (nextColWidth - 5);
+          }
+          
+          newColWidths[resizeState.index] = newWidth;
+          newColWidths[resizeState.index + 1] = nextColWidth - (newWidth - resizeState.startSize);
+        } else {
+          // 最后一列，直接调整
+          newColWidths[resizeState.index] = Math.max(5, newWidth);
+        }
+        
+        // 归一化百分比，确保总和为100%
+        const normalizedWidths = normalizePercents(newColWidths);
+        
+        // 同步更新content.col_widths (pt单位)
+        const newColWidthsPt = percentToPtWidths(
+          normalizedWidths,
+          block.metadata.table_width
+        );
+        
+        // 更新状态以显示当前尺寸
+        setResizeState({
+          ...resizeState,
+          currentSize: Math.round(newColWidthsPt[resizeState.index] * 10) / 10,
+        });
+        
+        updateBlock(block.id, {
+          metadata: {
+            ...block.metadata,
+            col_widths: normalizedWidths,
+          },
+          content: {
+            ...block.content,
+            col_widths: newColWidthsPt,
+          },
+        });
+      } else if (resizeState.type === 'row') {
+        // 调整行高 - 使用精确的像素到pt转换
+        const deltaY = e.clientY - resizeState.startPos;
+        const deltaPt = pixelToPt(deltaY);
+        const newHeight = Math.max(15, resizeState.startSize + deltaPt); // 最小15pt
+        const roundedHeight = Math.round(newHeight * 10) / 10; // 保留1位小数
+        
+        // 更新状态以显示当前尺寸
+        setResizeState({
+          ...resizeState,
+          currentSize: roundedHeight,
+        });
         
-        newColWidths[resizeState.index] = newWidth;
-        newColWidths[resizeState.index + 1] = newNextWidth;
-      } else {
-        newColWidths[resizeState.index] = newWidth;
+        const newRows = block.content.rows.map((row, idx) => {
+          if (idx !== resizeState.index) return row;
+          return { ...row, height: roundedHeight };
+        });
+        
+        updateBlock(block.id, {
+          content: { ...block.content, rows: newRows },
+        });
       }
-      
-      updateBlock(block.id, {
-        metadata: {
-          ...block.metadata,
-          col_widths: newColWidths,
-        },
-      });
-    } else if (resizeState.type === 'row') {
-      // 调整行高
-      const deltaY = e.clientY - resizeState.startPos;
-      // 每像素约等于0.75pt
-      const deltaPt = deltaY * 0.75;
-      const newHeight = Math.max(15, resizeState.startSize + deltaPt); // 最小15pt
-      
-      const newRows = block.content.rows.map((row, idx) => {
-        if (idx !== resizeState.index) return row;
-        return { ...row, height: newHeight };
-      });
-      
-      updateBlock(block.id, {
-        content: { rows: newRows },
-      });
-    }
-  }, [resizeState, block.id, block.metadata, block.content.rows, updateBlock]);
+    });
+  }, [resizeState, block.id, block.metadata, block.content, updateBlock]);
 
   // 结束拖动
   const handleMouseUp = useCallback(() => {
@@ -250,8 +298,18 @@ export const TableBlock: React.FC<TableBlockProps> = ({
       ? `${tableWidth}cm`
       : `${tableWidth}in`;
 
-  // 计算列宽
+  // 计算列宽 - 使用metadata中的百分比
   const colWidths = block.metadata.col_widths;
+  
+  // 如果没有metadata.col_widths，从content.col_widths推算百分比
+  const effectiveColWidths = colWidths && colWidths.length > 0 
+    ? colWidths 
+    : block.content.col_widths 
+      ? (() => {
+          const totalPt = block.content.col_widths.reduce((sum: number, w: number) => sum + w, 0);
+          return block.content.col_widths.map((w: number) => (w / totalPt) * 100);
+        })()
+      : [];
 
   return (
     <div className="table-block-wrapper" data-block-id={block.id}>
@@ -268,6 +326,30 @@ export const TableBlock: React.FC<TableBlockProps> = ({
         />
       )}
 
+      {/* 拖动尺寸提示 */}
+      {resizeState && resizeState.currentSize && (
+        <div 
+          className="resize-tooltip"
+          style={{
+            position: 'fixed',
+            left: resizeState.type === 'column' ? `${resizeState.startPos + 10}px` : '50%',
+            top: resizeState.type === 'row' ? `${resizeState.startPos + 10}px` : '50%',
+            transform: 'translate(-50%, -50%)',
+            background: 'rgba(0, 0, 0, 0.75)',
+            color: 'white',
+            padding: '4px 8px',
+            borderRadius: '4px',
+            fontSize: '12px',
+            pointerEvents: 'none',
+            zIndex: 1000,
+          }}
+        >
+          {resizeState.type === 'column' 
+            ? `宽度: ${resizeState.currentSize}pt` 
+            : `高度: ${resizeState.currentSize}pt`}
+        </div>
+      )}
+
       {/* 表格 */}
       <div className="table-container">
         <table
@@ -279,7 +361,7 @@ export const TableBlock: React.FC<TableBlockProps> = ({
           }}
         >
           <colgroup>
-            {colWidths.map((width, index) => (
+            {effectiveColWidths.map((width, index) => (
               <col key={index} style={{ width: `${width}%` }} />
             ))}
           </colgroup>
@@ -313,7 +395,7 @@ export const TableBlock: React.FC<TableBlockProps> = ({
                       }
                       onChange={handleCellChange}
                       onClick={handleCellClick}
-                      onColumnResize={colIndex < colWidths.length - 1 ? handleColumnResizeStart : undefined}
+                      onColumnResize={colIndex < effectiveColWidths.length - 1 ? handleColumnResizeStart : undefined}
                       onRowResize={rowIndex < block.content.rows.length - 1 ? handleRowResizeStart : undefined}
                     />
                   );

src/components/Editor/blocks/TableCell.css

@@ -34,21 +34,21 @@
 .resize-handle {
   position: absolute;
   background-color: transparent;
-  transition: background-color 0.15s ease;
+  transition: background-color 0.15s ease, opacity 0.15s ease;
   z-index: 10;
   opacity: 0;
 }
 
 /* 鼠标悬停在单元格上时显示手柄 */
 .table-cell:hover .resize-handle {
-  opacity: 1;
+  opacity: 0.6;
 }
 
 /* 拖动时手柄高亮 */
 .resize-handle:active,
 .resize-handle:hover {
-  background-color: rgba(24, 144, 255, 0.5);
-  opacity: 1;
+  background-color: rgba(24, 144, 255, 0.3);
+  opacity: 1 !important;
 }
 
 /* 列宽调整手柄 - 右边界 */
@@ -58,6 +58,7 @@
   width: 8px;
   height: 100%;
   cursor: col-resize;
+  user-select: none;
 }
 
 .resize-handle-column::before {
@@ -67,14 +68,16 @@
   left: 50%;
   transform: translate(-50%, -50%);
   width: 2px;
-  height: 60%;
-  background-color: rgba(24, 144, 255, 0.6);
+  height: 70%;
+  background-color: rgba(24, 144, 255, 0.8);
   border-radius: 1px;
   opacity: 0;
   transition: opacity 0.15s ease;
+  pointer-events: none;
 }
 
 .resize-handle-column:hover::before,
+.resize-handle-column:active::before,
 .table-cell:hover .resize-handle-column::before {
   opacity: 1;
 }
@@ -86,6 +89,7 @@
   width: 100%;
   height: 8px;
   cursor: row-resize;
+  user-select: none;
 }
 
 .resize-handle-row::before {
@@ -94,15 +98,17 @@
   top: 50%;
   left: 50%;
   transform: translate(-50%, -50%);
-  width: 60%;
+  width: 70%;
   height: 2px;
-  background-color: rgba(24, 144, 255, 0.6);
+  background-color: rgba(24, 144, 255, 0.8);
   border-radius: 1px;
   opacity: 0;
   transition: opacity 0.15s ease;
+  pointer-events: none;
 }
 
 .resize-handle-row:hover::before,
+.resize-handle-row:active::before,
 .table-cell:hover .resize-handle-row::before {
   opacity: 1;
 }
@@ -114,19 +120,34 @@
   width: 12px;
   height: 12px;
   cursor: nwse-resize;
-  background-color: rgba(24, 144, 255, 0.3);
-  border: 1px solid rgba(24, 144, 255, 0.5);
+  background-color: rgba(24, 144, 255, 0.2);
+  border: 1px solid rgba(24, 144, 255, 0.6);
   border-radius: 2px;
   opacity: 0;
+  transition: opacity 0.15s ease, background-color 0.15s ease;
 }
 
 .resize-handle-corner:hover,
+.resize-handle-corner:active,
 .table-cell:hover .resize-handle-corner {
-  background-color: rgba(24, 144, 255, 0.6);
-  border-color: rgba(24, 144, 255, 0.8);
+  background-color: rgba(24, 144, 255, 0.5);
+  border-color: rgba(24, 144, 255, 0.9);
   opacity: 1;
 }
 
+/* 角落手柄图标 */
+.resize-handle-corner::after {
+  content: '';
+  position: absolute;
+  right: 2px;
+  bottom: 2px;
+  width: 0;
+  height: 0;
+  border-style: solid;
+  border-width: 0 0 6px 6px;
+  border-color: transparent transparent rgba(24, 144, 255, 0.8) transparent;
+}
+
 /* 只读模式下完全隐藏调整手柄 */
 .table-cell[readonly] .resize-handle {
   display: none;

src/components/Editor/blocks/TableCell.tsx

@@ -66,6 +66,11 @@ export const TableCell: React.FC<TableCellProps> = ({
 
   // 解析样式
   const cellStyle = cellStyleToCSS(cell.style);
+  
+  // 如果单元格有明确的宽度(pt单位),添加到样式中
+  if (cell.width && cell.width > 0) {
+    cellStyle.width = `${cell.width}pt`;
+  }
 
   // 提取字体相关属性
   // 优先级：cell.style > 默认值（12pt）
@@ -118,12 +123,12 @@ export const TableCell: React.FC<TableCellProps> = ({
           fontSize: `${fontSize}pt`,
           fontFamily: fontFamily,
           lineHeight: 1.5,
-          textAlign: 'center', // 强制居中对齐
+          textAlign: cellStyle.textAlign || 'center',
         }}
       />
       
-      {/* 列宽调整手柄 */}
-      {!readOnly && onColumnResize && (
+      {/* 列宽调整手柄 - 只在非合并列的最后一个单元格显示 */}
+      {!readOnly && onColumnResize && cell.colspan === 1 && (
         <div
           className="resize-handle resize-handle-column"
           onMouseDown={handleColumnResizeMouseDown}
@@ -131,8 +136,8 @@ export const TableCell: React.FC<TableCellProps> = ({
         />
       )}
       
-      {/* 行高调整手柄 */}
-      {!readOnly && onRowResize && (
+      {/* 行高调整手柄 - 只在非合并行的最后一个单元格显示 */}
+      {!readOnly && onRowResize && cell.rowspan === 1 && (
         <div
           className="resize-handle resize-handle-row"
           onMouseDown={handleRowResizeMouseDown}
@@ -140,12 +145,12 @@ export const TableCell: React.FC<TableCellProps> = ({
         />
       )}
       
-      {/* 角落调整手柄(同时调整行高和列宽) */}
-      {!readOnly && onColumnResize && onRowResize && (
+      {/* 角落调整手柄(同时调整行高和列宽) - 只在普通单元格显示 */}
+      {!readOnly && onColumnResize && onRowResize && cell.rowspan === 1 && cell.colspan === 1 && (
         <div
           className="resize-handle resize-handle-corner"
           onMouseDown={(e) => {
-            // 同时触发两个方向的调整
+            // 优先触发列宽调整
             handleColumnResizeMouseDown(e);
           }}
           title="拖动调整尺寸"

src/components/SessionList/SessionHistoryList.tsx

@@ -0,0 +1,167 @@
+/**
+ * SessionHistoryList.tsx - 会话历史列表组件
+ * 
+ * 显示用户的会话历史，支持删除操作
+ */
+
+import React, { useEffect, useState } from 'react';
+import { Button, List, Modal, message, Spin, Typography, Tag } from 'antd';
+import { DeleteOutlined, ExclamationCircleOutlined, FileTextOutlined } from '@ant-design/icons';
+import {
+  getSessionList,
+  deleteSessionHistory,
+  formatSessionTime,
+} from '../../services/sessionService';
+
+const { Title, Text } = Typography;
+const { confirm } = Modal;
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Types
+// ══════════════════════════════════════════════════════════════════════════════
+
+interface Session {
+  sessionId: string;
+  documentCount: number;
+  latestDocument?: {
+    id: string;
+    updatedAt: number;
+  };
+}
+
+interface SessionHistoryListProps {
+  userId: string;
+  onSessionSelect?: (sessionId: string) => void;
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Component
+// ══════════════════════════════════════════════════════════════════════════════
+
+export const SessionHistoryList: React.FC<SessionHistoryListProps> = ({
+  userId,
+  onSessionSelect,
+}) => {
+  const [sessions, setSessions] = useState<Session[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [deleting, setDeleting] = useState<string | null>(null);
+
+  // 加载会话列表
+  const loadSessions = async () => {
+    setLoading(true);
+    try {
+      const result = await getSessionList(userId);
+      setSessions(result.sessions);
+    } catch (error) {
+      message.error('加载会话列表失败');
+      console.error(error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  // 初始加载
+  useEffect(() => {
+    loadSessions();
+  }, [userId]);
+
+  // 删除会话
+  const handleDeleteSession = (sessionId: string, documentCount: number) => {
+    confirm({
+      title: '确认删除会话历史？',
+      icon: <ExclamationCircleOutlined />,
+      content: `此操作将删除该会话的所有 ${documentCount} 个文档，且不可恢复。确定要继续吗？`,
+      okText: '确认删除',
+      okType: 'danger',
+      cancelText: '取消',
+      async onOk() {
+        setDeleting(sessionId);
+        try {
+          const result = await deleteSessionHistory(sessionId);
+          message.success(
+            `成功删除 ${result.data.deletedCount} 个文档`
+          );
+          // 重新加载列表
+          await loadSessions();
+        } catch (error) {
+          message.error('删除失败');
+          console.error(error);
+        } finally {
+          setDeleting(null);
+        }
+      },
+    });
+  };
+
+  // 渲染会话项
+  const renderSessionItem = (session: Session) => {
+    const isDeleting = deleting === session.sessionId;
+    const lastUpdateTime = session.latestDocument?.updatedAt || 0;
+
+    return (
+      <List.Item
+        actions={[
+          <Button
+            key="delete"
+            type="text"
+            danger
+            icon={<DeleteOutlined />}
+            loading={isDeleting}
+            onClick={(e) => {
+              e.stopPropagation();
+              handleDeleteSession(session.sessionId, session.documentCount);
+            }}
+          >
+            删除
+          </Button>,
+        ]}
+        onClick={() => onSessionSelect?.(session.sessionId)}
+        style={{ cursor: 'pointer' }}
+      >
+        <List.Item.Meta
+          avatar={<FileTextOutlined style={{ fontSize: 24, color: '#1890ff' }} />}
+          title={
+            <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+              <Text strong>{session.sessionId}</Text>
+              <Tag color="blue">{session.documentCount} 个文档</Tag>
+            </div>
+          }
+          description={
+            <Text type="secondary">
+              最后更新: {formatSessionTime(lastUpdateTime)}
+            </Text>
+          }
+        />
+      </List.Item>
+    );
+  };
+
+  return (
+    <div className="session-history-list">
+      <div style={{ marginBottom: 16, display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+        <Title level={4} style={{ margin: 0 }}>会话历史</Title>
+        <Button onClick={loadSessions} loading={loading}>
+          刷新
+        </Button>
+      </div>
+
+      <Spin spinning={loading}>
+        {sessions.length === 0 && !loading ? (
+          <div style={{ textAlign: 'center', padding: '40px 0', color: '#999' }}>
+            <FileTextOutlined style={{ fontSize: 48, marginBottom: 16 }} />
+            <div>暂无会话历史</div>
+          </div>
+        ) : (
+          <List
+            dataSource={sessions}
+            renderItem={renderSessionItem}
+            bordered
+            style={{ background: '#fff' }}
+          />
+        )}
+      </Spin>
+    </div>
+  );
+};
+
+export default SessionHistoryList;

src/components/SessionList/SessionList.tsx

@@ -173,12 +173,25 @@ const SessionList: React.FC<SessionListProps> = ({ onSessionLoad }) => {
   };
 
   /**
-   * Handle deleting a single session
+   * Handle deleting a single session (从后端删除)
    */
-  const handleDeleteSession = (sessionId: string, e: React.MouseEvent) => {
+  const handleDeleteSession = async (sessionId: string, e: React.MouseEvent) => {
     // Stop propagation to prevent loading the session
     e.stopPropagation();
-    deleteSession(sessionId);
+    
+    try {
+      // 从后端删除会话文档
+      const { deleteSessionHistory } = await import('../../services/sessionService');
+      const result = await deleteSessionHistory(sessionId);
+      
+      // 从本地状态删除
+      deleteSession(sessionId);
+      
+      antdMessage.success(`成功删除会话，共删除 ${result.data.deletedCount} 个文档`);
+    } catch (error) {
+      console.error('删除会话失败:', error);
+      antdMessage.error('删除会话失败，请重试');
+    }
   };
 
   /**
@@ -214,24 +227,41 @@ const SessionList: React.FC<SessionListProps> = ({ onSessionLoad }) => {
   };
 
   /**
-   * Batch delete selected sessions
+   * Batch delete selected sessions (从后端删除)
    */
-  const handleBatchDelete = () => {
+  const handleBatchDelete = async () => {
     if (selectedSessionIds.size === 0) {
       antdMessage.warning('请先选择要删除的会话');
       return;
     }
 
-    // Delete all selected sessions
-    selectedSessionIds.forEach(sessionId => {
-      deleteSession(sessionId);
-    });
-
-    // Reset selection state
-    setSelectedSessionIds(new Set());
-    setIsSelectionMode(false);
-    
-    antdMessage.success(`已删除 ${selectedSessionIds.size} 个会话`);
+    try {
+      // 从后端批量删除
+      const { deleteSessions } = await import('../../services/sessionService');
+      const result = await deleteSessions(Array.from(selectedSessionIds));
+      
+      // 从本地状态删除成功的会话
+      selectedSessionIds.forEach(sessionId => {
+        deleteSession(sessionId);
+      });
+
+      // Reset selection state
+      setSelectedSessionIds(new Set());
+      setIsSelectionMode(false);
+      
+      if (result.failedCount > 0) {
+        antdMessage.warning(
+          `删除完成：成功 ${result.successCount} 个，失败 ${result.failedCount} 个`
+        );
+      } else {
+        antdMessage.success(
+          `成功删除 ${result.successCount} 个会话，共删除 ${result.totalDeletedDocuments} 个文档`
+        );
+      }
+    } catch (error) {
+      console.error('批量删除失败:', error);
+      antdMessage.error('批量删除失败，请重试');
+    }
   };
 
   /**
@@ -267,10 +297,11 @@ const SessionList: React.FC<SessionListProps> = ({ onSessionLoad }) => {
               <MessageOutlined />
               <Text type="secondary">{messageCount}</Text>
             </Space>
+            {/* 显示导出文档数量 - 同一会话中可能有多个文档 */}
             {exportCount > 0 && (
               <Space size={4}>
                 <FileTextOutlined />
-                <Text type="secondary">{exportCount}</Text>
+                <Text type="secondary">{exportCount}个文档</Text>
               </Space>
             )}
             <Text type="secondary" style={{ marginLeft: 'auto' }}>
@@ -281,7 +312,7 @@ const SessionList: React.FC<SessionListProps> = ({ onSessionLoad }) => {
         {!isSelectionMode && (
           <Popconfirm
             title="删除会话"
-            description="确定要删除这个会话吗？此操作不可恢复。"
+            description={`确定要删除这个会话吗？会话中的${exportCount}个文档也将被删除，此操作不可恢复。`}
             onConfirm={(e) => handleDeleteSession(session.id, e!)}
             okText="删除"
             cancelText="取消"

src/services/documentService.ts

@@ -148,6 +148,35 @@ export const listDocuments = async (
 };
 
 /**
+ * List documents by session ID
+ *
+ * 根据sessionId查询该会话下的所有文档
+ * 这是一个便捷方法，自动设置sessionId过滤条件
+ *
+ * @param sessionId - Session ID to filter documents
+ * @param userId - User ID (默认为 'default-user')
+ * @param page - Page number (default: 1)
+ * @param pageSize - Items per page (default: 100)
+ * @returns Paginated list of documents for the session
+ * @throws {Error} When the request fails
+ */
+export const listDocumentsBySession = async (
+  sessionId: string,
+  userId: string = 'default-user',
+  page: number = 1,
+  pageSize: number = 100
+): Promise<ListDocumentsResponse> => {
+  return listDocuments({
+    userId,
+    sessionId,
+    page,
+    pageSize,
+    sortBy: 'created_at',
+    sortOrder: 'desc',
+  });
+};
+
+/**
  * Document service object (alternative export pattern)
  * Groups all document operations into a single namespace
  */
@@ -156,6 +185,7 @@ export const documentService = {
   get: getDocument,
   delete: deleteDocuments,
   list: listDocuments,
+  listBySession: listDocumentsBySession,
 };
 
 export default documentService;

src/services/sessionService.ts

@@ -0,0 +1,274 @@
+/**
+ * sessionService.ts - 会话管理服务
+ * 
+ * 提供会话历史的增删改查功能
+ */
+
+import axios from 'axios';
+
+const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8000';
+
+// ══════════════════════════════════════════════════════════════════════════════
+// 类型定义
+// ══════════════════════════════════════════════════════════════════════════════
+
+export interface DeleteSessionResponse {
+  code: number;
+  message: string;
+  data: {
+    deletedCount: number;
+    sessionId: string;
+    message: string;
+  };
+}
+
+export interface SessionDocument {
+  id: string;
+  sessionId: string;
+  userId: string;
+  contentDbPath: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface ListDocumentsResponse {
+  code: number;
+  message: string;
+  data: {
+    documents: SessionDocument[];
+    pagination: {
+      page: number;
+      pageSize: number;
+      total: number;
+      totalPages: number;
+    };
+  };
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// API 调用
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * 删除会话历史（删除指定 session_id 的所有文档）
+ * 
+ * @param sessionId - 会话 ID
+ * @returns 删除结果
+ */
+export async function deleteSessionHistory(
+  sessionId: string
+): Promise<DeleteSessionResponse> {
+  try {
+    const response = await axios.delete<DeleteSessionResponse>(
+      `${API_BASE_URL}/api/v1/documents/${sessionId}`
+    );
+    return response.data;
+  } catch (error) {
+    console.error('删除会话历史失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 获取会话的文档列表
+ * 
+ * @param sessionId - 会话 ID
+ * @param userId - 用户 ID
+ * @param page - 页码
+ * @param pageSize - 每页数量
+ * @returns 文档列表
+ */
+export async function getSessionDocuments(
+  sessionId: string,
+  userId: string,
+  page: number = 1,
+  pageSize: number = 20
+): Promise<ListDocumentsResponse> {
+  try {
+    const response = await axios.get<ListDocumentsResponse>(
+      `${API_BASE_URL}/api/v1/documents`,
+      {
+        params: {
+          userId,
+          sessionId,
+          page,
+          pageSize,
+        },
+      }
+    );
+    return response.data;
+  } catch (error) {
+    console.error('获取会话文档列表失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 获取所有会话列表（分组统计）
+ * 
+ * @param userId - 用户 ID
+ * @returns 会话列表
+ */
+export async function getSessionList(userId: string): Promise<{
+  sessions: Array<{
+    sessionId: string;
+    documentCount: number;
+    latestDocument?: SessionDocument;
+  }>;
+}> {
+  try {
+    // 获取所有文档
+    const response = await axios.get<ListDocumentsResponse>(
+      `${API_BASE_URL}/api/v1/documents`,
+      {
+        params: {
+          userId,
+          page: 1,
+          pageSize: 1000, // 获取所有文档
+        },
+      }
+    );
+
+    // 按 session_id 分组
+    const sessionMap = new Map<
+      string,
+      {
+        sessionId: string;
+        documentCount: number;
+        latestDocument?: SessionDocument;
+      }
+    >();
+
+    response.data.data.documents.forEach((doc) => {
+      const sessionId = doc.sessionId;
+      const session = sessionMap.get(sessionId) || {
+        sessionId,
+        documentCount: 0,
+      };
+
+      session.documentCount++;
+      
+      // 更新最新文档
+      if (
+        !session.latestDocument ||
+        doc.updatedAt > session.latestDocument.updatedAt
+      ) {
+        session.latestDocument = doc;
+      }
+
+      sessionMap.set(sessionId, session);
+    });
+
+    return {
+      sessions: Array.from(sessionMap.values()).sort((a, b) => {
+        // 按最新更新时间降序排序
+        const aTime = a.latestDocument?.updatedAt || 0;
+        const bTime = b.latestDocument?.updatedAt || 0;
+        return bTime - aTime;
+      }),
+    };
+  } catch (error) {
+    console.error('获取会话列表失败:', error);
+    throw error;
+  }
+}
+
+/**
+ * 批量删除多个会话
+ * 
+ * @param sessionIds - 会话 ID 数组
+ * @returns 删除结果
+ */
+export async function deleteSessions(
+  sessionIds: string[]
+): Promise<{
+  successCount: number;
+  failedCount: number;
+  totalDeletedDocuments: number;
+  errors: Array<{ sessionId: string; error: string }>;
+}> {
+  const results = {
+    successCount: 0,
+    failedCount: 0,
+    totalDeletedDocuments: 0,
+    errors: [] as Array<{ sessionId: string; error: string }>,
+  };
+
+  for (const sessionId of sessionIds) {
+    try {
+      const response = await deleteSessionHistory(sessionId);
+      results.successCount++;
+      results.totalDeletedDocuments += response.data.deletedCount;
+    } catch (error) {
+      results.failedCount++;
+      results.errors.push({
+        sessionId,
+        error: error instanceof Error ? error.message : '未知错误',
+      });
+    }
+  }
+
+  return results;
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// React Hooks (可选)
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * 使用会话删除功能的 Hook
+ * 
+ * @returns 删除函数和状态
+ */
+export function useDeleteSession() {
+  const [isDeleting, setIsDeleting] = React.useState(false);
+  const [error, setError] = React.useState<string | null>(null);
+
+  const deleteSession = async (sessionId: string) => {
+    setIsDeleting(true);
+    setError(null);
+
+    try {
+      const result = await deleteSessionHistory(sessionId);
+      return result;
+    } catch (err) {
+      const errorMessage =
+        err instanceof Error ? err.message : '删除会话失败';
+      setError(errorMessage);
+      throw err;
+    } finally {
+      setIsDeleting(false);
+    }
+  };
+
+  return { deleteSession, isDeleting, error };
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// 工具函数
+// ══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * 格式化会话时间
+ * 
+ * @param timestamp - 时间戳（毫秒）
+ * @returns 格式化的时间字符串
+ */
+export function formatSessionTime(timestamp: number): string {
+  const date = new Date(timestamp);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return '刚刚';
+  if (diffMins < 60) return `${diffMins} 分钟前`;
+  if (diffHours < 24) return `${diffHours} 小时前`;
+  if (diffDays < 7) return `${diffDays} 天前`;
+
+  return date.toLocaleDateString('zh-CN');
+}
+
+// 添加 React 导入（如果使用 Hooks）
+import React from 'react';

src/services/workflowService.ts

@@ -26,6 +26,8 @@ interface WorkflowMessage {
  */
 interface WorkflowRequest {
   chatId: string;
+  sessionId?: string; // 新增：显式传递sessionId
+  timestamp?: number; // 新增：时间戳避免缓存
   stream?: boolean;
   detail?: boolean;
   messages: WorkflowMessage[];
@@ -143,14 +145,16 @@ export const shouldTriggerWorkflow = (input: string): boolean => {
  * 3. Calls the local backend API (http://192.168.0.195:8000/api/v1/export/records)
  * 4. Returns the export record with downloadUrl
  *
+ * 重要：工作流会传递session_id给后端，确保同一个会话中生成的多个文档共用同一个session_id
+ *
  * @param userInput - User's text input (e.g., "生成一个地质报告")
- * @param chatId - Chat session ID
+ * @param sessionId - Chat session ID (用于关联多个文档到同一会话)
  * @returns Promise resolving to AI response text and optional export record
  * @throws {Error} When workflow call fails
  */
 export const triggerDocumentWorkflow = async (
   userInput: string,
-  chatId: string
+  sessionId: string
 ): Promise<{ content: string; exportRecord?: ExportRecordInfo }> => {
   try {
     const config = getWorkflowConfig();
@@ -162,7 +166,17 @@ export const triggerDocumentWorkflow = async (
       };
     }
 
+    // ⭐ 重要: 添加时间戳避免工作流缓存
+    // 每次调用都会生成唯一的chatId,但sessionId保持不变
+    // 这样工作流会为每个请求生成新的文档,但它们都关联到同一个sessionId
+    const timestamp = Date.now();
+    const uniqueChatId = `${sessionId}__${timestamp}`;
+
     // Call the workflow API
+    // 关键点:
+    // 1. chatId: 带时间戳的唯一ID,确保每次请求都被视为新请求
+    // 2. sessionId: 原始会话ID,传递给工作流,工作流会将其传递给后端 /api/v1/export/records
+    // 3. 后端在创建文档时会使用这个sessionId,确保同一会话的多个文档共用相同的session_id
     const response = await fetch(config.apiUrl, {
       method: 'POST',
       headers: {
@@ -170,7 +184,9 @@ export const triggerDocumentWorkflow = async (
         Authorization: `Bearer ${config.apiKey}`,
       },
       body: JSON.stringify({
-        chatId,
+        chatId: uniqueChatId, // 带时间戳的唯一ID，避免工作流缓存
+        sessionId: sessionId, // 原始sessionId，供工作流调用后端API时使用
+        timestamp: timestamp, // 显式传递时间戳
         stream: false,
         detail: false,
         messages: [

src/stores/chatStore.ts

@@ -10,6 +10,13 @@
  * - Sending messages to AI using external AI platform API
  * - Auto-generating Word documents for specific requests
  *
+ * ⭐ Session ID 和多文档关联逻辑：
+ * - 每个会话(session)有一个唯一的sessionId（使用UUID v4生成）
+ * - 在一个会话中生成的所有文档都会共用这个sessionId
+ * - 工作流会将sessionId传递给后端，后端在创建document时存储session_id字段
+ * - 通过session_id可以查询该会话下的所有文档
+ * - 删除会话时会删除所有关联的文档
+ *
  * @module stores/chatStore
  */
 
@@ -326,9 +333,43 @@ export const useChatStore = create<ChatStoreState>((set, get) => ({
 
       if (shouldUseWorkflow) {
         // Use workflow for document generation
+        // ⭐ 重要: 传递 sessionId 确保生成的文档与当前会话关联
+        // 在同一个会话中生成多个文档时:
+        // - 每次调用 triggerDocumentWorkflow 都会传递相同的 sessionId
+        // - 工作流会调用后端 /api/v1/export/records,并传递这个 sessionId
+        // - 后端在创建文档时会存储这个 session_id
+        // - 这样在数据库中就会有多条记录,id 不同但 session_id 相同
         const workflowResult = await triggerDocumentWorkflow(content, sessionId);
         aiResponse = workflowResult.content;
         exportRecord = workflowResult.exportRecord;
+        
+        // ⭐ 关键修改: 工作流返回 exportRecord 后,立即调用 POST /api/v1/documents
+        // 这样每次生成文档时都会在数据库中创建记录,而不是等用户点击"预览和编辑"
+        if (exportRecord) {
+          try {
+            // 动态导入 documentService 避免循环依赖
+            const { createDocument } = await import('../services/documentService');
+            
+            // 立即创建文档记录
+            const response = await createDocument({
+              userId: 'default-user', // TODO: 从认证上下文获取
+              fileUrl: exportRecord.downloadUrl,
+              sessionId: sessionId,
+            });
+            
+            // 更新 exportRecord 中的 documentId (用于后续预览)
+            exportRecord.documentId = response.documentId;
+            
+            // 缓存 recordId -> documentId 映射 (避免重复创建)
+            const cacheKey = `doc_cache_${sessionId}_${exportRecord.recordId}`;
+            localStorage.setItem(cacheKey, response.documentId);
+            
+            console.log(`✅ Document created automatically: ${response.documentId} with sessionId: ${sessionId}`);
+          } catch (error) {
+            console.error('❌ Failed to create document record:', error);
+            // 即使创建失败,也继续流程,用户可以稍后点击重试
+          }
+        }
       } else {
         // Use regular AI service for normal chat
         const aiResult = await getAIResponse(content, sessionId, get().messages);

src/types/editor.ts

@@ -132,6 +132,7 @@ export interface TableRow {
  */
 export interface TableContent {
   rows: TableRow[];
+  col_widths?: number[];  // 列宽数组(pt单位),可选
 }
 
 export interface TableBlock extends BaseBlock {

src/utils/blockOperations.ts

@@ -237,7 +237,7 @@ export function normalizeTableBlock(table: TableBlock): TableBlock {
  * 
  * @param colIndex 列索引(从1开始,可选)
  * @param width 单元格宽度(磅,可选)
- * @returns 空单元格
+ * @returns 空单元格，使用默认样式
  */
 export function createEmptyCell(colIndex?: number, width?: number): TableCell {
   return {
@@ -245,9 +245,13 @@ export function createEmptyCell(colIndex?: number, width?: number): TableCell {
     rowspan: 1,
     colspan: 1,
     col_index: colIndex,
-    style: {},
+    style: {
+      align: 'center' as const,      // 默认居中对齐
+      font_size: 12,                  // 默认字号12pt
+      font_name: '黑体',              // 默认字体黑体
+    },
     word_style: 'Normal',
-    width: width,
+    width: width !== undefined ? width : 100, // 默认宽度100磅
   };
 }
 
@@ -284,10 +288,14 @@ export function createEmptyRow(cols: number, colWidths?: number[], height?: numb
  * ```
  */
 export function insertTableRow(table: TableBlock, afterRow: number): TableBlock {
-  // 使用相邻行的高度作为新行的高度
-  const referenceHeight = table.content.rows[afterRow]?.height || 58;
+  // 使用默认行高，不继承上一行的高度
+  const defaultHeight = 58; // 默认行高58磅
+  
+  // 使用默认列宽，不继承表格的列宽
+  const defaultWidth = 100; // 默认列宽100磅
+  const defaultColWidths = Array(table.metadata.cols).fill(defaultWidth);
   
-  const newRow = createEmptyRow(table.metadata.cols, table.metadata.col_widths, referenceHeight);
+  const newRow = createEmptyRow(table.metadata.cols, defaultColWidths, defaultHeight);
   const rows = [...table.content.rows];
   rows.splice(afterRow + 1, 0, newRow);
   
@@ -314,14 +322,15 @@ export function insertTableRow(table: TableBlock, afterRow: number): TableBlock
  * ```
  */
 export function insertTableColumn(table: TableBlock, afterCol: number): TableBlock {
+  // 使用默认宽度，不继承上一列的宽度
+  const defaultWidth = 100; // 默认列宽100磅
+  
   const rows = table.content.rows.map((row) => {
     const cells = [...row.cells];
     
-    // 计算新列的宽度
-    const avgWidth = table.metadata.col_widths.reduce((sum, w) => sum + w, 0) / table.metadata.col_widths.length;
-    
-    // 插入新单元格，并设置正确的 col_index 和 width
-    cells.splice(afterCol + 1, 0, createEmptyCell(afterCol + 2, avgWidth));
+    // 插入新单元格，使用默认宽度和默认样式
+    const newCell = createEmptyCell(afterCol + 2, defaultWidth);
+    cells.splice(afterCol + 1, 0, newCell);
     
     // 更新后续单元格的 col_index
     for (let i = afterCol + 2; i < cells.length; i++) {
@@ -340,8 +349,7 @@ export function insertTableColumn(table: TableBlock, afterCol: number): TableBlo
   });
   
   const colWidths = [...table.metadata.col_widths];
-  const avgWidth = colWidths.reduce((sum, w) => sum + w, 0) / colWidths.length;
-  colWidths.splice(afterCol + 1, 0, avgWidth);
+  colWidths.splice(afterCol + 1, 0, defaultWidth);
   
   return {
     ...table,
@@ -545,6 +553,11 @@ export function mergeCells(
  * 将已合并的单元格拆分回独立单元格
  * 主单元格保留原有内容，其他单元格恢复为空单元格
  * 
+ * 关键逻辑：
+ * 1. 对于横向合并（colspan>1），需要在当前行**插入**新的单元格
+ * 2. 对于纵向合并（rowspan>1），需要恢复被隐藏的单元格（rowspan=0, colspan=0）
+ * 3. 对于同时横向和纵向合并，需要同时处理插入和恢复
+ * 
  * @param table 表格块
  * @param rowIndex 单元格所在行
  * @param colIndex 单元格所在列
@@ -581,39 +594,113 @@ export function splitCell(
   const colspan = targetCell.colspan || 1;
   
   const rows = table.content.rows.map((row, rowIdx) => {
-    // 不在合并范围内的行直接返回
-    if (rowIdx < rowIndex || rowIdx >= rowIndex + rowspan) {
-      return row;
+    const cells = [...row.cells];
+    
+    // 处理主单元格所在的行
+    if (rowIdx === rowIndex) {
+      // 1. 修改主单元格，清除合并标记
+      cells[colIndex] = {
+        ...cells[colIndex],
+        rowspan: 1,
+        colspan: 1,
+        col_index: colIndex + 1,
+        word_style: cells[colIndex].word_style || 'Normal',
+      };
+      
+      // 2. 如果有横向合并（colspan>1），在主单元格后面插入新的空单元格
+      if (colspan > 1) {
+        const newCells: TableCell[] = [];
+        for (let i = 0; i < colspan - 1; i++) {
+          newCells.push({
+            text: '',
+            rowspan: 1,
+            colspan: 1,
+            col_index: colIndex + 2 + i, // col_index从1开始
+            style: {
+              align: 'center' as const,
+              font_size: 12,
+              font_name: '黑体',
+            },
+            word_style: 'Normal',
+            width: cells[colIndex].width || 100,
+          });
+        }
+        // 在主单元格后插入新单元格
+        cells.splice(colIndex + 1, 0, ...newCells);
+        
+        // 更新后续单元格的 col_index
+        for (let i = colIndex + colspan; i < cells.length; i++) {
+          cells[i] = {
+            ...cells[i],
+            col_index: (cells[i].col_index || 0) + (colspan - 1),
+          };
+        }
+      }
+      
+      return { cells, height: row.height };
     }
     
-    const cells = row.cells.map((cell, colIdx) => {
-      // 不在合并范围内的列直接返回
-      if (colIdx < colIndex || colIdx >= colIndex + colspan) {
+    // 处理被纵向合并影响的其他行
+    if (rowIdx > rowIndex && rowIdx < rowIndex + rowspan) {
+      // 查找并恢复被隐藏的单元格
+      let foundHiddenCell = false;
+      const newCells = cells.map((cell, cellIdx) => {
+        // 找到对应列位置的被隐藏单元格
+        if (cellIdx === colIndex && (cell.rowspan === 0 || cell.colspan === 0)) {
+          foundHiddenCell = true;
+          
+          // 恢复为单个正常单元格
+          return {
+            text: '',
+            rowspan: 1,
+            colspan: 1,
+            col_index: colIndex + 1,
+            style: {
+              align: 'center' as const,
+              font_size: 12,
+              font_name: '黑体',
+            },
+            word_style: 'Normal',
+            width: cell.width || 100,
+          } as TableCell;
+        }
         return cell;
-      }
+      });
       
-      // 主单元格：恢复为普通单元格,清除合并标记
-      if (rowIdx === rowIndex && colIdx === colIndex) {
-        return {
-          ...cell,
-          rowspan: 1,
-          colspan: 1,
-          col_index: colIdx + 1, // 确保 col_index 存在
-          word_style: cell.word_style || 'Normal', // 确保 word_style 存在
-        };
+      // 如果主单元格有横向合并，需要插入额外的单元格
+      if (foundHiddenCell && colspan > 1) {
+        const additionalCells: TableCell[] = [];
+        for (let i = 0; i < colspan - 1; i++) {
+          additionalCells.push({
+            text: '',
+            rowspan: 1,
+            colspan: 1,
+            col_index: colIndex + 2 + i,
+            style: {
+              align: 'center' as const,
+              font_size: 12,
+              font_name: '黑体',
+            },
+            word_style: 'Normal',
+            width: newCells[colIndex].width || 100,
+          });
+        }
+        newCells.splice(colIndex + 1, 0, ...additionalCells);
+        
+        // 更新后续单元格的 col_index
+        for (let i = colIndex + colspan; i < newCells.length; i++) {
+          newCells[i] = {
+            ...newCells[i],
+            col_index: (newCells[i].col_index || 0) + (colspan - 1),
+          };
+        }
       }
       
-      // 被合并的单元格：恢复为独立空单元格
-      return createEmptyCell(
-        colIdx + 1, // col_index从1开始
-        cell.width // 保留原有宽度
-      );
-    });
+      return { cells: newCells, height: row.height };
+    }
     
-    return { 
-      cells,
-      height: row.height, // 保留行高
-    };
+    // 其他行不受影响
+    return { cells, height: row.height };
   });
   
   return {

src/utils/tableUtils.ts

@@ -0,0 +1,118 @@
+/**
+ * tableUtils.ts - 表格工具函数
+ * 
+ * 处理表格尺寸计算和转换
+ */
+
+/**
+ * 计算列宽百分比转pt
+ * 
+ * @param percentWidths - 百分比宽度数组
+ * @param tableWidthPercent - 表格宽度百分比(默认100)
+ * @param pageWidthPt - 页面可用宽度(pt单位,默认A4纸宽度减去边距)
+ * @returns pt单位的列宽数组
+ */
+export function percentToPtWidths(
+  percentWidths: number[],
+  tableWidthPercent: number = 100,
+  pageWidthPt: number = 478 // A4纸宽度595pt - 左右边距各71pt ≈ 453pt
+): number[] {
+  const tableActualWidthPt = pageWidthPt * (tableWidthPercent / 100);
+  return percentWidths.map(percent => 
+    Math.round((tableActualWidthPt * percent / 100) * 10) / 10
+  );
+}
+
+/**
+ * 计算列宽pt转百分比
+ * 
+ * @param ptWidths - pt单位的列宽数组
+ * @returns 百分比宽度数组
+ */
+export function ptToPercentWidths(ptWidths: number[]): number[] {
+  const totalPt = ptWidths.reduce((sum, w) => sum + w, 0);
+  if (totalPt === 0) return ptWidths.map(() => 0);
+  
+  const percentWidths = ptWidths.map(w => (w / totalPt) * 100);
+  
+  // 归一化,确保总和为100%
+  const totalPercent = percentWidths.reduce((sum, w) => sum + w, 0);
+  if (Math.abs(totalPercent - 100) > 0.1) {
+    const factor = 100 / totalPercent;
+    return percentWidths.map(w => Math.round(w * factor * 100) / 100);
+  }
+  
+  return percentWidths.map(w => Math.round(w * 100) / 100);
+}
+
+/**
+ * 像素转pt (在96 DPI下)
+ * 
+ * @param pixels - 像素值
+ * @returns pt值
+ */
+export function pixelToPt(pixels: number): number {
+  // 1pt = 4/3 像素 (在96 DPI下)
+  // 1像素 = 3/4 pt = 0.75pt
+  return Math.round(pixels * 0.75 * 10) / 10;
+}
+
+/**
+ * pt转像素 (在96 DPI下)
+ * 
+ * @param pt - pt值
+ * @returns 像素值
+ */
+export function ptToPixel(pt: number): number {
+  // 1pt = 4/3 像素
+  return Math.round(pt * 1.333 * 10) / 10;
+}
+
+/**
+ * 归一化百分比数组,确保总和为100%
+ * 
+ * @param percentWidths - 百分比宽度数组
+ * @returns 归一化后的百分比数组
+ */
+export function normalizePercents(percentWidths: number[]): number[] {
+  const total = percentWidths.reduce((sum, w) => sum + w, 0);
+  if (total === 0) return percentWidths;
+  
+  if (Math.abs(total - 100) < 0.1) {
+    return percentWidths; // 已经接近100%
+  }
+  
+  const factor = 100 / total;
+  return percentWidths.map(w => Math.round(w * factor * 100) / 100);
+}
+
+/**
+ * 验证并修复表格数据的一致性
+ * 
+ * @param content - 表格内容
+ * @param metadata - 表格元数据
+ * @returns 修复后的数据
+ */
+export function validateTableData(
+  content: { rows: any[]; col_widths?: number[] },
+  metadata: { cols: number; col_widths: number[]; table_width: number }
+): {
+  content: { rows: any[]; col_widths?: number[] };
+  metadata: { cols: number; col_widths: number[]; table_width: number };
+} {
+  // 确保metadata.col_widths存在且长度正确
+  if (!metadata.col_widths || metadata.col_widths.length !== metadata.cols) {
+    // 平均分配
+    metadata.col_widths = Array(metadata.cols).fill(100 / metadata.cols);
+  }
+  
+  // 如果content.col_widths不存在,从metadata计算
+  if (!content.col_widths || content.col_widths.length !== metadata.cols) {
+    content.col_widths = percentToPtWidths(
+      metadata.col_widths,
+      metadata.table_width
+    );
+  }
+  
+  return { content, metadata };
+}