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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.64.0
+Version: 0.66.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.66.0}/pyproject.toml

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

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

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

@@ -0,0 +1,86 @@
+# 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.
+
+## Approvals (`approvals.py`)
+
+Bot runs cannot use confirmation-required tools, so a bot that may only
+suggest still leaves someone retyping its suggestion. Approvals are the
+sanctioned way through: the bot stores exactly what it proposes, an
+authorised person presses approve or reject in the chat, and only then does
+the action run — once, under the shipper's scope, with who and when recorded.
+
+| Rule | Why |
+|------|-----|
+| Approvers per channel (`ARIA_CHANNEL_APPROVERS`, plus admins); none by default | fail closed |
+| Only in the conversation that raised it | a forwarded card cannot be approved elsewhere |
+| A single conditional UPDATE claims the request | two presses cannot both execute |
+| Expires after 24 h | stale numbers should be recomputed, not approved |
+| The conversation must still be bound to the same shipper | a rebound group cannot run the old client's action |
+| The payload is frozen at request time | what was approved is what runs |
+| Failures are recorded, not shown in the chat | exceptions can name host paths |
+
+A channel renders the request with two buttons and calls
+`ApprovalStore.decide`; actions are registered in `EXECUTORS`. The first,
+`purchase_order_draft`, writes a CSV to `ARIA_APPROVAL_OUTBOX/<shipper>/` for
+the 3PL's purchasing system: Aria has no integration that places orders, and
+does not pretend to.

aria_code-0.66.0/src/aria_code/apps/channels/approvals.py

