aria-code 0.117.0__tar.gz → 0.119.0__tar.gz

{aria_code-0.117.0/src/aria_code.egg-info → aria_code-0.119.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.117.0
+Version: 0.119.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -172,7 +172,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.117.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.117.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.119.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.119.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.117.0 → aria_code-0.119.0}/README.md

@@ -15,7 +15,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.117.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.117.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.119.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.119.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.117.0 → aria_code-0.119.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.117.0"
+version = "0.119.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -276,7 +276,6 @@ include = ["aria_code*"]
 
 [tool.setuptools.package-data]
 "*" = ["*.yaml", "*.json", "*.md", "*.txt", "*.sh"]
-"aria_code.ui" = ["assets/*.png"]
 
 # ── Ruff linting ───────────────────────────────────────────────────────────────
 [tool.ruff]

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/_version.py

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

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/apps/cli/providers/base.py

@@ -33,9 +33,17 @@ class LLMThinking:
 
 @dataclass(frozen=True)
 class LLMToolCall:
-    """Model requested a tool call."""
+    """Model requested a tool call.
+
+    ``call_id`` and ``thought_signature`` are opaque values some backends
+    (Gemini) hand out with a call and require back, unchanged, when the call
+    is replayed in history. Providers that have no such thing leave them None.
+    The signature is base64 text, not bytes, because history is JSON.
+    """
     tool: str
     params: dict
+    call_id: Optional[str] = None
+    thought_signature: Optional[str] = None
 
 
 @dataclass(frozen=True)

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/apps/cli/providers/vertexai_stream.py

