@whyshu/argent-engine 0.7.6 → 0.7.8

package/engine/scripts/orchestrator.py

@@ -625,6 +625,20 @@ def _notify_mode() -> str:
     return mode if mode in NOTIFY_MODES else "final"      # 非法值按缺省（保守：不发步骤）
 
 
+DONE_CARD_MODE_ENV = "FULL_DONE_CARD_MODE"
+DONE_CARD_MODES = ("single", "batch", "off")
+
+
+def _done_card_mode() -> str:
+    """FULL 完成卡粒度：single=每票发（旧缺省）；batch=只由 batch 汇总发；off=都不发。
+
+    客户机 2026-10-21 口径：不要再逐票发 FULL 成功卡 ⇒ 设 FULL_DONE_CARD_MODE=batch。
+    """
+    raw = _profile_from_deploy(DONE_CARD_MODE_ENV, "") or "single"
+    mode = raw.strip().lower()
+    return mode if mode in DONE_CARD_MODES else "single"
+
+
 def _should_send(kind: str, final: bool = False) -> bool:
     """该条通知要不要真的对外发（纯函数，便于回归）。
 
@@ -639,6 +653,15 @@ def _should_send(kind: str, final: bool = False) -> bool:
     return bool(final)
 
 
+def _message_id_from_output(out: str) -> str:
+    """从 lark-cli 的 JSON 输出里取 message_id（兼容 data.message_id / message_id）。"""
+    try:
+        d = json.loads(str(out or ""))
+        return str(d.get("data", {}).get("message_id") or d.get("message_id") or "")
+    except Exception:
+        return ""
+
+
 def _notify_fact_path() -> Path:
     try:
         return _flow_data_dir() / NOTIFY_FACT_FILE
@@ -2450,6 +2473,35 @@ STEP_FALLBACKS: dict[int, dict[str, tuple[Optional[str], list[str]]]] = {
 # 修复「1 号格做月边界」缺陷：11 号会被误判为新月初（8/13 双月视图截断 bug）——
 # 改为逐格月份过渡分配（大数→1 回落即进下月，月份可越出视图末月=下月尾部格）。
 # __DATE_OFFSET__ 为占位符：调用处 replace 为实际 date_offset（JS 含 {} 对象字面量，不能用 .format）。
+EXACT_DATE_JS = r"""({targetIso}) => {
+    const days = document.querySelectorAll('div.day');
+    const MONTHS = ['enero','febrero','marzo','abril','mayo','junio','julio',
+                    'agosto','septiembre','octubre','noviembre','diciembre'];
+    const my = document.querySelector('.focus-ui-datepicker__content__month-year');
+    const header = my ? (my.textContent || '').trim().toLowerCase() : '';
+    const viewMonths = MONTHS.map((m, mi) => header.includes(m) ? mi : -1).filter(x => x >= 0);
+    const ym = header.match(/(\d{4})/);
+    if (!viewMonths.length || !ym) return {found: false, reason: 'header_unreliable', header};
+    const viewYear = parseInt(ym[1], 10);
+    const t = new Date(targetIso + 'T12:00:00');
+    let month = viewMonths[0] - 1, year = viewYear, prev = 0, started = false;
+    for (let i = 0; i < days.length; i++) {
+        const txt = (days[i].textContent || '').trim();
+        if (!/^\d+$/.test(txt)) continue;
+        const d = parseInt(txt, 10);
+        if (d === 1 && (prev > 1 || prev === 0)) {
+            if (!started) { started = true; month = viewMonths[0]; year = viewYear; }
+            else { month++; if (month > 11) { month = 0; year++; } }
+        }
+        prev = d;
+        if (started && year === t.getFullYear() && month === t.getMonth() && d === t.getDate()) {
+            const cls = days[i].className || '';
+            return {found: true, idx: i, disabled: cls.includes('day--disabled'), cls, header};
+        }
+    }
+    return {found: false, reason: 'not_in_view', header};
+}"""
+
 FALLBACK_DATE_JS = r"""() => {
     const days = document.querySelectorAll('div.day');
     const n = days.length;
@@ -2930,6 +2982,33 @@ class RequestRateMeter:
         return f"请求 {self.rate()} 次/分（峰值 {self.peak}/分，整轮 {self.total} 次）"
 
 
+def _tab_close_lock(cdp_url: str):
+    """跨进程串行化「窗口最后一个标签」守卫；失败时退化为无锁（不影响关闭）。"""
+    try:
+        import fcntl
+        port = str(cdp_url or '').rsplit(':', 1)[-1].strip('/ ')
+        path = f"/tmp/argent-tab-close-{port or 'default'}.lock"
+        f = open(path, 'a+')
+        fcntl.flock(f, fcntl.LOCK_EX)
+        return f
+    except Exception:
+        return None
+
+
+def _tab_close_unlock(handle) -> None:
+    if handle is None:
+        return
+    try:
+        import fcntl
+        fcntl.flock(handle, fcntl.LOCK_UN)
+    except Exception:
+        pass
+    try:
+        handle.close()
+    except Exception:
+        pass
+
+
 class PlaywrightClient:
     """Playwright CDP 统一封装：connect_over_cdp 直连紫鸟浏览器（默认 127.0.0.1:52420）。
 
@@ -3052,11 +3131,15 @@ class PlaywrightClient:
             if page is None or page.is_closed():
                 return
             pctx = page.context
-            if len(pctx.pages) > 1:
-                await page.close()
-            else:
-                print(f"[{time.strftime('%H:%M:%S')}] 🗂️ 记录标签为窗口最后 1 个，保留不关"
-                      f"（KB-133 窗口守卫：防紫鸟窗口退出）", file=sys.stderr, flush=True)
+            lock = _tab_close_lock(self.cdp_url)
+            try:
+                if len(pctx.pages) > 1:
+                    await page.close()
+                else:
+                    print(f"[{time.strftime('%H:%M:%S')}] 🗂️ 记录标签为窗口最后 1 个，保留不关"
+                          f"（KB-133 窗口守卫：防紫鸟窗口退出）", file=sys.stderr, flush=True)
+            finally:
+                _tab_close_unlock(lock)
         except Exception:
             pass
 
@@ -3194,12 +3277,16 @@ class PlaywrightClient:
                 if pg.is_closed():
                     continue
                 pctx = pg.context
-                if len(pctx.pages) > 1:
-                    await pg.close()
-                    closed += 1
-                else:
-                    print(f"[{time.strftime('%H:%M:%S')}] 🗂️ 保留最后 1 个标签不关"
-                          f"（窗口守卫：防紫鸟窗口退出）", file=sys.stderr, flush=True)
+                lock = _tab_close_lock(self.cdp_url)
+                try:
+                    if len(pctx.pages) > 1:
+                        await pg.close()
+                        closed += 1
+                    else:
+                        print(f"[{time.strftime('%H:%M:%S')}] 🗂️ 保留最后 1 个标签不关"
+                              f"（窗口守卫：防紫鸟窗口退出）", file=sys.stderr, flush=True)
+                finally:
+                    _tab_close_unlock(lock)
             except Exception:
                 pass
         if closed:
@@ -6540,6 +6627,10 @@ class FeishuClient:
         """
         if not record_id or not self.cfg.feishu_ready:
             return False
+        # 测试/只取消预约：所有进度写入口统一跳过（含 _finalize_partial 等直接调用点）
+        if os.environ.get("ARGENT_NO_PROGRESS") == "1":
+            print(f"[{time.strftime('%H:%M:%S')}] ⏭ ARGENT_NO_PROGRESS=1：跳过写「当前步骤」", file=sys.stderr, flush=True)
+            return False
         label = str(step_label or "")
         if "全部完成" in label:
             why = ""
@@ -6815,7 +6906,7 @@ class FeishuClient:
     def send_card(self, card: dict, fallback_text: str,
                   profile: Optional[str] = None,
                   chat_id: Optional[str] = None,
-                  final: bool = False) -> None:
+                  final: bool = False) -> str:
         """KB-110：发送 interactive card；失败自动降级为文字（不丢通知）。
 
         profile：通知身份（默认 NOTIFY_PROFILE 客户 Bot）；chat_id 覆盖目标群
@@ -6827,23 +6918,23 @@ class FeishuClient:
         if not _should_send("card", final=final):
             _record_notify_fact("card", target_chat or target_user,
                                 fallback_text or json.dumps(card, ensure_ascii=False))
-            return
+            return ""
         if not (self.cfg.feishu_ready and (target_chat or target_user)):
             return
         eff_profile = profile or self.cfg.notify_profile or NOTIFY_PROFILE
         try:
             if target_chat:
-                self._run(["im", "+messages-send", "--chat-id", target_chat,
+                out = self._run(["im", "+messages-send", "--chat-id", target_chat,
                            "--msg-type", "interactive",
                            "--content", json.dumps(card, ensure_ascii=False)],
                           timeout=60, retries=1, profile=eff_profile)
             else:
-                self._run(["im", "+messages-send", "--user-id", target_user,
+                out = self._run(["im", "+messages-send", "--user-id", target_user,
                            "--msg-type", "interactive",
                            "--content", json.dumps(card, ensure_ascii=False)],
                           timeout=60, retries=1, profile=eff_profile)
             self._log("  📇 已发送飞书卡片通知") if hasattr(self, "_log") else print("[lark-cli] 卡片已发送", flush=True)
-            return
+            return _message_id_from_output(out)
         except StepError as exc:
             # 降级兜底：卡片失败 → 发原文字（不丢通知）
             if hasattr(self, "_log"):
@@ -6863,6 +6954,17 @@ class FeishuClient:
                 pass
 
 
+    def update_card(self, message_id: str, card: dict, profile: Optional[str] = None) -> str:
+        """原地更新已发送的 interactive 卡片；返回 message_id（失败抛 StepError）。"""
+        if not message_id:
+            raise StepError(0, "cli_error", "update_card 缺少 message_id")
+        eff_profile = profile or self.cfg.notify_profile or NOTIFY_PROFILE
+        out = self._run(["im", "messages", "patch", "--message-id", message_id,
+                         "--data", json.dumps({"content": json.dumps(card, ensure_ascii=False)}, ensure_ascii=False)],
+                        timeout=60, retries=1, profile=eff_profile)
+        return _message_id_from_output(out) or message_id
+
+
 # ────────────────────────────────────────────────
 # JS 片段（仅保留数据提取类；交互全部用 Playwright 原生 click/fill）
 # ────────────────────────────────────────────────
@@ -7387,8 +7489,21 @@ class Orchestrator:
                                         ticket_attestation=self._ticket_attestation())
         self.feishu.set_confirm(self.state.record_id, False)
         self._log(f"  ✅ 整票完成（{why}）")
+        if getattr(self, "_batch_card_mode", False):
+            # 批量模式：单票不再发完成卡，统一由批次卡片汇总
+            return True
         if not notify:
             return True
+        # 2026-10-21 客户口径：不再逐票发 FULL 成功卡；batch 模式只允许批次汇总卡。
+        mode = _done_card_mode()
+        if mode == "off" or (mode == "batch" and not getattr(self, "_batch_card_mode", False)):
+            try:
+                _record_notify_fact("card", self.cfg.feishu_chat or self.cfg.feishu_user,
+                                    f"FULL 完成卡已抑制（{DONE_CARD_MODE_ENV}={mode}）："
+                                    f"货件#{self.state.shipment_id} {self.state.sku}")
+            except Exception:
+                pass
+            return True
         # KB-110：完成通知卡片化（绿卡 ✅），失败降级为原文字
         # 2026-09-18：这是**唯一默认外发**的通知（final=True）——落内部群、主 Bot 身份
         _done_chat, _done_profile = _done_card_sink(self.cfg)
@@ -7501,6 +7616,10 @@ class Orchestrator:
         """
         if not self.state.record_id:
             return
+        # 测试/只取消预约：不写 FULL 当前步骤（避免测试污染生产 FULL 流程）
+        if os.environ.get("ARGENT_NO_PROGRESS") == "1":
+            self._log("  ⏭ ARGENT_NO_PROGRESS=1：跳过写「当前步骤」")
+            return
         labels = STEP_PROGRESS.get(step)
         if not labels:
             return
@@ -7520,6 +7639,8 @@ class Orchestrator:
         """
         if not self.state.record_id:
             return
+        if os.environ.get("ARGENT_NO_PROGRESS") == "1":
+            return
         labels = STEP_PROGRESS.get(step)
         if labels:
             base = labels[0]
@@ -9486,9 +9607,10 @@ class Orchestrator:
 
     async def step4_appointment(self) -> None:
         self._log("步骤4 货件预约时间")
-        # 同店步骤4互斥锁（方案C，2026-08-14）：同店多记录并行时预约提交串行排队——
-        # ML 同店同一时段只允许一个有效预约，锁消除并发同时段冲突（根治）。换时段/换日期
-        # 重试兜底平台侧残留冲突（如历史预约占时段）。锁覆盖整个步骤 4（含重试循环），finally 释放。
+        # 同店步骤4互斥锁（方案C，2026-08-14）：**保守串行**，不是已验证的平台规则。
+        # ⚠️ 2026-10-20 复核：没有实验/事故证据证明 ML 同店同时段只能有一个预约；
+        # 这条锁最初只是设计假设。保留它的收益是降低同店并发提交/页态干扰，
+        # 代价是步4串行排队；待双票同店实测后再决定保留或移除。锁覆盖整个步骤4，finally 释放。
         self._acquire_store_step4_lock()
         try:
             # ── 4-pre：**仓容前置探测**（2026-10-10）─────────────────────────────
@@ -9607,7 +9729,8 @@ class Orchestrator:
             ev["platform_error"] = plat
         return ev
 
-    async def _book_appointment(self, hour_idx: int, date_offset: int = 1) -> None:
+    async def _book_appointment(self, hour_idx: int, date_offset: int = 1, exact_date: str = '',
+                                time_from: str = '', time_to: str = '') -> None:
         """预约页表单填写+提交：运输方式 → 日期(平台今天+date_offset) → 时段(hour_idx) → 双 Confirmar → 等跳转。
 
         页面必须已在 appointment-v2（调用方保证）；hour_idx=0 选第一个可用时段（现状），
