aria-code 0.132.0__tar.gz → 0.134.0__tar.gz

{aria_code-0.132.0/src/aria_code.egg-info → aria_code-0.134.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.132.0
+Version: 0.134.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.132.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.132.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.134.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.134.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.132.0 → aria_code-0.134.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.132.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.132.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.134.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.134.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.132.0 → aria_code-0.134.0}/pyproject.toml

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

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

{aria_code-0.132.0 → aria_code-0.134.0}/src/aria_code/apps/cli/exec_events.py

@@ -98,6 +98,21 @@ class ExecEvents:
 
     def __init__(self, out: TextIO | None):
         self.out = out
+        # Preserve the established JSONL contract unless a streaming consumer
+        # opts in. Never emit provider reasoning; only visible answer tokens.
+        import os
+        self.streaming = out is not None and os.environ.get("ARIA_EVENTS_STREAM", "").strip().lower() in (
+            "1", "true", "yes",
+        )
+
+    def text_delta(self, text: str) -> None:
+        if self.streaming and text:
+            self.emit("answer.delta", text=text)
+
+    def status(self, state: str, message: str) -> None:
+        if self.streaming:
+            self.emit("turn.status", state=_redact_activity_text(state, limit=80),
+                      message=_redact_activity_text(message, limit=PARAM_CHARS))
 
     def emit(self, event_type: str, **fields: Any) -> None:
         if self.out is None:

{aria_code-0.132.0 → aria_code-0.134.0}/src/aria_code/apps/cli/headless.py

@@ -11,7 +11,7 @@ on whichever module loaded last.
 
 from __future__ import annotations
 
-def _headless_approval(config: dict, auto_approve, always_allow):
+def _headless_approval(config: dict, auto_approve, always_allow, *, on_denied=None):
     """Answer approvals with what the operator granted up front, and nothing more.
 
     ``auto_approve`` and ``always_allow`` are read at call time from the module
@@ -23,8 +23,10 @@ def _headless_approval(config: dict, auto_approve, always_allow):
 
     def decide(tool_name: str, params: dict):
         if not (auto_approve() or tool_name in (always_allow() or ())):
-            return ApprovalDecision.deny("no one is here to approve it; pass --allow-tools or "
-                                         "--dangerously-skip-permissions")
+            reason = "no one is here to approve it; pass --allow-tools or --dangerously-skip-permissions"
+            if on_denied is not None:
+                on_denied(tool_name, reason)
+            return ApprovalDecision.deny(reason)
         if tool_name == "run_command":
             return ApprovalDecision.allow(policy=config.get("command_policy", "safe"), user_approved=True)
         return ApprovalDecision.allow()
@@ -188,10 +190,13 @@ class HeadlessMixin:
                     # stays, and the pre-approval answers it the way the REPL would.
                     confirm_tools=frozenset(_CONFIRM_TOOLS),
                     approval_callback=_headless_approval(
-                        self.config, lambda: _auto_approve_session, lambda: _session_always_allow),
+                        self.config, lambda: _auto_approve_session, lambda: _session_always_allow,
+                        on_denied=lambda tool, reason: events.status("approval_denied", f"{tool}: {reason}")),
                     approval_applier=_apply_approval_decision,
                     on_tool_call=events.tool_started,
                     on_tool_result=events.tool_completed,
+                    on_token=events.text_delta if events.streaming else None,
+                    on_status=events.status if events.streaming else None,
                     return_result=True,
                 )
                 _tools_used = list(getattr(_turn.final, "tools", []) or [])

{aria_code-0.132.0 → aria_code-0.134.0}/src/aria_code/runtime/agent_loop.py

@@ -1136,6 +1136,43 @@ TEXT_TOOL_CALL_DIRECTIVE = (
 _CODE_SPAN = re.compile(r"```.*?(?:```|\Z)|`[^`\n]*`", re.DOTALL)
 
 
+_MAX_PROMPT_ECHO_RETRIES = 1
+
+# A reply after a tool round that is an instruction to the assistant rather
+# than an answer to the user: the model continued our follow-up message (the
+# reply even starts with the space that would separate the two) instead of
+# acting on it. Seen on Gemini: " Do not stop until all necessary actions have
+# been performed." ended a turn as its final answer with nothing changed.
+_PROMPT_ECHO_MAX_CHARS = 240
+_PROMPT_ECHO = re.compile(
+    r"^(?:do not stop|don't stop|if you are (?:finished|done)|if the task is"
+    r"|continue (?:using|with|the task)|use (?:the )?tools|you (?:must|should) (?:continue|now)"
+    r"|make sure (?:to|you)|remember to)\b"
+    r"|\b(?:necessary actions|your final (?:response|answer)|describe your findings"
+    r"|continue using tools|\d+-\d+ sentences)\b",
+    re.IGNORECASE,
+)
+
+PROMPT_ECHO_DIRECTIVE = (
+    "Your last reply was an instruction, not an answer: it reads like a "
+    "continuation of the prompt, and the task is not finished. Carry on with "
+    "the user's request — call the tools you need. When the work is actually "
+    "done, reply with what you changed and how you checked it."
+)
+
+
+def looks_like_prompt_echo(text: str) -> bool:
+    """True when a short final reply is an instruction aimed at the assistant.
+
+    Only short, single-paragraph replies qualify: a real answer that happens
+    to say "make sure to run the tests" is longer, or follows a summary.
+    """
+    stripped = (text or "").strip()
+    if not stripped or len(stripped) > _PROMPT_ECHO_MAX_CHARS or "\n\n" in stripped:
+        return False
+    return bool(_PROMPT_ECHO.search(_CODE_SPAN.sub("", stripped)))
+
+
 def looks_like_text_tool_calls(text: str) -> bool:
     """True when a reply with no real tool calls contains written-out ones.
 
