aria-code 0.123.0__tar.gz → 0.125.0__tar.gz

{aria_code-0.123.0/src/aria_code.egg-info → aria_code-0.125.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.123.0
+Version: 0.125.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.123.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.123.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.125.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.125.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.123.0 → aria_code-0.125.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.123.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.123.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.125.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.125.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.123.0 → aria_code-0.125.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.123.0"
+version = "0.125.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.125.0/src/aria_code/__init__.py

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

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/_version.py

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

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/apps/cli/chat_turn.py

@@ -196,6 +196,9 @@ class ChatTurnMixin:
             await self._maybe_auto_compact_before_turn(_incoming_for_compact)
         except Exception:
             pass
+        # The whole session as it stands before this turn, for /rewind turn.
+        from apps.cli import transactions as _transactions
+        _transactions.capture(self, message)
         self.conversation.append({"role": "user", "content": user_content})
 
         # ── 路由决策：支持工具调用的模型走 LLM+tool call，否则走确定性路由 ──
@@ -483,7 +486,9 @@ class ChatTurnMixin:
         elapsed = 0.0
 
         try:
-            from apps.cli.todo_tracker import clear_todos as _clear_todos
+            # The update_todos tool writes the aria_code.* copy; clearing the
+            # bare-named one cleared a list nothing wrote to.
+            from aria_code.apps.cli.todo_tracker import clear_todos as _clear_todos
             _clear_todos()  # reset task checklist for this new turn
         except Exception:
             pass
@@ -625,6 +630,19 @@ class ChatTurnMixin:
         # 而不是把"请重试"推给用户(60s 的工具结果/思考不该因一次抽风作废)。
         # 仅对 empty_response 重试;其他错误(配额/鉴权等)走原有 rescue 链。
         _ACTION_VIEW_ACTIVE[0] = _action_view is not None
+        # The task worktree this turn edits instead of the user's files; None
+        # when isolation is off or this is not a git repository.
+        from apps.cli import task_isolation as _task_isolation
+
+        def _task_note(text: str) -> None:
+            if HAS_RICH:
+                from rich.markup import escape as _escape_markup
+                console.print(f"  [dim]{_escape_markup(text)}[/dim]")
+            else:
+                print(f"  {text}")
+
+        _task = _task_isolation.prepare(_runtime_config, notify=_task_note)
+        _task_context = _task_isolation.execution_context(_task, _runtime_config)
         try:
             for _rt_attempt in range(2):
                 try:
@@ -653,6 +671,7 @@ class ChatTurnMixin:
                         execution_context=lambda: {
                             "_run_id": self._active_run_id,
                             "_session_id": self.session_id,
+                            **_task_context,
                         },
                         return_result=True,
                     )
@@ -1055,11 +1074,22 @@ class ChatTurnMixin:
                         console if HAS_RICH else None,
                         _delivery,
                         run_id=str(result.get("run_id") or ""),
-                        root=os.getcwd(),
+                        root=_task_context.get("_workspace") or os.getcwd(),
                     )
                 except Exception as _delivery_err:
                     logger.debug("delivery report not shown: %s", _delivery_err)
 
+            # A turn that changed files in its task worktree: apply, keep, discard.
+            await self._offer_task_apply(_task, _task_note)
+
+            # Whether the code now passes its checks — what the next
+            # transaction point records, and what /rewind green looks for.
+            from aria_code.runtime.transactions import verdict_from_acceptance
+            self._code_verdict = verdict_from_acceptance(
+                result.get("acceptance") if isinstance(result, dict) else None,
+                getattr(self, "_code_verdict", ""),
+            )
+
             # Metadata line — detailed stats
             metadata = turn_result.metadata
             prompt_t = metadata.prompt_tokens
@@ -1258,5 +1288,24 @@ class ChatTurnMixin:
                 data={"elapsed_seconds": elapsed},
             )
 