@@ -9789,8 +9912,13 @@ class Orchestrator:
         # 4c. 日期选择：点击只读日期输入框打开日历，然后灰圈算法选第 30 格
         await self.browser.click_selector_with_fallback(4, "date_input")
         await asyncio.sleep(1)
-        picked = await self._pick_date(date_offset)
-        self._log(f"  预约日期: {picked}")
+        if exact_date:
+            picked = await self._pick_exact_date(exact_date)
+            self._last_booked_date = exact_date
+        else:
+            picked = await self._pick_date(date_offset)
+            self._last_booked_date = getattr(self, '_last_picked_date', '') or ''
+        self._log(f"  预约日期: {picked}（严格目标={exact_date or '-'}）")
         # 4d. 时间选择（div.hour 列表；hour_idx=0 取第一个=现状，冲突重试时递增换时段）
         hour_chain = self.sel.chain(4, "hour")
         loc = self.browser.page.locator(hour_chain[0])
@@ -9810,7 +9938,37 @@ class Orchestrator:
                 raise StepError(4, "business",
                                 f"预约失败：可用时段不足（需第 {hour_idx + 1} 个时段，实际 {await loc.count()} 个）",
                                 recovery_attempted=["appointment_hour_retry"])
-            hour_text = (await loc.nth(hour_idx).text_content() or "").strip()
+            # 用户三个条件之「时间范围」：按页面真实时段筛选；无匹配时段 ⇒ 不提交，
+            # 让 appointment worker 把该日标为 selectable_no_slot 并继续下一日/下一轮。
+            chosen_idx = hour_idx
+            hour_texts = []
+            for _i in range(await loc.count()):
+                try:
+                    hour_texts.append(((await loc.nth(_i).text_content()) or "").strip())
+                except Exception:
+                    hour_texts.append("")
+            if time_from or time_to:
+                def _minutes(t: str) -> int:
+                    m = re.search(r"(\d{1,2})[:：.](\d{2})", t or "")
+                    if not m:
+                        return -1
+                    return int(m.group(1)) * 60 + int(m.group(2))
+                lo = _minutes(time_from) if time_from else 0
+                hi = _minutes(time_to) if time_to else 24 * 60
+                chosen_idx = -1
+                for _i, _text in enumerate(hour_texts):
+                    _start = _minutes(_text)
+                    if _start >= 0 and lo <= _start < hi:
+                        chosen_idx = _i
+                        break
+                if chosen_idx < 0:
+                    raise StepError(4, "business",
+                                    f"预约失败：指定时间范围内无可预约时段（{time_from or '-'}~{time_to or '-'}；"
+                                    f"该日实际时段 {len(hour_texts)} 个）",
+                                    recovery_attempted=["appointment_hour_range"])
+                hour_idx = chosen_idx
+            hour_text = (hour_texts[hour_idx] if hour_idx < len(hour_texts) else "") or ""
+            self._last_booked_slot = hour_text
             await loc.nth(hour_idx).click(timeout=15000)
         except StepError:
             raise
