aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/__init__.py

@@ -0,0 +1,111 @@
+"""Aria Code.
+
+This package is importable under two roots by design, and has been since the
+src/ restructure: ``aria_code.X`` and a bare ``X``. The tree uses both — 399
+modules import each other bare (``from market_data_client import get_mdc``)
+while others use the package path, and the tests patch whichever root the code
+under test actually uses. tests/test_single_import_root.py exists to keep a
+single *file* from mixing the two.
+
+In development both roots resolve because pyproject's
+``pythonpath = [".", "src", "src/aria_code"]`` and tests/conftest.py put them
+there. An installed wheel has neither, so only ``aria_code`` resolved and the
+console script died immediately:
+
+    $ aria-code --version
+    ModuleNotFoundError: No module named 'aria_cli'
+
+4.4.1 did not hit this because its wheel predates the restructure — it shipped
+``aria_cli.py`` and 56 other modules at top level, so the bare root *was* the
+package. After the move, nothing put the inner directory on the path.
+
+Adding it here rather than shipping a .pth file keeps it inside the package, so
+it applies to `pip install`, `pip install -e .`, a zipapp and a PyInstaller
+bundle alike, and it is visible to anyone reading the package rather than hidden
+in site-packages.
+
+Both roots now give the same module object (``_OneModulePerFile`` below), so
+a bare import is an alias rather than a second copy.
+
+This is a bridge, not the destination. One root is the goal — v4.4.2 converted
+the tree to ``aria_code.*`` throughout — but converting it means moving every
+test's patch target with it, and doing that silently under a release is how the
+bare-root bugs in this history were introduced.
+"""
+
+import importlib as _importlib
+import importlib.abc as _importlib_abc
+import importlib.machinery as _machinery
+import os as _os
+import sys as _sys
+
+_HERE = _os.path.dirname(_os.path.abspath(__file__))
+if _HERE not in _sys.path:
+    # Appended, not inserted: a module that legitimately shadows one of these
+    # names in the user's own project must keep winning.
+    _sys.path.append(_HERE)
+
+
+class _OneModulePerFile(_importlib_abc.MetaPathFinder, _importlib_abc.Loader):
+    """A bare import of a module in this package returns the ``aria_code.*`` object.
+
+    Two roots used to mean two module objects per file, each with its own
+    globals, and nothing ever errored: a patch, a registry, a cache or an
+    exception class applied to one copy simply missed code using the other.
+    In one week that was a task list cleared in the copy nobody wrote to, a
+    rewind whose conflict error was a different class from the one caught,
+    and a test fixture isolating a ledger nobody used while the real one
+    filled with pending tasks. Here ``import runtime.checkpoints`` and
+    ``import aria_code.runtime.checkpoints`` give the same object.
+
+    Only when the bare name would load a file from this package: a user's
+    own ``tools`` or ``utils`` earlier on ``sys.path`` is found first and
+    left alone, as before.
+    """
+
+    def __init__(self, root: str) -> None:
+        self._own: dict = {}
+        self.root = _os.path.normcase(root) + _os.sep
+        if not getattr(_sys, "frozen", False) and _os.path.isdir(root):
+            self.names = {
+                entry[:-3] if entry.endswith(".py") else entry
+                for entry in _os.listdir(root)
+                if entry != "__init__.py" and not entry.startswith(("_", "."))
+                and (entry.endswith(".py") or _os.path.isfile(_os.path.join(root, entry, "__init__.py")))
+            }
+        else:
+            # Frozen Python modules live in PYZ, not a physical source tree.
+            # PyInstaller's pkgutil hook enumerates that archive even when the
+            # package directory is absent, or contains only bundled data files.
+            from pkgutil import iter_modules
+            self.names = {module.name for module in iter_modules([root])
+                          if not module.name.startswith(("_", "."))}
+
+    def find_spec(self, fullname, path=None, target=None):
+        if fullname.partition(".")[0] not in self.names:
+            return None
+        spec = _machinery.PathFinder.find_spec(fullname, path)
+        origin = getattr(spec, "origin", None) or ""
+        locations = list(getattr(spec, "submodule_search_locations", None) or ())
+        mine = [loc for loc in [origin, *locations] if loc and _os.path.normcase(loc).startswith(self.root)]
+        if spec is None or not mine:
+            return None
+        return _machinery.ModuleSpec(fullname, self, is_package=bool(locations))
+
+    def create_module(self, spec):
+        module = _importlib.import_module("aria_code." + spec.name)
+        # Keyed by name: importing the real module can alias others first.
+        self._own[spec.name] = (module.__spec__, getattr(module, "__loader__", None))
+        return module
+
+    def exec_module(self, module):
+        # Already executed under its aria_code.* name. The import system has
+        # just stamped this alias's spec on it; put the real one back, or
+        # importlib.reload() would re-run this no-op instead of the module.
+        module.__spec__, module.__loader__ = self._own.pop(module.__spec__.name)
+
+
+if not any(isinstance(finder, _OneModulePerFile) for finder in _sys.meta_path):
+    _sys.meta_path.insert(0, _OneModulePerFile(_HERE))
+
+del _HERE, _importlib_abc  # the finder still uses _os, _importlib and _machinery