@@ -7,8 +7,10 @@ what to do rather than leaking a ModuleNotFoundError.
 """
 
 import asyncio
+import base64
 import json
 import os
+import re
 from typing import AsyncGenerator, Optional
 
 from aria_code.apps.cli.providers.base import (
@@ -26,6 +28,13 @@ _MISSING_SDK_MESSAGE = (
     "  或改用其他模型：/model  （Ollama 本地模型无需额外依赖）"
 )
 
+# How runtime.agent_loop.build_tool_followup ends its results text; what
+# follows is guidance, not a copy of the results.
+_TOOL_RESULTS_TRAILERS = (
+    "\n\n⚠ Tool(s) returned errors:",
+    "\n\nAll tools completed successfully.",
+)
+
 
 import logging
 
@@ -88,6 +97,40 @@ def _chunk_text(chunk) -> str:
     return ""
 
 
+def _chunk_calls(chunk) -> list:
+    """The function calls in a chunk, with their ids and thought signatures.
+
+    Signatures are base64 text: the call is recorded in history, and history
+    is JSON.
+    """
+    calls = []
+    for candidate in (getattr(chunk, "candidates", None) or [])[:1]:
+        content = getattr(candidate, "content", None)
+        for part in (getattr(content, "parts", None) or []):
+            fc = getattr(part, "function_call", None)
+            if not fc:
+                continue
+            call = {
+                "tool": fc.name,
+                "params": {k: v for k, v in fc.args.items()} if fc.args else {},
+            }
+            if getattr(fc, "id", None):
+                call["call_id"] = fc.id
+            signature = getattr(part, "thought_signature", None)
+            if signature:
+                call["thought_signature"] = base64.b64encode(signature).decode("ascii")
+            calls.append(call)
+    if not calls:
+        # No call parts to read (a chunk without candidates): take the SDK's
+        # own list, which has no signatures.
+        for fc in (getattr(chunk, "function_calls", None) or []):
+            calls.append({
+                "tool": fc.name,
+                "params": {k: v for k, v in fc.args.items()} if fc.args else {},
+            })
+    return calls
+
+
 class VertexAIProvider(LLMProvider):
     """Native Vertex AI provider using google-genai."""
     
@@ -170,40 +213,109 @@ class VertexAIProvider(LLMProvider):
                 self._client = genai.Client(api_key=api_key)
         return self._client
         
+    def _requires_thought_signatures(self) -> bool:
+        """Gemini 3 and later reject a replayed function call without its signature."""
+        match = re.search(r"gemini-(\d+)", str(self.model).lower())
+        return bool(match) and int(match.group(1)) >= 3
+
+    @staticmethod
+    def _append(contents: list, role: str, parts: list, types) -> None:
+        # Gemini requires alternating roles: user, model, user, model.
+        if contents and contents[-1].role == role:
+            contents[-1].parts.extend(parts)
+        else:
+            contents.append(types.Content(role=role, parts=parts))
+
+    @staticmethod
+    def _strip_tool_results_text(text: str) -> str:
+        """Drop the text copy of tool results from the loop's follow-up message.
+
+        The follow-up repeats every result as ``## Tool Results ...`` text for
+        providers that have no native tool turn. Once the results have gone to
+        Gemini as function responses, that copy is not just redundant: it is a
+        transcript of tool calls written as prose, and Gemini learns from it to
+        write its next calls — and their results — as prose too, which run
+        nothing. Only what the loop appends after the results is kept: the
+        error / completion guidance and any loop-guard directives.
+        """
+        cut = max(text.rfind(marker) for marker in _TOOL_RESULTS_TRAILERS)
+        return text[cut:].strip() if cut >= 0 else ""
+
     def _messages_to_contents(self, messages: list):
         # Convert aria chat messages to genai Content objects
         from google.genai import types
-        
+
         system_instruction = self.system_override or ""
         contents = []
-        
+        # Calls from the latest native model turn that still need a
+        # function_response, as [name, id] pairs.
+        unanswered: list = []
+        native_results = False
+
+        def answer_leftovers() -> None:
+            # Gemini rejects a turn that leaves any call of the previous model
+            # turn unanswered — e.g. when the batch was cut short.
+            parts = [
+                types.Part(function_response=types.FunctionResponse(
+                    name=name, id=call_id, response={"error": "not executed"}))
+                for name, call_id in unanswered
+            ]
+            unanswered.clear()
+            if parts:
+                self._append(contents, "user", parts, types)
+
         for msg in messages:
             role = msg.get("role", "user")
             content_str = msg.get("content", "")
-            
+
             if role == "system":
                 if system_instruction:
                     system_instruction += "\n\n" + content_str
                 else:
                     system_instruction = content_str
                 continue
-                
+
             genai_role = "user" if role == "user" else "model"
-            
+
+            if role == "assistant" and msg.get("tool_calls"):
+                answer_leftovers()
+                parts = self._function_call_parts(msg["tool_calls"], types)
+                if parts is not None:
+                    if str(content_str or "").strip():
+                        parts.insert(0, types.Part.from_text(text=content_str))
+                    self._append(contents, "model", parts, types)
+                    unanswered = [
+                        [part.function_call.name, part.function_call.id]
+                        for part in parts
+                        if part.function_call
+                    ]
+                    native_results = False
+                    continue
+                # No usable signatures (history from before they were kept, or
+                # from another provider): fall through to the text rendering.
+
+            if role == "tool" and unanswered:
+                tool_name = msg.get("name") or ""
+                index = next(
+                    (i for i, (name, _) in enumerate(unanswered) if name == tool_name),
+                    0,
+                )
+                name, call_id = unanswered.pop(index)
+                self._append(contents, "user", [types.Part(
+                    function_response=types.FunctionResponse(
+                        name=name, id=call_id, response={"result": str(content_str)}),
+                )], types)
+                native_results = True
+                continue
+
             if role == "tool":
-                # Rendered as text, not as a FunctionResponse part.
+                # No native call to answer: rendered as text instead.
                 #
                 # Gemini only accepts a function_response that answers a
-                # function_call it can see in the preceding model turn, and the
-                # agent loop does not preserve those: it records the assistant
-                # turn as plain text. Sending an unanswered function_response
-                # made the conversation malformed, and Gemini replied with a
-                # single whitespace character and no tool call — the turn died
-                # as "empty_response" a round or two in, every time.
-                #
-                # The information is not lost by doing this: the loop already
-                # puts the same results in the follow-up user message that
-                # comes next, in a form written to be read.
+                # function_call it can see in the preceding model turn.
+                # Sending an unanswered function_response made the
+                # conversation malformed, and Gemini replied with a single
+                # whitespace character and no tool call.
                 tool_name = msg.get("name") or "tool"
                 text = f"[{tool_name}] {content_str}".strip()
                 if not text:
@@ -214,7 +326,17 @@ class VertexAIProvider(LLMProvider):
                     contents.append(types.Content(
                         role="user", parts=[types.Part.from_text(text=text)]))
                 continue
-                
+
+            answer_leftovers()
+            if (
+                native_results
+                and role == "user"
+                and isinstance(content_str, str)
+                and content_str.lstrip().startswith("## Tool Results")
+            ):
+                content_str = self._strip_tool_results_text(content_str)
+            native_results = False
+
             # An empty part is worse than no part. When a model answers a turn
             # with nothing but a function call — which Gemini does routinely,
             # and which the agent loop records as an assistant message whose
@@ -234,6 +356,37 @@ class VertexAIProvider(LLMProvider):
                 
         return contents, system_instruction
 
+    def _function_call_parts(self, tool_calls: list, types) -> Optional[list]:
+        """The assistant's recorded calls as function_call parts.
+
+        None when they cannot be replayed natively: Gemini 3 rejects a call
+        replayed without the thought signature it was issued with, and calls
+        recorded before signatures were kept (or by another provider) have none.
+        """
+        parts = []
+        signed = False
+        for tool_call in tool_calls:
+            fn = tool_call.get("function", tool_call)
+            name = str(fn.get("name") or "")
+            if not name:
+                continue
+            args = fn.get("arguments", {})
+            if isinstance(args, str):
+                try:
+                    args = json.loads(args)
+                except json.JSONDecodeError:
+                    args = {}
+            part = types.Part(function_call=types.FunctionCall(
+                name=name, args=dict(args or {}), id=tool_call.get("id") or None))
+            signature = tool_call.get("thought_signature")
+            if signature:
+                part.thought_signature = base64.b64decode(signature)
+                signed = True
+            parts.append(part)
+        if not parts or (self._requires_thought_signatures() and not signed):
+            return None
+        return parts
+
     def _schema_from_dict(self, d: dict, types):
         if not d:
             return None
@@ -365,11 +518,17 @@ class VertexAIProvider(LLMProvider):
                                 full_response += text
                                 yield LLMToken(text=text)
 
-                            if chunk.function_calls:
-                                for fc in chunk.function_calls:
-                                    args = {k: v for k, v in fc.args.items()} if fc.args else {}
-                                    yield LLMToolCall(tool=fc.name, params=args)
-                                    tool_calls.append({"tool": fc.name, "params": args})
+                            # Read calls from the parts, not chunk.function_calls:
+                            # the thought signature lives on the part, and Gemini 3
+                            # refuses the next request if the call is replayed
+                            # without it.
+                            for call in _chunk_calls(chunk):
+                                yield LLMToolCall(
+                                    tool=call["tool"], params=call["params"],
+                                    call_id=call.get("call_id"),
+                                    thought_signature=call.get("thought_signature"),
+                                )
+                                tool_calls.append(call)
 
                             for candidate in (getattr(chunk, "candidates", None) or []):
                                 reason = getattr(candidate, "finish_reason", None)

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/packages/aria_sdk/streaming.py

@@ -38,6 +38,10 @@ async def stream_provider_result(
                 on_thinking(event.content)
         elif event_kind(event) == "LLMToolCall":
             call = {"tool": event.tool, "params": dict(event.params)}
+            if getattr(event, "call_id", None):
+                call["call_id"] = event.call_id
+            if getattr(event, "thought_signature", None):
+                call["thought_signature"] = event.thought_signature
             tool_calls.append(call)
             if on_tool_call:
                 on_tool_call(event.tool, dict(event.params))

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/runtime/agent_loop.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import re
 import time
 from dataclasses import dataclass, field
 from typing import AsyncGenerator, Awaitable, Callable, Dict, FrozenSet, Iterable, List, Optional, Sequence, Tuple, Union
@@ -933,6 +934,13 @@ async def execute_tool_turn(
         {
             "tool": str(tool_call.get("tool", "")),
             "params": dict(tool_call.get("params", {}) or {}),
+            # Opaque provider tokens (Gemini call ids / thought signatures)
+            # that must be replayed with the call in the next request.
+            **{
+                key: tool_call[key]
+                for key in ("call_id", "thought_signature")
+                if tool_call.get(key)
+            },
         }
         for tool_call in pending
     ]
@@ -1010,7 +1018,13 @@ async def execute_tool_turn(
             "function": {
                 "name": str(tool_call.get("tool", "")),
                 "arguments": dict(tool_call.get("params", {}) or {}),
-            }
+            },
+            **({"id": tool_call["call_id"]} if tool_call.get("call_id") else {}),
+            **(
+                {"thought_signature": tool_call["thought_signature"]}
+                if tool_call.get("thought_signature")
+                else {}
+            ),
         }
         for tool_call in pending_transcript
         if tool_call.get("tool")
@@ -1064,6 +1078,37 @@ def _truncate_tool_result(text: str, limit: int = _MAX_TOOL_RESULT_CHARS) -> str
     )
 
 
+_MAX_TEXT_TOOL_CALL_RETRIES = 2
+
+# What a reply looks like when the model wrote tool calls instead of making
+# them: a raw call tag, Gemini's "default_api:" call syntax, or an imitation of
+# the "## Tool Results" block build_tool_followup produces.
+_TEXT_TOOL_CALL = re.compile(
+    r"<tool_call>|\bdefault_api[:.]\w|^#{2,3} ?Tool Results\b|^### \[\w+\] (?:✓ Success|❌ Error)",
+    re.MULTILINE,
+)
+
+TEXT_TOOL_CALL_DIRECTIVE = (
+    "Your last reply wrote tool calls (or tool results) as text. None of them "
+    "were executed and no files were changed. Do not write calls or results "
+    "out as text: call the tools through function calling, and only report "
+    "results you actually received."
+)
+
+
+_CODE_SPAN = re.compile(r"```.*?(?:```|\Z)|`[^`\n]*`", re.DOTALL)
+
+
+def looks_like_text_tool_calls(text: str) -> bool:
+    """True when a reply with no real tool calls contains written-out ones.
+
+    Code spans are ignored, so an answer that quotes these formats — this
+    being a coding agent, a repo can well contain them — is not mistaken
+    for one.
+    """
+    return bool(text) and bool(_TEXT_TOOL_CALL.search(_CODE_SPAN.sub("", text)))
+
+
 def build_tool_followup(tool_results: Sequence[dict]) -> str:
     """Build a structured follow-up message from tool results.
 