@@ -9969,6 +10127,75 @@ class Orchestrator:
         ev = await self._appointment_page_evidence()
         return appointment_failure_text(appointment_form_verdict(ev), f"{base}｜{await self._calendar_diag()}")
 
+    async def _selected_date_iso(self) -> str:
+        """读取当前日历中 day--selected 对应的日期（YYYY-MM-DD）；失败返回空串。"""
+        try:
+            return await self.browser.page.evaluate(r"""() => {
+                const days = document.querySelectorAll('div.day');
+                const MONTHS = ['enero','febrero','marzo','abril','mayo','junio','julio',
+                                'agosto','septiembre','octubre','noviembre','diciembre'];
+                const my = document.querySelector('.focus-ui-datepicker__content__month-year');
+                const header = my ? (my.textContent || '').trim().toLowerCase() : '';
+                const viewMonths = MONTHS.map((m, mi) => header.includes(m) ? mi : -1).filter(x => x >= 0);
+                const ym = header.match(/(\d{4})/);
+                if (!viewMonths.length || !ym) return '';
+                let month = viewMonths[0] - 1, year = parseInt(ym[1], 10), prev = 0, started = false;
+                for (let i = 0; i < days.length; i++) {
+                    const txt = (days[i].textContent || '').trim();
+                    if (!/^\d+$/.test(txt)) continue;
+                    const d = parseInt(txt, 10);
+                    if (d === 1 && (prev > 1 || prev === 0)) {
+                        if (!started) { started = true; month = viewMonths[0]; year = parseInt(ym[1], 10); }
+                        else { month++; if (month > 11) { month = 0; year++; } }
+                    }
+                    prev = d;
+                    if (started && (days[i].className || '').includes('day--selected')) {
+                        return year + '-' + String(month + 1).padStart(2, '0') + '-' + String(d).padStart(2, '0');
+                    }
+                }
+                return '';
+            }""") or ""
+        except Exception:
+            return ""
+
+    async def _pick_exact_date(self, target_iso: str) -> str:
+        """严格选目标日期：只允许点目标日；disabled/找不到 ⇒ 报错，⛔ 不跳日。"""
+        from datetime import date as _date
+        tgt = _date.fromisoformat(target_iso)
+        target_month, target_year = tgt.month - 1, tgt.year
+        days = self.browser.page.locator("div.day")
+        for flip in range(3):
+            st = await self._calendar_state()
+            header = str(st.get("header") or "").lower()
+            months = ['enero','febrero','marzo','abril','mayo','junio','julio',
+                      'agosto','septiembre','octubre','noviembre','diciembre']
+            vis = [i for i, m in enumerate(months) if m in header]
+            yr_m = __import__('re').search(r'(\d{4})', header)
+            yr = int(yr_m.group(1)) if yr_m else 0
+            if target_month in vis and (not yr or yr == target_year):
+                r = await self.browser.page.evaluate(EXACT_DATE_JS, {"targetIso": target_iso})
+                if not r.get("found"):
+                    raise StepError(4, "selector_not_found",
+                                    f"预约失败：目标日期 {target_iso} 在日历中找不到（不跳日）",
+                                    recovery_attempted=["exact_date_strict"])
+                if r.get("disabled"):
+                    raise StepError(4, "business",
+                                    f"目标日期 {target_iso} 不可选（day--disabled）；不跳到其他日期",
+                                    recovery_attempted=["exact_date_strict"])
+                idx = int(r["idx"])
+                txt = (await days.nth(idx).text_content() or "").strip()
+                await days.nth(idx).click(timeout=15000)
+                await asyncio.sleep(1.0)
+                await self._verify_day_selected(days, idx)
+                await self._validate_picked_date()
+                self._last_picked_date = target_iso
+                return txt
+            await self._flip_month(st, target_month, target_year)
+            await asyncio.sleep(0.8)
+        raise StepError(4, "selector_not_found",
+                        f"预约失败：翻月后仍未找到目标日期 {target_iso}（不跳日）",
+                        recovery_attempted=["exact_date_strict", "exact_date_flip"])
+
     async def _pick_date(self, date_offset: int = 1) -> str:
         """灰圈算法：找 div.day--current，从其后的第 date_offset 格（灰圈后 1 格=明天）起选日期（跳过表头与 disabled 格）。
 
@@ -10027,6 +10254,7 @@ class Orchestrator:
                 # 8/13 用户实测加固：选日成功后校验所选日期 >= 今天+1（第二天）（防 fallback
                 # 在翻月失败后误选当月最近可用日，如 8/13 < 8/14 要求）→ 拒绝确认
                 await self._validate_picked_date()
+                self._last_picked_date = await self._selected_date_iso()
                 return txt
             n = await days.count()
             target = idx + date_offset  # 灰圈后第 date_offset 格=平台今天+date_offset（跳过表头/disabled 由下方 while 循环处理）
@@ -10053,6 +10281,7 @@ class Orchestrator:
             # 8/13 用户实测加固：主路径也校验所选日期 >= 今天+1（灰圈 idx+1 在翻月
             # 失败/视图异常时可能指向旧视图过早日期）→ 拒绝确认
             await self._validate_picked_date()
+            self._last_picked_date = await self._selected_date_iso()
             return txt
         raise StepError(4, "selector_not_found",
                         await self._pick_date_failure_text("翻月后仍无法选中"),
@@ -12224,7 +12453,7 @@ class Orchestrator:
         同 record 双写会往生产表写两遍（旧实现是函数内 `import fcntl` + `except: pass` ⇒
         Windows 上静默无锁）。被别人持有仍按原语义返回 None（skipped）。
         """