aria_code/_version.py

@@ -0,0 +1,20 @@
+"""Single source of truth for the package version.
+
+__version__ used to live in aria_cli.py, which meant anything wanting the
+version string had to import the whole interactive CLI — prompt_toolkit,
+bootstrap hooks, the tool registry, all of it. The three consumers each worked
+around that differently: a crash reporter (since removed) and a diagnostics accessor imported
+aria_cli anyway, and the MCP server went to importlib.metadata instead, with a
+comment explaining that pulling in aria_cli was too heavy for a binary whose
+job is speaking JSON-RPC over stdio.
+
+Keeping it here costs nothing to import and gives all three the same answer.
+Note that importlib.metadata reports what was *installed*, which is not the
+same thing when running from a source checkout.
+"""
+
+from __future__ import annotations
+
+__all__ = ["__version__"]
+
+__version__ = "0.167.0"

aria_code/account_memory.py

@@ -0,0 +1,296 @@
+"""Account-scoped durable memory: a cloud snapshot plus a retryable outbox.
+
+Only newly captured account facts are queued. Legacy files and repository
+instructions are never uploaded. A failed request never becomes a success.
+"""
+
+from __future__ import annotations
+
+import uuid
+import os
+from contextlib import contextmanager
+import json
+import threading
+import time
+from typing import Callable
+
+from aria_code.account_session import account_id, account_root, get_account_token, read_config
+from aria_code.cloud_memory import CloudMemoryClient
+from aria_code.packages.aria_core.secure_file import write_secret_json
+
+_LOCKS: dict[str, threading.RLock] = {}
+_SYNC_LOCKS: dict[str, threading.Lock] = {}
+_LOCK = threading.Lock()
+
+
+def _lock_for(table, key, factory):
+    with _LOCK:
+        return table.setdefault(str(key), factory())
+
+
+@contextmanager
+def _state_lock(path):
+    """Protect read-modify-write across CLI windows as well as threads."""
+    with _lock_for(_LOCKS, path, threading.RLock):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        descriptor = os.open(str(path) + ".lock", os.O_CREAT | os.O_RDWR, 0o600)
+        with os.fdopen(descriptor, "r+b") as handle:
+            if os.name == "nt":
+                import msvcrt
+
+                handle.seek(0, 2)
+                if handle.tell() == 0:
+                    handle.write(b"0")
+                    handle.flush()
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+                try:
+                    yield
+                finally:
+                    handle.seek(0)
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(handle, fcntl.LOCK_EX)
+                try:
+                    yield
+                finally:
+                    fcntl.flock(handle, fcntl.LOCK_UN)
+
+
+def _write_state(path, data):
+    temporary = path.with_name(f".{path.name}.{os.getpid()}.{threading.get_ident()}.tmp")
+    try:
+        write_secret_json(temporary, data)
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+class AccountMemory:
+    def __init__(self, config: dict | Callable[[], dict] | None = None, save=None):
+        self._config = config if config is not None else read_config
+        self.save = save
+
+    def config(self):
+        return self._config() if callable(self._config) else self._config
+
+    def _owner(self):
+        config = self.config()
+        uid = account_id(config)
+        return config, uid, account_root(config) / "cloud-memory.json"
+
+    @staticmethod
+    def _read(path):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            return data if isinstance(data, dict) else {}
+        except (OSError, ValueError):
+            return {}
+
+    def status(self):
+        config, uid, path = self._owner()
+        with _state_lock(path):
+            data = self._read(path)
+        return {
+            "account_id": uid,
+            "email": config.get("email") or "",
+            "enabled": data.get("preferences", {}).get("enabled", True),
+            "pending": len(data.get("outbox", [])),
+            "last_synced": data.get("last_synced"),
+            "error": data.get("error"),
+        }
+
+    def facts(self, *, include_disabled=False):
+        _, uid, path = self._owner()
+        if not uid:
+            return []
+        with _state_lock(path):
+            data = self._read(path)
+        if not include_disabled and data.get("preferences", {}).get("enabled") is False:
+            return []
+        outbox = data.get("outbox", [])
+        hidden = {op["id"] for op in outbox if op.get("op") == "delete"}
+        cancelled = set(data.get("cancelled_adds", []))
+        facts = [
+            f
+            for f in data.get("facts", [])
+            if f.get("id") not in hidden and (f.get("metadata") or {}).get("client_id") not in cancelled
+        ]
+        seen = {f.get("content") for f in facts}
+        for op in outbox:
+            if op.get("op") == "add" and op.get("content") not in seen:
+                facts.append({"id": op["id"], "content": op["content"], "pending": True})
+                seen.add(op["content"])
+        return facts
+
+    def context(self, max_chars=800):
+        _, uid, path = self._owner()
+        if not uid:
+            return ""
+        with _state_lock(path):
+            preferences = self._read(path).get("preferences", {})
+        if preferences.get("enabled") is False:
+            return ""
+        lines = [str(preferences[key]).strip() for key in ("nickname", "occupation", "about") if preferences.get(key)]
+        lines.extend(str(f.get("content", "")) for f in self.facts())
+        text = "\n".join(dict.fromkeys(lines))[:max_chars]
+        return f"## Account Memory\n{text}\n" if text else ""
+
+    def add(self, content: str):
+        config, uid, path = self._owner()
+        content = content.strip()[:4000]
+        if not uid or not content:
+            return False
+        # Stable per queued operation, so a retry is idempotent but an explicit
+        # re-add after deletion can create a new fact.
+        item_id = uuid.uuid4().hex
+        with _state_lock(path):
+            data = self._read(path)
+            if data.get("preferences", {}).get("enabled") is False or account_id(self.config()) != uid:
+                return False
+            if any(f.get("content") == content for f in data.get("facts", [])):
+                return True
+            outbox = data.setdefault("outbox", [])
+            if not any(op.get("op") == "add" and op.get("content") == content for op in outbox):
+                outbox.append({"op": "add", "id": item_id, "content": content})
+            _write_state(path, data)
+        return True
+
+    def forget(self, item_id):
+        _, uid, path = self._owner()
+        if not uid:
+            return False
+        with _state_lock(path):
+            data = self._read(path)
+            pending = data.setdefault("outbox", [])
+            local = any(op.get("id") == item_id and op.get("op") == "add" for op in pending)
+            if local:
+                data["cancelled_adds"] = list(set(data.get("cancelled_adds", [])) | {item_id})
+            data["outbox"] = [op for op in pending if op.get("id") != item_id]
+            if not local and any(f.get("id") == item_id for f in data.get("facts", [])):
+                data["outbox"].append({"op": "delete", "id": item_id})
+            _write_state(path, data)
+        return True
+
+    def sync(self, *, force=False):
+        config, uid, path = self._owner()
+        if not uid:
+            return {"ok": False, "reason": "sign-in-required"}
+        lock = _lock_for(_SYNC_LOCKS, path, threading.Lock)
+        if not lock.acquire(blocking=False):
+            return {"ok": False, "reason": "in-progress"}
+        state_lock = lambda: _state_lock(path)
+        original = config.get("auth_token")
+
+        def current():
+            now = self.config()
+            return account_id(now) == uid and now.get("auth_token") == original
+
+        def update(**fields):
+            if not current():
+                return
+            with state_lock():
+                data = self._read(path)
+                data.update(fields)
+                _write_state(path, data)
+
+        try:
+            with state_lock():
+                data = self._read(path)
+            if not force and time.time() - data.get("last_attempt", 0) < 60:
+                return {"ok": not data.get("error"), "cached": True}
+            update(last_attempt=time.time())
+            token = get_account_token(config, self.save)
+            if token:
+                original = token
+            if not token or not current():
+                update(error="sign-in-required")
+                return {"ok": False, "reason": "sign-in-required"}
+            from aria_code.apps.cli.endpoint_migration import PRODUCTION_API_URL
+
+            client = CloudMemoryClient(str(config.get("api_url") or PRODUCTION_API_URL), token)
+            preferences = client.get_preferences()
+            if not preferences or not current():
+                reason = "sign-in-required" if client.last_status == 401 else "service-unavailable"
+                update(error=reason)
+                return {"ok": False, "reason": reason}
+            # A newly disabled switch takes effect even if the next read fails.
+            update(preferences=preferences)
+            summary = client._request("GET", "/api/v2/memory/summary")
+            if summary is None:
+                update(error="service-unavailable")
+                return {"ok": False, "reason": "service-unavailable"}
+            if not current():
+                return {"ok": False, "reason": "account-changed"}
+            facts = summary.get("facts", [])
+            facts = [f for f in facts if isinstance(f, dict) and f.get("id") and isinstance(f.get("content"), str)]
+            update(preferences=preferences, facts=facts)
+            enabled = preferences.get("enabled") is not False
+            with state_lock():
+                latest = self._read(path)
+                cancelled = set(latest.get("cancelled_adds", []))
+                outbox = latest.setdefault("outbox", [])
+                for fact in facts:
+                    if (fact.get("metadata") or {}).get("client_id") in cancelled:
+                        deletion = {"op": "delete", "id": fact["id"]}
+                        if deletion not in outbox:
+                            outbox.append(deletion)
+                _write_state(path, latest)
+                pending = list(outbox)
+            failed = False
+            for op in pending[:10]:
+                if not enabled and op["op"] == "add":
+                    continue
+                if not current():
+                    return {"ok": False, "reason": "account-changed"}
+                if op["op"] == "add":
+                    existing = next(
+                        (
+                            f
+                            for f in facts
+                            if (f.get("metadata") or {}).get("client_id") == op["id"]
+                            or f.get("content") == op["content"]
+                        ),
+                        None,
+                    )
+                    item = existing or client._request(
+                        "POST",
+                        "/api/v2/memory/items",
+                        body={
+                            "content": op["content"],
+                            "client_id": op["id"],
+                            "scope": "user",
+                            "kind": "durable",
+                            "metadata": {"source": "aria-code", "client_id": op["id"]},
+                        },
+                    )
+                    success = isinstance(item, dict) and bool(item.get("id"))
+                    if success and not existing and not item.get("deleted_at"):
+                        facts.append(item)
+                else:
+                    success = client.delete_item(op["id"])
+                    if success:
+                        facts = [f for f in facts if f.get("id") != op["id"]]
+                if not current():
+                    return {"ok": False, "reason": "account-changed"}
+                if not success:
+                    failed = True
+                    break
+                with state_lock():
+                    latest = self._read(path)
+                    latest["outbox"] = [item for item in latest.get("outbox", []) if item != op]
+                    if op["op"] == "add" and op["id"] in latest.get("cancelled_adds", []) and item.get("id"):
+                        deletion = {"op": "delete", "id": item["id"]}
+                        if deletion not in latest["outbox"]:
+                            latest["outbox"].append(deletion)
+                    latest["facts"] = facts
+                    _write_state(path, latest)
+            update(last_synced=time.time(), error="pending-retry" if failed else None)
+            return {"ok": not failed, "pending": self.status()["pending"], "enabled": enabled}
+        except Exception:
+            update(error="service-unavailable")
+            return {"ok": False, "reason": "service-unavailable"}
+        finally:
+            lock.release()

