aria-code 0.116.0__tar.gz → 0.118.0__tar.gz

{aria_code-0.116.0/src/aria_code.egg-info → aria_code-0.118.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.116.0
+Version: 0.118.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.116.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.116.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.118.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.118.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.116.0 → aria_code-0.118.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.116.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.116.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.118.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.118.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.116.0 → aria_code-0.118.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.116.0"
+version = "0.118.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" }

{aria_code-0.116.0 → aria_code-0.118.0}/src/aria_code/_version.py

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

{aria_code-0.116.0 → aria_code-0.118.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.116.0 → aria_code-0.118.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.116.0 → aria_code-0.118.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.116.0 → aria_code-0.118.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.116.0 → aria_code-0.118.0}/src/aria_code/runtime/subagent.py

@@ -114,6 +114,7 @@ def restore_tasks() -> int:
     explicit interrupted task rather than silently disappearing.
     """
     restored = 0
+    interrupted = []
     for record in _ledger().restore():
         task_id = str(record.get("task_id") or "").strip()
         if not task_id or task_id in _TASKS:
@@ -141,8 +142,16 @@ def restore_tasks() -> int:
             handoff=dict(record.get("handoff") or {}),
         )
         _TASKS[task_id] = task
-        _persist(task)
+        if status == "interrupted" and record.get("status") == "running":
+            interrupted.append(task.snapshot())
         restored += 1
+    if interrupted:
+        # Completed/queued records have not changed. Persist all interrupted
+        # records together; per-task upserts made restoration quadratic.
+        try:
+            _ledger().upsert_many(interrupted)
+        except Exception:
+            pass  # Persistence failure must not discard restored live state.
     return restored
 
 

{aria_code-0.116.0 → aria_code-0.118.0}/src/aria_code/runtime/task_ledger.py

@@ -69,18 +69,32 @@ class TaskLedger:
                 os.unlink(temp_name)
 
     def upsert(self, record: Mapping[str, Any]) -> None:
-        task_id = str(record.get("task_id") or "").strip()
-        if not task_id:
-            raise ValueError("Task record requires task_id")
-        records = self.load()
-        snapshot = dict(record)
-        snapshot["updated_at"] = time.time()
-        result = str(snapshot.get("result") or "")
-        if len(result) > MAX_RESULT_CHARS:
-            snapshot["result"] = result[:MAX_RESULT_CHARS] + "\n…[truncated in task ledger]"
-            snapshot["result_truncated"] = True
-        records[task_id] = snapshot
-        self.save(records)
+        self.upsert_many((record,))
+
+    def upsert_many(self, records: Iterable[Mapping[str, Any]]) -> None:
+        """Persist a batch with one read and one atomic replacement.
+
+        Validate the entire batch before touching disk. Restoring interrupted
+        tasks at startup must not rewrite the full ledger for every task.
+        """
+        snapshots = {}
+        updated_at = time.time()
+        for record in records:
+            task_id = str(record.get("task_id") or "").strip()
+            if not task_id:
+                raise ValueError("Task record requires task_id")
+            snapshot = dict(record)
+            snapshot["updated_at"] = updated_at
+            result = str(snapshot.get("result") or "")
+            if len(result) > MAX_RESULT_CHARS:
+                snapshot["result"] = result[:MAX_RESULT_CHARS] + "\n…[truncated in task ledger]"
+                snapshot["result_truncated"] = True
+            snapshots[task_id] = snapshot
+        if not snapshots:
+            return
+        stored = self.load()
+        stored.update(snapshots)
+        self.save(stored)
 
     def restore(self) -> Iterable[dict[str, Any]]:
         return self.load().values()

{aria_code-0.116.0 → aria_code-0.118.0}/src/aria_code/ui/banner.py

@@ -207,21 +207,27 @@ 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
+@lru_cache(maxsize=2)
+def _artwork_pixels(theme: str = "dark"):
+    """The robot's pixel map as Rich half-blocks: two flat pixels per cell."""
     from rich.text import Text
-    from .robot_pixels import HEIGHT, PIXELS, WIDTH
+    from .robot_pixels import GRID, HEIGHT, PALETTES, SEAM_ROW, WIDTH
 
-    rgb = zlib.decompress(base64.b85decode(PIXELS))
+    colours = PALETTES[theme]
     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}")
+            top, bottom = GRID[y][x], GRID[y + 1][x]
+            if top == bottom == ".":
+                face.append(" ")
+            elif bottom == ".":
+                face.append("▀", style=colours[top])
+            elif top == ".":
+                face.append("▄", style=colours[bottom])
+            elif y + 1 == SEAM_ROW and top == bottom == "B":
+                face.append("▁", style=f"{colours['seam']} on {colours['B']}")
+            else:
+                face.append("▀", style=f"{colours[top]} on {colours[bottom]}")
         if y + 2 < HEIGHT:
             face.append("\n")
     return face
@@ -234,7 +240,7 @@ def _mascot(console, width: int):
     escapes, so the PNG is written separately after reserving its cells.
     """
     from rich.text import Text
-    from .robot_pixels import BOUNDS, HEIGHT, WIDTH
+    from .robot_pixels import BOUNDS, HEIGHT, IMAGE_COLUMNS, IMAGE_ROWS, 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":
@@ -248,12 +254,14 @@ def _mascot(console, width: int):
         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)
+            sequence = render_image(str(asset), IMAGE_COLUMNS, method, crop=BOUNDS,
+                                    cells_high=IMAGE_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
+                blank = Text("\n".join([" " * IMAGE_COLUMNS] * IMAGE_ROWS))
+                return blank, IMAGE_COLUMNS, IMAGE_ROWS, sequence
+    theme = "light" if _is_light_theme() else "dark"
+    return _artwork_pixels(theme).copy(), WIDTH, HEIGHT // 2, None
 
 
 def _summary_lines(view: StartupDashboardViewModel) -> list[str]: