修复报价上下文并完善订单节点和异常统计

AGENTS.md

@@ -16,7 +16,7 @@ Use `am.py` for CLI/WSGI, `logistics_chat/` for business code, and `static/css/`
 | Pricing | `logistics_chat/pricing.py`: `RATES`, `calc_freight`; `quote_intent.py`: `parse_intent`; `quote_service.py`: `answer_quote`; `quote_engine.py`: `quantity`, `render_rates`; `quote_answers.py`, `quote_fees.py`: local business terms and fees |
 | US quote data | `logistics_chat/quote_workbook.py`: local detail export; `quote_data.py`: versioned SQLite imports; `quote_engine.py`: matching/calculation; `quote_service.py`: conversational reply; `scripts/import_quote_data.py` |
 | Common customer questions | `logistics_chat/shipping_faq.py`: pre-shipment material; `quote_allocations.py`: per-warehouse weights; `quote_context.py`: chronological edits; `order_explanations.py`: business status, latest actual nodes and operation boundaries |
-| Reply boundaries / list pages | `logistics_chat/customer_faq.py`: supported actions; `quote_scope.py`: US-only fallback; `quote_edits.py`: rejected conditions; `quote_material.py`: partial metal chargeable weight; `order_listing.py`: scoped counts and conversation pages |
+| Reply boundaries / order summaries | `logistics_chat/customer_faq.py`: supported actions; `quote_scope.py`: US-only fallback; `quote_edits.py`: rejected conditions; `quote_material.py`: partial metal chargeable weight; `order_query.py`: bounded filters; `order_listing.py`: scoped five-row summaries and conversation pages; `order_tracking.py`: `current_stage` |
 | Tracking | `logistics_chat/tracking.py`: `extract_tracking_no`, `build_track`, `CARD_PREFIX` |
 | Order test data | `logistics_chat/order_data.py`: `lookup_order`, `count_orders`, `answer_query`, `import_records`; `scripts/import_order_test_data.py` |
 | Persistence | `logistics_chat/db.py`: `init_db`, `save_message`; `logistics_chat/history_service.py` |

docs/architecture.md

@@ -113,7 +113,7 @@ tests/                        # 按业务模块组织的回归
 - `chat_service.create_chat_stream` 的订单查询使用本地 `order_test_data`；忽略附件路径、重量、日期和三维尺寸，保留标识中的后缀，不再调用 `build_track` 生成模拟轨迹。旧模拟函数仅兼容旧导入，不进入聊天查询路径。未知单号、多条匹配和查表失败明确说明，禁止回退模型编造状态。
 - `CARD_PREFIX` 新增 `kind=order`：仅包含白名单概要、申报货物汇总和订单业务状态历史，不包含姓名、地址、内部备注或操作人。`order_tracking.py` 从 `order_test_data.tracking_json` 的已关联事实生成物流轨迹；存在有效事实时设置 `node_kind=logistics`，`nodes` 仅存实际节点，`estimated_nodes` 单独展示预计节点，`tracking_status` 只按实际节点序号推进。相同货柜/节点按最新观测修正时间，预计事实不覆盖实际事实；多柜独立展示。缺失的节点、地点和签收事实不得补造，提柜、还柜不等于签收。子单不继承父单重量或轨迹；COMPLETED 只表示头程订单完成。没有物流事实时继续展示业务状态历史。页面和模型上下文不附加测试副本声明或导入时间。订单及物流追问只在同一 `conv_id` 内复用最近单号，并重新查表取得修改后的值；新报价或其他话题不会沿用旧订单。
 - 订单表不提供管理页面或对外增删改接口；表数据在运行时 SQLite 内维护，导入脚本默认保留已有记录，只有显式 `--replace` 覆盖。匿名 HTTP 查单在读取订单前返回登录引导；`g.customer_tenant_id` 由可信客户认证适配器设置，不接受访客 key、请求参数或客户自报 Header。客户范围非空时必须传给 `lookup_order`，并与 `ORDER_DATA_TENANT_ID` 的额外限制取交集。源库连接凭据和快照在仓库外，业务库只读，不随服务查询访问源库。
-- 登录后的订单数量查询由 `parse_count_query` 识别，`count_orders` 使用与单号查询相同的 `tenant_filter` 交集规则，必须显式提供非空客户范围；SQL 直接计算订单票数和已登记入仓码的订单票数，按需过滤明确的业务状态。无额外筛选时统计授权范围全部订单，不复用上一票单号；无法识别的附加条件不静默丢弃，也不交给模型猜数。成功统计返回的内部 `_customer_data` 标记由 `chat_service` 消费并移除，使纯文本统计同样在保存/发送前绑定会话客户和范围；不增加公开 SSE 字段或管理接口。
+- 登录后的订单数量由 `parse_count_query` / `order_query.parse_query` 识别，汇总、筛选和列表共用 `order_listing.read_orders` 的服务端 `tenant_filter` 交集与同一只读快照；`count_orders` 保留原聚合调用契约。默认给总数、已登记入仓码数及最多5条按来源更新时间排序的摘要；支持业务状态、明确标记的异常和当前实际节点。未指定节点的轨迹统计按订单分组，每票只计一次，多柜不同进度单列，预计节点不推进进度，业务完成不当作签收。未知条件不默认为全部，也不交给模型猜数。内部 `_customer_data` 和 `_order_list_state` 在发送前移除，事实历史绑定客户与范围；无新增公开API。
 - 客户认证使用独立 `customer_users`、`customer_tenant_grants` 与 `customer_sessions` 表，由 `customer_service.attach_customer` 在访客恢复之后验证并设置 `g.customer`、单客户 `g.customer_tenant_id` 或多客户 `g.customer_tenant_ids`；只保存密码哈希与登录 token 哈希。默认账号首次关联当前本地订单的客户范围，之后不自动扩大，普通账号仍按明确关联过滤；`lookup_order` 的单客户参数及多客户白名单都与环境限制取交集。会话的 `customer_scope` 保存范围指纹。登录 Cookie 为 HttpOnly、SameSite=Lax，在 HTTPS 上为 Secure，绑定当前访客并在 8 小时后失效；退出、账号停用、密码或客户范围改变使旧会话失效。默认客户账号不赋予客服后台权限。
 - 匿名查单返回 SSE `login_required` 与正文，客户页提供登录按钮；`customer.js` 登录成功后仅在原会话版本未变化时继续原问题，保留期间输入的新草稿。登录过期导致界面清空时，只允许同一客户重新通过历史归属校验后恢复原会话并续查；换账号、访问范围变化、历史加载失败或切换话题均不重放旧问题。侧栏可独立登录/退出，登录状态在窗口恢复焦点时刷新。首次返回订单卡片时，会话绑定客户 ID 和客户范围；历史、人工会话及后续生成同时校验访客、客户和范围。退出立即清除当前可见订单内容和历史标题缓存，重新登录同一身份可恢复；匿名清空历史不删除被登录保护的会话。
 - 底部及欢迎卡片的查入仓码入口先确认客户登录，再打开 `OrderLookup`，不自动新建会话或发送缺少号码的问题。当前及历史订单卡片的号码也打开该查询框，保留真实的入仓码/订单号标签，支持单独复制和重新查询。提交使用既有 `/stream_chat` 并显示明确的用户问句，结果追加到当前会话；主输入框草稿及已上传附件不清空、不代发。人工接待、未加载历史或其他请求进行中时不抢占路由。切换话题/身份关闭弹窗，迟到的登录/状态/复制结果不得改动新上下文；弹窗跟随手机可视视口并将焦点还给触发按钮。
@@ -149,7 +149,11 @@ tests/                        # 按业务模块组织的回归
 
 `quote_edits.py` 先移除被明确否定的仓码或交货仓，再解析替换条件。共享尺寸解析支持英寸转换和口语长宽高，“一个箱子”可形成单箱条件；总计立方米不作为尺寸单位“米”。
 
-`order_listing.py` 负责列表与下一页/上一页/指定页码，每页20票；从当前会话最近的列表回复恢复页码和业务状态，重新以服务端客户范围查询实际总数和该页数据。COUNT与分页读取处于同一只读事务；无有效列表上下文时要求先列订单，不推测剩余数量。页码有界，筛选及翻页回复与订单事实一样保护历史，不增加公开API或管理入口。
+`order_listing.py` 负责数量摘要、查看全部和翻页。数量摘要最多5票，直接翻页继续每页5票；明确列出订单或“查看全部”按每页20票。`chat_history.order_list_state` 保存筛选、页码、页大小和成功回复的消息ID，绑定客户与范围；只保存仍为最新消息的状态，迟到回复不能覆盖新话题。中间插问同条件总数保留列表页码，改筛选重置，新话题停止沿用。每次重新查询授权数据，不缓存数量；计数及分页来自同一只读快照，无有效上下文先引导查询，页码有界。
+
+`order_test_data.exception_reason` 是人工明确登记、允许客户查看的物流异常原因；非空表示该票有异常标记，空值表示未标记，不推断货物正常。取消、审核驳回和无轨迹均不自动标为物流异常。可直接维护此字段，不增加管理页面；旧快照未提供该字段时即使显式覆盖也保留已有原因，显式提供空字符串才清除。后续MCP适配返回相同事实即可。
+
+共享尺寸解析将单位与长宽高绑定，支持每边单位和混合单位，不受“12英寸显示器”等商品描述影响。报价沿当前会话回溯到最近话题边界，不按10轮截断；其他国家、新一票及订单话题隔离不变。“铁铝部分还是10KG”等口语仅在先前已明确计费重时更新该基数，既不覆盖整票总重，也不把未确认毛重直接当计费重。
 
 已确认海派计费重保留原小数，不向上取整，每箱最低12KG仍生效。原实重小数原样展示；无限小数的材积结果以“约”展示有限位数，金额计算仍使用原Decimal精度，不把显示近似当作计费进位。
 