aria_code/account_session.py

@@ -0,0 +1,166 @@
+"""Firebase account identity and refresh shared by the CLI and memory client.
+
+JWT claims here are a local consistency check, never authorization: the API
+still verifies Firebase's signature/project on every request.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import time
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Callable
+
+from aria_code.packages.aria_core.paths import aria_home
+from aria_code.packages.aria_core.secure_file import write_secret_json
+
+PROJECT_ID = "arthera-66e5b"
+
+
+def read_config() -> dict:
+    try:
+        value = json.loads((aria_home() / "config.json").read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def claims_for(token: str) -> dict:
+    try:
+        encoded = token.split(".")[1]
+        claims = json.loads(base64.urlsafe_b64decode(encoded + "=" * (-len(encoded) % 4)))
+        if claims.get("aud") != PROJECT_ID or claims.get("iss") != f"https://securetoken.google.com/{PROJECT_ID}":
+            return {}
+        return claims if isinstance(claims.get("sub"), str) and claims["sub"] else {}
+    except (ValueError, IndexError, TypeError, AttributeError):
+        return {}
+
+
+def account_id(config: dict) -> str | None:
+    if not config.get("auth_token"):
+        return None
+    uid = str(config.get("user_id") or "")
+    claims = claims_for(str(config["auth_token"]))
+    # Never infer identity from email or reuse a different account's token.
+    return uid if uid and claims.get("sub") == uid else None
+
+
+def account_root(config: dict | None = None) -> Path:
+    config = read_config() if config is None else config
+    uid = account_id(config)
+    bucket = hashlib.sha256(uid.encode()).hexdigest() if uid else "anonymous"
+    return aria_home() / "accounts" / bucket
+
+
+def profile_path(config: dict | None = None) -> Path:
+    return account_root(config) / "ARIA.md"
+
+
+def persist_if_current(config: dict, original: tuple, updates: dict, save: Callable | None = None) -> bool:
+    if (config.get("user_id"), config.get("auth_token"), config.get("refresh_token")) != original:
+        return False
+    config.update(updates)
+    if save:
+        save(config)
+    else:
+        disk = read_config()
+        if (disk.get("user_id"), disk.get("auth_token"), disk.get("refresh_token")) != original:
+            return False
+        disk.update(updates)
+        write_secret_json(aria_home() / "config.json", disk)
+    return True
+
+
+def get_account_token(config: dict, save: Callable | None = None, *, force=False) -> str | None:
+    uid = account_id(config)
+    if not uid:
+        return None
+    token = str(config["auth_token"])
+    claims = claims_for(token)
+    try:
+        expires = float(claims.get("exp", 0))
+    except (ValueError, TypeError):
+        return None
+    if not force and expires > time.time() + 120:
+        return token
+    refresh = config.get("refresh_token")
+    if not refresh:
+        return token if expires > time.time() else None
+    original = (uid, token, refresh)
+    from aria_code.apps.cli.google_login import FIREBASE_WEB_API_KEY
+
+    request = urllib.request.Request(
+        f"https://securetoken.googleapis.com/v1/token?key={FIREBASE_WEB_API_KEY}",
+        data=urllib.parse.urlencode({"grant_type": "refresh_token", "refresh_token": refresh}).encode(),
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=8) as response:
+            result = json.loads(response.read())
+        fresh = result.get("id_token", "")
+        fresh_claims = claims_for(fresh)
+        if (
+            result.get("user_id") != uid
+            or fresh_claims.get("sub") != uid
+            or float(fresh_claims.get("exp", 0)) <= time.time()
+        ):
+            return None
+        updates = {"auth_token": fresh, "refresh_token": result.get("refresh_token") or refresh}
+        if isinstance(fresh_claims.get("email"), str):
+            updates["email"] = fresh_claims["email"].strip().lower()
+        from datetime import datetime, timezone
+
+        updates["token_expires_at"] = datetime.fromtimestamp(float(fresh_claims["exp"]), timezone.utc).isoformat()
+        if not persist_if_current(config, original, updates, save):
+            return None
+        return fresh
+    except Exception:
+        # Do not expose tokens, refresh tokens, HTTP bodies or URLs in errors.
+        return token if not force and expires > time.time() else None
+
+
+def password_session(email: str, password: str) -> dict:
+    """Browserless fallback, using the exact same Firebase account provider."""
+    from aria_code.apps.cli.google_login import FIREBASE_WEB_API_KEY
+
+    request = urllib.request.Request(
+        f"https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key={FIREBASE_WEB_API_KEY}",
+        data=json.dumps({"email": email, "password": password, "returnSecureToken": True}).encode(),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=15) as response:
+        result = json.loads(response.read())
+    token, uid = result.get("idToken"), result.get("localId")
+    if not token or claims_for(token).get("sub") != uid:
+        raise ValueError("Missing Firebase identity")
+    return {
+        "auth_token": token,
+        "user_id": uid,
+        "refresh_token": result.get("refreshToken"),
+        "email": result.get("email"),
+        "display_name": result.get("displayName"),
+        "provider": "password",
+    }
+
+
+async def prepare_account(config: dict, save=None) -> str | None:
+    """Refresh credentials, and give memory two seconds before using its cache.
+
+    The fenced sync may finish in the background; a slow memory service must
+    not hold up sending a chat turn. Its status/outbox remains inspectable.
+    """
+    import asyncio
+    from aria_code.account_memory import AccountMemory
+
+    token = await asyncio.to_thread(get_account_token, config, save)
+    try:
+        await asyncio.wait_for(asyncio.shield(asyncio.to_thread(AccountMemory(config, save=save).sync)), timeout=2)
+    except asyncio.TimeoutError:
+        pass
+    return token

aria_code/adk_apps/__init__.py

@@ -0,0 +1 @@
+"""ADK application packages shipped as optional Aria Code integrations."""

aria_code/adk_apps/aria_code_review/__init__.py

@@ -0,0 +1 @@
+"""Google ADK entrypoint package for Aria's read-only code reviewer."""

