aria-code 0.64.0__tar.gz → 0.65.0__tar.gz

{aria_code-0.64.0 → aria_code-0.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.64.0
+Version: 0.65.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.64.0 → aria_code-0.65.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.64.0"
+version = "0.65.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.64.0"
+__version__ = "0.65.0"

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code/apps/channels/README.md

@@ -45,3 +45,18 @@ send(reply)
 `aria_feishu_bot.feishu_inbound` is the Feishu version of that first step.
 Conversation keys are `<channel>:<conversation id>`, so the same chat id on
 two platforms is two conversations.
+
+## The shipper digest (`digest.py`)
+
+The first thing the conversation layer enables that a reply-only bot cannot:
+each group bound to a shipper is sent, unprompted, what needs attention —
+reorders, SKUs with too little history to plan, dead stock, waybills to query,
+and safe carrier switches. `run_digests(store, senders)` walks the bindings and
+hands each digest to that channel's sender, so a new channel registers a
+`(conversation_id, title, body) -> bool` function and gets the digest too.
+
+Data comes from the operator's `ARIA_SHIPPER_FEEDS` file, never from chat, and
+is read through the logistics tools under `ARIA_OWNER_SCOPE`, so a shared
+multi-shipper export yields only that shipper's lines. Configuration problems
+go to the log, not the client's group; a day with nothing to report sends
+nothing.

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code/apps/channels/conversation.py

@@ -192,6 +192,12 @@ class ConversationStore:
         with self._db() as db:
             db.execute("DELETE FROM bindings WHERE conversation = ?", (key,))
 
+    def bindings(self) -> List[Tuple[str, str]]:
+        """Every (conversation key, shipper) binding, for jobs that push to them."""
+        with self._db() as db:
+            return [tuple(row) for row in db.execute(
+                "SELECT conversation, owner_id FROM bindings ORDER BY conversation")]
+
     def owner_for(self, key: str) -> Optional[str]:
         with self._db() as db:
             row = db.execute("SELECT owner_id FROM bindings WHERE conversation = ?", (key,)).fetchone()

aria_code-0.65.0/src/aria_code/apps/channels/digest.py

@@ -0,0 +1,185 @@
+"""The daily shipper digest: what needs attention, pushed to the shipper's group.
+
+A bot that only answers questions waits to be asked about the SKU that ran out
+yesterday. This sends each shipper's group, unprompted, what the 3PL would
+otherwise find out too late: what to reorder, what history is too thin to
+plan from, what stock has stopped moving, which waybills to query with the
+carrier, and where a cheaper carrier is at least as reliable.
+
+Platform-neutral like the rest of apps/channels: it walks the conversations
+bound to a shipper (ConversationStore) and hands each digest to that
+channel's sender. Feishu is the first sender; another channel registers one.
+
+Where the data comes from is the operator's decision, not the chat's:
+ARIA_SHIPPER_FEEDS names a JSON file mapping each shipper to its exports —
+
+    {"ACME": {"inventory": "/data/acme/skus.csv", "waybills": "/data/acme/waybills.csv"},
+     "*":    {"inventory": "/data/wms/all_skus.csv"}}
+
+"*" is the fallback for shippers without their own entry, typically one
+multi-shipper export. Letting a chat command set a path would let anyone in
+the group read any CSV on the host.
+
+Every number comes from plan_inventory_policy and score_carriers, run with
+ARIA_OWNER_SCOPE set to the shipper — the same tool-level confinement a bound
+conversation gets — so a shared multi-shipper export yields only that
+shipper's lines, and a file without owner_id is refused rather than guessed.
+Digests are built one at a time: the scope is process environment, and the
+tools are synchronous, so nothing else runs while it is set.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Awaitable, Callable, Dict, Iterator, List, Optional
+
+from aria_code.apps.channels.conversation import ConversationStore
+from aria_code.tools.logistics_tenancy import OWNER_SCOPE_ENV
+
+logger = logging.getLogger(__name__)
+
+FEEDS_ENV = "ARIA_SHIPPER_FEEDS"
+MAX_LINES = 8  # per section; a digest is a prompt to look, not the report
+
+# (conversation_id, title, body) -> delivered?
+Sender = Callable[[str, str, str], Awaitable[bool]]
+
+
+@dataclass
+class Digest:
+    owner_id: str
+    title: str
+    body: str = ""
+    items: int = 0
+    problems: List[str] = field(default_factory=list)
+
+    @property
+    def worth_sending(self) -> bool:
+        return self.items > 0
+
+
+def load_feeds(path: Optional[str] = None) -> Dict[str, Dict[str, str]]:
+    """The operator's shipper → export files map; {} when not configured."""
+    source = path or os.environ.get(FEEDS_ENV, "").strip()
+    if not source:
+        return {}
+    data = json.loads(Path(source).expanduser().read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"{FEEDS_ENV} must be a JSON object of shipper -> feeds")
+    return {str(k): {kind: str(v) for kind, v in (feeds or {}).items()} for k, feeds in data.items()}
+
+
+def feeds_for(owner_id: str, feeds: Dict[str, Dict[str, str]]) -> Dict[str, str]:
+    return feeds.get(owner_id) or feeds.get("*") or {}
+
+
+@contextmanager
+def _confined_to(owner_id: str) -> Iterator[None]:
+    previous = os.environ.get(OWNER_SCOPE_ENV)
+    os.environ[OWNER_SCOPE_ENV] = owner_id
+    try:
+        yield
+    finally:
+        if previous is None:
+            os.environ.pop(OWNER_SCOPE_ENV, None)
+        else:
+            os.environ[OWNER_SCOPE_ENV] = previous
+
+
+def _section(title: str, lines: List[str]) -> str:
+    shown = lines[:MAX_LINES]
+    more = f"\n- …另有 {len(lines) - MAX_LINES} 项" if len(lines) > MAX_LINES else ""
+    return f"**{title}（{len(lines)}）**\n" + "\n".join(f"- {line}" for line in shown) + more
+
+
+def build_digest(owner_id: str, feeds: Dict[str, Dict[str, str]]) -> Digest:
+    from aria_code.tools.logistics_carriers import tool_score_carriers
+    from aria_code.tools.logistics_inventory import tool_plan_inventory_policy
+
+    digest = Digest(owner_id=owner_id, title=f"📦 {owner_id} 今日库存与运费提醒")
+    sources = feeds_for(owner_id, feeds)
+    sections: List[str] = []
+
+    with _confined_to(owner_id):
+        if sources.get("inventory"):
+            result = tool_plan_inventory_policy({"file_path": sources["inventory"]})
+            if result.get("success"):
+                items = result["data"]["items"]
+                reorder = [i for i in items if i.get("action") == "reorder"]
+                thin = [i for i in items if i.get("action") == "insufficient_history"]
+                dead = [i for i in items if i.get("movement") == "dead"]
+                if reorder:
+                    sections.append(_section("建议补货", [
+                        f"{i['sku']}：订 {i['suggested_order_qty']}（现有可用 {i['inventory_position']:g}，"
+                        f"补货点 {i['reorder_point']}，约可撑 {i['days_of_cover']} 天）" for i in reorder]))
+                if thin:
+                    sections.append(_section("历史不足、未给建议", [
+                        f"{i['sku']}：仅 {i['history_days']} 天出库记录" for i in thin]))
+                if dead:
+                    sections.append(_section("呆滞库存", [
+                        f"{i['sku']}：在库 {i['on_hand']:g}" for i in dead]))
+                digest.items += len(reorder) + len(thin) + len(dead)
+            else:
+                digest.problems.append(f"inventory: {result.get('error')}")
+
+        if sources.get("waybills"):
+            result = tool_score_carriers({"file_path": sources["waybills"]})
+            if result.get("success"):
+                data = result["data"]
+                anomalies, savings = data.get("anomalies") or [], data.get("savings") or []
+                if anomalies:
+                    sections.append(_section("运费待核对", [
+                        f"{a['waybill_no']}（{a['carrier']} {a['lane']}）：{a['detail']}" for a in anomalies]))
+                if savings:
+                    sections.append(_section("可节省的线路", [
+                        f"{s['lane']}：{s['from_carrier']} → {s['to_carrier']}，"
+                        f"按近期运量约省 {s['estimated_saving']:g}（准时率不低于现承运商）" for s in savings]))
+                digest.items += len(anomalies) + len(savings)
+            else:
+                digest.problems.append(f"waybills: {result.get('error')}")
+
+    if not sources:
+        digest.problems.append(f"no feeds configured for {owner_id}")
+    digest.body = "\n\n".join(sections) + (
+        "\n\n建议数量未计入起订量、箱规和供应商条款；运费异常请先与承运商核对再下结论。" if sections else "")
+    return digest
+
+
+async def run_digests(store: ConversationStore, senders: Dict[str, Sender],
+                      feeds: Optional[Dict[str, Dict[str, str]]] = None) -> List[Dict[str, str]]:
+    """Send today's digest to every bound conversation that has something to say.
+
+    Returns one record per conversation for the log. Problems — a missing
+    feed, a file the tenancy check refused — go to the log only: a client's
+    group is not where a 3PL's configuration errors belong.
+    """
+    feeds = load_feeds() if feeds is None else feeds
+    report: List[Dict[str, str]] = []
+    built: Dict[str, Digest] = {}
+    for conversation, owner_id in store.bindings():
+        channel, _, conversation_id = conversation.partition(":")
+        send = senders.get(channel)
+        if send is None:
+            report.append({"conversation": conversation, "status": "no_sender"})
+            continue
+        if owner_id not in built:
+            try:
+                built[owner_id] = build_digest(owner_id, feeds)
+            except Exception as exc:  # one bad feed must not stop the others
+                logger.warning("digest for %s failed: %s", owner_id, exc)
+                report.append({"conversation": conversation, "status": "error"})
+                continue
+        digest = built[owner_id]
+        for problem in digest.problems:
+            logger.warning("digest %s: %s", owner_id, problem)
+        if not digest.worth_sending:
+            report.append({"conversation": conversation, "status": "nothing_to_report"})
+            continue
+        delivered = await send(conversation_id, digest.title, digest.body)
+        report.append({"conversation": conversation, "status": "sent" if delivered else "send_failed"})
+    return report

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code/aria_daemon.py

@@ -1080,6 +1080,25 @@ async def _execute_job(job: dict) -> None:
             conn.commit()
 
 
+# ── Shipper digest ───────────────────────────────────────────────────────────
+
+async def _run_shipper_digests() -> None:
+    """Push each bound shipper group its digest (apps/channels/digest.py)."""
+    try:
+        from apps.channels.conversation import ConversationStore
+        from apps.channels.digest import run_digests
+
+        senders = {}
+        if os.environ.get("FEISHU_APP_ID") and os.environ.get("FEISHU_APP_SECRET"):
+            from aria_feishu_bot import send_digest_card
+            senders["feishu"] = send_digest_card
+        report = await run_digests(ConversationStore(), senders)
+        for line in report:
+            logger.info("shipper digest %s: %s", line["conversation"], line["status"])
+    except Exception as exc:
+        logger.error("shipper digest job failed: %s", exc)
+
+
 # ── APScheduler cron ─────────────────────────────────────────────────────────
 
 def _start_scheduler() -> None:
@@ -1152,6 +1171,20 @@ def _start_scheduler() -> None:
         )
         logger.info("Registered 4 default scheduled jobs (morning / US / evening / weekly)")
 