logistics_chat/chat_service.py

@@ -115,6 +115,7 @@ def create_chat_stream(msg, conv_id):
         order_answer = {'t':'当前报价表未提供该目的地的按方费率，请提供目的仓或邮编、实际重量和尺寸，由人工客服确认报价。'}
     if order_answer is not None:
         customer_data = order_answer.pop('_customer_data',False) or 'card' in order_answer
+        order_list_state=order_answer.pop('_order_list_state',None)
 
         def track_stream():
             if customer_data:
@@ -125,7 +126,10 @@ def create_chat_stream(msg, conv_id):
             save_message(conv_id, 'user', msg)
             content = (CARD_PREFIX + json.dumps(order_answer['card'], ensure_ascii=False)
                        if 'card' in order_answer else order_answer['t'])
-            save_message(conv_id, 'assistant', content)
+            message_id=save_message(conv_id, 'assistant', content)
+            if order_list_state is not None:
+                from .order_listing import save_state
+                save_state(conv_id,order_list_state,message_id)
             yield sse(order_answer)
             yield sse({'d': 1})
         return (track_stream(), {'Cache-Control': 'no-cache', 'X-Accel-Buffering': 'no'})

logistics_chat/db.py

@@ -54,6 +54,8 @@ def init_db():
         cur.execute('ALTER TABLE chat_history ADD COLUMN visitor_id TEXT')
     if 'customer_id' not in cols:
         cur.execute('ALTER TABLE chat_history ADD COLUMN customer_id INTEGER')
+    if 'order_list_state' not in cols:
+        cur.execute('ALTER TABLE chat_history ADD COLUMN order_list_state TEXT')
     if 'customer_scope' not in cols:
         cur.execute('ALTER TABLE chat_history ADD COLUMN customer_scope TEXT')
         if 'customer_tenant_id' in cols:
@@ -232,6 +234,7 @@ def save_message(conv_id, role, content):
     if not inserted:
         conn.close()
         return 'deleted'
+    message_id=cur.lastrowid
     if role == 'user':
         row = cur.execute('SELECT title FROM chat_history WHERE id=?', (conv_id,)).fetchone()
         if row and (not row[0] or row[0] == '新对话'):
@@ -239,6 +242,7 @@ def save_message(conv_id, role, content):
     cur.execute('UPDATE chat_history SET utime=? WHERE id=?', (now_str(), conv_id))
     conn.commit()
     conn.close()
+    return message_id
 
 
 def last_user_question(conv_id):

logistics_chat/order_data.py

@@ -14,7 +14,7 @@ from .customer_service import order_login_response
 FIELDS = ('source_order_id', 'tenant_id', 'order_no', 'inbound_code', 'shipment_id',
           'status', 'country_code', 'transport_mode', 'warehouse_code', 'order_role',
           'parent_order_no', 'package_count', 'gross_weight_kg', 'volume_cbm',
-          'history_json', 'tracking_json', 'data_note', 'source_updated_at', 'snapshot_at')
+          'history_json', 'tracking_json', 'exception_reason', 'data_note', 'source_updated_at', 'snapshot_at')
 STATUS_LABELS = {'DRAFT': '草稿', 'SUBMITTED': '已提交', 'APPROVED': '审核通过',
                  'ACCEPTED': '已接单', 'REJECTED': '审核驳回', 'PROCESSING': '履约中',
                  'COMPLETED': '头程订单已完成', 'CANCELLED': '已取消'}
@@ -23,7 +23,7 @@ FIELD_LABELS = {'inbound':'入仓码', 'number':'订单号', 'shipment':'Shipmen
                 'weight':'申报毛重', 'volume':'申报体积', 'role':'订单层级',
                 'parent':'父订单号', 'updated':'来源更新时间'}
 IDENTIFIER = re.compile(r'(?<![A-Za-z0-9_-])[A-Za-z0-9][A-Za-z0-9_-]{5,63}(?![A-Za-z0-9_-])')
-ORDER_DETAIL = r'状态|进度|轨迹|到哪|开船|到港|清关|提柜|还柜|签收|预计|什么时候|何时|多久|重量|毛重|体积|件数|箱数|目的地|目的国|目的仓|仓库|父订单|运费|费用|价格|几件|几箱|公斤|千克|多少钱'
+ORDER_DETAIL = r'状态|进度|轨迹|异常|到哪|开船|到港|清关|提柜|还柜|签收|预计|什么时候|何时|多久|重量|毛重|体积|件数|箱数|目的地|目的国|目的仓|仓库|父订单|运费|费用|价格|几件|几箱|公斤|千克|多少钱'
 
 
 class OrderDataUnavailable(Exception):
@@ -39,13 +39,15 @@ def init_order_table(connection):
         status TEXT NOT NULL, country_code TEXT, transport_mode TEXT, warehouse_code TEXT,
         order_role TEXT, parent_order_no TEXT,
         package_count INTEGER, gross_weight_kg TEXT, volume_cbm TEXT,
