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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.63.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.63.0 → aria_code-0.65.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.63.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.63.0 → aria_code-0.65.0}/src/aria_code/_version.py

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

aria_code-0.65.0/src/aria_code/apps/channels/README.md

@@ -0,0 +1,62 @@
+# Channel Apps
+
+Target role: adapters for non-terminal entrypoints.
+
+Examples:
+
+- relay server/client;
+- Feishu bot;
+- Telegram bot;
+- webhooks;
+- future desktop or browser UI.
+
+Each channel should translate inbound messages into gateway requests and render
+gateway responses back to the channel. It should not bypass safety, runtime, or
+artifact policies.
+
+## The conversation layer (`conversation.py`)
+
+Everything a chat bot decides that does not depend on the platform lives in
+one module, so every channel — Feishu today, Arthera's own bot later — gets
+the same rules from the same code:
+
+| Rule | Where |
+|------|-------|
+| In a group, answer only when addressed; in a direct chat, always | `should_respond` |
+| One group = one shipper (货主), bound by an admin with `/owner <id>` | `handle_owner_command`, `ConversationStore` |
+| Admins are per channel: `ARIA_CHANNEL_ADMINS=feishu:ou_x,telegram:42` | `is_admin` |
+| Context is the conversation's own recent messages, never another's; capped at 20 messages and 7 days | `ConversationStore.history` |
+| A bound conversation runs every turn with `ARIA_OWNER_SCOPE`, enforced by the logistics tools themselves | `ChannelTurn.env`, `tools/logistics_tenancy.py` |
+
+A new channel is an adapter: turn the platform's event into an
+`InboundMessage`, then
+
+```python
+if not should_respond(msg):
+    return
+reply = handle_owner_command(msg, store)          # /owner commands
+if reply is None:
+    turn = prepare_turn(msg, store)               # context + shipper scope
+    reply = await run_model(turn.prompt, history=turn.history, env=turn.env)
+    store.record(msg.key, "assistant", reply)
+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.65.0/src/aria_code/apps/channels/conversation.py

@@ -0,0 +1,280 @@
+"""The platform-neutral half of every chat channel.
+
+A chat bot does the same five things on any platform: decide whether a
+message is for it, know which client a conversation belongs to, remember what
+was just said there, keep each conversation's memory to itself, and hand the
+model a turn. Only parsing the platform's event and sending its reply differ.
+This module is the part that does not differ, so Feishu, Telegram, and a bot
+on Arthera's own app or website share one implementation of the rules that
+matter — and a new channel is an adapter of a few dozen lines:
+
+    msg = InboundMessage(channel="myapp", conversation_id=room_id, kind="group",
+                         sender_id=user_id, text=text, mentions_bot=True)
+    if not should_respond(msg):
+        return
+    turn = prepare_turn(msg, store)
+    reply = await run_my_model(turn.prompt, history=turn.history, env=turn.env)
+    store.record(msg.key, "assistant", reply)
+
+The guarantees, each tested in tests/test_conversation_core.py:
+
+  - In a group the bot answers only when addressed; in a direct chat, always.
+  - A conversation bound to a shipper (货主) runs every turn with
+    ARIA_OWNER_SCOPE set, which the logistics tools enforce themselves
+    (tools/logistics_tenancy.py) — the binding does not rely on the prompt.
+  - Only channel admins (ARIA_CHANNEL_ADMINS) can bind or unbind.
+  - History is per conversation and never crosses: the context for a turn is
+    built from that conversation's own messages and nothing else.
+  - History is bounded twice: the last `max_turns` messages, none older than
+    `ttl_seconds`. A chat bot that keeps every client message forever is a
+    liability, not a feature.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sqlite3
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Dict, List, Optional, Tuple
+
+from aria_code.apps.channels.registry import CHANNEL_TASK_SCHEMA
+from aria_code.tools.logistics_tenancy import OWNER_SCOPE_ENV
+
+ADMINS_ENV = "ARIA_CHANNEL_ADMINS"
+DB_ENV = "ARIA_CONVERSATIONS_DB"
+_OWNER_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.\-]{0,63}$")
+
+
+@dataclass(frozen=True)
+class InboundMessage:
+    """One message, as any channel adapter normalises it."""
+
+    channel: str                 # "feishu", "telegram", "web", ...
+    conversation_id: str         # the chat / group / room on that channel
+    kind: str                    # "direct" or "group"
+    sender_id: str
+    text: str
+    message_id: str = ""
+    mentions_bot: bool = False
+    reply_to: str = ""           # the message this one answers, if any
+    sender_aliases: Tuple[str, ...] = ()   # other ids for the same person
+
+    @property
+    def key(self) -> str:
+        """Unique across channels: two platforms may reuse the same chat id."""
+        return f"{self.channel}:{self.conversation_id}"
+
+    @property
+    def sender_ids(self) -> Tuple[str, ...]:
+        return tuple(i for i in (self.sender_id, *self.sender_aliases) if i)
+
+
+def should_respond(msg: InboundMessage) -> bool:
+    """Direct chats always; groups only when the bot is addressed."""
+    if msg.kind == "direct":
+        return True
+    return bool(msg.mentions_bot)
+
+
+def is_admin(msg: InboundMessage, env: Optional[Dict[str, str]] = None) -> bool:
+    """ARIA_CHANNEL_ADMINS="feishu:ou_abc,telegram:12345" — per channel, fail closed."""
+    raw = (env if env is not None else os.environ).get(ADMINS_ENV, "")
+    admins = {item.strip() for item in raw.split(",") if item.strip()}
+    return any(f"{msg.channel}:{sid}" in admins for sid in msg.sender_ids)
+
+
+# ── Admin commands ───────────────────────────────────────────────────────────
+
+_OWNER_COMMAND = re.compile(r"^/(?:owner|货主)(?:\s+(\S+))?\s*$", re.IGNORECASE)
+_UNBIND_WORDS = {"off", "clear", "none", "解除", "取消"}
+
+
+def parse_owner_command(text: str) -> Optional[Tuple[str, str]]:
+    """'/owner' → show; '/owner ACME' → bind; '/owner off' → unbind. None otherwise."""
+    match = _OWNER_COMMAND.match((text or "").strip())
+    if not match:
+        return None
+    arg = (match.group(1) or "").strip()
+    if not arg:
+        return ("show", "")
+    if arg.lower() in _UNBIND_WORDS:
+        return ("unbind", "")
+    return ("bind", arg)
+
+
+def handle_owner_command(msg: InboundMessage, store: "ConversationStore",
+                         env: Optional[Dict[str, str]] = None) -> Optional[str]:
+    """Run an /owner command and return the reply text, or None if it is not one."""
+    command = parse_owner_command(msg.text)
+    if command is None:
+        return None
+    action, owner = command
+    current = store.owner_for(msg.key)
+    if action == "show":
+        return (f"本会话绑定的货主：{current}" if current
+                else "本会话未绑定货主。管理员可发送 /owner <货主ID> 绑定。")
+    if not is_admin(msg, env):
+        return "只有管理员可以修改本会话绑定的货主。"
+    if msg.kind != "group":
+        # A direct chat is one person, not a client; binding it would confine
+        # an operator's own chat to one shipper and surprise them later.
+        return "货主只能绑定到群聊：一个群对应一个货主。"
+    if action == "unbind":
+        store.unbind_owner(msg.key)
+        return "已解除本会话的货主绑定。"
+    if not _OWNER_ID.match(owner):
+        return "货主 ID 只能包含字母、数字、下划线、点和短横线，最长 64 个字符。"
+    store.bind_owner(msg.key, owner, bound_by=f"{msg.channel}:{msg.sender_id}")
+    return f"已绑定：本会话之后的分析只会使用货主 {owner} 的数据。"
+
+
+# ── Storage ──────────────────────────────────────────────────────────────────
+
+def default_db_path() -> Path:
+    configured = os.environ.get(DB_ENV, "").strip()
+    if configured:
+        return Path(configured).expanduser()
+    return Path.home() / ".aria" / "conversations.db"
+
+
+class ConversationStore:
+    """Owner bindings and bounded per-conversation history, in one SQLite file."""
+
+    def __init__(self, path: Optional[Path | str] = None, *, max_turns: int = 20,
+                 ttl_seconds: float = 7 * 86400, clock: Callable[[], float] = time.time) -> None:
+        self.path = Path(path) if path else default_db_path()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.max_turns = max(1, int(max_turns))
+        self.ttl_seconds = float(ttl_seconds)
+        self._clock = clock
+        with self._db() as db:
+            db.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS bindings (
+                    conversation TEXT PRIMARY KEY,
+                    owner_id     TEXT NOT NULL,
+                    bound_by     TEXT NOT NULL,
+                    bound_at     REAL NOT NULL
+                );
+                CREATE TABLE IF NOT EXISTS history (
+                    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+                    conversation TEXT NOT NULL,
+                    role         TEXT NOT NULL,
+                    sender       TEXT NOT NULL DEFAULT '',
+                    content      TEXT NOT NULL,
+                    at           REAL NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS history_by_conversation ON history (conversation, id);
+                """
+            )
+        try:
+            os.chmod(self.path, 0o600)  # client messages: owner-readable only
+        except OSError:
+            pass
+
+    def _db(self) -> sqlite3.Connection:
+        return sqlite3.connect(str(self.path))
+
+    # bindings
+    def bind_owner(self, key: str, owner_id: str, *, bound_by: str) -> None:
+        with self._db() as db:
+            db.execute(
+                "INSERT INTO bindings (conversation, owner_id, bound_by, bound_at) VALUES (?, ?, ?, ?) "
+                "ON CONFLICT(conversation) DO UPDATE SET owner_id=excluded.owner_id, "
+                "bound_by=excluded.bound_by, bound_at=excluded.bound_at",
+                (key, owner_id, bound_by, self._clock()),
+            )
+
+    def unbind_owner(self, key: str) -> None:
+        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()
+        return row[0] if row else None
+
+    # history
+    def record(self, key: str, role: str, content: str, *, sender: str = "") -> None:
+        if role not in ("user", "assistant") or not (content or "").strip():
+            return
+        now = self._clock()
+        with self._db() as db:
+            db.execute("INSERT INTO history (conversation, role, sender, content, at) VALUES (?, ?, ?, ?, ?)",
+                       (key, role, sender, content, now))
+            self._prune(db, key, now)
+
+    def history(self, key: str) -> List[Dict[str, str]]:
+        """Oldest first, in the {role, content} shape model providers take."""
+        now = self._clock()
+        with self._db() as db:
+            self._prune(db, key, now)
+            rows = db.execute(
+                "SELECT role, content FROM history WHERE conversation = ? ORDER BY id", (key,)
+            ).fetchall()
+        return [{"role": role, "content": content} for role, content in rows]
+
+    def forget(self, key: str) -> None:
+        with self._db() as db:
+            db.execute("DELETE FROM history WHERE conversation = ?", (key,))
+
+    def _prune(self, db: sqlite3.Connection, key: str, now: float) -> None:
+        db.execute("DELETE FROM history WHERE conversation = ? AND at < ?", (key, now - self.ttl_seconds))
+        db.execute(
+            "DELETE FROM history WHERE conversation = ? AND id NOT IN "
+            "(SELECT id FROM history WHERE conversation = ? ORDER BY id DESC LIMIT ?)",
+            (key, key, self.max_turns),
+        )
+
+
+# ── Turns ────────────────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class ChannelTurn:
+    """Everything a model call needs for one message, platform-free."""
+
+    prompt: str
+    history: List[Dict[str, str]] = field(default_factory=list)
+    owner_scope: Optional[str] = None
+
+    @property
+    def env(self) -> Dict[str, str]:
+        """Environment for a subprocess running this turn's tools."""
+        return {OWNER_SCOPE_ENV: self.owner_scope} if self.owner_scope else {}
+
+    def as_task(self, msg: InboundMessage) -> Dict[str, object]:
+        """The same turn as a structured channel task (aria.channel_task.v1)."""
+        return {
+            "schema": CHANNEL_TASK_SCHEMA,
+            "channel": msg.channel,
+            "conversation": msg.key,
+            "message_id": msg.message_id,
+            "prompt": self.prompt,
+            "history": list(self.history),
+            "owner_scope": self.owner_scope,
+        }
+
+
+def prepare_turn(msg: InboundMessage, store: ConversationStore) -> ChannelTurn:
+    """Record the incoming message and build the turn that answers it.
+
+    History is read before this message is recorded, so the turn carries the
+    conversation so far plus the new prompt — not the prompt twice.
+    """
+    history = store.history(msg.key)
+    owner = store.owner_for(msg.key)
+    store.record(msg.key, "user", msg.text, sender=msg.sender_id)
+    prompt = msg.text
+    if owner:
+        prompt = (f"[本会话属于货主 {owner}。只分析该货主的数据，回答中不要提及其他货主。]\n"
+                  f"{msg.text}")
+    return ChannelTurn(prompt=prompt, history=history, owner_scope=owner)

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.63.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