@@ -0,0 +1,263 @@
+"""Approvals: a bot may propose an action with consequences, a person decides.
+
+Bot runs cannot use confirmation-required tools, because nobody in a chat can
+answer a terminal prompt. That stops harm and also stops the useful half of
+the job — a reorder list someone still has to retype. This is the other way
+through: the bot writes down exactly what it proposes, an authorised person
+approves or rejects it in the chat, and only then does it happen, with a
+record of who decided what and when.
+
+Platform-neutral like the rest of apps/channels. A channel renders a request
+with approve/reject buttons and calls `decide` when one is pressed; the rules
+below hold whichever platform the button was on:
+
+  - Who may decide: ARIA_CHANNEL_APPROVERS, plus ARIA_CHANNEL_ADMINS, per
+    channel ("feishu:ou_x"). Nobody, when neither is set.
+  - Where: only in the conversation the request was raised in. A card
+    forwarded to another chat cannot be approved there.
+  - Once: the transition out of "pending" is a single conditional UPDATE, so
+    two clicks, or two approvers at the same moment, cannot both execute.
+  - Not late: a request expires after `ttl_seconds` (24 h).
+  - Not for someone else: the conversation must still be bound to the shipper
+    the request was made for, and the action runs under ARIA_OWNER_SCOPE.
+  - What was approved is what runs: the payload is frozen at request time and
+    executed as stored, never recomputed — the approver saw these lines.
+
+Actions are registered in EXECUTORS. The first, "purchase_order_draft", writes
+a CSV draft to an outbox directory (ARIA_APPROVAL_OUTBOX) for the 3PL's own
+purchasing system to pick up. Aria does not place orders: it has no
+integration that could, and pretending otherwise would be the wrong default.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import os
+import secrets
+import sqlite3
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+
+from aria_code.apps.channels.conversation import ADMINS_ENV, default_db_path
+from aria_code.tools.logistics_tenancy import OWNER_SCOPE_ENV
+
+APPROVERS_ENV = "ARIA_CHANNEL_APPROVERS"
+OUTBOX_ENV = "ARIA_APPROVAL_OUTBOX"
+
+PENDING, APPROVED, REJECTED, EXPIRED, FAILED = "pending", "approved", "rejected", "expired", "failed"
+
+
+def can_decide(channel: str, sender_ids: Tuple[str, ...], env: Optional[Dict[str, str]] = None) -> bool:
+    env = env if env is not None else os.environ
+    allowed = set()
+    for key in (APPROVERS_ENV, ADMINS_ENV):
+        allowed |= {item.strip() for item in env.get(key, "").split(",") if item.strip()}
+    return any(f"{channel}:{sid}" in allowed for sid in sender_ids if sid)
+
+
+@dataclass(frozen=True)
+class Approval:
+    id: str
+    conversation: str
+    owner_id: str
+    kind: str
+    payload: Dict[str, Any]
+    summary: str
+    requested_by: str
+    requested_at: float
+    status: str
+    decided_by: str = ""
+    decided_at: float = 0.0
+    result: str = ""
+
+
+@dataclass(frozen=True)
+class Decision:
+    ok: bool
+    message: str
+    approval: Optional[Approval] = None
+
+
+@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
+
+
+# ── Executors ────────────────────────────────────────────────────────────────
+
+def outbox_dir() -> Path:
+    configured = os.environ.get(OUTBOX_ENV, "").strip()
+    return Path(configured).expanduser() if configured else Path.home() / ".aria" / "outbox"
+
+
+def execute_purchase_order_draft(approval: Approval) -> str:
+    """Write the approved lines, exactly as approved, as a CSV draft."""
+    lines = approval.payload.get("lines") or []
+    if not lines:
+        raise ValueError("nothing to order")
+    folder = outbox_dir() / approval.owner_id
+    folder.mkdir(parents=True, exist_ok=True)
+    os.chmod(folder, 0o700)
+    stamp = time.strftime("%Y%m%d", time.localtime(approval.decided_at or time.time()))
+    path = folder / f"PO-{approval.owner_id}-{stamp}-{approval.id[:8]}.csv"
+    with path.open("x", newline="", encoding="utf-8") as handle:  # never overwrite a draft
+        writer = csv.writer(handle)
+        writer.writerow(["owner_id", "sku", "order_qty", "approval_id", "approved_by", "approved_at"])
+        decided = time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(approval.decided_at))
+        for line in lines:
+            writer.writerow([approval.owner_id, line["sku"], line["qty"], approval.id,
+                             approval.decided_by, decided])
+    return str(path)
+
+
+EXECUTORS: Dict[str, Callable[[Approval], str]] = {
+    "purchase_order_draft": execute_purchase_order_draft,
+}
+
+
+def propose_reorder(owner_id: str, inventory_path: str) -> Optional[Tuple[str, Dict[str, Any]]]:
+    """A purchase-order draft from the shipper's reorder list, or None if nothing to order."""
+    from aria_code.tools.logistics_inventory import tool_plan_inventory_policy
+
+    with _confined_to(owner_id):
+        result = tool_plan_inventory_policy({"file_path": inventory_path})
+    if not result.get("success"):
+        raise ValueError(result.get("error") or "inventory analysis failed")
+    lines = [{"sku": i["sku"], "qty": int(i["suggested_order_qty"])}
+             for i in result["data"]["items"]
+             if i.get("action") == "reorder" and i.get("suggested_order_qty")]
+    if not lines:
+        return None
+    summary = "\n".join(f"- {line['sku']}：{line['qty']}" for line in lines)
+    return summary, {"lines": lines}
+
+
+# ── Store ────────────────────────────────────────────────────────────────────
+
+class ApprovalStore:
+    """Requests and decisions, in the same SQLite file as the conversations."""
+
+    def __init__(self, path: Optional[Path | str] = None, *, ttl_seconds: float = 24 * 3600,
+                 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.ttl_seconds = float(ttl_seconds)
+        self._clock = clock
+        with self._db() as db:
+            db.execute(
+                """CREATE TABLE IF NOT EXISTS approvals (
+                    id TEXT PRIMARY KEY, conversation TEXT NOT NULL, owner_id TEXT NOT NULL,
+                    kind TEXT NOT NULL, payload TEXT NOT NULL, summary TEXT NOT NULL,
+                    requested_by TEXT NOT NULL, requested_at REAL NOT NULL,
+                    status TEXT NOT NULL, decided_by TEXT NOT NULL DEFAULT '',
+                    decided_at REAL NOT NULL DEFAULT 0, result TEXT NOT NULL DEFAULT '')"""
+            )
+        try:
+            os.chmod(self.path, 0o600)
+        except OSError:
+            pass
+
+    def _db(self) -> sqlite3.Connection:
+        return sqlite3.connect(str(self.path))
+
+    def request(self, *, conversation: str, owner_id: str, kind: str, payload: Dict[str, Any],
+                summary: str, requested_by: str) -> Approval:
+        if kind not in EXECUTORS:
+            raise ValueError(f"unknown action {kind!r}")
+        approval_id = secrets.token_urlsafe(12)  # unguessable: it travels in a card button
+        with self._db() as db:
+            db.execute(
+                "INSERT INTO approvals (id, conversation, owner_id, kind, payload, summary, "
+                "requested_by, requested_at, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (approval_id, conversation, owner_id, kind, json.dumps(payload, ensure_ascii=False),
+                 summary, requested_by, self._clock(), PENDING),
+            )
+        return self.get(approval_id)  # type: ignore[return-value]
+
+    def get(self, approval_id: str) -> Optional[Approval]:
+        with self._db() as db:
+            row = db.execute(
+                "SELECT id, conversation, owner_id, kind, payload, summary, requested_by, requested_at, "
+                "status, decided_by, decided_at, result FROM approvals WHERE id = ?", (approval_id,)
+            ).fetchone()
+        if not row:
+            return None
+        values = list(row)
+        values[4] = json.loads(values[4])
+        return Approval(*values)
+
+    def recent(self, conversation: str, limit: int = 5) -> List[Approval]:
+        with self._db() as db:
+            ids = [r[0] for r in db.execute(
+                "SELECT id FROM approvals WHERE conversation = ? ORDER BY requested_at DESC LIMIT ?",
+                (conversation, limit))]
+        return [a for a in (self.get(i) for i in ids) if a]
+
+    def _transition(self, approval_id: str, status: str, by: str, result: str = "",
+                    expect: str = PENDING) -> bool:
+        with self._db() as db:
+            cursor = db.execute(
+                "UPDATE approvals SET status = ?, decided_by = ?, decided_at = ?, result = ? "
+                "WHERE id = ? AND status = ?",
+                (status, by, self._clock(), result, approval_id, expect),
+            )
+            return cursor.rowcount == 1
+
+    def decide(self, approval_id: str, *, conversation: str, current_owner: Optional[str],
+               decided_by: str, approve: bool, authorised: bool) -> Decision:
+        """Apply one approve/reject press. Every refusal says why, and changes nothing."""
+        approval = self.get(approval_id)
+        if approval is None or approval.conversation != conversation:
+            # The same answer for "no such request" and "not this chat's": a
+            # forwarded card learns nothing about where it came from.
+            return Decision(False, "找不到这条审批，或它不属于本会话。")
+        if not authorised:
+            return Decision(False, "你没有审批权限。", approval)
+        if approval.status != PENDING:
+            who = f"（{approval.decided_by}）" if approval.decided_by else ""
+            return Decision(False, f"这条审批已经是「{_STATUS_LABEL.get(approval.status, approval.status)}」{who}。", approval)
+        if self._clock() - approval.requested_at > self.ttl_seconds:
+            self._transition(approval_id, EXPIRED, "system")
+            return Decision(False, "这条审批已过期，请重新发起。", self.get(approval_id))
+        if current_owner != approval.owner_id:
+            return Decision(False, "本会话绑定的货主已变更，这条审批不能再执行。", approval)
+
+        if not approve:
+            if not self._transition(approval_id, REJECTED, decided_by):
+                return Decision(False, "这条审批刚刚已被处理。", self.get(approval_id))
+            return Decision(True, "已驳回。", self.get(approval_id))
+
+        # Claim it first; only the press that wins the claim executes.
+        if not self._transition(approval_id, APPROVED, decided_by, result="executing"):
+            return Decision(False, "这条审批刚刚已被处理。", self.get(approval_id))
+        claimed = self.get(approval_id)
+        try:
+            with _confined_to(approval.owner_id):
+                outcome = EXECUTORS[approval.kind](claimed)  # type: ignore[arg-type]
+        except Exception as exc:
+            # The reason is kept in the record for the operator; the chat only
+            # learns that it failed, since an exception can name host paths.
+            self._transition(approval_id, FAILED, decided_by, result=str(exc)[:500], expect=APPROVED)
+            return Decision(False, "已批准，但执行失败，原因已记录。", self.get(approval_id))
+        with self._db() as db:
+            db.execute("UPDATE approvals SET result = ? WHERE id = ?", (outcome, approval_id))
+        return Decision(True, "已批准并执行。", self.get(approval_id))
+
+
+_STATUS_LABEL = {PENDING: "待审批", APPROVED: "已批准", REJECTED: "已驳回", EXPIRED: "已过期", FAILED: "执行失败"}
+
+
+def status_label(status: str) -> str:
+    return _STATUS_LABEL.get(status, status)

{aria_code-0.64.0 → aria_code-0.66.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.66.0/src/aria_code/apps/channels/digest.py

@@ -0,0 +1,186 @@
+"""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])
+                        + "\n在群里 @Aria 发送 /补货，可发起采购单草稿审批。")
+                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.66.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