aria_code/adk_apps/aria_code_review/agent.py

@@ -0,0 +1,32 @@
+"""Google ADK entrypoint: a bounded reviewer for pasted code."""
+
+from __future__ import annotations
+
+import os
+
+from google.adk.agents.llm_agent import Agent
+
+from aria_code.packages.adk_bridge import CodeReviewTools
+
+
+_tools = CodeReviewTools()
+
+root_agent = Agent(
+    model=os.getenv("ARIA_ADK_MODEL", "gemini-3.8-flash"),
+    name="aria_code_review",
+    description="A read-only code reviewer for user-submitted source text.",
+    instruction="""You are Aria Code Review, a careful software reviewer.
+
+Ask the user to paste the relevant source code when it has not been supplied.
+Use review_code for deterministic findings and preserve its severity, line,
+rule, and limitations. Never claim to have opened a local path, accessed a
+repository, run a command, changed a file, or executed tests: this ADK agent
+has none of those capabilities.
+
+Explain only findings supported by the submitted code. Separate deterministic
+findings from suggestions, and recommend a test or validation step where
+appropriate. Do not expose credentials appearing in source; tell the user to
+revoke and rotate any exposed credential instead.
+""",
+    tools=[_tools.review_code],
+)

aria_code/adk_apps/aria_research/__init__.py