+    async def _offer_task_apply(self, task, say) -> None:
+        """Ask whether a task's changes should reach the user's files."""
+        if task is None:
+            return
+        from apps.cli import task_isolation
+
+        def _choose(options, title):
+            return _arrow_select(options, selected=0, title=title,
+                                 shortcuts={"a": 0, "k": 1, "d": 2},
+                                 collapse_to="task")
+
+        loop = asyncio.get_running_loop()
+        try:
+            await loop.run_in_executor(None, lambda: task_isolation.offer(
+                task, choose=_choose, say=say, session_id=self.session_id))
+        except Exception as exc:
+            logger.debug("task apply offer failed: %s", exc)
+            say(f"Task {task.task_id} kept; /task apply or /task discard.")
+
 
 __all__ = ["ChatTurnMixin"]

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/apps/cli/commands/catalog.py

@@ -75,7 +75,7 @@ VISIBLE_SLASH_COMMANDS: FrozenSet[str] = frozenset({
     # Broker
     "/broker", "/account", "/positions", "/orders", "/paper", "/trade",
     # Code & project
-    "/project", "/init", "/review", "/code", "/plan", "/orchestrate", "/run", "/tasks", "/delegate", "/canva", "/completions", "/lsp",
+    "/project", "/init", "/review", "/code", "/plan", "/orchestrate", "/run", "/task", "/tasks", "/impact", "/workflow", "/delegate", "/canva", "/completions", "/lsp",
     # Research
     "/team", "/warehouse", "/deep",
     # Quant

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/apps/cli/commands/core_cmds.py

@@ -58,7 +58,15 @@ class CoreCommandsMixin:
             return False
         # Only match registered commands and skills, not file paths like /Users/...
         cmd = text.split(maxsplit=1)[0].lower()
-        return cmd in self.commands or cmd in self.skill_map
+        return cmd in self.commands or cmd in self.skill_map or self._workflow_named(cmd)
+    def _workflow_named(self, cmd: str) -> bool:
+        """``/release`` when ``.aria/workflows/release.yaml`` exists here."""
+        try:
+            from aria_code.runtime.workflows import names
+            root = self.terminal.config.get("_session_workspace_root") or os.getcwd()
+            return cmd.lstrip("/") in names(root)
+        except Exception:
+            return False
     async def execute(self, text: str):
         from aria_code.apps.cli.helpers import _fuzzy_match
         reference_service = getattr(self.terminal, "_reference_service", None)
@@ -102,6 +110,10 @@ class CoreCommandsMixin:
                     print(f"\n  ✗ {cmd_name} error: {_cmd_err}\n{_tb_str}")
         elif cmd_name in self.skill_map:
             await self._execute_skill(self.skill_map[cmd_name], args)
+        elif self._workflow_named(cmd_name):
+            # After commands and skills: a repository file never shadows a
+            # built-in. /workflow run <name> reaches it either way.
+            await self.cmd_workflow(f"run {cmd_name.lstrip('/')} {args}".rstrip())
         else:
             # Fuzzy match: suggest closest command
             all_cmds = list(self.commands.keys()) + list(self.skill_map.keys())
@@ -634,6 +646,32 @@ class CoreCommandsMixin:
             for t in tasks:
                 preview = t.prompt[:50]
                 print(f"  {t.task_id}  {t.status:10s}  {t.age_str():>5s}  {preview}")
+    def cmd_task(self, args: str):
+        """Show, diff, apply or discard the coding task's worktree."""
+        from apps.cli import task_isolation
+
+        text = task_isolation.command(args, self.terminal.config, session_id=self.terminal.session_id or "")
+        if self.context.has_rich:
+            from rich.markup import escape
+            self.context.console.print(escape(text))
+        else:
+            print(text)
+    def cmd_impact(self, args: str):
+        """/impact <path|symbol> [...] — dependents, tests and services of a change."""
+        targets = shlex.split(args)
+        if not targets:
+            msg = "Usage: /impact <path|symbol> [...]   e.g. /impact src/auth/session.py Session.refresh"
+            self.context.console.print(f"[dim]{msg}[/dim]") if self.context.has_rich else print(msg)
+            return
+        from aria_code.runtime.project_graph import load_project_graph
+
+        root = self.terminal.config.get("_session_workspace_root") or os.getcwd()
+        text = load_project_graph(root).impact(targets).render()
+        if self.context.has_rich:
+            from rich.markup import escape
+            self.context.console.print(escape(text))
+        else:
+            print(text)
     def cmd_delegate(self, args: str):
         """Delegate a task to the Claude Code or Codex CLI as a background subagent."""
         try:

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/apps/cli/commands/workflow_cmds.py

@@ -254,6 +254,9 @@ class WorkflowCommandsMixin:
         if mode in {"conversation", "chat"}:
             self.cmd_undo("")
             return
+        if mode in {"turn", "turns", "green"}:
+            self._rewind_transaction(mode, identifier, assume_yes=assume_yes, is_zh=is_zh)
+            return
         if mode not in {"code", "both", "list"}:
             identifier = parts[0]
             mode = "code"
@@ -345,6 +348,155 @@ class WorkflowCommandsMixin:
             for path in result.restored_paths:
                 print(f"  {path}")
 
+    def _rewind_transaction(self, mode: str, ref: str, *, assume_yes: bool, is_zh: bool) -> None:
+        """``/rewind turns`` · ``/rewind turn [N|id]`` · ``/rewind green``.
+
+        A turn rewind puts back files, conversation, task list, approvals,
+        background tasks and the task worktree as they were before that turn.
+        """
+        from apps.cli import transactions
+        from aria_code.runtime.checkpoints import CheckpointConflictError
+
+        con = self.context.console if self.context.has_rich else None
+
+        def say(text: str, style: str = "dim") -> None:
+            if con is not None:
+                from rich.markup import escape
+                con.print(f"[{style}]{escape(text)}[/{style}]" if style else escape(text))
+            else:
+                print(text)
+
+        session_id = str(self.terminal.session_id or "default")
+        store = transactions.store()
+        if mode == "turns":
+            points = store.list(session_id)
+            if not points:
+                say("还没有可回退的轮次" if is_zh else "No turns to rewind yet")
+                return
+            say("回退点（✓ 检查通过 ✗ 失败 ≈ 仅改动前已有的失败 · 未验证）" if is_zh
+                else "Rewind points (✓ checks passed  ✗ failed  ≈ only failures that predate it  · unverified)", "bold")
+            for line in transactions.describe(points):
+                say(line, "")
+            say("/rewind turn N  ·  /rewind green")
+            return
+
+        point = store.latest_green(session_id) if mode == "green" else store.find(session_id, ref or "1")
+        if point is None:
+            if mode == "green":
+                say("没有检查通过的回退点" if is_zh else "No point where the checks passed")
+            else:
+                say(f"没有回退点 {ref or '1'}" if is_zh else f"No rewind point {ref or '1'}; see /rewind turns")
+            return
+        if not assume_yes:
+            question = (
+                f"  回退到第 {point.turn} 轮之前（文件、对话、待办、授权一起恢复）？ [y/N] " if is_zh else
+                f"  Rewind to before turn {point.turn} — files, conversation, tasks and approvals? [y/N] "
+            )
+            try:
+                answer = (con.input(question) if con is not None else input(question)).strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                return
+            if answer not in {"y", "yes"}:
+                say("已取消" if is_zh else "Cancelled")
+                return
+        try:
+            outcome = transactions.rewind(self.terminal, point)
+        except CheckpointConflictError as exc:
+            say((f"回退已停止，未做任何改动: {exc}" if is_zh else f"Rewind stopped, nothing changed: {exc}"), "red")
+            return
+        except Exception as exc:
+            say((f"回退失败: {exc}" if is_zh else f"Rewind failed: {exc}"), "red")
+            return
+        for index, line in enumerate(outcome.lines()):
+            say(line, "green" if index == 0 else "dim")
+
+    def _workflow_workspace(self) -> str:
+        return self.terminal.config.get("_session_workspace_root") or os.getcwd()
+
+    def _wf_say(self, text: str, style: str = "dim") -> None:
+        if self.context.has_rich:
+            from rich.markup import escape
+            self.context.console.print(f"[{style}]{escape(text)}[/{style}]" if style else escape(text))
+        else:
+            print(text)
+
+    def _wf_ask(self, question: str) -> bool:
+        try:
+            answer = (self.context.console.input(question) if self.context.has_rich else input(question))
+        except (EOFError, KeyboardInterrupt):
+            return False
+        return answer.strip().lower() in {"y", "yes"}
+
+    async def cmd_workflow(self, args: str):
+        """/workflow list | show <name> | run <name> [args] | new <name>."""
+        from aria_code.runtime import workflows
+
+        parts = args.strip().split(maxsplit=2)
+        sub = parts[0].lower() if parts else "list"
+        name = parts[1].lstrip("/").lower() if len(parts) > 1 else ""
+        rest = parts[2] if len(parts) > 2 else ""
+        workspace = self._workflow_workspace()
+
+        if sub == "list":
+            found = workflows.names(workspace)
+            if not found:
+                self._wf_say("No workflows. /workflow new <name> creates .aria/workflows/<name>.yaml")
+                return
+            for item in found:
+                try:
+                    workflow = workflows.find(workspace, item)
+                    self._wf_say(f"  /{item:<14} {workflow.description or ''}  ({len(workflow.steps)} steps)", "")
+                except workflows.WorkflowError as exc:
+                    self._wf_say(f"  /{item:<14} invalid: {exc}", "red")
+            return
+        if sub == "new":
+            if not name:
+                self._wf_say("Usage: /workflow new <name>")
+                return
+            target = pathlib.Path(workspace) / ".aria" / "workflows" / f"{name}.yaml"
+            if target.exists():
+                self._wf_say(f"{target} already exists", "yellow")
+                return
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(workflows.TEMPLATE.format(name=name), encoding="utf-8")
+            self._wf_say(f"Created {target}; edit its steps, then run /{name}", "green")
+            return
+        if sub not in {"show", "run"} or not name:
+            self._wf_say("Usage: /workflow list | show <name> | run <name> [args] | new <name>")
+            return
+        try:
+            workflow = workflows.find(workspace, name)
+        except workflows.WorkflowError as exc:
+            self._wf_say(str(exc), "red")
+            return
+        if workflow is None:
+            self._wf_say(f"No workflow '{name}' in .aria/workflows; /workflow list", "yellow")
+            return
+        if sub == "show":
+            for line in workflow.outline():
+                self._wf_say(line, "")
+            return
+        await self._run_workflow(workflow, rest)
+
+    async def _run_workflow(self, workflow, args: str) -> None:
+        from aria_code.runtime.workflows import TrustStore
+        from aria_code.apps.cli.workflow_runner import run_workflow, summary_lines
+
+        trust = TrustStore.load()
+        if not trust.trusted(workflow):
+            self._wf_say("This workflow comes from the repository and has not run here before"
+                      " (or its file changed). It will run:", "yellow")
+            for line in workflow.outline():
+                self._wf_say(line, "")
+            if not self._wf_ask("  Trust and run it? [y/N] "):
+                self._wf_say("Cancelled")
+                return
+            trust.trust(workflow)
+        results = await run_workflow(self.terminal, workflow, args, ask=self._wf_ask, say=self._wf_say)
+        for index, line in enumerate(summary_lines(workflow, results)):
+            style = ("red" if "FAILED" in line else "yellow" if "STOPPED" in line else "green") if index == 0 else "dim"
+            self._wf_say(line, style)
+
     async def cmd_retry(self, args: str):
         last_user_msg = None
         for i in range(len(self.terminal.conversation) - 1, -1, -1):

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/apps/cli/prompts/coding.py

@@ -14,7 +14,10 @@ CODING_SYSTEM_PROMPT = (
     "so the top of the map is where a change most likely belongs. To locate one named thing, call "
     "`find_symbol` rather than guessing a path: it returns exact file:line definitions, plus "
     "near-miss suggestions when the name does not exist. Use `search_code`/`glob` for literal text "
-    "and file patterns; do NOT use them to hunt for a definition you could look up directly.\n\n"
+    "and file patterns; do NOT use them to hunt for a definition you could look up directly. "
+    "Before changing a file, class or function other code may depend on, call `impact_analysis` "
+    "with it: it lists the files that use it, what imports those, the tests that cover them and "
+    "the services that ship them — check those callers instead of assuming none exist.\n\n"
 
     "## VERIFICATION IS AUTOMATIC\n"
     "After you change files and stop calling tools, the inferred checks (tests, type-check, build) "

{aria_code-0.123.0 → aria_code-0.125.0}/src/aria_code/apps/cli/providers/runtime_bridge.py

@@ -136,9 +136,45 @@ def build_acceptance_gate(executor, config: Optional[dict] = None, message: str
         root=root,
         max_attempts=int(cfg.get("acceptance_max_attempts", 2) or 2),
         commands=_declared_acceptance_commands(cfg, message),
+        baseline=_build_baseline(executor, cfg, timeout),
     )
 
 
+def _build_baseline(executor, cfg: dict, timeout: int):
+    """Reruns a failed check on the code before the change; None when off.
+
+    In a task worktree the "before" is the task's starting snapshot, in the
+    user's own repository. Otherwise it is the working tree with this turn's
+    edits undone from the checkpoints recorded after this point.
+    """
+    if not cfg.get("test_baseline", True):
+        return None
+    try:
+        import os
+
+        from aria_code.packages.aria_core.paths import aria_home
+        from aria_code.runtime.approval import ApprovalDecision
+        from aria_code.runtime.baseline import Baseline
+        from aria_code.runtime.checkpoints import CheckpointStore
+
+        context = dict(executor.execution_context() or {}) if getattr(executor, "execution_context", None) else {}
+        base_commit = str(context.get("_task_base") or "")
+        workspace = cfg.get("_session_workspace_root") or os.getcwd()
+
+        def run(command: str, cwd: str) -> dict:
+            return executor.execute_local("run_command", {"command": command, "cwd": cwd, "timeout": timeout},
+                                          approval=ApprovalDecision.allow(policy="balanced", user_approved=True))
+
+        return Baseline(
+            workspace, run=run, base_commit=base_commit,
+            undo_since=None if base_commit else CheckpointStore().max_sequence(),
+            session_id=str(context.get("_session_id") or ""),
+            scratch_root=aria_home() / "worktrees" / "baselines",
+        )
+    except Exception:
+        return None
+
+
 def build_change_contract(config: Optional[dict] = None, message: str = "", executor=None):
     """The project's change contract with this request as its goal, or None.
 
@@ -435,3 +471,40 @@ async def run_chat_via_runtime(
         review=review,
     )
     return result if return_result else result.text
+
+
+def subagent_run_options(config: dict, task: Any) -> tuple[dict, dict]:
+    """The config and execution context a background task's turn runs under.
+
+    A task names its own workspace (its worktree, for an isolated one) and its
+    own mode; the session's are not its. Without this the runner sent every
+    task's tools to the session's directory, whatever the task said.
+    """
+    cfg = dict(config or {})
+    mode = str(getattr(task, "mode", "") or "read-only")
+    cfg["permission_mode"] = "read-only" if mode == "read-only" else "workspace-write"
+    context: dict = {"_session_id": str(getattr(task, "session_id", "") or "")}
+    workspace = str(getattr(task, "workspace", "") or "")
+    if workspace:
+        cfg["_session_workspace_root"] = workspace
+        context["_workspace"] = workspace
+    spec = getattr(task, "worktree_spec", None)
+    if spec is not None:
+        context["_workspace_origin"] = str(spec.repository)
+        context["_workspace_restricted"] = True
+    return cfg, context
+
+
+async def run_subagent_turn(prompt: str, task: Any, *, local_tools, tool_schemas: List[dict],
+                            config: dict, api_url: Optional[str]) -> str:
+    """Run one background task through the same runtime as a chat turn."""
+    cfg, context = subagent_run_options(config, task)
+    result = await run_chat_via_runtime(
+        prompt=prompt, history=[], local_tools=local_tools, tool_schemas=tool_schemas,
+        model=str(cfg.get("model") or ""), config=cfg, api_url=api_url,
+        ollama_url=str(cfg.get("ollama_url") or "http://localhost:11434"),
+        execution_context=lambda: dict(context), return_result=True,
+    )
+    if getattr(result, "error", None) and not str(getattr(result, "text", "") or "").strip():
+        raise RuntimeError(str(result.error))
+    return str(getattr(result, "text", "") or "")