+        # Shipper digest: each group bound to a shipper gets what needs
+        # attention. Only when the operator has said where the data is.
+        if os.environ.get("ARIA_SHIPPER_FEEDS", "").strip():
+            cron = os.environ.get("ARIA_DIGEST_CRON", "30 8 * * 1-6").strip()
+            scheduler.add_job(
+                _run_shipper_digests,
+                CronTrigger.from_crontab(cron, timezone="Asia/Shanghai"),
+                id="default_shipper_digest",
+                name="货主库存与运费提醒",
+                replace_existing=True,
+                misfire_grace_time=1800,
+            )
+            logger.info("Registered shipper digest [%s]", cron)
+
         scheduler.start()
         logger.info("APScheduler started with %d job(s)", len(scheduler.get_jobs()))
         return scheduler

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code/aria_feishu_bot.py

@@ -297,11 +297,17 @@ async def _reply_card_raw(message_id: str, title: str, body: str,
 
 
 async def send_card_to_chat(chat_id: str, title: str, body: str,
-                            color: str = "blue", receive_id_type: str = "chat_id") -> None:
-    """Send a new card message to a chat (group or user)."""
+                            color: str = "blue", receive_id_type: str = "chat_id") -> bool:
+    """Send a new card message to a chat (group or user). True if Feishu accepted it.
+
+    The content is the card itself. It was wrapped as {"card": ...} — the
+    custom-webhook format, which /im/v1/messages rejects — and the response
+    was never read, so every proactive send failed without a trace. Nothing
+    scheduled depended on it until the shipper digest.
+    """
     token = await _get_access_token()
     if not token:
-        return
+        return False
     elements = _build_card_elements(body)
     card = {
         "config": {"wide_screen_mode": True},
@@ -311,17 +317,23 @@ async def send_card_to_chat(chat_id: str, title: str, body: str,
     try:
         import httpx
         async with httpx.AsyncClient(timeout=15) as client:
-            await client.post(
+            resp = await client.post(
                 f"{_FEISHU_API}/im/v1/messages?receive_id_type={receive_id_type}",
                 headers={"Authorization": f"Bearer {token}"},
                 json={
                     "receive_id": chat_id,
                     "msg_type":   "interactive",
-                    "content":    json.dumps({"card": card}),
+                    "content":    json.dumps(card),
                 },
             )
+        result = resp.json()
     except Exception as exc:
         logger.warning("send_card_to_chat failed: %s", exc)
+        return False
+    if result.get("code") != 0:
+        logger.warning("send_card_to_chat rejected: code=%s msg=%s", result.get("code"), result.get("msg"))
+        return False
+    return True
 
 
 # ── Command router ─────────────────────────────────────────────────────────────
@@ -1082,6 +1094,34 @@ def feishu_inbound(event: Dict[str, Any], text: str) -> InboundMessage:
     )
 
 
+async def _send_digest_now(conversation: str, message_id: str) -> None:
+    """/digest: this group's shipper digest, now, as a reply."""
+    from aria_code.apps.channels.digest import build_digest, load_feeds
+
+    owner = _conversation_store().owner_for(conversation)
+    if not owner:
+        await reply_text(message_id, "本群未绑定货主，没有可发送的简报。管理员可发送 /owner <货主ID> 绑定。")
+        return
+    try:
+        digest = build_digest(owner, load_feeds())
+    except Exception as exc:
+        logger.warning("digest for %s failed: %s", owner, exc)
+        digest = None
+    if digest is None or digest.problems and not digest.worth_sending:
+        # The details are for the operator's log, not the client's group.
+        await reply_text(message_id, "暂时无法生成简报，已记录到运维日志。")
+        return
+    if not digest.worth_sending:
+        await reply_text(message_id, f"{owner}：今天没有需要处理的补货、呆滞或运费异常。")
+        return
+    await reply_card(message_id, digest.title, digest.body, "orange")
+
+
+async def send_digest_card(chat_id: str, title: str, body: str) -> bool:
+    """The Feishu sender for apps.channels.digest.run_digests."""
+    return await send_card_to_chat(chat_id, title, body, "orange")
+
+
 # ── Main event dispatcher (called by feishu_routes.py or standalone) ──────────
 
 async def dispatch_event(raw: Dict[str, Any], *, authorized_by_binding: bool = False) -> Dict[str, Any]:
@@ -1163,6 +1203,9 @@ async def dispatch_event(raw: Dict[str, Any], *, authorized_by_binding: bool = F
         if owner_reply is not None:
             await reply_text(msg_id, owner_reply)
             return {"code": 0}
+        if text.strip().lower() in ("/digest", "/简报"):
+            asyncio.create_task(_send_digest_now(inbound.key, msg_id))
+            return {"code": 0}
 
         # A task copies the context it is created in, so every aria subprocess
         # the tasks below start runs under this conversation's shipper scope.

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.64.0
+Version: 0.65.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.64.0 → aria_code-0.65.0}/src/aria_code.egg-info/SOURCES.txt

@@ -143,6 +143,7 @@ src/aria_code/apps/__init__.py
 src/aria_code/apps/channels/README.md
 src/aria_code/apps/channels/__init__.py
 src/aria_code/apps/channels/conversation.py
+src/aria_code/apps/channels/digest.py
 src/aria_code/apps/channels/intake.py
 src/aria_code/apps/channels/registry.py
 src/aria_code/apps/channels/tradingview.py
@@ -663,6 +664,7 @@ tests/test_safety_service_adoption.py
 tests/test_service_diagnostics_security.py
 tests/test_session_search.py
 tests/test_settings_service.py
+tests/test_shipper_digest.py
 tests/test_single_import_root.py
 tests/test_skill_agent_binding.py
 tests/test_skill_catalog.py

aria_code-0.65.0/tests/test_shipper_digest.py

@@ -0,0 +1,241 @@
+"""The daily shipper digest: right content, right group, nothing else's.
+
+apps/channels/digest.py pushes each group bound to a shipper what needs
+attention. These pin what a 3PL would be embarrassed by: one shipper's lines
+in another's group, a digest built from a file nobody can attribute, a
+configuration error shown to a client, and a "sent" that was never delivered.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import csv
+import json
+import os
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+from aria_code.apps.channels.conversation import ConversationStore
+from aria_code.apps.channels.digest import build_digest, load_feeds, run_digests
+from aria_code.tools.logistics_tenancy import OWNER_SCOPE_ENV
+
+ROOT = Path(__file__).resolve().parents[1]
+INVENTORY = ROOT / "evals" / "fixtures" / "inventory_reorder" / "skus.csv"     # all ACME
+WAYBILLS = ROOT / "evals" / "fixtures" / "freight_audit" / "waybills.csv"     # no owner_id
+
+
+@pytest.fixture(autouse=True)
+def isolated(monkeypatch, tmp_path):
+    for key in (OWNER_SCOPE_ENV, "ARIA_SHIPPER_FEEDS", "FEISHU_ALLOWED_USER_IDS", "ARIA_CHANNEL_ADMINS"):
+        monkeypatch.delenv(key, raising=False)
+    monkeypatch.setenv("ARIA_CONVERSATIONS_DB", str(tmp_path / "bot.db"))
+
+
+def _shared_export(tmp_path) -> dict:
+    """One multi-shipper WMS/TMS export each — the common 3PL setup."""
+    inventory = tmp_path / "all_skus.csv"
+    rows = list(csv.DictReader(INVENTORY.open()))
+    beta = [{**r, "owner_id": "BETA", "sku": "B" + r["sku"][1:]} for r in rows]
+    with inventory.open("w", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows + beta)
+    waybills = tmp_path / "all_waybills.csv"
+    rows = list(csv.DictReader(WAYBILLS.open()))
+    with waybills.open("w", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=["owner_id", *rows[0]])
+        writer.writeheader()
+        writer.writerows({"owner_id": "ACME", **r} for r in rows)
+    return {"*": {"inventory": str(inventory), "waybills": str(waybills)}}
+
+
+class TestBuildDigest:
+    def test_a_shipper_sees_its_reorders_thin_history_and_freight_issues(self, tmp_path):
+        digest = build_digest("ACME", _shared_export(tmp_path))
+        assert digest.worth_sending and not digest.problems
+        for expected in ("A100", "A200", "A600", "A400", "W1007", "W1093", "YTO → JD"):
+            assert expected in digest.body
+        assert "A500" not in digest.body, "covered by an open purchase order"
+
+    def test_a_shared_export_yields_only_that_shippers_lines(self, tmp_path):
+        digest = build_digest("BETA", _shared_export(tmp_path))
+        assert "B100" in digest.body
+        assert "A100" not in digest.body
+        assert "W1007" not in digest.body, "the waybills are all ACME's"
+
+    def test_a_file_that_cannot_be_attributed_is_refused_not_guessed(self):
+        digest = build_digest("ACME", {"ACME": {"waybills": str(WAYBILLS)}})
+        assert not digest.worth_sending
+        assert digest.problems and "owner_id" in digest.problems[0]
+
+    def test_no_feeds_is_a_problem_not_an_empty_success(self):
+        digest = build_digest("ACME", {})
+        assert not digest.worth_sending and digest.problems
+
+    def test_the_scope_does_not_outlive_the_digest(self, tmp_path):
+        build_digest("ACME", _shared_export(tmp_path))
+        assert OWNER_SCOPE_ENV not in os.environ
+
+    def test_feeds_come_from_the_operators_file(self, tmp_path, monkeypatch):
+        path = tmp_path / "feeds.json"
+        path.write_text(json.dumps({"ACME": {"inventory": "/data/a.csv"}}))
+        monkeypatch.setenv("ARIA_SHIPPER_FEEDS", str(path))
+        assert load_feeds() == {"ACME": {"inventory": "/data/a.csv"}}
+        monkeypatch.delenv("ARIA_SHIPPER_FEEDS")
+        assert load_feeds() == {}
+
+
+class TestRunDigests:
+    def test_each_bound_group_gets_its_own_shippers_digest(self, tmp_path):
+        store = ConversationStore(tmp_path / "c.db")
+        store.bind_owner("feishu:oc_acme", "ACME", bound_by="t")
+        store.bind_owner("feishu:oc_gamma", "GAMMA", bound_by="t")   # nothing in the export
+        store.bind_owner("telegram:42", "ACME", bound_by="t")        # no telegram sender here
+        sent = []
+
+        async def send(conversation_id, title, body):
+            sent.append((conversation_id, body))
+            return True
+
+        report = asyncio.run(run_digests(store, {"feishu": send}, _shared_export(tmp_path)))
+        statuses = {r["conversation"]: r["status"] for r in report}
+        assert statuses == {"feishu:oc_acme": "sent", "feishu:oc_gamma": "nothing_to_report",
+                            "telegram:42": "no_sender"}
+        assert [c for c, _ in sent] == ["oc_acme"]
+        assert "A100" in sent[0][1]
+
+    def test_a_failed_send_is_reported_as_failed(self, tmp_path):
+        store = ConversationStore(tmp_path / "c.db")
+        store.bind_owner("feishu:oc_acme", "ACME", bound_by="t")
+
+        async def send(*args):
+            return False
+
+        report = asyncio.run(run_digests(store, {"feishu": send}, _shared_export(tmp_path)))
+        assert report == [{"conversation": "feishu:oc_acme", "status": "send_failed"}]
+
+    def test_problems_stay_in_the_log(self, tmp_path):
+        store = ConversationStore(tmp_path / "c.db")
+        store.bind_owner("feishu:oc_acme", "ACME", bound_by="t")
+        sent = []
+
+        async def send(*args):
+            sent.append(args)
+            return True
+
+        asyncio.run(run_digests(store, {"feishu": send}, {"ACME": {"waybills": str(WAYBILLS)}}))
+        assert sent == []
+
+
+# ── Feishu ────────────────────────────────────────────────────────────────────
+
+import aria_code.aria_feishu_bot as bot  # noqa: E402
+
+
+class _Response:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def json(self):
+        return self._payload
+
+
+class _Client:
+    def __init__(self, payload, posts):
+        self.payload, self.posts = payload, posts
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *exc):
+        return False
+
+    async def post(self, url, **kwargs):
+        self.posts.append(kwargs["json"])
+        return _Response(self.payload)
+
+
+def _send(payload):
+    posts = []
+
+    async def token():
+        return "t"
+
+    async def go():
+        with mock.patch.object(bot, "_get_access_token", token), \
+             mock.patch("httpx.AsyncClient", lambda **kw: _Client(payload, posts)):
+            return await bot.send_card_to_chat("oc_acme", "title", "body")
+
+    return asyncio.run(go()), posts
+
+
+class TestFeishuSend:
+    def test_the_content_is_the_card_itself(self):
+        ok, posts = _send({"code": 0})
+        assert ok
+        card = json.loads(posts[0]["content"])
+        assert "card" not in card, "the {'card': ...} wrapper is the webhook format; the API rejects it"
+        assert card["header"]["title"]["content"] == "title"
+
+    def test_a_rejected_send_is_not_reported_as_delivered(self):
+        ok, _ = _send({"code": 230002, "msg": "bot not in chat"})
+        assert ok is False
+
+
+class TestDigestCommand:
+    def _run(self, monkeypatch, tmp_path, *, bound):
+        monkeypatch.setenv("FEISHU_ALLOWED_USER_IDS", "ou_ops")
+        monkeypatch.setenv("ARIA_SHIPPER_FEEDS", str(tmp_path / "feeds.json"))
+        (tmp_path / "feeds.json").write_text(json.dumps(_shared_export(tmp_path)))
+        if bound:
+            bot._conversation_store().bind_owner("feishu:oc_acme", "ACME", bound_by="t")
+        out = {"text": [], "cards": []}
+
+        async def reply_text(message_id, text):
+            out["text"].append(text)
+
+        async def reply_card(message_id, title, body, *args, **kwargs):
+            out["cards"].append((title, body))
+
+        event = {"header": {"event_type": "im.message.receive_v1"}, "event": {
+            "sender": {"sender_id": {"open_id": "ou_ops"}},
+            "message": {"message_id": "om_1", "chat_id": "oc_acme", "chat_type": "group",
+                        "message_type": "text", "content": json.dumps({"text": "@_user_1 /digest"}),
+                        "mentions": [{"key": "@_user_1", "id": {"open_id": "ou_bot"}}]}}}
+
+        async def go():
+            with mock.patch.object(bot, "reply_text", reply_text), \
+                 mock.patch.object(bot, "reply_card", reply_card):
+                await bot.dispatch_event(event)
+                for _ in range(3):
+                    await asyncio.sleep(0)
+
+        asyncio.run(go())
+        return out
+
+    def test_in_a_bound_group_it_replies_with_the_digest(self, monkeypatch, tmp_path):
+        out = self._run(monkeypatch, tmp_path, bound=True)
+        assert len(out["cards"]) == 1 and "A100" in out["cards"][0][1]
+
+    def test_in_an_unbound_group_it_says_how_to_bind(self, monkeypatch, tmp_path):
+        out = self._run(monkeypatch, tmp_path, bound=False)
+        assert out["cards"] == [] and "/owner" in out["text"][0]
+
+
+class TestDaemonJob:
+    def test_it_sends_through_feishu_when_the_app_is_configured(self, monkeypatch):
+        import aria_code.aria_daemon as daemon
+        monkeypatch.setenv("FEISHU_APP_ID", "cli_x")
+        monkeypatch.setenv("FEISHU_APP_SECRET", "s")
+        seen = {}
+
+        async def fake_run(store, senders, feeds=None):
+            seen["channels"] = sorted(senders)
+            return []
+
+        with mock.patch("aria_code.apps.channels.digest.run_digests", fake_run), \
+             mock.patch("apps.channels.digest.run_digests", fake_run, create=True):
+            asyncio.run(daemon._run_shipper_digests())
+        assert seen["channels"] == ["feishu"]