-        if self.args.no_lock:  # 并发实测/调试开关：跳过文件锁
+        if self.args.no_lock and not force:  # 并发实测/调试开关：跳过文件锁
             self._log("⚠️ 并发实测模式（无锁）")
             return True
         record_id = (self.state.record_id or "").strip()
@@ -12266,10 +12495,11 @@ class Orchestrator:
         name = str(self.state.store_name or self.cfg.store_name or "").strip()
         return re.sub(r"[^\w.-]+", "_", name).strip("_")
 
-    def _acquire_store_step4_lock(self) -> None:
+    def _acquire_store_step4_lock(self, force: bool = False) -> None:
         """阻塞获取同店步骤4互斥锁（`$ARGENT_LOCK_DIR/ziniao-store-<key>-step4.lock`，默认 /tmp）。
 
-        同店多记录并行时，步骤4预约提交串行排队（ML 同店同时段互斥规则）。
+        ⚠️ 这是**保守串行锁**：没有实验/事故证据证明“ML 同店同时段只能有一个预约”；
+    它只用于降低同店并发提交/页态干扰，不是已验证的平台规则（2026-10-20 复核）。
         锁随进程退出自动释放：锁对象保存 self._store_step4_lock 防回收。
         键口径与执行者锁统一走 `_store_lock_key()`（缺陷⑪）。
 
@@ -12278,7 +12508,7 @@ class Orchestrator:
         且平台侧的残留预约要人工擦。所以锁**不可用** ⇒ 抛 `StepError`（本步明确失败、下轮重试），
         绝不静默无锁硬提交。（"被别人持有"不是不可用：这里本来就是阻塞等它释放。）
         """