@@ -0,0 +1 @@
+"""Read-only Aria market-research agent for Google ADK."""

aria_code/adk_apps/aria_research/agent.py

@@ -0,0 +1,31 @@
+"""Google ADK entrypoint: ``adk web adk_apps`` discovers ``aria_research``."""
+
+from __future__ import annotations
+
+import os
+
+from google.adk.agents.llm_agent import Agent
+
+from aria_code.packages.adk_bridge import MarketResearchTools
+
+
+_tools = MarketResearchTools()
+
+root_agent = Agent(
+    model=os.getenv("ARIA_ADK_MODEL", "gemini-3.8-flash"),
+    name="aria_research",
+    description="A read-only market-research assistant for Aria Code and Arthera.",
+    instruction="""You are Aria Research, a careful financial-research assistant.
+
+Use get_market_snapshot for live market facts and explicitly identify its data
+quality, timestamp, warnings, and source limitations. Use get_market_data_health
+when a data result is missing, stale, or conflicting. Do not invent prices,
+returns, news, citations, positions, or tool output.
+
+This agent is research-only. Never claim to execute, recommend, place, modify,
+or schedule trades. Do not request credentials. State clearly that your output
+is research assistance, not investment advice. For quantitative conclusions,
+separate observed facts from hypotheses and mention material uncertainty.
+""",
+    tools=[_tools.get_market_snapshot, _tools.get_market_data_health],
+)