-        history_json TEXT NOT NULL DEFAULT '[]', tracking_json TEXT NOT NULL DEFAULT '[]', data_note TEXT,
+        history_json TEXT NOT NULL DEFAULT '[]', tracking_json TEXT NOT NULL DEFAULT '[]', exception_reason TEXT, data_note TEXT,
         source_updated_at TEXT, snapshot_at TEXT,
         UNIQUE(tenant_id, order_no)
     )''')
     columns = {row[1] for row in connection.execute('PRAGMA table_info(order_test_data)')}
     if 'tracking_json' not in columns:
         connection.execute("ALTER TABLE order_test_data ADD COLUMN tracking_json TEXT NOT NULL DEFAULT '[]'")
+    if 'exception_reason' not in columns:
+        connection.execute('ALTER TABLE order_test_data ADD COLUMN exception_reason TEXT')
     connection.execute('CREATE INDEX IF NOT EXISTS idx_order_test_inbound ON order_test_data(inbound_code)')
     connection.execute('CREATE INDEX IF NOT EXISTS idx_order_test_shipment ON order_test_data(shipment_id)')
 
@@ -62,6 +64,10 @@ def import_records(connection, records, replace=False):
         row['source_order_id'] = str(row['source_order_id']) if row['source_order_id'] is not None else None
         row['order_no'] = str(row['order_no']).strip()
         row['status'] = str(row['status'] or 'DRAFT')
+        if row['exception_reason'] is not None:
+            if not isinstance(row['exception_reason'],str) or len(row['exception_reason'])>2000:
+                raise ValueError('exception_reason must be customer-visible text up to 2000 characters')
+            row['exception_reason']=row['exception_reason'].strip() or None
         history = row['history_json'] or []
         if isinstance(history, str): history = json.loads(history)
         if not isinstance(history, list): raise ValueError('history_json must contain a list')
@@ -78,7 +84,8 @@ def import_records(connection, records, replace=False):
             continue
         columns = ','.join(FIELDS)
         placeholders = ','.join('?' for _ in FIELDS)
-        updates = ','.join(key+'=excluded.'+key for key in FIELDS if key not in ('tenant_id', 'order_no'))
+        updates = ','.join(key+'=excluded.'+key for key in FIELDS if key not in ('tenant_id', 'order_no')
+                          and (key!='exception_reason' or key in source))
         connection.execute(f'INSERT INTO order_test_data ({columns}) VALUES ({placeholders}) '
             f'ON CONFLICT(tenant_id,order_no) DO UPDATE SET {updates}', [row[key] for key in FIELDS])
         inserted += 1
@@ -179,44 +186,14 @@ def count_orders(tenant_ids, status=None):
 
 
 def parse_count_query(message):
-    """Recognize bounded total/status questions without ignoring unknown filters."""
-    if is_lookup_help(message):
-        return None
-    noun = r'订单|运单|入仓码|入仓号|\borders?\b|\bshipments?\b'
-    count = r'多少|几(?:个|票|条|张|笔)|总数|数量|总量|统计|数一下|(?:订单|运单)数(?!量)|\bhow\s+many\b|\bcount\b|\bnumber\b|\btotal\b'
-    if not re.search(noun,message,re.I) or not re.search(count,message,re.I):
-        return None
-    if re.search(r'公斤|千克|\bkg\b|重量|毛重|体积|件数|箱数|运费|费用|价格|多少钱',message,re.I):
-        return None
-    remaining = message
-    statuses = []
-    for phrase, status in (('头程订单已完成','COMPLETED'),('已完成','COMPLETED'),('履约中','PROCESSING'),
-                           ('处理中','PROCESSING'),('已取消','CANCELLED'),('审核通过','APPROVED'),
-                           ('审核驳回','REJECTED'),('已接单','ACCEPTED'),('已提交','SUBMITTED'),('草稿','DRAFT')):
-        if phrase in remaining:
-            statuses.append(status)
-            remaining = remaining.replace(phrase,'')
-    remaining = re.sub(count+'|'+noun,'',remaining,flags=re.I)
-    remaining = re.sub(r'当前账号|当前账户|账号下|账户下|名下|可查询|能查到|可以查到|目前|现在|当前|一共|总共|合计|总计|'
-                       r'请问|麻烦|帮我|想知道|想查|想看|请|查询|查一下|查下|查查|看一下|看看|看下|一下|下|全部|所有|共有|我的|我|能|有|的|个|票|条|张|笔|呢|吗|呀|啊|共|'
-                       r'\b(?:what|is|of|do|i|have|are|there|my|in|all|the|currently)\b|[\s，,。.!！?？、：:]','',remaining,flags=re.I)
-    return {'status':statuses[0] if statuses else None, 'unsupported':bool(remaining or len(set(statuses)) > 1)}
+    if is_lookup_help(message):return None
+    from .order_query import parse_query
+    return parse_query(message)
 
 
-def answer_count_query(intent, tenants):
-    if not tenants:
-        return order_login_response()
-    if intent['unsupported']:
-        return {'t':'暂不支持按这个条件统计。可以查询订单总数，或按草稿、已提交、履约中、已完成、已取消等业务状态统计。'}
-    try:
-        counts = count_orders(tenants,intent['status'])
-    except OrderDataUnavailable:
-        return {'t':'订单信息暂时无法读取，请稍后重试。'}
-    if intent['status']:
-        text = f"您当前有 {counts['total']} 票业务状态为“{STATUS_LABELS[intent['status']]}”的订单"
-    else:
-        text = f"您当前共有 {counts['total']} 票订单"
-    return {'t':text + f"，其中 {counts['with_inbound']} 票已登记入仓码。", '_customer_data':True}
+def answer_count_query(intent, tenants,conv_id=None):
+    from .order_listing import answer_summary
+    return answer_summary(intent,tenants,conv_id)
 
 
 def answer_list_query(message, tenants, conv_id=None):
@@ -233,6 +210,14 @@ def extract_reference(message):
     message = re.sub(r'(?<![A-Za-z0-9_-])\d{4}-\d{1,2}-\d{1,2}'
                      r'(?:[T ]\d{1,2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?'
                      r'(?![A-Za-z0-9_-])', ' ', message)
+    from .pricing import DIMENSION_PATTERNS
+    for pattern in DIMENSION_PATTERNS:
+        def remove_dimensions(match):
+            end=match.start()+len(match[0].rstrip())
+            before=message[match.start()-1:match.start()] if match.start() else ''
+            after=message[end:end+1]
+            return match[0] if re.search(r'[A-Za-z0-9_.-]',before+after) else ' '
+        message=pattern.sub(remove_dimensions,message)
     message = re.sub(r'(?<![A-Za-z0-9_.-])\d+(?:\.\d+)?\s*[*xX×]\s*\d+(?:\.\d+)?\s*[*xX×]\s*\d+(?:\.\d+)?'
                      r'(?:\s*(?:inches|inch|in|cm|mm|m|英寸|厘米|毫米|米|["″]))?(?![A-Za-z0-9_.-])', ' ', message, flags=re.I)
     message = re.sub(r'(?<![A-Za-z0-9_-])\d+(?:\.\d+)?\s*'
@@ -354,7 +339,7 @@ def answer_query(message, conv_id):
         if explanation:return {'t':explanation}
     count_intent = parse_count_query(message) if not references else None
     if count_intent is not None:
-        return answer_count_query(count_intent,tenants)
+        return answer_count_query(count_intent,tenants,conv_id)
     if not references:
         listed=answer_list_query(message,tenants,conv_id)
         if listed is not None:return listed

logistics_chat/order_explanations.py

@@ -6,7 +6,7 @@ import re
 def detail_question(message):
     if re.search(r'报价|运费|海派|海卡|\d+\s*(?:KG|公斤)',message,re.I) and not re.search(r'这票|该订单|我的订单',message):
         return False
-    return bool(re.search(r'上架|没更新|未更新|没有更新|不更新|少了?.*(?:箱|件)|到了?几箱|逐箱|每箱.*签收|'
+    return bool(re.search(r'异常原因|为什么异常|什么异常|上架|没更新|未更新|没有更新|不更新|少了?.*(?:箱|件)|到了?几箱|逐箱|每箱.*签收|'
                           r'已完成.*(?:签收|送达)|(?:签收|送达).*已完成|催单|催一下|拦截|改.*(?:收货|收件).*地址|(?:收货|收件)地址.*改|快递单号|付过款|付款状态|'
                           r'(?:这票|该订单|我的货).*(?:发货|发走|出库|开船)',message))
 
@@ -22,6 +22,9 @@ def explain_order(message,row,card):
     if not detail_question(message):return None
     reference=row.get('inbound_code') or row['order_no']
     lines=[f'入仓码 {reference}。' if row.get('inbound_code') else f'订单号 {reference}。']
+    if re.search(r'异常原因|为什么异常|什么异常',message):
+        reason=(row.get('exception_reason') or '').strip()
+        return lines[0]+('已记录的异常原因：'+reason if reason else '当前未登记异常原因，请联系人工核实。')
     if re.search(r'催单|催一下|拦截',message):
         return lines[0]+'催单或拦截需联系人工客服办理；当前仅查询订单，尚未提交催单或拦截申请。'
     if re.search(r'付过款|付款状态',message):

logistics_chat/order_listing.py

@@ -1,9 +1,13 @@
-"""Bounded conversational pagination over the server-validated customer scope."""
+"""Scoped summaries, five-row previews and durable conversational list pages."""
 
+from collections import Counter,deque
+import json
 import re
 import sqlite3
 
 from .db import connect
+from .order_query import parse_query,filters,STAGE_LABELS
+from .order_tracking import current_stage
 
 
 def page_command(message):
@@ -15,55 +19,156 @@ def page_command(message):
     return None
 
 
-def answer_list(message,tenants,conv_id=None):
-    from .order_data import is_lookup_help,parse_count_query,tenant_filter,STATUS_LABELS
-    from .customer_service import order_login_response
+def valid_filters(query):
+    from .order_data import STATUS_LABELS
+    return (isinstance(query,dict) and set(query)=={'status','stage','exception'}
+            and (query['status'] is None or query['status'] in STATUS_LABELS)
+            and (query['stage'] is None or query['stage'] in STAGE_LABELS)
+            and isinstance(query['exception'],bool))
 
+
+def load_state(conv_id):
+    from .customer_service import current_customer_id,current_scope_key
+    from .visitor_service import visitor_id
+    if not conv_id:return None
+    connection=connect()
+    try:
+        row=connection.execute('SELECT order_list_state FROM chat_history WHERE id=? AND visitor_id=? '
+            'AND customer_id=? AND customer_scope=?',
+            (conv_id,visitor_id(),current_customer_id(),current_scope_key())).fetchone()
+        state=json.loads(row[0]) if row and row[0] else None
+        if not isinstance(state,dict) or not valid_filters(state.get('query')):return None
+        if type(state.get('page')) is not int or not 1<=state['page']<=10000:return None
+        if state.get('size') not in (5,20) or type(state.get('message_id')) is not int:return None
+        for (text,) in connection.execute("SELECT content FROM messages WHERE conv_id=? AND role='user' AND id>? ORDER BY id",
+                                         (conv_id,state['message_id'])):
+            if page_command(text) is None and parse_query(text) is None and text.strip() not in ('查看全部','查看全部订单'):
+                return None
+        return state
+    except (ValueError,TypeError):return None
+    finally:connection.close()
+
+
+def save_state(conv_id,state,message_id):
+    """Called only after the reply and customer binding have been persisted."""
+    from .customer_service import current_customer_id,current_scope_key
+    from .visitor_service import visitor_id
+    if not conv_id or type(message_id) is not int:return
+    connection=connect()
+    try:
+        state=dict(state)
+        state['message_id']=message_id
+        connection.execute('UPDATE chat_history SET order_list_state=? WHERE id=? AND visitor_id=? '
+            'AND customer_id=? AND customer_scope=? '
+            'AND NOT EXISTS(SELECT 1 FROM messages WHERE conv_id=? AND id>?)',
+            (json.dumps(state,ensure_ascii=False),conv_id,visitor_id(),current_customer_id(),current_scope_key(),conv_id,message_id))
+        connection.commit()
+    finally:connection.close()
+
+
+def read_orders(tenants,query,page=1,size=5):
+    """One scoped snapshot; each order occupies one actual-node bucket."""
+    from .order_data import tenant_filter
+    scope=tenant_filter(tenant_ids=tenants)
+    if scope is None or not valid_filters(query):raise ValueError('Explicit customer scope and filters required')
+    connection=connect()
+    try:
+        connection.row_factory=sqlite3.Row
+        where=' WHERE 1=1'+scope[0];values=scope[1]
+        if query['status']:where+=' AND status=?';values=values+[query['status']]
+        connection.execute('BEGIN')
+        rows=connection.execute('SELECT order_no,inbound_code,status,warehouse_code,tracking_json,exception_reason '
+            'FROM order_test_data'+where+' ORDER BY COALESCE(julianday(source_updated_at),julianday(snapshot_at),0) DESC,id DESC',values)
+        total=with_inbound=0;groups=Counter();selected=[];tail=deque(maxlen=size)
+        for row in rows:
+            item=dict(row)
+            item['exception_reason']=(item['exception_reason'] or '').strip()
+            if query['exception'] and not item['exception_reason']:continue
+            item['stage']=current_stage(item.pop('tracking_json'))
+            if query['stage'] and query['stage']!=item['stage']:continue
+            total+=1;with_inbound+=bool((item['inbound_code'] or '').strip());groups[item['stage']]+=1
+            tail.append(item)
+            if (page-1)*size<total<=page*size:selected.append(item)
+        last=max(1,(total+size-1)//size)
+        if page>last:
+            page=last;selected=list(tail)[-(total-(last-1)*size):] if total else []
+        return {'total':total,'with_inbound':with_inbound,'groups':groups,'rows':selected,'page':page}
+    finally:connection.close()
+
+
+def row_text(row):
+    from .order_data import STATUS_LABELS
+    def clean(value):return re.sub(r'[\r\n\t]+',' ',str(value or '未登记'))
+    text=f'- 入仓码：{clean(row["inbound_code"])}；订单号：{clean(row["order_no"])}；业务状态：{STATUS_LABELS.get(row["status"],row["status"])}；目的仓：{clean(row["warehouse_code"])}；当前节点：{STAGE_LABELS[row["stage"]]}'
+    if row['exception_reason']:text+='；异常原因：'+clean(row['exception_reason'])
+    return text
+
+
+def unsupported(listing=False):
+    return {'t':f'暂不支持按这个条件{"列出订单" if listing else "统计"}。可以查询订单总数、业务状态、明确标记的异常，或按当前实际物流节点统计；请一次指定一个节点。'}
+
+
+def answer_summary(intent,tenants,conv_id=None):
+    from .customer_service import order_login_response
+    from .order_data import STATUS_LABELS
+    if not tenants:return order_login_response()
+    if intent['unsupported']:return unsupported()
+    query=filters(intent)
+    try:
+        data=read_orders(tenants,query)
+        total=data['total']
+        if query['stage']:
+            text=f'您当前有 {total} 票当前节点为“{STAGE_LABELS[query["stage"]]}”的订单'
+        elif query['status']:
+            text=f'您当前有 {total} 票业务状态为“{STATUS_LABELS[query["status"]]}”的订单'
+        elif query['exception']:text=f'您当前有 {total} 票明确标记异常的订单'
+        else:text=f'您当前共有 {total} 票订单'
+        if query['exception'] and (query['stage'] or query['status']):text+='（已明确标记异常）'
+        if query['stage'] and query['status']:text+=f'（业务状态：{STATUS_LABELS[query["status"]]}）'
+        lines=[text+f'，其中 {data["with_inbound"]} 票已登记入仓码。']
+        if intent.get('grouped'):
+            lines.append('按当前实际物流节点分布（每票只计一次）：')
+            lines.extend(f'- {label}：{data["groups"][code]}票' for code,label in STAGE_LABELS.items() if data['groups'][code])
+        if data['rows']:
+            lines.append(f'最近更新的{len(data["rows"])}票：')
+            lines.extend(row_text(row) for row in data['rows'])
+            lines.append('回复“查看全部”展开列表，或发送入仓码查询详情。')
+        state={'query':query,'page':1,'size':5}
+        previous=load_state(conv_id)
+        if previous and previous['query']==query:state={key:previous[key] for key in ('query','page','size')}
+        return {'t':'\n'.join(lines),'_customer_data':True,'_order_list_state':state}
+    except sqlite3.Error:return {'t':'订单信息暂时无法读取，请稍后重试。'}
+
+
+def answer_list(message,tenants,conv_id=None):
+    from .order_data import is_lookup_help,STATUS_LABELS
+    from .customer_service import order_login_response
     command=page_command(message)
+    expand=message.strip(' ，,。.!！?？') in ('查看全部','查看全部订单')
     initial=(not is_lookup_help(message) and re.search(r'订单|运单|\borders?\b|\bshipments?\b',message,re.I)
              and re.search(r'列出|列表|全部|所有|\blist\b',message,re.I))
-    if command is None and not initial:return None
+    if command is None and not initial and not expand:return None
     if not tenants:return order_login_response()
-    page=1;status=None
-    if command is None:
-        intent=parse_count_query(re.sub(r'列出|列表|全部|所有|\blist\b','多少',message,flags=re.I))
-        if intent is None or intent['unsupported']:
-            return {'t':'暂不支持按这个条件列出订单。可查看全部订单或按履约中、已完成等业务状态查询。'}
-        status=intent['status']
-    scope=tenant_filter(tenant_ids=tenants)
-    if scope is None:return order_login_response()
-    connection=None
     try:
-        connection=connect()
-        if command is not None:
-            if not conv_id:return {'t':'请先在当前对话中发送“列出我的订单”，再翻页查看。'}
-            prior=connection.execute("SELECT content FROM messages WHERE conv_id=? AND role='assistant' ORDER BY id DESC LIMIT 1",(conv_id,)).fetchone()
-            header=prior[0].split('\n',1)[0] if prior else ''
-            match=re.fullmatch(r'您当前的订单列表（.*第(\d+)页；业务状态：([^）]+)）：',header)
-            if not match:return {'t':'请先在当前对话中发送“列出我的订单”，再翻页查看。'}
-            labels={label:code for code,label in STATUS_LABELS.items()}
-            status=labels.get(match[2])
-            if match[2]!='全部' and status is None:return {'t':'请重新指定需要查看的订单状态。'}
-            page=int(command) if isinstance(command,int) else max(1,int(match[1])+(1 if command=='next' else -1))
+        previous=load_state(conv_id)
+        if command is not None or expand:
+            if not previous:return {'t':'请先在当前对话中发送“列出我的订单”或查询订单数量，再翻页查看。'}
+            query=previous['query'];size=20 if expand else previous['size']
+            page=1 if expand else int(command) if isinstance(command,int) else max(1,previous['page']+(1 if command=='next' else -1))
             if not 1<=page<=10000:return {'t':'请提供1至10000之间的有效页码。'}
-        where=' WHERE 1=1'+scope[0];values=scope[1]
-        if status:where+=' AND status=?';values=values+[status]
-        # Both reads see one current snapshot and apply exactly the same scope/filter.
-        connection.execute('BEGIN')
-        total=connection.execute('SELECT COUNT(*) FROM order_test_data'+where,values).fetchone()[0]
-        page=min(page,max(1,(total+19)//20))
-        rows=connection.execute('SELECT order_no,inbound_code,status,warehouse_code FROM order_test_data'+where+
-            ' ORDER BY id DESC LIMIT 20 OFFSET ?',values+[(page-1)*20]).fetchall()
-        if not rows:return {'t':'当前账号下没有符合条件的订单。','_customer_data':True}
-        label=STATUS_LABELS[status] if status else '全部'
-        first='先列出20票；' if page==1 and total>20 else ''
-        lines=[f'您当前的订单列表（{first}第{page}页；业务状态：{label}）：',f'共{total}票，当前显示第{(page-1)*20+1}至{(page-1)*20+len(rows)}票。']
-        for number,inbound,business_status,warehouse in rows:
-            lines.append(f'- 入仓码：{inbound or "未登记"}；订单号：{number}；业务状态：{STATUS_LABELS.get(business_status,business_status)}；目的仓：{warehouse or "未登记"}')
-        lines.append('回复“下一页”查看后续订单。' if page*20<total else '当前已是最后一页。')
+        else:
+            intent=parse_query(message,listing=True)
+            if intent is None or intent['unsupported']:return unsupported(True)
+            query=filters(intent);page=1;size=20
+        data=read_orders(tenants,query,page,size);page=data['page'];total=data['total']
+        state={'query':query,'page':page,'size':size}
+        if not total:return {'t':'当前账号下没有符合条件的订单。','_customer_data':True,'_order_list_state':state}
+        label=STATUS_LABELS[query['status']] if query['status'] else '全部'
+        first=f'先列出{size}票；' if page==1 and total>size else ''
+        extra=('；当前节点：'+STAGE_LABELS[query['stage']] if query['stage'] else '')+('；明确标记异常' if query['exception'] else '')
+        lines=[f'您当前的订单列表（{first}第{page}页；业务状态：{label}{extra}）：',f'共{total}票，当前显示第{(page-1)*size+1}至{(page-1)*size+len(data["rows"])}票。']
+        lines.extend(row_text(row) for row in data['rows'])
+        lines.append('回复“下一页”查看后续订单。' if page*size<total else '当前已是最后一页。')
         lines.append('发送入仓码可查询该票订单和物流轨迹。')
-        return {'t':'\n'.join(lines),'_customer_data':True}
-    except sqlite3.Error:
-        return {'t':'订单信息暂时无法读取，请稍后重试。'}
-    finally:
-        if connection is not None:connection.close()
+        return {'t':'\n'.join(lines),'_customer_data':True,'_order_list_state':state}
+    except sqlite3.Error:return {'t':'订单信息暂时无法读取，请稍后重试。'}

logistics_chat/order_query.py

@@ -0,0 +1,61 @@
+"""Recognize explicit, whitelisted order summary and list filters."""
+
+import re
+
+from .order_tracking import NODE_LABELS
+
+
+NODE_PHRASES = (
+    ('DOMESTIC_RECEIVED',r'已入国内仓|已入仓'),
+    ('LOADING_COMPLETED',r'已完成装柜|已装柜'),
+    ('DEPARTED_WAREHOUSE',r'已离开国内仓库|已离仓|已出库'),
+    ('AT_ORIGIN_PORT',r'重箱已进入起运港或码头|已到起运港|已进起运港'),
+    ('LOADED_ON_VESSEL',r'已装船'),
+    ('DEPARTED_ORIGIN_PORT',r'船舶已离开起运港|已开船|开船'),
+    ('IN_TRANSIT',r'海运途中|运输中|在途|海上'),
+    ('ARRIVED_DESTINATION_PORT',r'船舶已到目的港|已到目的港|已到港|到港'),
+    ('DISCHARGED_FROM_VESSEL',r'已卸船、未清关|卸船未清关|已卸船|卸船'),
+    ('PICKUP_READY',r'已清关、可提柜|已清关|清关完成|可提柜'),
+    ('PICKED_UP',r'已提柜|提柜'),
+    ('EMPTY_RETURNED',r'已还柜|还柜'),
+    ('NO_ACTUAL',r'没有实际轨迹|暂无实际节点|没有轨迹|无轨迹'),
+    ('MIXED',r'多柜进度不一致|多柜进度不同'),
+)
+STAGE_LABELS = {code:labels[1] for code,labels in NODE_LABELS.items()}
+STAGE_LABELS.update(NO_ACTUAL='暂无实际节点',MIXED='多柜进度不同')
+STATUSES = (('头程订单已完成','COMPLETED'),('已完成','COMPLETED'),('履约中','PROCESSING'),
+            ('处理中','PROCESSING'),('已取消','CANCELLED'),('审核通过','APPROVED'),
+            ('审核驳回','REJECTED'),('已接单','ACCEPTED'),('已提交','SUBMITTED'),('草稿','DRAFT'))
+NOUN = r'订单|运单|入仓码|入仓号|\borders?\b|\bshipments?\b'
+COUNT = r'多少|几(?:个|票|条|张|笔)|总数|数量|总量|统计|数一下|(?:订单|运单)数(?!量)|\bhow\s+many\b|\bcount\b|\bnumber\b|\btotal\b'
+
+
+def parse_query(message,listing=False):
+    if not re.search(NOUN,message,re.I):return None
+    if not listing and not (re.search(COUNT,message,re.I) or re.search(r'分布|(?:都|分别).*到哪',message)):return None
+    if re.search(r'公斤|千克|\bkg\b|重量|毛重|体积|件数|箱数|运费|费用|价格|多少钱',message,re.I):return None
+    remaining=message
+    statuses=[];nodes=[]
+    # Unknown/negated logistics conditions must never silently become a total.
+    unsupported=bool(re.search(r'未到港|没到港|还没|未开船|未发货|未签收|已签收|已送达|曾经|曾到|到过|正常订单|无异常',remaining))
+    for code,pattern in NODE_PHRASES:
+        if re.search(pattern,remaining):
+            nodes.append(code);remaining=re.sub(pattern,'',remaining)
+    for phrase,status in STATUSES:
+        if phrase in remaining:
+            statuses.append(status);remaining=remaining.replace(phrase,'')
+    exception=bool(re.search(r'异常',remaining))
+    remaining=re.sub(r'物流异常|异常','',remaining)
+    grouped=not nodes and bool(re.search(r'轨迹|节点|阶段|到哪',remaining))
+    remaining=re.sub(r'物流轨迹|物流节点|当前节点|轨迹|节点|阶段|到哪里|到哪|各自|各个|每个|分别|分布|各|都|了', '',remaining)
+    remaining=re.sub(COUNT+'|'+NOUN,'',remaining,flags=re.I)
+    remaining=re.sub(r'当前账号|当前账户|账号下|账户下|名下|可查询|能查到|可以查到|目前|现在|当前|一共|总共|合计|总计|'
+        r'请问|麻烦|帮我|想知道|想查|想看|请|查询|查一下|查下|查查|看一下|看看|看下|一下|下|列出|列表|显示|全部|所有|共有|我的|我|能|有|的|个|票|条|张|笔|呢|吗|呀|啊|共|'
+        r'\b(?:list|what|is|of|do|i|have|are|there|my|in|all|the|currently)\b|[\s，,。.!！?？、：:]','',remaining,flags=re.I)
+    return {'status':statuses[0] if statuses else None,'stage':nodes[0] if nodes else None,
+            'exception':exception,'grouped':grouped,
+            'unsupported':bool(unsupported or remaining or len(set(statuses))>1 or len(set(nodes))>1)}
+
+
+def filters(intent):
+    return {key:intent.get(key) for key in ('status','stage','exception')}

logistics_chat/order_tracking.py

@@ -33,14 +33,14 @@ def parse_time(value):
         return None
 
 
-def build_tracking(raw):
-    """Latest observation corrects a milestone; forecasts never advance progress."""
+def tracking_facts(raw):
+    """Share the same corrections and actual/estimated split with aggregation."""
     try:
         facts = json.loads(raw) if isinstance(raw, str) else raw
     except (ValueError, TypeError):
-        return None
+        return {},{}
     if not isinstance(facts, list):
-        return None
+        return {},{}
     actual, estimated = {}, {}
     for index, fact in enumerate(facts):
         if not isinstance(fact, dict) or not isinstance(fact.get('code'), str) or fact['code'] not in NODE_LABELS:
@@ -55,8 +55,27 @@ def build_tracking(raw):
             candidate = (observation, index, when, fact)
             if key not in target or candidate[:2] > target[key][:2]:
                 target[key] = candidate
-    if not actual and not estimated:
-        return None
+    return actual,estimated
+
+
+def current_stage(raw):
+    actual,estimated=tracking_facts(raw)
+    progress={}
+    for (shipment,code) in actual:
+        if shipment not in progress or NODE_LABELS[code][0]>NODE_LABELS[progress[shipment]][0]:
+            progress[shipment]=code
+    shipments={shipment for shipment,_ in actual.keys() | estimated.keys() if shipment}
+    if shipments:
+        if not any(shipment in progress for shipment in shipments) and '' in progress:return progress['']
+        progress={shipment:progress.get(shipment,'NO_ACTUAL') for shipment in shipments}
+    codes=set(progress.values())
+    return next(iter(codes)) if len(codes)==1 else 'MIXED' if codes else 'NO_ACTUAL'
+
+
+def build_tracking(raw):
+    """Latest observation corrects a milestone; forecasts never advance progress."""
+    actual,estimated=tracking_facts(raw)
+    if not actual and not estimated:return None
 
     shipments = sorted({key[0] for key in actual.keys() | estimated.keys()} - {''})
     multiple = len(shipments) > 1

logistics_chat/pricing.py

@@ -94,15 +94,36 @@ RATES = {
 
 CBM_CHANNELS = ("卡航", "普卡", "铁路", "海运")
 
-def parse_dims(t):
-    """解析长x宽x高，支持小数、空格及 x/×/* 分隔。
+DIMENSION_NUMBER = r'(?<![\d.+-])(\d+(?:\.\d+)?)(?![\d.])'
+DIMENSION_UNIT = r'\s*(英寸|毫米|厘米|公分|米|(?:inches|inch|in|cm|mm|m)(?=$|[^A-Za-z0-9²³]|[xX])|["″])?\s*'
+DIMENSION_AXIS = DIMENSION_NUMBER + DIMENSION_UNIT
+DIMENSION_PATTERNS = tuple(re.compile(pattern,re.I) for pattern in (
+    DIMENSION_AXIS+r'[*xX×]\s*'+DIMENSION_AXIS+r'[*xX×]\s*'+DIMENSION_AXIS,
+    r'长\s*'+DIMENSION_AXIS+r'宽\s*'+DIMENSION_AXIS+r'高\s*'+DIMENSION_AXIS,
+    DIMENSION_AXIS+r'长\s*'+DIMENSION_AXIS+r'宽\s*'+DIMENSION_AXIS+r'高',
+))
 
-    用"最长连续数字"匹配三组，要求每组前后都不与其它数字相连，
-    这样 "100x80x60 200kg" 里的 60 不会被后面的 200 吞成 6020。
-    """
-    match = re.search(r'(?<![\d.+-])(\d+(?:\.\d+)?)\s*[*xX×]\s*'
-                      r'(\d+(?:\.\d+)?)\s*[*xX×]\s*(\d+(?:\.\d+)?)(?![\d.])', t)
-    return [float(value) for value in match.groups()] if match else None
+
+def dimension_measurement(text):
+    """Keep units attached to the three packaging axes, not product descriptions."""
+    matches=[match for pattern in DIMENSION_PATTERNS if (match:=pattern.search(text))]
+    if not matches:return None
+    match=min(matches,key=lambda item:item.start())
+    parts=match.groups()
+    values=[float(parts[index]) for index in (0,2,4)]
+    aliases={'英寸':'in','inches':'in','inch':'in','"':'in','″':'in',
+             '毫米':'mm','厘米':'cm','公分':'cm','米':'m'}
+    units=[aliases.get(value.lower(),value.lower()) if value else None for value in parts[1::2]]
+    default=next((unit for unit in reversed(units) if unit),'cm')
+    units=[unit or default for unit in units]
+    if len(set(units))==1:return values,units[0]
+    factors={'cm':1,'mm':0.1,'m':100,'in':2.54}
+    return [value*factors[unit] for value,unit in zip(values,units)],'cm'
+
+
+def parse_dims(t):
+    measurement=dimension_measurement(t)
+    return measurement[0] if measurement else None
 
 
 SHIPPING_REGION_PATTERNS = tuple((re.compile(pattern, re.I), region) for region, pattern in (
@@ -142,15 +163,6 @@ def parse_shipping_intent(text):
 
     # 尺寸：在原始文本上解析（空格有助于区分尺寸和后面的重量）
     intent["dims"] = parse_dims(text)
-    if not intent["dims"]:
-        # 支持“长100宽80高60”
-        dl = re.search(r"长(\d+(?:\.\d+)?)宽(\d+(?:\.\d+)?)高(\d+(?:\.\d+)?)", t)
-        if dl:
-            intent["dims"] = [float(x) for x in dl.groups()]
-        else:
-            dl = re.search(r"(\d+(?:\.\d+)?)长(\d+(?:\.\d+)?)宽(\d+(?:\.\d+)?)高", t)
-            if dl:
-                intent["dims"] = [float(x) for x in dl.groups()]
 
     # 重量：带单位的数字。去掉空格后在原始文本上匹配，
     # 但不能把尺寸里的数字（如 120*100*100 的第三个数）当成重量
@@ -182,6 +194,8 @@ def parse_shipping_intent(text):
 
 def detect_dim_unit(text):
     """Recognize explicit dimensions; aggregate CBM does not imply meters."""
+    measurement=dimension_measurement(text)
+    if measurement:return measurement[1]
     low = text.lower()
     if re.search(r'英寸|\binch(?:es)?(?![A-Za-z])|\d\s*in(?![A-Za-z0-9])|\d\s*["″]',low):
         return 'in'

logistics_chat/quote_context.py

@@ -9,7 +9,10 @@ QUANTITY_QUESTION='箱数已更改，请确认新的总重或各箱重量，原
 
 def merge_intent(current,previous):
     result=deepcopy(current)
-    excluded={'mode','text','errors','dim_unit','quantity_note','quantity_uncertain','preserve_total'}
+    excluded={'mode','text','errors','dim_unit','quantity_note','quantity_uncertain','preserve_total','metal_weight_update'}
+    if current.get('metal_weight_update') and previous.get('metal_chargeable_weight') is None:
+        result['metal_chargeable_weight']=None
+        result['errors'].append('请确认铁铝部分的计费重，不能把毛重直接当作计费重。')
     if current.get('warehouse') or current.get('unknown_warehouses'):
         excluded.update(('postal','zone','zones'))
     elif current.get('postal'):

logistics_chat/quote_intent.py

@@ -164,6 +164,7 @@ def parse_intent(message,warehouse_codes):
         'errors':errors,'mode':request_mode(text),'english':True if english else (False if re.search(r'[\u4e00-\u9fff]',message) else None),
         'material':materials['material'],'metal_scope':materials['metal_scope'],
         'metal_chargeable_weight':materials['metal_chargeable_weight'],
+        'metal_weight_update':materials['metal_weight_update'],
         'address_type':('non_fba' if re.search(r'私人|住宅|商业地址|非亚马逊',text) else ('fba' if warehouses else None)),
         'preserve_total':True if re.search(r'总重不变|重量不变',text) else None,'text':text}
 

logistics_chat/quote_material.py

@@ -16,15 +16,18 @@ def material_intent(text,weight_pattern,to_kg):
               else 'ordinary' if ordinary or re.search(r'塑料|木制',text) else None)
     name=r'(?:铁铝|铁制品|钢制品|铝制品|铁件|钢件|铝件|金属)(?:部分|货物)?(?:的)?'
     patterns=(name+r'\s*计费重(?:量)?\s*(?:为|是|[:：])?\s*'+weight_pattern.pattern,
-              name+r'\s*按\s*'+weight_pattern.pattern+r'\s*计费')
-    charged=None;cleaned=text;errors=[]
-    for pattern in patterns:
+              name+r'\s*按\s*'+weight_pattern.pattern+r'\s*计费',
+              r'(?:铁铝|铁制品|钢制品|铝制品|铁件|钢件|铝件|金属)部分(?:的计费重(?:量)?)?\s*'
+              r'(?:还是|仍然是|仍是|改为|改成|换成)\s*'+weight_pattern.pattern)
+    charged=None;cleaned=text;errors=[];oral=False
+    for index,pattern in enumerate(patterns):
         matches=list(re.finditer(pattern,text,re.I))
         for match in matches:
             value=to_kg(*match.groups())
             if charged is not None and Decimal(charged)!=value:errors.append('铁铝货物的计费重不一致，请确认。')
             charged=str(value);scope='partial'
+            oral=oral or (index==2 and '计费重' not in match[0])
             if not 0<value<=1000000:errors.append('请提供大于0的有效铁铝货物计费重。')
             cleaned=cleaned[:match.start()]+' '*(match.end()-match.start())+cleaned[match.end():]
     return {'material':material,'metal_scope':scope,'metal_chargeable_weight':charged,
-            'quantity_text':cleaned,'errors':errors}
+            'quantity_text':cleaned,'errors':errors,'metal_weight_update':True if oral else None}

logistics_chat/quote_scope.py

@@ -2,8 +2,7 @@
 
 import re
 
-from .db import connect
-from .quote_intent import US,QUOTE_WORDS,parse_intent,is_followup
+from .quote_intent import US
 from .pricing import shipping_region
 
 
@@ -15,17 +14,8 @@ def answer_us_fallback(message,conv_id):
     active=bool(US.search(current))
     if not active and shipping_region(current) is not None:return None
     if not active and conv_id:
-        connection=connect()
-        try:
-            recent=connection.execute("SELECT content FROM messages WHERE conv_id=? AND role='user' ORDER BY id DESC LIMIT 10",(conv_id,)).fetchall()
-        finally:connection.close()
-        for (previous,) in recent:
-            previous=clean_conditions(previous)
-            if re.search(r'理赔|赔偿|破损|丢失|退件|投诉|查单|轨迹|签收|换个话题',previous):break
-            if US.search(previous):active=True;break
-            if shipping_region(previous) is not None:break
-            parsed=parse_intent(previous,set())
-            if not (QUOTE_WORDS.search(previous) or is_followup(previous,parsed)):break
+        from .quote_service import previous_quote_intents
+        active=any(intent['country']=='US' for intent in previous_quote_intents(conv_id,set()))
     if not active:return None
     from .quote_data import load_book
     if not load_book():return {'t':'当前尚未包含可用的美国报价表，请提供目的地仓码或邮编及货物信息，联系人工确认。'}

logistics_chat/quote_service.py

@@ -9,29 +9,39 @@ from .quote_data import load_book, postcode_fee
 from .quote_engine import US, QUOTE_WORDS, parse_intent, is_followup, variants, render_rates
 
 
+def previous_quote_intents(conv_id,codes):
+    """Read the current quote back to its topic boundary, without a turn cutoff."""
+    earlier_intents=[]
+    if conv_id:
+        connection=connect()
+        try:
+            recent=connection.execute("SELECT content FROM messages WHERE conv_id=? AND role='user' ORDER BY id DESC",(conv_id,))
+            for (previous,) in recent:
+                if re.search(r'理赔|赔偿|破损|丢失|退件|投诉|查单|轨迹|签收|换个话题|另外问',previous):break
+                earlier=parse_intent(previous,codes)
+                if earlier['country']=='other':break
+                if not (QUOTE_WORDS.search(previous) or US.search(previous) or is_followup(previous,earlier) or
+                        any(earlier.get(key) for key in ('weight','dims','cbm','warehouse','postal'))):break
+                earlier_intents.append(earlier)
+                if not is_followup(previous,earlier):break
+        finally:
+            connection.close()
+    return earlier_intents
+
+
 def intent_with_context(message, conv_id, book):
     from .quote_context import merge_intent
 
     codes = {row['code'] for row in book['warehouses']}
     codes.update(value.upper() for rate in book['rates'] for value in rate['destinations'])
     intent = parse_intent(message,codes)
-    earlier_intents=[]
-    if conv_id and is_followup(message,intent):
-        connection=connect()
-        try:
-            recent=connection.execute("SELECT content FROM messages WHERE conv_id=? AND role='user' ORDER BY id DESC LIMIT 10",(conv_id,)).fetchall()
-        finally:
-            connection.close()
-        for (previous,) in recent:
-            if re.search(r'理赔|赔偿|破损|丢失|退件|投诉|查单|轨迹|签收',previous):break
-            earlier=parse_intent(previous,codes)
-            if earlier['country']=='other':break
-            if not (QUOTE_WORDS.search(previous) or US.search(previous) or is_followup(previous,earlier) or
-                    any(earlier.get(key) for key in ('weight','dims','cbm','warehouse','postal'))):break
-            earlier_intents.append(earlier)
-            if not is_followup(previous,earlier):break
+    earlier_intents=previous_quote_intents(conv_id,codes) if is_followup(message,intent) else []
+    if intent.get('metal_weight_update') and not earlier_intents:
+        intent['metal_chargeable_weight']=None
+        intent['errors'].append('请确认铁铝部分的计费重，不能把毛重直接当作计费重。')
     if earlier_intents:
         state=earlier_intents[-1]
+        if state.get('metal_weight_update'):state['metal_chargeable_weight']=None
         for update in list(reversed(earlier_intents[:-1]))+[intent]:
             state=merge_intent(update,state)
         intent=state

tests/test_customer_gap_fixes.py

@@ -103,6 +103,47 @@ class CustomerGapTests(unittest.TestCase):
         self.assertIn('最高项70元/件',text)
         self.assertNotIn('请补充箱数',text)
 
+    def test_box_units_are_local_and_each_axis_can_carry_its_own_unit(self):
+        cases=(('12英寸显示器，包装60x40x30cm',[60,40,30],'cm',Decimal('30')),
+               ('80cm×70cm×60cm',[80,70,60],'cm',Decimal('56')),
+               ('80cmx70cmx60cm',[80,70,60],'cm',Decimal('56')),
+               ('800mm*700mm*600mm',[800,700,600],'mm',Decimal('56')),
+               ('长80厘米宽70厘米高60厘米',[80,70,60],'cm',Decimal('56')),
+               ('0.8m×70cm×600mm',[80,70,60],'cm',Decimal('56')),
+               ('12英寸显示器，包装60x40x30',[60,40,30],'cm',Decimal('30')))
+        for wording,dims,unit,charge in cases:
+            with self.subTest(wording=wording):
+                intent=parse_intent('美国美西30KG，'+wording+'，1箱义乌普船海派',set())
+                self.assertEqual(intent['dims'],dims);self.assertEqual(intent['dim_unit'],unit)
+                self.assertEqual(quantity(intent,{'kind':'parcel','unit':'kg'}),charge)
+                text=self.ask('美国美西30KG，'+wording+'，1箱义乌普船海派')
+                self.assertIn(f'{charge}KG =',text)
+                self.assertNotIn('请补充箱数',text)
+
+    def test_oral_partial_weight_edits_never_overwrite_the_whole_shipment(self):
+        cid=self.conversation()
+        self.ask('美国美西30KG，部分铁制品，铁铝部分计费重10KG，义乌普船海派',cid)
+        for q,amount in (('铁铝部分还是10KG',110),('铁铝部分改成8KG',100),('铁铝部分仍是8KG',100)):
+            text=self.ask(q,cid)
+            self.assertIn('美国 30KG',text);self.assertIn(f'30KG = {amount}元',text)
+        self.assertIn('大于0',self.ask('铁铝部分改为-1KG',cid))
+        fresh=self.conversation()
+        self.assertIn('请确认铁铝部分的计费重',self.ask('美国美西30KG，铁铝部分还是10KG，义乌普船海派',fresh))
+        self.assertNotIn('×10KG',self.ask('一共多少钱，给我最终总价',fresh))
+
+    def test_long_quote_chain_retains_conditions_but_topic_changes_stop_reuse(self):
+        cid=self.conversation();self.ask('美国美西30KG，义乌普船海派',cid)
+        for _ in range(15):self.assertIn('每箱不足12KG',self.ask('这个报价按毛重还是净重？',cid))
+        self.assertIn('美国 50KG',self.ask('50KG呢',cid))
+        self.assertIn('美国渠道',self.ask('这个物流服务范围具体怎么执行？',cid))
+        self.assertIn('请先',self.ask('下一页',cid))
+        from logistics_chat.quote_service import answer_quote
+        from logistics_chat.quote_scope import answer_us_fallback
+        with self.app.test_request_context('/'):
+            self.assertIsNone(answer_quote('新的一票50KG发德国报价',cid))
+            db.save_message(cid,'user','换个话题，我要查订单')
+            self.assertIsNone(answer_us_fallback('50KG呢',cid))
+
     def test_comparing_two_weights_is_not_treated_as_two_cartons(self):
         cid=self.conversation();self.ask('美国30KG海派报价',cid)
         text=self.ask('单箱12.5KG会不会按13KG收费？',cid)
@@ -194,6 +235,13 @@ class CustomerGapTests(unittest.TestCase):
         self.ask('美国30KG海派报价',cid)
         self.assertIn('请先',self.ask('下一页',cid))
 
+    def test_count_interruptions_do_not_erase_the_active_list_page(self):
+        self.seed_pages();self.login();cid=self.conversation()
+        self.ask('列出我的全部订单',cid)
+        self.ask('我有多少个运单',cid)
+        text=self.ask('下一页',cid)
+        self.assertIn('第2页',text);self.assertEqual(text.count('- 入仓码：'),6)
+
     def test_clearance_followup_modification_and_unknown_payment_do_not_call_model(self):
         self.assertTrue(self.events('我的订单已清关了吗')[0]['login_required'])
         self.login();cid=self.conversation();self.events('QAFOCUS20260001',cid)

tests/test_order_counts.py

@@ -78,14 +78,15 @@ class OrderCountTests(unittest.TestCase):
                              'What is the number of my orders?'):
                 with self.subTest(question=question):
                     events = self.events(question,cid)
-                    self.assertEqual(events[0],{'t':'您当前共有 2 票订单，其中 1 票已登记入仓码。'})
+                    self.assertTrue(events[0]['t'].startswith('您当前共有 2 票订单，其中 1 票已登记入仓码。'))
+                    self.assertEqual(events[0]['t'].count('- 入仓码：'),2)
                     self.assertEqual(events[-1],{'d':1})
             model.assert_not_called()
         with self.app.app_context():
             connection = db.connect()
             order_data.import_records(connection,[{'tenant_id':'tenant-a','order_no':'COUNT20260004','inbound_code':'INB20260004'}])
             connection.commit(); connection.close()
-        self.assertEqual(self.events('我有多少个运单')[0]['t'],'您当前共有 3 票订单，其中 2 票已登记入仓码。')
+        self.assertTrue(self.events('我有多少个运单')[0]['t'].startswith('您当前共有 3 票订单，其中 2 票已登记入仓码。'))
 
     def test_business_status_filters_are_exact_and_unknown_conditions_never_return_the_total(self):
         self.login()
@@ -152,7 +153,7 @@ class OrderCountTests(unittest.TestCase):
             with self.app.app_context():
                 with self.assertRaises(order_data.OrderDataUnavailable):
                     order_data.count_orders(('tenant-a',))
-        with patch('logistics_chat.order_data.count_orders',side_effect=order_data.OrderDataUnavailable):
+        with patch('logistics_chat.order_listing.read_orders',side_effect=sqlite3.OperationalError):
             events = self.events('我有多少个运单')
         self.assertIn('暂时无法读取',events[0]['t'])
 
@@ -164,7 +165,7 @@ class OrderCountTests(unittest.TestCase):
                 (' \t\r\n','COUNT20260002','tenant-a'))
             order_data.import_records(connection,[{'tenant_id':'tenant-a','order_no':'COUNT20260005','inbound_code':'INB20260001'}])
             connection.commit(); connection.close()
-        self.assertEqual(self.events('我有多少个运单')[0]['t'],'您当前共有 3 票订单，其中 2 票已登记入仓码。')
+        self.assertTrue(self.events('我有多少个运单')[0]['t'].startswith('您当前共有 3 票订单，其中 2 票已登记入仓码。'))
         with self.app.app_context():
             connection = db.connect()
             connection.execute("DELETE FROM order_test_data WHERE tenant_id='tenant-a'")

tests/test_order_statistics.py

@@ -0,0 +1,166 @@
+"""Statistics use explicit exception reasons and actual, order-level progress."""
+
+import json
+from pathlib import Path
+import sqlite3
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from logistics_chat import create_app,db,order_data
+from logistics_chat.order_tracking import current_stage
+
+
+def fact(code,shipment='',forecast=False):
+    return {'code':code,'shipment_key':shipment,
+            'estimated_at' if forecast else 'actual_at':'2026-10-01 10:00'}
+
+
+class OrderStatisticsTests(unittest.TestCase):
+    def setUp(self):
+        folder=tempfile.TemporaryDirectory();self.addCleanup(folder.cleanup);root=Path(folder.name)
+        self.app=create_app({'TESTING':True,'DATABASE':root/'data.db','UPLOAD_DIR':root/'uploads',
+            'BACKUP_DIR':root/'backups','LOG_DIR':root/'logs','DEEPSEEK_API_KEY':'',
+            'CUSTOMER_DEMO_TENANT_ID':'a','RATE_LIMIT_PER_MIN':1000})
+        self.client=self.app.test_client();self.client.post('/api/visitor/session',json={'key':'1'*64})
+        rows=[{'tenant_id':'a','order_no':f'STAT2026{i:04}','inbound_code':f'INSTAT2026{i:04}',
+            'status':'PROCESSING','source_updated_at':f'2026-10-{i+1:02} 10:00',
+            'tracking_json':[fact('IN_TRANSIT'),fact('ARRIVED_DESTINATION_PORT'),fact('EMPTY_RETURNED',forecast=True)],
+            'exception_reason':f'待核实资料{i}' if i<6 else None} for i in range(10)]
+        rows += [{'tenant_id':'a','order_no':'CLEAR20260001','status':'PROCESSING',
+                  'tracking_json':[fact('ARRIVED_DESTINATION_PORT'),fact('PICKUP_READY')],'exception_reason':'等待客户资料'},
+                 {'tenant_id':'a','order_no':'CLEAR20260002','status':'PROCESSING','tracking_json':[fact('PICKUP_READY')]},
+                 {'tenant_id':'a','order_no':'MIXED20260001','tracking_json':[fact('ARRIVED_DESTINATION_PORT','A'),fact('PICKUP_READY','B')]},
+                 {'tenant_id':'a','order_no':'FORECAST20260001','tracking_json':[fact('ARRIVED_DESTINATION_PORT',forecast=True)]},
+                 {'tenant_id':'a','order_no':'BUSINESS20260001','status':'COMPLETED','tracking_json':'[]'},
+                 {'tenant_id':'a','order_no':'REJECTED20260001','status':'REJECTED','exception_reason':'  \t\n'},
+                 {'tenant_id':'b','order_no':'SECRET20260001','status':'PROCESSING','tracking_json':[fact('ARRIVED_DESTINATION_PORT')],'exception_reason':'不能泄露'}]
+        with self.app.app_context():
+            c=db.connect();order_data.import_records(c,rows);c.commit();c.close()
+
+    def login(self):
+        self.assertTrue(self.client.post('/api/customer/login',json={'username':'admin','password':'123456'}).json['ok'])
+
+    def ask(self,q,cid=None):
+        with patch('logistics_chat.ai_client.post_completion') as model:
+            response=self.client.post('/stream_chat',json={'msg':q,'conv_id':cid})
+            events=[json.loads(line[6:]) for line in response.get_data(as_text=True).split('\n\n') if line.startswith('data: ')]
+            model.assert_not_called()
+        self.assertEqual(events[-1],{'d':1},events)
+        self.assertNotIn('_order_list_state',str(events));self.assertNotIn('_customer_data',str(events))
+        self.assertNotIn('SECRET',str(events));self.assertNotIn('不能泄露',str(events))
+        return events[0]
+
+    def test_guests_never_read_aggregate_or_exception_facts(self):
+        with patch('logistics_chat.order_listing.read_orders') as read:
+            for q in ('我有多少异常订单','到港的有多少运单','各个轨迹节点分别有多少订单','查看全部','下一页'):
+                self.assertTrue(self.ask(q)['login_required'])
+            read.assert_not_called()
+
+    def test_summaries_show_at_most_five_recent_rows_and_keep_intersecting_filters(self):
+        self.login()
+        total=self.ask('我有多少个订单')['t']
+        self.assertIn('共有 16 票',total);self.assertEqual(total.count('- 入仓码：'),5)
+        abnormal=self.ask('我有多少个异常订单')['t']
+        self.assertIn('7 票明确标记异常',abnormal);self.assertEqual(abnormal.count('- 入仓码：'),5)
+        self.assertNotIn('REJECTED20260001',abnormal)
+        arrived=self.ask('现在到港的有多少运单')['t']
+        self.assertIn('10 票当前节点为“船舶已到目的港”',arrived)
+        self.assertEqual(arrived.count('- 入仓码：'),5)
+        self.assertIn('STAT20260009',arrived);self.assertNotIn('STAT20260000',arrived)
+        self.assertNotIn('CLEAR20260001',arrived)
+        text=self.ask('已清关的异常订单有多少')['t']
+        self.assertIn('1 票当前节点为“已清关、可提柜”',text);self.assertIn('等待客户资料',text)
+
+    def test_distribution_counts_each_order_once_and_never_uses_forecasts_or_business_completion(self):
+        self.login()
+        text=self.ask('各个轨迹节点分别有多少订单')['t']
+        for token in ('船舶已到目的港：10票','已清关、可提柜：2票','多柜进度不同：1票','暂无实际节点：3票'):
+            self.assertIn(token,text)
+        self.assertNotIn('已还柜：',text);self.assertNotIn('已签收：',text)
+
+    def test_expand_and_pages_keep_filters_and_refresh_counts(self):
+        self.login();cid=self.client.post('/api/new_chat').json['id']
+        self.ask('我有多少异常订单',cid)
+        text=self.ask('下一页',cid)['t']
+        self.assertIn('第2页',text);self.assertEqual(text.count('- 入仓码：'),2)
+        text=self.ask('查看全部',cid)['t']
+        self.assertIn('共7票',text);self.assertEqual(text.count('- 入仓码：'),7)
+        self.assertIn('明确标记异常',text)
+        with self.app.app_context():
+            c=db.connect();c.execute('UPDATE order_test_data SET exception_reason=NULL WHERE tenant_id=?',('a',));c.commit();c.close()
+        self.assertIn('没有符合条件',self.ask('下一页',cid)['t'])
+
+    def test_pages_do_not_cross_conversations_or_login_boundaries(self):
+        self.login();cid=self.client.post('/api/new_chat').json['id']
+        self.ask('到港的订单有多少',cid)
+        self.assertIn('第2页',self.ask('下一页',cid)['t'])
+        self.ask('当前订单总数',cid)
+        self.assertIn('共16票',self.ask('查看全部',cid)['t'])
+        self.client.post('/api/customer/logout')
+        self.assertTrue(self.ask('下一页',cid)['login_required'])
+        self.assertEqual(self.client.get('/api/get_messages',query_string={'conv_id':cid}).json,[])
+        self.login();self.assertIn('共16票',self.ask('查看全部',cid)['t'])
+        other=self.client.post('/api/new_chat').json['id']
+        self.assertIn('请先',self.ask('下一页',other)['t'])
+
+    def test_unknown_or_ambiguous_filters_do_not_degenerate_to_totals(self):
+        self.login()
+        for q in ('今天有多少异常订单','未到港的订单有多少','到港和已清关分别有多少订单','已签收的有多少运单'):
+            with self.subTest(q=q):self.assertIn('暂不支持按这个条件统计',self.ask(q)['t'])
+
+    def test_exception_reasons_are_editable_and_old_reimports_preserve_them(self):
+        self.login()
+        with self.app.app_context():
+            c=db.connect();order_data.import_records(c,[{'tenant_id':'a','order_no':'CLEAR20260001','status':'PROCESSING'}],replace=True);c.commit();c.close()
+        self.assertIn('等待客户资料',self.ask('CLEAR20260001的异常原因是什么')['t'])
+        cid=self.client.post('/api/new_chat').json['id'];self.ask('CLEAR20260001',cid)
+        self.assertIn('等待客户资料',self.ask('为什么异常',cid)['t'])
+        with self.app.app_context():
+            c=db.connect();order_data.import_records(c,[{'tenant_id':'a','order_no':'CLEAR20260001','exception_reason':''}],replace=True);c.commit();c.close()
+        self.assertIn('未登记异常原因',self.ask('CLEAR20260001的异常原因是什么')['t'])
+
+    def test_missing_actuals_and_bad_tracking_do_not_count_as_arrived(self):
+        self.assertEqual(current_stage([fact('ARRIVED_DESTINATION_PORT','A'),fact('PICKUP_READY','B',True)]),'MIXED')
+        self.assertEqual(current_stage([fact('ARRIVED_DESTINATION_PORT',forecast=True)]),'NO_ACTUAL')
+        self.assertEqual(current_stage('{broken'),'NO_ACTUAL')
+        self.assertEqual(current_stage([fact('UNKNOWN')]),'NO_ACTUAL')
+        self.assertEqual(current_stage([fact('DOMESTIC_RECEIVED'),fact('ARRIVED_DESTINATION_PORT','A',True)]),'DOMESTIC_RECEIVED')
+
+    def test_node_names_do_not_collide_with_business_status_or_drop_negations(self):
+        from logistics_chat.order_query import parse_query
+        intent=parse_query('已完成装柜的订单有多少')
+        self.assertFalse(intent['unsupported']);self.assertIsNone(intent['status'])
+        self.assertEqual(intent['stage'],'LOADING_COMPLETED')
+        self.assertTrue(parse_query('未清关的订单有多少')['unsupported'])
+        self.assertTrue(parse_query('没有异常的订单有多少')['unsupported'])
+
+    def test_state_survives_app_restart_and_rejects_late_reply_updates(self):
+        self.login();cid=self.client.post('/api/new_chat').json['id']
+        self.ask('我有多少异常订单',cid)
+        restarted=create_app(dict(self.app.config,INITIALIZE_RUNTIME=False))
+        client=restarted.test_client()
+        # Copy opaque cookies without exporting them.
+        for cookie in self.client._cookies.values():client.set_cookie(cookie.key,cookie.value)
+        response=client.post('/stream_chat',json={'msg':'下一页','conv_id':cid}).get_data(as_text=True)
+        self.assertIn('第2页',response)
+        from logistics_chat.order_listing import save_state
+        cookies='; '.join(cookie.key+'='+cookie.value for cookie in self.client._cookies.values())
+        with self.app.test_request_context('/',headers={'Cookie':cookies}):
+            self.app.preprocess_request()
+            from logistics_chat.customer_service import current_customer_id
+            self.assertIsNotNone(current_customer_id())
+            c=db.connect();prior=c.execute('SELECT order_list_state FROM chat_history WHERE id=?',(cid,)).fetchone()[0]
+            state=json.loads(prior);c.close()
+            db.save_message(cid,'user','换个话题，我要报价')
+            save_state(cid,{'query':state['query'],'page':1,'size':5},state['message_id'])
+            c=db.connect();self.assertEqual(c.execute('SELECT order_list_state FROM chat_history WHERE id=?',(cid,)).fetchone()[0],prior);c.close()
+
+    def test_schema_migration_preserves_old_orders(self):
+        c=sqlite3.connect(':memory:')
+        try:
+            c.execute('CREATE TABLE order_test_data (id INTEGER PRIMARY KEY,tenant_id TEXT,order_no TEXT,status TEXT,inbound_code TEXT,shipment_id TEXT)')
+            c.execute("INSERT INTO order_test_data VALUES(1,'a','OLD20260001','PROCESSING',NULL,NULL)")
+            order_data.init_order_table(c);order_data.init_order_table(c)
+            self.assertEqual(c.execute('SELECT order_no,exception_reason,tracking_json FROM order_test_data').fetchone(),('OLD20260001',None,'[]'))
+        finally:c.close()