@@ -1452,6 +1489,7 @@ async def run_agent(
     grounded_results = 1 if opts.evidence_already_grounded else 0
     stop_reason = "max_rounds"
     text_tool_call_retries = 0
+    prompt_echo_retries = 0
 
     for round_num in range(opts.max_rounds):
         # ── 预算闸门 ─────────────────────────────────────────────────────────
@@ -1562,6 +1600,34 @@ async def run_agent(
             current_message = TEXT_TOOL_CALL_DIRECTIVE
             turn_state.reset_response()
             continue
+        if (not pending and round_num > 0
+                and looks_like_prompt_echo(result.get("response") or response_text)):
+            # After a tool round the model "answered" by continuing our own
+            # follow-up instead of acting on it. Accepting that ended tasks
+            # as completed with nothing changed. One more round, then incomplete.
+            prompt_echo_retries += 1
+            if prompt_echo_retries > _MAX_PROMPT_ECHO_RETRIES:
+                stop_reason = "prompt_echo"
+                yield AgentEventStatus(
+                    state=stop_reason,
+                    message="Model replied with an instruction instead of an answer; task remains incomplete",
+                )
+                turn_state.append_response(
+                    "\n\nThe model replied with an instruction instead of an answer "
+                    "and did not continue the task."
+                )
+                break
+            yield AgentEventStatus(
+                state="prompt_echo",
+                message="Model replied with an instruction instead of an answer; asking it to continue",
+            )
+            history = list(history) + [
+                {"role": "user", "content": current_message},
+                {"role": "assistant", "content": turn_state.total_response},
+            ]
+            current_message = PROMPT_ECHO_DIRECTIVE
+            turn_state.reset_response()
+            continue
         if not pending:
             # ── 验收闸门 ─────────────────────────────────────────────────────
             # 模型不再要工具 = 它认为做完了。这是唯一一个「宣称完成」的出口,

{aria_code-0.132.0 → aria_code-0.134.0}/src/aria_code/runtime/baseline.py

@@ -7,14 +7,18 @@ the failed command once more on the code as it was before the change and
 compares:
 
 * pytest: by test id (``FAILED tests/x.py::test_y``). Failures that also
-  fail on the baseline are pre-existing; the rest are the change's.
+  fail on the baseline are pre-existing; the rest are the change's. The
+  baseline run continues past collection errors (see ``_keep_collecting``).
 * anything else: by exit status. A command that fails on the baseline too
   is pre-existing as a whole.
 
 "Before the change" is the task's starting snapshot when the turn runs in a
 task worktree. Otherwise it is the working tree now with this turn's edits
 undone from their checkpoints — edits a shell command made are not
-recorded, so they are in the baseline too.
+recorded, so they are in the baseline too. Outside a git repository the
+working tree is copied instead of checked out, when it is small enough
+(``_COPY_MAX_FILES``/``_COPY_MAX_BYTES``); without a baseline every failure
+counts as the change's, and the model is sent to "fix" unrelated code.
 
 It runs only after a failure, in a scratch worktree removed straight after,
 and each command at most once per turn.
@@ -24,7 +28,9 @@ from __future__ import annotations
 
 import inspect
 import logging
+import os
 import re
+import shutil
 import uuid
 from dataclasses import dataclass
 from pathlib import Path
@@ -36,6 +42,15 @@ logger = logging.getLogger(__name__)
 
 _PYTEST_FAILURE = re.compile(r"^(?:FAILED|ERROR)\s+(\S+?)(?:\s+-\s|$)", re.MULTILINE)
 
+# A workspace outside git is copied for its baseline only up to this size; a
+# turn started in a home directory must not copy the home directory.
+_COPY_MAX_FILES = 5_000
+_COPY_MAX_BYTES = 100 * 1024 * 1024
+_COPY_SKIPPED = frozenset({
+    ".git", ".hg", ".svn", "node_modules", ".venv", "venv", "__pycache__",
+    ".mypy_cache", ".pytest_cache", ".ruff_cache", ".tox", ".nox",
+})
+
 # ``(command, cwd) -> run result dict``, as the acceptance gate's runner returns.
 BaselineRunner = Callable[[str, str], Union[dict, Awaitable[dict]]]
 
@@ -69,6 +84,23 @@ def compare(after_output: str, after_failed: bool, before: Optional[tuple[int, s
     return Comparison(preexisting=True, note="failing before this change")
 
 
+_PYTEST_COMMAND = re.compile(r"(?:^|[\s/])(?:py\.test|pytest)(?:\s|$)")
+
+
+def _keep_collecting(command: str) -> str:
+    """Let a pytest baseline run past collection errors.
+
+    Before the change a test file often cannot even be imported — it tests the
+    function the task is about to add — and pytest then stops at collection,
+    running nothing else. A test that was already red elsewhere is missing from
+    that baseline, so after the change it would look new and be "repaired".
+    """
+    if (not _PYTEST_COMMAND.search(command) or "--continue-on-collection-errors" in command
+            or re.search(r"[|;&<>`$]", command)):
+        return command
+    return f"{command} --continue-on-collection-errors"
+
+
 class Baseline:
     def __init__(
         self,
@@ -92,7 +124,7 @@ class Baseline:
         """``(exit_code, output)`` of ``command`` before the change; None if unknown."""
         if command not in self._results:
             try:
-                self._results[command] = await self._run(command)
+                self._results[command] = await self._run(_keep_collecting(command))
             except Exception as exc:
                 logger.debug("baseline run failed: %s", exc)
                 self._results[command] = None
@@ -100,10 +132,19 @@ class Baseline:
 
     async def _run(self, command: str) -> Optional[tuple[int, str]]:
         repo = repository_root(self.workspace)
+        destination = (self.scratch_root / f"baseline-{uuid.uuid4().hex[:8]}").resolve()
         if repo is None:
-            return None
+            if self.base_commit or not self._copy(destination):
+                return None
+            try:
+                self._undo_turn(self.workspace, destination)
+                raw = self.run(command, str(destination))
+                if inspect.isawaitable(raw):
+                    raw = await raw
+            finally:
+                shutil.rmtree(destination, ignore_errors=True)
+            return self._result(raw)
         commit = self.base_commit or snapshot(repo)[0]
-        destination = (self.scratch_root / f"baseline-{uuid.uuid4().hex[:8]}").resolve()
         linked = checkout(repo, commit, destination)
         try:
             if not self.base_commit:
@@ -116,11 +157,42 @@ class Baseline:
                 raw = await raw
         finally:
             remove_checkout(repo, destination, linked)
+        return self._result(raw)
+
+    @staticmethod
+    def _result(raw: Any) -> tuple[int, str]:
         from .acceptance import _read_run_result
 
         code, output, error = _read_run_result(raw)
         return (code if not error else 1, output)
 
+    def _copy(self, destination: Path) -> bool:
+        """Copy the workspace to ``destination``; False (and nothing left) when too big."""
+        files: list[tuple[Path, Path]] = []
+        total = 0
+        for directory, dirnames, filenames in os.walk(self.workspace):
+            dirnames[:] = [name for name in dirnames if name not in _COPY_SKIPPED]
+            for name in filenames:
+                source = Path(directory) / name
+                if source.is_symlink():
+                    pass   # copied as a link: it may point outside the workspace
+                elif source.is_file():
+                    total += source.stat().st_size
+                else:
+                    continue
+                files.append((source, destination / source.relative_to(self.workspace)))
+                if len(files) > _COPY_MAX_FILES or total > _COPY_MAX_BYTES:
+                    return False
+        try:
+            for source, target in files:
+                target.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(source, target, follow_symlinks=False)
+        except OSError:
+            shutil.rmtree(destination, ignore_errors=True)
+            raise
+        destination.mkdir(parents=True, exist_ok=True)
+        return True
+
     def _undo_turn(self, repo: Path, destination: Path) -> None:
         """Put back what this turn's checkpointed edits replaced."""
         if self.undo_since is None:

{aria_code-0.132.0 → aria_code-0.134.0}/src/aria_code/runtime/delivery.py

@@ -357,6 +357,7 @@ class DeliveryLedger:
                 "loop_guard": "Stopped repeating a failing call — look at the error above",
                 "checks_failed": "Fix the failing checks",
                 "text_tool_calls": "The model wrote tool calls as text — retry the turn",
+                "prompt_echo": "The model stopped without an answer — retry the turn",
             }.get(stop_reason, f"Stopped: {stop_reason}")
         elif verified is False and checks and all(c["passed"] or c.get("preexisting") for c in checks):
             # Red only where it was red before this change (runtime/baseline.py).

{aria_code-0.132.0 → aria_code-0.134.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.132.0
+Version: 0.134.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.132.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.132.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.134.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.134.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.132.0 → aria_code-0.134.0}/src/aria_code.egg-info/SOURCES.txt

@@ -777,6 +777,7 @@ tests/test_runtime_worktrees.py
 tests/test_runway_video_client.py
 tests/test_rust_cli.py
 tests/test_rust_state.py
+tests/test_rust_stream.py
 tests/test_safety_permissions.py
 tests/test_safety_service.py
 tests/test_safety_service_adoption.py

{aria_code-0.132.0 → aria_code-0.134.0}/tests/test_baseline.py

@@ -122,3 +122,64 @@ def test_a_task_worktree_is_compared_with_its_starting_snapshot(repo, tmp_path):
 
     assert report.failures[0].new_failures == ("test_calc.py::test_add",)
     assert verdict_from_acceptance(gate.summary(), "") == FAILED
+
+
+@pytest.fixture
+def plain(tmp_path):
+    """The eval's fixture: no git, one test red before the task and unrelated to it."""
+    work = tmp_path / "plain"
+    work.mkdir()
+    (work / "legacy.py").write_text("def legacy_rate():\n    return 0.15\n")
+    (work / "text.py").write_text("def shout(text):\n    return text.upper()\n")
+    (work / "test_legacy.py").write_text(
+        "from legacy import legacy_rate\n\ndef test_legacy_rate():\n    assert legacy_rate() == 0.2\n")
+    (work / "test_text.py").write_text(
+        "from text import slugify\n\ndef test_slugify():\n    assert slugify('A b') == 'a-b'\n")
+    return work
+
+
+def test_outside_git_the_workspace_is_copied_for_the_baseline(plain, tmp_path):
+    baseline = Baseline(plain, run=run_in, undo_since=CheckpointStore().max_sequence(),
+                        session_id="s", scratch_root=tmp_path / "scratch")
+    edit(plain / "text.py", "def shout(text):\n    return text.upper()\n\n"
+                            "def slugify(text):\n    return '-'.join(text.lower().split())\n")
+    gate = gate_for(plain, baseline)
+    gate.record_tool("write_file", {"success": True, "path": str(plain / "text.py")})
+
+    report = asyncio.run(gate.run())
+
+    assert not report.passed and not report.regressed     # only test_legacy, red before too
+    assert report.failures[0].old_failures == ("test_legacy.py::test_legacy_rate",)
+    assert list((tmp_path / "scratch").iterdir()) == []   # the copy is removed
+
+
+def test_outside_git_a_new_failure_still_counts(plain, tmp_path):
+    baseline = Baseline(plain, run=run_in, undo_since=CheckpointStore().max_sequence(),
+                        session_id="s", scratch_root=tmp_path / "scratch")
+    edit(plain / "text.py", "def slugify(text):\n    return text\n")
+    gate = gate_for(plain, baseline)
+    gate.record_tool("write_file", {"success": True, "path": str(plain / "text.py")})
+
+    report = asyncio.run(gate.run())
+
+    assert report.regressed
+    assert "test_text.py::test_slugify" in report.failures[0].new_failures
+
+
+def test_a_large_workspace_outside_git_gets_no_baseline(plain, tmp_path, monkeypatch):
+    from aria_code.runtime import baseline as module
+
+    monkeypatch.setattr(module, "_COPY_MAX_FILES", 2)
+    baseline = Baseline(plain, run=run_in, scratch_root=tmp_path / "scratch")
+    assert asyncio.run(baseline.result(PYTEST)) is None
+    assert not (tmp_path / "scratch").exists() or list((tmp_path / "scratch").iterdir()) == []
+
+
+def test_a_pytest_baseline_runs_past_collection_errors():
+    from aria_code.runtime.baseline import _keep_collecting
+
+    assert _keep_collecting("python -m pytest -q").endswith("--continue-on-collection-errors")
+    assert _keep_collecting("/venv/bin/pytest tests/x.py").endswith("--continue-on-collection-errors")
+    for unchanged in ("npm test", "pytest -q | tail -5", "make test",
+                      "pytest --continue-on-collection-errors"):
+        assert _keep_collecting(unchanged) == unchanged

{aria_code-0.132.0 → aria_code-0.134.0}/tests/test_exec_events.py

@@ -43,7 +43,61 @@ def test_a_file_body_is_reported_by_size():
 
 def test_no_stream_writes_nothing_and_odd_values_still_serialise():
     ExecEvents(None).emit("turn.started", prompt="x")
-    assert json_safe({"p": Path("/a"), "s": {1}}) == {"p": "/a", "s": "{1}"}
+    path = Path("/a")
+    assert json_safe({"p": path, "s": {1}}) == {"p": str(path), "s": "{1}"}
+
+
+def test_visible_answer_streaming_is_opt_in_and_status_is_redacted(monkeypatch):
+    monkeypatch.delenv("ARIA_EVENTS_STREAM", raising=False)
+    out = io.StringIO()
+    old = ExecEvents(out)
+    old.text_delta("invisible until completion")
+    old.status("thinking", "status")
+    assert not old.streaming and out.getvalue() == ""
+    monkeypatch.setenv("ARIA_EVENTS_STREAM", "1")
+    events = ExecEvents(out)
+    assert events.streaming and not ExecEvents(None).streaming
+    events.text_delta("你好\n```python\nprint(1)\n```\n")
+    events.status("working", "Authorization: Bearer abc123def456")
+    records = [json.loads(line) for line in out.getvalue().splitlines()]
+    assert records[0]["type"] == "answer.delta" and records[0]["text"].startswith("你好\n```")
+    assert records[1]["type"] == "turn.status" and "abc123def456" not in records[1]["message"]
+
+
+@pytest.mark.asyncio
+async def test_headless_runtime_streams_visible_text_and_retains_approval(monkeypatch):
+    from aria_code.aria_cli import ArtheraTerminal
+    from aria_code.apps.cli.providers import runtime_bridge
+
+    monkeypatch.setenv("ARIA_EVENTS_STREAM", "1")
+    terminal = ArtheraTerminal.__new__(ArtheraTerminal)
+    terminal.config = {"model": "google/gemini-3.5-flash", "permission_mode": "read-only"}
+    terminal.api_url = None
+    terminal.commands = SimpleNamespace(is_command=lambda _: False)
+    terminal._maybe_show_intent_preflight = lambda *a, **k: False
+    async def no_intercept(_):
+        return False
+    terminal._try_football_nl_intercept = no_intercept
+    namespace = terminal._run_prompt_turn.__func__.__globals__
+    monkeypatch.setitem(namespace, "_run_deterministic_chain", lambda *a, **k: {"success": False})
+    monkeypatch.setitem(namespace, "HAS_RICH", False)
+    monkeypatch.setitem(namespace, "_auto_approve_session", False)
+    monkeypatch.setitem(namespace, "_session_always_allow", set())
+    async def turn(**kwargs):
+        assert not kwargs["approval_callback"]("write_file", {"path": "a.py"}).approved
+        assert kwargs.get("on_thinking") is None
+        kwargs["on_token"]("你好")
+        kwargs["on_status"]("working", "Reading a project")
+        kwargs["on_token"]("世界")
+        return SimpleNamespace(ok=True, text="你好世界", error="", final=SimpleNamespace(provider="fake"))
+    monkeypatch.setattr(runtime_bridge, "run_chat_via_runtime", turn)
+    out = io.StringIO()
+    events = ExecEvents(out)
+    result = await terminal._run_prompt_turn("hello", quiet=True, events=events)
+    assert result["success"] and result["response"] == "你好世界"
+    records = [json.loads(line) for line in out.getvalue().splitlines()]
+    assert [e["type"] for e in records] == ["turn.status", "answer.delta", "turn.status", "answer.delta"]
+    assert records[0]["state"] == "approval_denied" and "write_file" in records[0]["message"]
 
 
 class _Terminal:

{aria_code-0.132.0 → aria_code-0.134.0}/tests/test_headless_command_approval.py

@@ -10,7 +10,9 @@ total) or stopped (no output file).
 from __future__ import annotations
 
 import inspect
+import os
 import shlex
+import subprocess
 import sys
 
 from aria_code.apps.cli.headless import _apply_approval_decision, _headless_approval
@@ -40,7 +42,9 @@ def test_an_approved_script_runs_under_the_safe_policy(tmp_path, monkeypatch):
 
     monkeypatch.setenv("ARIA_ARTIFACT_ROOT", str(tmp_path / "artifacts"))
     (tmp_path / "calc.py").write_text("print(2 + 3)\n")
-    params = {"command": f"{shlex.quote(sys.executable)} calc.py", "policy": "safe", "cwd": str(tmp_path),
+    argv = [sys.executable, "calc.py"]
+    command = subprocess.list2cmdline(argv) if os.name == "nt" else shlex.join(argv)
+    params = {"command": command, "policy": "safe", "cwd": str(tmp_path),
               "permission_mode": "workspace-write", "network_enabled": False}
     blocked = tool_run_command(dict(params), has_rich=False)
     assert not blocked["success"] and "blocked by policy" in blocked["error"]

{aria_code-0.132.0 → aria_code-0.134.0}/tests/test_runtime_agent_loop.py

@@ -927,6 +927,101 @@ class MultiEditTests(unittest.TestCase):
         self.assertTrue(r.get("warning"))
 
 
+class PromptEchoTests(unittest.TestCase):
+    """A reply that continues our follow-up instead of answering must not end the task."""
+
+    def _run(self, provider_fn, tools):
+        async def collect():
+            return [
+                event
+                async for event in run_agent(
+                    "fix the failing test",
+                    [],
+                    provider_fn=provider_fn,
+                    tool_executor=ToolExecutor(tools),
+                    options=AgentOptions(max_rounds=6),
+                )
+            ]
+
+        return asyncio.run(collect())
+
+    @staticmethod
+    def _tools(ran):
+        def read_file(params):
+            ran.append(params["path"])
+            return {"success": True, "content": "x"}
+
+        return {"read_file": (read_file, "Read")}
+
+    @staticmethod
+    def _call(path):
+        return {"success": True, "response": "", "provider": "fake",
+                "tool_calls_pending": [{"tool": "read_file", "params": {"path": path}}]}
+
+    def test_detects_instructions_but_not_answers(self):
+        from aria_code.runtime.agent_loop import looks_like_prompt_echo
+
+        # Both replies ended real eval tasks as "completed" with nothing changed.
+        self.assertTrue(looks_like_prompt_echo(" Do not stop until all necessary actions have been performed."))
+        self.assertTrue(looks_like_prompt_echo(" If you are finished, describe your findings in 1-4 sentences."))
+        self.assertFalse(looks_like_prompt_echo("Fixed the off-by-one in slug.py; all 5 tests pass."))
+        self.assertFalse(looks_like_prompt_echo("Done. Make sure the cache directory is writable before deploying."))
+        self.assertFalse(looks_like_prompt_echo(
+            "Changed `risk.py` to annualise the ratio.\n\nMake sure to rerun the backtest; "
+            "if you are finished reviewing, it can be merged."))
+        self.assertFalse(looks_like_prompt_echo(""))
+
+    def test_an_echo_gets_one_more_round(self):
+        messages, ran = [], []
+
+        async def provider_fn(message, history, **kwargs):
+            messages.append(message)
+            if len(messages) == 1:
+                return self._call("a.py")
+            if len(messages) == 2:
+                return {"success": True, "provider": "fake",
+                        "response": " Do not stop until all necessary actions have been performed."}
+            if len(messages) == 3:
+                return self._call("b.py")
+            return {"success": True, "response": "Fixed it; tests pass.", "provider": "fake"}
+
+        events = self._run(provider_fn, self._tools(ran))
+
+        self.assertTrue(any(isinstance(e, AgentEventStatus) and e.state == "prompt_echo" for e in events))
+        self.assertIn("not an answer", messages[2])
+        self.assertEqual([os.path.basename(p) for p in ran], ["a.py", "b.py"])
+        result = events[-1].result
+        self.assertTrue(result.success)
+        self.assertEqual(result.final_text, "Fixed it; tests pass.")
+
+    def test_a_persistent_echo_ends_the_turn_incomplete(self):
+        calls = []
+
+        async def provider_fn(message, history, **kwargs):
+            calls.append(message)
+            if len(calls) == 1:
+                return self._call("a.py")
+            return {"success": True, "provider": "fake",
+                    "response": " If you are finished, describe your findings in 1-4 sentences."}
+
+        events = self._run(provider_fn, self._tools([]))
+
+        result = events[-1].result
+        self.assertFalse(result.success)
+        self.assertEqual(result.stop_reason, "prompt_echo")
+        self.assertEqual(len(calls), 3)
+
+    def test_a_short_first_reply_is_left_alone(self):
+        # No tool round yet: there is no follow-up of ours to have continued.
+        async def provider_fn(message, history, **kwargs):
+            return {"success": True, "provider": "fake",
+                    "response": "Make sure to run it with Python 3.11."}
+
+        events = self._run(provider_fn, {})
+
+        self.assertTrue(events[-1].result.success)
+
+
 class TextToolCallTests(unittest.TestCase):
     """A reply that writes tool calls as text ran nothing and must not end the task."""