-        if self.args.no_lock:  # 并发实测/调试开关：跳过文件锁
+        if self.args.no_lock and not force:  # 并发实测/调试开关：跳过文件锁
             self._log("⚠️ 并发实测模式（无锁）")
             return
         store_id = self._store_lock_key()
@@ -12530,6 +12760,93 @@ class Orchestrator:
                     result["capacity_lift_max"] = _capacity_max_lift
                 return result
 
+    # ── 批量汇总卡片（一张卡实时更新）────────────────────────────────────────
+    BATCH_ERP_URL = os.environ.get("ML_ERP_BATCH_URL", "https://whyshu.com/admin/argent/#/office")
+
+    def _batch_card_payload(self, results: list[dict], total: int, done: bool = False) -> dict:
+        rows = []
+        ok = bad = 0
+        for i, r in enumerate(results, 1):
+            st = str(r.get("status") or "")
+            if st == "success":
+                ok += 1; state = "完成"; detail = "已上传标签/箱唛"
+            elif st == "partial":
+                bad += 1; state = "失败"; detail = "部分步骤失败"
+            elif st == "failed":
+                bad += 1; state = "失败"; detail = "失败"
+            elif st == "skipped":
+                state = "跳过"; detail = "跳过"
+            else:
+                state = st or "未知"; detail = ""
+            if st in ("partial", "failed") and r.get("error"):
+                detail = str((r.get("error") or {}).get("message") or detail)[:80]
+            rows.append({
+                "seq": str(i),
+                "record": str(r.get("record_id") or ""),
+                "shipment": str(r.get("shipment_id") or "-"),
+                "sku": str(r.get("sku") or "-"),
+                "state": state,
+                "detail": detail or "-",
+            })
+        title = "✅ FULL 批次完成" if done else "⏳ FULL 批次进行中"
+        header = "green" if done and bad == 0 else ("orange" if done else "blue")
+        elements = [
+            {"tag": "markdown", "content": f"**{self.state.store_name or self.cfg.store_name or '店铺'}**｜完成 {len(results)}/{total}｜成功 {ok}｜失败 {bad}"},
+        ]
+        if rows:
+            elements.append({
+                "tag": "table", "page_size": 20, "row_height": "low",
+                "header_style": {"bold": True, "background_style": "grey"},
+                "columns": [
+                    {"name": "seq", "display_name": "#", "data_type": "text", "width": "80px"},
+                    {"name": "shipment", "display_name": "货件号", "data_type": "text", "width": "120px"},
+                    {"name": "sku", "display_name": "SKU", "data_type": "text", "width": "140px"},
+                    {"name": "state", "display_name": "状态", "data_type": "text", "width": "90px"},
+                    {"name": "detail", "display_name": "结果", "data_type": "text", "width": "260px"},
+                ],
+                "rows": rows,
+            })
+        else:
+            elements.append({"tag": "markdown", "content": "暂无完成记录"})
+        elements.append({
+            "tag": "button", "text": {"tag": "plain_text", "content": "查看更多 / 打开 ERP"},
+            "type": "primary_filled", "width": "fill",
+            "behaviors": [{"type": "open_url", "default_url": self.BATCH_ERP_URL}],
+        })
+        return {
+            "schema": "2.0",
+            "config": {"wide_screen_mode": True},
+            "header": {"template": header, "title": {"tag": "plain_text", "content": title}},
+            "body": {"elements": elements},
+        }
+
+    def _batch_card_init(self, total: int) -> None:
+        self._batch_card_mode = True
+        self._batch_card_total = total
+        self._batch_card_message_id = ""
+        if getattr(self.feishu, "dry_run", False):
+            return
+        try:
+            chat, profile = _done_card_sink(self.cfg)
+            self._batch_card_chat = chat
+            self._batch_card_profile = profile
+            self._batch_card_message_id = self.feishu.send_card(
+                self._batch_card_payload([], total, done=False),
+                f"FULL 批次进行中：{self.state.store_name or self.cfg.store_name}（0/{total}）",
+                profile=profile, chat_id=chat, final=True)
+        except Exception as exc:                              # noqa: BLE001
+            self._log(f"  ⚠️ 批次卡片初始化失败（不影响流程）: {exc}")
+
+    def _batch_card_update(self, results: list[dict], done: bool = False) -> None:
+        if not getattr(self, "_batch_card_message_id", ""):
+            return
+        try:
+            self.feishu.update_card(self._batch_card_message_id,
+                                    self._batch_card_payload(results, self._batch_card_total, done=done),
+                                    profile=getattr(self, "_batch_card_profile", None))
+        except Exception as exc:                              # noqa: BLE001
+            self._log(f"  ⚠️ 批次卡片更新失败（不影响流程）: {exc}")
+
     async def _run_batch(self, mode: str, allow_write: bool,
                          step_filter: Optional[int]) -> dict[str, Any]:
         """KB-085 批量模式：一次 CDP 连接内处理同店多条记录（每记录独立标签页）。
@@ -12618,7 +12935,10 @@ class Orchestrator:
                     "results": results, "dry_run": dry_run}
         self._log(f"  ✅ 单连接已建立（连接 1 次 / 标签页 {len(record_ids)} 个），开始逐记录执行")
         results: list[dict[str, Any]] = []
+        self._batch_card_init(len(record_ids))
         for idx, rid in enumerate(record_ids):
+            if idx > 0:
+                self._batch_card_update(results, done=False)
             self._log(f"  ── 记录 {idx + 1}/{len(record_ids)}: {rid} ──")
             try:
                 rec = self.feishu.get_record(rid)
@@ -12726,6 +13046,7 @@ class Orchestrator:
                 # KB-133：改用带窗口守卫的关标签（关掉窗口最后一个标签会连带 Chromium
                 # 窗口退出 → 批内下一条记录「未找到窗口」，2026-09-11 实证）
                 await self.browser.close_record_page(page)
+        self._batch_card_update(results, done=True)
         await self.browser.close()
         self._log(f"📦 批量模式完成：连接 1 次 / 标签页 {len(record_ids)} 个 / 结果 {len(results)} 条")
         _rate = self._rate_summary()
@@ -12817,8 +13138,9 @@ class Orchestrator:
 
         # §8.57：**先拿店铺级执行者锁，再碰店铺窗口**（record 锁在取窗口之后才生效，挡不住抢窗）。
         # 拿不到 ⇒ skipped 退出：不写表、不发卡、不算失败。
-        if not self.acquire_store_executor_lock():
-            return {"status": "skipped", "reason": "store_busy",
+        if not getattr(self.args, "no_store_lock", False):
+            if not self.acquire_store_executor_lock():
+                return {"status": "skipped", "reason": "store_busy",
                     "holder": self._store_exec_holder,
                     "store": self.state.store_name or self.cfg.store_name}
 
@@ -13495,14 +13817,75 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--store-name", help="店铺名过滤待处理记录（如 1店-子账号；取第一条店铺名匹配的 Pending+就绪 记录）")
     # KB-085：批量模式——一次 CDP 连接内处理同店多条记录（每记录独立标签页）
     p.add_argument("--records", help="批量模式：逗号分隔记录 ID 列表（poll 按店分组传入；单连接多标签页，需配合 --store-name）")
+    p.add_argument("--parallel-records", type=int, default=0,
+                   help="批量模式并行度：>1 时每条记录独立子进程+独立标签页并发执行（默认 0=逐记录串行）")
     p.add_argument("--cdp-url", help=f"紫鸟浏览器 CDP 地址（默认 {DEFAULT_CDP_URL}）")
     p.add_argument("--no-lock", action="store_true",
                    help="跳过 record flock 锁，仅供并发实测/调试")
+    p.add_argument("--no-store-lock", action="store_true",
+                   help="跳过店铺级执行者锁（仅供父批处理已持锁时派出的子进程）")
     p.add_argument("--dry-run", action="store_true",
                    help="lip-poll 预演：识别/拾取判定只打印不写表（KB-095 远程机安全实测）")
     return p
 
 
+async def _run_batch_parallel(orch: "Orchestrator", args: argparse.Namespace) -> dict[str, Any]:
+    """批量并行：父进程持有店铺锁，每条记录派独立 orchestrator 子进程 + 独立标签页。"""
+    record_ids = [r.strip() for r in str(args.records or "").split(",") if r.strip()]
+    if not record_ids:
+        return {"status": "failed", "error": {"step": None, "type": "business", "message": "--records 为空"}}
+    if not orch.acquire_store_executor_lock():
+        return {"status": "batch", "connections": 0, "records": len(record_ids),
+                "results": [{"status": "skipped", "record_id": r, "reason": "store_busy"} for r in record_ids]}
+    parallel = max(1, min(5, int(args.parallel_records or 2)))
+    store = args.store_name or orch.state.store_name or orch.cfg.store_name or ""
+    sem = asyncio.Semaphore(parallel)
+    script = str(Path(__file__).resolve())
+
+    async def run_one(rid: str) -> dict[str, Any]:
+        async with sem:
+            cmd = [sys.executable, script, "--mode", "full", "--record-id", rid,
+                   "--store-name", store, "--allow-write", "--no-store-lock"]
+            orch._log(f"  🚀 并行子进程: record={rid}（店铺锁由父进程持有）")
+            proc = await asyncio.create_subprocess_exec(
+                *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, "ARGENT_NO_STORE_LOCK": "1"},
+            )
+            out, err = await proc.communicate()
+            out_s = out.decode("utf-8", "replace")
+            err_s = err.decode("utf-8", "replace")
+            result = None
+            for line in reversed(out_s.splitlines()):
+                try:
+                    j = json.loads(line)
+                    if isinstance(j, dict) and j.get("status"):
+                        result = j
+                        break
+                except Exception:
+                    continue
+            if result is None:
+                result = {"status": "failed", "record_id": rid,
+                          "error": {"step": None, "type": "cli_error",
+                                    "message": (err_s or out_s)[-800:] or f"子进程退出码 {proc.returncode}"}}
+            result.setdefault("record_id", rid)
+            result["parallel_child_exit"] = proc.returncode
+            orch._log(f"  ✅ 并行子进程完成: record={rid} status={result.get('status')} exit={proc.returncode}")
+            return result
+
+    try:
+        results = await asyncio.gather(*(run_one(r) for r in record_ids))
+    finally:
+        try:
+            lock = getattr(orch, "_store_exec_lock", None)
+            if lock is not None:
+                lock.release()
+                orch._store_exec_lock = None
+        except Exception:
+            pass
+    return {"status": "batch", "connections": 0, "records": len(record_ids),
+            "parallel": parallel, "store": store, "results": list(results)}
+
+
 async def _run_and_close(orch: "Orchestrator", args: argparse.Namespace) -> dict[str, Any]:
     """统一运行入口：无论成功/失败/needs_approval/异常，finally 必关自建标签页（防泄漏）。
 
@@ -13850,7 +14233,10 @@ def main(argv: Optional[list[str]] = None) -> int:
 
     orch = Orchestrator(cfg, sel, args)
     try:
-        result = asyncio.run(_run_and_close(orch, args))
+        if args.records and int(args.parallel_records or 0) > 1 and args.mode == "full":
+            result = asyncio.run(_run_batch_parallel(orch, args))
+        else:
+            result = asyncio.run(_run_and_close(orch, args))
     except StepError as exc:  # 顶层兜底（如配置缺失/步骤保护未捕获）
         orch._fail_record(exc.step or 0, exc, dry_run=args.mode == "dry-run")
         result = {"status": "failed", "record_id": orch.state.record_id or None,