@@ -1353,6 +1398,7 @@ async def run_agent(
     loop_guard = LoopGuard()
     grounded_results = 1 if opts.evidence_already_grounded else 0
     stop_reason = "max_rounds"
+    text_tool_call_retries = 0
 
     for round_num in range(opts.max_rounds):
         # ── 预算闸门 ─────────────────────────────────────────────────────────
@@ -1435,6 +1481,34 @@ async def run_agent(
         turn_state.apply_model_result(result, response_text)
 
         pending = result.get("tool_calls_pending", [])
+        if not pending and looks_like_text_tool_calls(result.get("response") or response_text):
+            # The model wrote its calls (and often their "results") as prose:
+            # nothing ran. Ending here reported a task as done — sometimes with
+            # tests "passing" — while no file had been touched. Say so and
+            # give it the round back; if it keeps doing it, end incomplete.
+            text_tool_call_retries += 1
+            if text_tool_call_retries > _MAX_TEXT_TOOL_CALL_RETRIES:
+                stop_reason = "text_tool_calls"
+                yield AgentEventStatus(
+                    state=stop_reason,
+                    message="Model kept writing tool calls as text; task remains incomplete",
+                )
+                turn_state.append_response(
+                    "\n\nThe model kept writing tool calls as text instead of "
+                    "calling the tools; none of them were executed."
+                )
+                break
+            yield AgentEventStatus(
+                state="text_tool_calls",
+                message="Model wrote tool calls as text; asking it to call them",
+            )
+            history = list(history) + [
+                {"role": "user", "content": current_message},
+                {"role": "assistant", "content": turn_state.total_response},
+            ]
+            current_message = TEXT_TOOL_CALL_DIRECTIVE
+            turn_state.reset_response()
+            continue
         if not pending:
             # ── 验收闸门 ─────────────────────────────────────────────────────
             # 模型不再要工具 = 它认为做完了。这是唯一一个「宣称完成」的出口,

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/ui/banner.py

@@ -19,8 +19,6 @@ from __future__ import annotations
 
 import os
 import shutil
-from functools import lru_cache
-from pathlib import Path
 from typing import Optional
 
 from .startup_dashboard import StartupDashboardViewModel
@@ -207,53 +205,16 @@ def _robot_text():
     return face
 
 
-@lru_cache(maxsize=1)
-def _artwork_pixels():
-    """Rich half-blocks sampled from the reference, without importing Pillow."""
-    import base64
-    import zlib
-    from rich.text import Text
-    from .robot_pixels import HEIGHT, PIXELS, WIDTH
-
-    rgb = zlib.decompress(base64.b85decode(PIXELS))
-    face = Text()
-    for y in range(0, HEIGHT, 2):
-        for x in range(WIDTH):
-            top = rgb[(y * WIDTH + x) * 3:(y * WIDTH + x) * 3 + 3].hex()
-            bottom = rgb[((y + 1) * WIDTH + x) * 3:((y + 1) * WIDTH + x) * 3 + 3].hex()
-            face.append("▀", style=f"#{top} on #{bottom}")
-        if y + 2 < HEIGHT:
-            face.append("\n")
-    return face
-
+def _mascot(console):
+    """Return (renderable, columns): the compact robot, or nothing.
 
-def _mascot(console, width: int):
-    """Return (renderable, columns, rows, optional native image sequence).
-
-    Inline graphics go only to a real TTY. Rich's text parser strips OSC/APC
-    escapes, so the PNG is written separately after reserving its cells.
+    ARIA_ROBOT_RENDER=off leaves the four summary lines without a robot.
     """
     from rich.text import Text
-    from .robot_pixels import BOUNDS, HEIGHT, WIDTH
-    mode = os.getenv("ARIA_ROBOT_RENDER", "auto").strip().lower()
-    tty = bool(console.is_terminal and getattr(console.file, "isatty", lambda: False)())
-    if mode == "off":
-        return Text(), 0, 4, None
-    if console.no_color or console.color_system is None:
-        # Uncoloured half-blocks are a solid rectangle, not a robot.
-        return _robot_text(), 9, 4, None
-    if mode == "compact" or width < 60 or (not tty and mode not in ("pixels", "image")):
-        return _robot_text(), 9, 4, None
-    if mode != "pixels" and tty:
-        from .image_render import best_method, render_image
-        method = best_method()
-        if method in ("iterm", "kitty"):
-            rows = (HEIGHT + 1) // 2 + 1  # aspect-preserving image may occupy a fraction more
-            asset = Path(__file__).parent / "assets" / "aria-robot.png"
-            sequence = render_image(str(asset), WIDTH, method, crop=BOUNDS, cells_high=rows)
-            if sequence and sequence.startswith(("\x1b]1337;", "\x1b_G")):
-                return Text("\n".join([" " * WIDTH] * rows)), WIDTH, rows, sequence
-    return _artwork_pixels().copy(), WIDTH, HEIGHT // 2, None
+
+    if os.getenv("ARIA_ROBOT_RENDER", "").strip().lower() == "off":
+        return Text(), 0
+    return _robot_text(), 9
 
 
 def _summary_lines(view: StartupDashboardViewModel) -> list[str]:
@@ -308,7 +269,7 @@ def render_startup_dashboard(
     terminal_width: Optional[int] = None,
     terminal_height: Optional[int] = None,
 ) -> None:
-    """The original mascot beside the model/workspace summary, then notes."""
+    """The robot beside the model/workspace summary, then notes."""
     del rich_box, terminal_height
     from .robot import ROBOT_ROW_COUNT, get_robot_row
 
@@ -327,18 +288,13 @@ def render_startup_dashboard(
     from rich.text import Text
 
     width = terminal_width or _console_width(console)
-    face, columns, rows, sequence = _mascot(console, width)
+    face, columns = _mascot(console)
     block = Table.grid(padding=(0, 2))
     block.add_column(no_wrap=True, width=columns or None)
     # One line per row, cut rather than wrapped, so the block keeps its height.
     block.add_column(no_wrap=True, overflow="ellipsis", max_width=max(10, width - columns - 3))
     block.add_row(face, Text.from_markup("\n".join(_summary_lines(view)), overflow="ellipsis"))
     console.print(block)
-    if sequence:
-        # Reserve the rows first (also handles scrolling), draw at their top,
-        # then restore the cursor before the notes and prompt are printed.
-        console.file.write(f"\x1b7\x1b[{rows}A\r{sequence}\x1b8")
-        console.file.flush()
     for note in _notes(view):
         console.print(Text.from_markup("  " + note, overflow="ellipsis"), no_wrap=True)
 

{aria_code-0.117.0 → aria_code-0.119.0}/src/aria_code/ui/robot.py

@@ -10,8 +10,10 @@ screen, base, feet), each unit one sub-pixel across and half a sub-pixel down
 — which, with terminal cells twice as tall as wide, keeps the units square.
 The eye is two quadrants (a square), the dash a lower-quarter block (2:1),
 the cap corners ▛ ▜, the ears ▌ ▐, the four feet ▀. Colours are sampled from
-the artwork; only the body is deepened on light terminals, where the
-artwork's cream would vanish against a white background.
+the artwork (docs/assets/aria-robot.png) on this grid; only the light-theme
+greys and body are deepened, where the artwork's would vanish against a
+white background. The orange seam between body and base is left out: at
+this size it would share a cell with two other colours, and a cell has two.
 
 Runtime state is shown by the compact status dot, not by the mascot.
 """
@@ -88,22 +90,22 @@ _STATUS = {
 # resolves to a Rich style ("<fg> on <bg>").
 _COLOURS = {
     "dark": {
-        "body":   "#F3EEE9",   # cream shell
-        "screen": "#0B0A09",   # black screen
-        "eye":    "#F1EDE9",   # square eye
-        "dash":   "#EDBC7F",   # orange dash
-        "ear":    "#989088",   # grey ear nub
-        "base":   "#CDAD8F",   # tan underside with the orange seam
-        "leg":    "#B4AEA6",   # grey feet
+        "body":   "#F4EBE4",   # cream shell
+        "screen": "#0E0E0E",   # black screen
+        "eye":    "#FFFDF5",   # square eye, brighter than the shell
+        "dash":   "#F9B467",   # orange dash
+        "ear":    "#B6ADA4",   # grey ear nub
+        "base":   "#B6ADA4",   # grey underside
+        "leg":    "#D5CCC3",   # light grey feet
     },
     "light": {
         "body":   "#E6DDD0",   # deeper cream: the artwork's would vanish on white
-        "screen": "#0B0A09",
-        "eye":    "#F6F2EA",
-        "dash":   "#EDBC7F",
-        "ear":    "#8C847B",
-        "base":   "#C9A57F",
-        "leg":    "#A39C93",
+        "screen": "#0E0E0E",
+        "eye":    "#FFFDF5",
+        "dash":   "#F9B467",
+        "ear":    "#9C948B",
+        "base":   "#9C948B",
+        "leg":    "#B8AFA6",
     },
 }
 

{aria_code-0.117.0 → aria_code-0.119.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.117.0
+Version: 0.119.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -172,7 +172,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.117.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.117.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.119.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.119.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>