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

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

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

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

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

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

@@ -0,0 +1,47 @@
+# 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.

aria_code-0.64.0/src/aria_code/apps/channels/conversation.py

@@ -0,0 +1,274 @@
+"""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 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.63.0 → aria_code-0.64.0}/src/aria_code/aria_feishu_bot.py

@@ -53,9 +53,20 @@ import re
 import sys
 import tempfile
 import time
+from contextvars import ContextVar
 from pathlib import Path
 from typing import Any, Dict, Optional
 
+from aria_code.apps.channels.conversation import (
+    ChannelTurn,
+    ConversationStore,
+    InboundMessage,
+    handle_owner_command,
+    prepare_turn,
+    should_respond,
+)
+from aria_code.tools.logistics_tenancy import OWNER_SCOPE_ENV
+
 logger = logging.getLogger(__name__)
 
 # Strip ANSI escape codes from aria CLI output
@@ -695,7 +706,7 @@ def _bot_cli_flags() -> list[str]:
     return ["--allow-tools", ",".join(tools)] if tools else []
 
 
-async def _query_aria_direct(text: str, timeout: int = 90) -> str:
+async def _query_aria_direct(text: str, timeout: int = 90, history: Optional[list] = None) -> str:
     """
     Query the LLM directly via providers/llm/registry.py — no subprocess, no tool use.
     Used for conversational NL queries where we want a clean text answer.
@@ -709,7 +720,7 @@ async def _query_aria_direct(text: str, timeout: int = 90) -> str:
 
         collected: list[str] = []
         result = await _aio.wait_for(
-            stream_cloud_fallback(text, history=[], on_token=collected.append),
+            stream_cloud_fallback(text, history=list(history or []), on_token=collected.append),
             timeout=timeout,
         )
         if result.get("success") and collected:
@@ -738,6 +749,11 @@ async def _query_aria_llm(text: str, timeout: int = 120) -> str:
         # ARIA_BOT_MODE=1: plain output for a chat card. It no longer approves
         # tools; see _bot_cli_flags.
         bot_env = {**os.environ, "ARIA_BOT_MODE": "1"}
+        # A conversation bound to a shipper confines every tool in this run to
+        # that shipper; the logistics tools enforce it (logistics_tenancy).
+        bot_env.pop(OWNER_SCOPE_ENV, None)
+        if _TURN_OWNER.get():
+            bot_env[OWNER_SCOPE_ENV] = _TURN_OWNER.get()
         proc = await asyncio.create_subprocess_exec(
             sys.executable, str(aria_cli), "-p", text, *_bot_cli_flags(),
             stdin=asyncio.subprocess.DEVNULL,   # no interactive prompts
@@ -1006,6 +1022,66 @@ def verify_feishu_request(headers: Dict[str, str], body: bytes, payload: Dict[st
                    "unverified events are refused")
 
 
+# ── Conversation layer (apps/channels/conversation.py) ───────────────────────
+
+# The shipper the current conversation is bound to, for every task it spawns.
+_TURN_OWNER: ContextVar[Optional[str]] = ContextVar("aria_feishu_turn_owner", default=None)
+_STORE: Optional[ConversationStore] = None
+_MENTION_TOKEN = re.compile(r"@_user_\d+")
+
+
+def _conversation_store() -> ConversationStore:
+    global _STORE
+    if _STORE is None or str(_STORE.path) != str(_conversation_db_path()):
+        _STORE = ConversationStore(_conversation_db_path())
+    return _STORE
+
+
+def _conversation_db_path() -> Path:
+    from aria_code.apps.channels.conversation import default_db_path
+    return default_db_path()
+
+
+def _strip_mentions(text: str) -> str:
+    """Feishu writes each @ as a placeholder (@_user_1); the model needs the words."""
+    return re.sub(r"\s+", " ", _MENTION_TOKEN.sub(" ", text or "")).strip()
+
+
+def _mentions_bot(message: Dict[str, Any]) -> bool:
+    """Whether a group message addresses this bot.
+
+    With FEISHU_BOT_OPEN_ID set, the bot's own id must be among the mentions.
+    Without it, any mention counts — correct for an app without the
+    read-all-group-messages permission, which receives only @-mentions of
+    itself; set the id if the app has that permission.
+    """
+    mentions = message.get("mentions") or []
+    own_id = os.environ.get("FEISHU_BOT_OPEN_ID", "").strip()
+    if own_id:
+        return any((m.get("id") or {}).get("open_id") == own_id for m in mentions)
+    return bool(mentions)
+
+
+def feishu_inbound(event: Dict[str, Any], text: str) -> InboundMessage:
+    """A Feishu im.message.receive_v1 event as a platform-neutral message."""
+    message = event.get("message") or {}
+    sender = (event.get("sender") or {}).get("sender_id") or {}
+    open_id = sender.get("open_id", "")
+    user_id = sender.get("user_id", "")
+    direct = message.get("chat_type") == "p2p"
+    return InboundMessage(
+        channel="feishu",
+        conversation_id=message.get("chat_id", ""),
+        kind="direct" if direct else "group",
+        sender_id=open_id or user_id,
+        sender_aliases=(user_id,) if open_id and user_id else (),
+        text=text,
+        message_id=message.get("message_id", ""),
+        mentions_bot=direct or _mentions_bot(message),
+        reply_to=message.get("parent_id", ""),
+    )
+
+
 # ── 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]:
@@ -1066,22 +1142,44 @@ async def dispatch_event(raw: Dict[str, Any], *, authorized_by_binding: bool = F
     except Exception:
         content = {}
 
+    # Groups: only what is addressed to the bot. Feishu delivers just the
+    # @-mentions unless the app holds the read-all-group-messages permission;
+    # with it, this is what stops the bot answering every message in the room.
+    # Images, audio and files cannot @ anyone, so in a group they are ignored.
+    if msg.get("chat_type") != "p2p" and msg_type not in ("text", "post"):
+        return {"code": 0}
+
     # ── Text message ──────────────────────────────────────────────────────────
     if msg_type == "text":
-        text = content.get("text", "").strip()
-        # Strip @bot mention (飞书群里 @ 机器人会带前缀)
-        if text.startswith("@"):
-            text = " ".join(text.split()[1:]).strip()
+        text = _strip_mentions(content.get("text", ""))
         if not text:
             return {"code": 0}
+        inbound = feishu_inbound(event, text)
+        if not should_respond(inbound):
+            return {"code": 0}
 
-        if text.startswith("/"):
-            logger.info("Feishu /cmd from %s: %s", user_id, text[:80])
-            asyncio.create_task(_handle_command(text, msg_id, user_id, chat_id))
-        else:
-            # Free-form natural language → Aria LLM
-            logger.info("Feishu NL query from %s: %s", user_id, text[:80])
-            asyncio.create_task(_handle_nl_query(text, msg_id, chat_id))
+        store = _conversation_store()
+        owner_reply = handle_owner_command(inbound, store)
+        if owner_reply is not None:
+            await reply_text(msg_id, owner_reply)
+            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.
+        # Reset afterwards: dispatch_event runs in its caller's context.
+        scope_token = _TURN_OWNER.set(store.owner_for(inbound.key))
+        try:
+            if text.startswith("/"):
+                logger.info("Feishu /cmd from %s: %s", user_id, text[:80])
+                asyncio.create_task(_handle_command(text, msg_id, user_id, chat_id))
+            else:
+                # Free-form natural language → Aria LLM, with this conversation's context
+                logger.info("Feishu NL query from %s: %s", user_id, text[:80])
+                turn = prepare_turn(inbound, store)
+                asyncio.create_task(_handle_nl_query(text, msg_id, chat_id, turn=turn,
+                                                     conversation=inbound.key))
+        finally:
+            _TURN_OWNER.reset(scope_token)
 
     # ── Voice / Audio ─────────────────────────────────────────────────────────
     elif msg_type == "audio":
@@ -1341,7 +1439,8 @@ def _resolve_cn_company(text: str) -> str:
     return result
 
 
-async def _handle_nl_query(text: str, message_id: str, chat_id: str = "") -> None:
+async def _handle_nl_query(text: str, message_id: str, chat_id: str = "", *,
+                           turn: Optional[ChannelTurn] = None, conversation: str = "") -> None:
     """Route free-form natural language to Aria LLM and reply."""
     import re as _re_nl
     _low = text.strip().lower()
@@ -1406,8 +1505,16 @@ async def _handle_nl_query(text: str, message_id: str, chat_id: str = "") -> Non
                 return
 
     await reply_or_send(message_id, chat_id, "🤔 思考中…", f"> {_orig[:120]}", "blue")
-    # Use direct LLM call (no subprocess, no tool execution) for conversational queries
-    result = await _query_aria_direct(text, timeout=120)
+    # Use direct LLM call (no subprocess, no tool execution) for conversational queries.
+    # With a turn, the model sees this conversation's recent messages and, when
+    # the conversation is bound to a shipper, which one.
+    if turn is not None:
+        prompt = turn.prompt if resolved == _orig else f"{turn.prompt}\n({text})"
+        result = await _query_aria_direct(prompt, timeout=120, history=turn.history)
+        if conversation and not result.startswith("❌"):
+            _conversation_store().record(conversation, "assistant", result[:2000])
+    else:
+        result = await _query_aria_direct(text, timeout=120)
     color = "red" if result.startswith("❌") else "green"
     await reply_or_send(message_id, chat_id, "💡 Aria 回答", result[:2000], color,
                         footer="Aria Code · AI 分析")

{aria_code-0.63.0 → aria_code-0.64.0}/src/aria_code/tools/logistics_tenancy.py

@@ -19,13 +19,27 @@ fails closed.
 What an error message says is part of the guarantee: it may say how many
 shippers the data spans, but never which, so a refusal does not itself
 disclose another client's name.
+
+Conversation scope
+------------------
+A chat bound to one shipper (a 3PL usually keeps one group per client) sets
+ARIA_OWNER_SCOPE for every turn it runs. Then, whatever the model asks for:
+  - owner_id defaults to that shipper, and naming another is refused;
+  - all_owners is refused — the internal view has no place in a client chat;
+  - records without owner_id are refused, because nothing shows they are this
+    shipper's (a file on the host could be anyone's).
+This is enforced here rather than in a prompt, so it holds for the CLI, the
+MCP server and every chat channel alike, and does not depend on the model
+choosing to comply.
 """
 
 from __future__ import annotations
 
+import os
 from typing import Any, Iterable
 
 OWNER_FIELD = "owner_id"
+OWNER_SCOPE_ENV = "ARIA_OWNER_SCOPE"
 
 INTERNAL_MARKER = "INTERNAL — cross-shipper view; not for client distribution"
 
@@ -34,6 +48,11 @@ class TenancyError(ValueError):
     """The records cannot be analysed without mixing shippers."""
 
 
+def active_owner_scope() -> str:
+    """The shipper this process is confined to, or "" when unconfined."""
+    return os.environ.get(OWNER_SCOPE_ENV, "").strip()
+
+
 def _owner_of(record: dict[str, Any]) -> str:
     value = record.get(OWNER_FIELD)
     return "" if value is None else str(value).strip()
@@ -55,10 +74,26 @@ def scope_records(
     if wanted and all_owners:
         raise TenancyError("Pass owner_id or all_owners, not both")
 
+    scope = active_owner_scope()
+    if scope:
+        if all_owners:
+            raise TenancyError(
+                "This conversation is confined to one shipper; the cross-shipper view "
+                "is not available here"
+            )
+        if wanted and wanted != scope:
+            raise TenancyError("This conversation is confined to one shipper and cannot analyse another")
+        wanted = scope
+
     labelled = [r for r in records if _owner_of(r)]
     unlabelled = len(records) - len(labelled)
 
     if not labelled:
+        if scope:
+            raise TenancyError(
+                f"This conversation is confined to one shipper, so every record must carry "
+                f"{OWNER_FIELD} to show it is theirs; these records have none"
+            )
         if wanted:
             raise TenancyError(
                 f"owner_id {wanted!r} was requested, but the records carry no {OWNER_FIELD}"
@@ -79,7 +114,10 @@ def scope_records(
         if not in_scope:
             # Deliberately does not list the owners that *are* present.
             raise TenancyError(f"No records for owner_id {wanted!r}")
-        return in_scope, {"mode": "single_owner", "owner_id": wanted, "client_facing": True}
+        result_scope = {"mode": "single_owner", "owner_id": wanted, "client_facing": True}
+        if scope:
+            result_scope["conversation_scoped"] = True
+        return in_scope, result_scope
 
     if len(owners) == 1:
         (only,) = owners

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.63.0
+Version: 0.64.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.64.0}/src/aria_code.egg-info/SOURCES.txt

@@ -142,6 +142,7 @@ src/aria_code/apps/README.md
 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/intake.py
 src/aria_code/apps/channels/registry.py
 src/aria_code/apps/channels/tradingview.py
@@ -537,6 +538,7 @@ tests/test_container_entrypoints.py
 tests/test_context_checkpoints.py
 tests/test_context_references.py
 tests/test_context_service.py
+tests/test_conversation_core.py
 tests/test_crash_report.py
 tests/test_credential_file_permissions.py
 tests/test_custom_providers.py

{aria_code-0.63.0 → aria_code-0.64.0}/tests/test_chat_bots_fail_closed.py

@@ -36,9 +36,11 @@ ENV_KEYS = ("FEISHU_ALLOWED_USER_IDS", "FEISHU_ENCRYPT_KEY", "FEISHU_VERIFICATIO
 
 
 @pytest.fixture(autouse=True)
-def clean_env(monkeypatch):
+def clean_env(monkeypatch, tmp_path):
     for key in ENV_KEYS:
         monkeypatch.delenv(key, raising=False)
+    # Served messages are recorded per conversation; keep that out of ~/.aria.
+    monkeypatch.setenv("ARIA_CONVERSATIONS_DB", str(tmp_path / "conversations.db"))
 
 
 def _event(text="/run /price AAPL", *, open_id="ou_stranger", user_id="", chat_type="p2p"):