aria-code 0.110.0__tar.gz → 0.111.0__tar.gz

{aria_code-0.110.0/src/aria_code.egg-info → aria_code-0.111.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.110.0
+Version: 0.111.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
@@ -169,8 +169,9 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center"><a href="README_CN.md">简体中文</a> · English</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?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
-  <a href="https://pypi.org/project/aria-code/"><img src="https://img.shields.io/pypi/v/aria-code?style=flat-square&logo=pypi&label=PyPI" alt="PyPI version"></a>
+  <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.111.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.111.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>
@@ -230,12 +231,16 @@ Aria checks for a newer stable version in the background at startup, at most onc
 ```bash
 aria update --check  # check without installing
 aria update          # install the newest stable version for this install channel
+aria update --to 0.110.0  # choose a specific stable release
+aria update --rollback   # native macOS/Linux: restore the previous managed release offline
 ```
 
 In an interactive session, use `/update --check` or `/update`, then restart Aria. Native updates verify SHA-256 and the downloaded binary's version before switching the command; a failed download or verification leaves the existing command in place. Startup checks only notify. To disable them, set `check_for_update_on_startup` to `false` in `~/.aria-code/config.json`.
 
 For GitHub notifications, open [this repository](https://github.com/artheras/aria-code), select **Watch → Custom → Releases**, and save. Notifications follow your GitHub notification settings. Published stable releases appear on the [release page](https://github.com/artheras/aria-code/releases/latest) once the platform assets and package publishing have completed.
 
+Native macOS/Linux updates retain interrupted transfers and can use the verified official npm platform artifact when GitHub downloads fail. For recovery and a model generation check (`aria health --model --tools --json`), see [updates and model diagnostics](docs/update-and-model-diagnostics.md).
+
 To use a local model, install [Ollama](https://ollama.com/download), pull a coding model, and start Aria in local-only mode:
 
 ```bash

{aria_code-0.110.0 → aria_code-0.111.0}/README.md

@@ -13,8 +13,9 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center"><a href="README_CN.md">简体中文</a> · English</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?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
-  <a href="https://pypi.org/project/aria-code/"><img src="https://img.shields.io/pypi/v/aria-code?style=flat-square&logo=pypi&label=PyPI" alt="PyPI version"></a>
+  <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.111.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.111.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>
@@ -74,12 +75,16 @@ Aria checks for a newer stable version in the background at startup, at most onc
 ```bash
 aria update --check  # check without installing
 aria update          # install the newest stable version for this install channel
+aria update --to 0.110.0  # choose a specific stable release
+aria update --rollback   # native macOS/Linux: restore the previous managed release offline
 ```
 
 In an interactive session, use `/update --check` or `/update`, then restart Aria. Native updates verify SHA-256 and the downloaded binary's version before switching the command; a failed download or verification leaves the existing command in place. Startup checks only notify. To disable them, set `check_for_update_on_startup` to `false` in `~/.aria-code/config.json`.
 
 For GitHub notifications, open [this repository](https://github.com/artheras/aria-code), select **Watch → Custom → Releases**, and save. Notifications follow your GitHub notification settings. Published stable releases appear on the [release page](https://github.com/artheras/aria-code/releases/latest) once the platform assets and package publishing have completed.
 
+Native macOS/Linux updates retain interrupted transfers and can use the verified official npm platform artifact when GitHub downloads fail. For recovery and a model generation check (`aria health --model --tools --json`), see [updates and model diagnostics](docs/update-and-model-diagnostics.md).
+
 To use a local model, install [Ollama](https://ollama.com/download), pull a coding model, and start Aria in local-only mode:
 
 ```bash

{aria_code-0.110.0 → aria_code-0.111.0}/pyproject.toml

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

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

{aria_code-0.110.0 → aria_code-0.111.0}/src/aria_code/apps/cli/commands/diagnostic_cmds.py

@@ -227,6 +227,29 @@ class DiagnosticCommandsMixin:
             print()
 
     async def cmd_health(self, args: str):
+        try:
+            parts = shlex.split(args)
+        except ValueError:
+            message = "Usage: /health [--model] [--tools] [--json]"
+            self.context.console.print(message) if self.context.has_rich else print(message)
+            return
+        if parts:
+            if any(part not in {"--model", "--tools", "--json"} for part in parts):
+                message = "Usage: /health [--model] [--tools] [--json]"
+                self.context.console.print(message) if self.context.has_rich else print(message)
+                return
+            if not any(part in {"--model", "--tools"} for part in parts):
+                message = "Run /health --model --json to explicitly test model generation."
+                self.context.console.print(message) if self.context.has_rich else print(message)
+                return
+            from aria_code.apps.cli.model_probe import probe_model
+            report = await probe_model(self.terminal.config, self.terminal.api_url, tools="--tools" in parts)
+            message = json.dumps(report.to_dict(), ensure_ascii=False) if "--json" in parts else (
+                f"{report.model} · {report.route} · {report.category}: {report.message}"
+                + (f"\n{report.suggestion}" if report.suggestion else "")
+            )
+            self.context.console.print(message, markup=False) if self.context.has_rich else print(message)
+            return
         import aiohttp
         if self.context.has_rich:
             self.context.console.print()
@@ -251,10 +274,12 @@ class DiagnosticCommandsMixin:
                             self.context.console.print(f"  [green]●[/green] [dim]{label}[/dim]  {detail}")
                         else:
                             print(f"  + {label}  {detail}")
-            except Exception:
+            except Exception as exc:
+                from aria_code.packages.aria_services.provider_health import classify_provider_error
+                category = classify_provider_error(label, exc).category
                 if self.context.has_rich:
-                    self.context.console.print(f"  [red]●[/red] [dim]{label}[/dim]  offline")
+                    self.context.console.print(f"  [red]●[/red] [dim]{label}[/dim]  {category}")
                 else:
-                    print(f"  - {label}  offline")
+                    print(f"  - {label}  {category}")
         if self.context.has_rich:
             self.context.console.print()

aria_code-0.111.0/src/aria_code/apps/cli/model_probe.py

@@ -0,0 +1,166 @@
+"""Explicit model diagnostics using the selected transport, without file tools."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+from dataclasses import asdict, dataclass
+import json
+import time
+
+from aria_code.apps.cli.providers.chat_routing import first_round_route
+from aria_code.packages.aria_services.provider_health import classify_provider_error
+
+
+@dataclass(frozen=True)
+class ModelProbe:
+    model: str
+    route: str
+    success: bool
+    category: str
+    message: str
+    duration_ms: int
+    text_verified: bool = False
+    tools_verified: bool = False
+    provider: str = ""
+    first_token_ms: int | None = None
+    suggestion: str = ""
+    schema: str = "aria.model_probe.v1"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+_PROBE_TOOL = {"type": "function", "function": {
+    "name": "aria_probe_ping",
+    "description": "A diagnostic echo with no file access or side effects.",
+    "parameters": {"type": "object", "properties": {"echo": {"type": "string"}}, "required": ["echo"]},
+}}
+
+
+async def probe_model(config: dict, api_url: str = "", *, tools: bool = False,
+                      timeout: float = 30) -> ModelProbe:
+    """One text request, optionally one inert tool call and its round trip.
+
+    Do not use the agent gateway: its provider fallback and project tools can
+    hide a broken primary route or perform work. Never change saved settings.
+    """
+    from aria_code.apps.cli.providers.base import AriaSSEProvider, ConfiguredProvider, OllamaProvider
+    from aria_code.packages.aria_sdk.streaming import stream_provider_result
+
+    cfg = dict(config)
+    model = str(cfg.get("model") or "")
+    route = first_round_route(model, cfg, api_url)
+    started = time.monotonic()
+    cancel = asyncio.Event()
+    text_ok = tool_ok = False
+    provider_name = ""
+    first_token = None
+
+    def token(_text):
+        nonlocal first_token
+        if _text.strip() and first_token is None:
+            first_token = round((time.monotonic() - started) * 1000)
+
+    def result(ok, category, message, suggestion=""):
+        return ModelProbe(model, route, ok, category, message,
+                          round((time.monotonic() - started) * 1000),
+                          text_ok, tool_ok, provider_name, first_token, suggestion)
+
+    def failed(error):
+        raw = str(error or "empty_response")
+        if "backend_local_tools_unsupported" in raw or "tool_protocol" in raw:
+            return result(False, "protocol_unsupported", "Backend does not support the local tool protocol.",
+                          "Update the backend protocol or use a direct provider for local project tasks.")
+        issue = classify_provider_error(provider_name or route, error)
+        suggestions = {
+            "auth": "Check credentials and project permissions; for Google Cloud, verify gcloud/ADC authorization.",
+            "configuration": "Set your Google Cloud project: /config set gcp_project=<project-id> or GOOGLE_CLOUD_PROJECT.",
+            "model_unavailable": "Check the selected model ID, project and serving region with /model.",
+            "rate_limited": "Wait for the quota cooldown or check the provider quota.",
+            "timeout": "Check network and provider latency; increase --timeout if needed.",
+            "no_data": "The selected route returned no visible text; check its streaming/model configuration.",
+        }
+        return result(False, issue.category, issue.message,
+                      suggestions.get(issue.category, "Check the selected provider and connection settings."))
+
+    def provider(local_tools=False):
+        if route == "cloud":
+            return AriaSSEProvider(api_url, model, auth_token=cfg.get("auth_token"),
+                                   use_react_gateway=bool(cfg.get("arthera_react_gateway")),
+                                   local_tools=local_tools)
+        if route == "ollama":
+            return OllamaProvider(str(cfg.get("ollama_url") or "http://localhost:11434"), model,
+                                  system_override="Only perform the requested diagnostic.",
+                                  show_market_prefetch_status=False)
+        return ConfiguredProvider(cfg, model)
+
+    async def run():
+        nonlocal text_ok, tool_ok, provider_name
+        reply = await stream_provider_result(provider(), "Reply with the single word READY.", [],
+                                             tools=[], cancel_event=cancel, on_token=token)
+        provider_name = str(reply.get("provider") or route)
+        if not reply.get("success") or not str(reply.get("response") or "").strip():
+            return failed(reply.get("error") or "empty_response")
+        text_ok = True
+        if not tools:
+            return result(True, "ok", "Selected model returned visible text.")
+        diagnostic = provider(local_tools=True)
+        request = "Call aria_probe_ping exactly once with echo='READY'. Do not answer in text before calling it."
+        call = await stream_provider_result(diagnostic, request, [], tools=[_PROBE_TOOL], cancel_event=cancel)
+        if not call.get("success"):
+            return failed(call.get("error"))
+        calls = list(call.get("tool_calls_pending") or [])
+        if len(calls) != 1 or calls[0].get("tool") != "aria_probe_ping" or calls[0].get("params") != {"echo": "READY"}:
+            return result(False, "tool_protocol", "Model did not return the requested diagnostic tool call.",
+                          "Check that this model and transport support function calling.")
+        history = [{"role": "user", "content": request},
+                   {"role": "assistant", "content": "", "tool_calls": [{"id": "aria-probe-1", "type": "function",
+                    "function": {"name": "aria_probe_ping", "arguments": '{"echo":"READY"}'}}]},
+                   {"role": "tool", "name": "aria_probe_ping", "tool_call_id": "aria-probe-1", "content": '{"echo":"READY"}'}]
+        reply = await stream_provider_result(diagnostic, "The diagnostic tool returned READY. Reply READY.", history,
+                                             tools=[], cancel_event=cancel)
+        if not reply.get("success") or not str(reply.get("response") or "").strip():
+            return failed(reply.get("error") or "empty_response")
+        tool_ok = True
+        return result(True, "ok", "Selected model returned text and completed the diagnostic tool round trip.")
+
+    try:
+        return await asyncio.wait_for(run(), timeout=timeout)
+    except asyncio.TimeoutError:
+        return failed("model probe timed out")
+    except Exception as exc:
+        return failed(exc)
+    finally:
+        cancel.set()
+
+
+def main(argv=None) -> int:
+    """Fast standalone equivalent of /health --model; no REPL or agent import."""
+    parser = argparse.ArgumentParser(prog="aria health", description="Probe the selected model without accessing project files")
+    parser.add_argument("--model", action="store_true", help="Send a short text generation request")
+    parser.add_argument("--tools", action="store_true", help="Also verify an inert tool call and its result")
+    parser.add_argument("--model-id", help="Probe this model without changing your saved selection")
+    parser.add_argument("--timeout", type=float, default=30, help="Total probe deadline in seconds (1–60)")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    if not 1 <= args.timeout <= 60:
+        parser.error("--timeout must be between 1 and 60 seconds")
+    from aria_code.apps.cli.bootstrap import initialize_cli_environment, default_config, runtime_paths
+    from aria_code.apps.cli.config_store import load_cli_config
+
+    initialize_cli_environment()
+    cfg = load_cli_config(runtime_paths(), default_config())
+    if args.model_id:
+        cfg["model"] = args.model_id
+    if not (args.model or args.tools):
+        report = ModelProbe(str(cfg.get("model") or ""), first_round_route(str(cfg.get("model") or ""), cfg, cfg.get("api_url")),
+                            False, "not_probed", "Run aria health --model to test generation; add --tools to test function calling.", 0)
+    else:
+        report = asyncio.run(probe_model(cfg, str(cfg.get("api_url") or ""), tools=args.tools, timeout=args.timeout))
+    if args.json:
+        print(json.dumps(report.to_dict(), ensure_ascii=False))
+    else:
+        print(f"{report.model} · {report.route} · {report.category}: {report.message}")
+        if report.suggestion:
+            print(report.suggestion)
+    return 0 if report.success else (2 if report.category == "not_probed" else 1)

{aria_code-0.110.0 → aria_code-0.111.0}/src/aria_code/apps/cli/providers/base.py

@@ -12,6 +12,7 @@ Implement the protocol on any class or pass a coroutine that matches
 from __future__ import annotations
 
 import asyncio
+from contextlib import suppress
 from dataclasses import dataclass, field
 from typing import AsyncGenerator, Optional, Protocol, runtime_checkable
 
@@ -129,27 +130,34 @@ async def _stream_callback_provider(invoke, *, done_provider: str) -> AsyncGener
     task = asyncio.create_task(
         invoke(_on_token, _on_thinking, _on_tool_call, _on_tool_result, _on_status)
     )
-    while not task.done() or not queue.empty():
+    try:
+        while not task.done() or not queue.empty():
+            try:
+                yield await asyncio.wait_for(queue.get(), timeout=0.05)
+            except asyncio.TimeoutError:
+                continue
         try:
-            yield await asyncio.wait_for(queue.get(), timeout=0.05)
-        except asyncio.TimeoutError:
-            continue
+            result = await task
+        except Exception as exc:
+            yield LLMDone(response="", provider=done_provider, success=False, error=str(exc))
+            return
 
-    try:
-        result = await task
-    except Exception as exc:
-        yield LLMDone(response="", provider=done_provider, success=False, error=str(exc))
-        return
-
-    yield LLMDone(
-        response=result.get("response", ""),
-        tool_calls_pending=result.get("tool_calls_pending", []),
-        usage=result.get("usage", {}),
-        provider=result.get("provider", done_provider),
-        success=result.get("success", False),
-        cancelled=result.get("cancelled", False),
-        error=result.get("error", ""),
-    )
+        yield LLMDone(
+            response=result.get("response", ""),
+            tool_calls_pending=result.get("tool_calls_pending", []),
+            usage=result.get("usage", {}),
+            provider=result.get("provider", done_provider),
+            success=result.get("success", False),
+            cancelled=result.get("cancelled", False),
+            error=result.get("error", ""),
+        )
+    finally:
+        # A deadline or an early-closing consumer must also stop the request
+        # behind this callback adapter, rather than leave it running invisibly.
+        if not task.done():
+            task.cancel()
+        with suppress(asyncio.CancelledError, Exception):
+            await task
 
 
 # ── Protocol ─────────────────────────────────────────────────────────────────

aria_code-0.111.0/src/aria_code/apps/cli/release_download.py

@@ -0,0 +1,159 @@
+"""Bounded, resumable release transfers. Activation still verifies the digest."""
+from __future__ import annotations
+
+from contextlib import contextmanager
+import http.client
+import json
+import os
+from pathlib import Path
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+
+class DownloadTimeout(TimeoutError):
+    pass
+
+
+@contextmanager
+def _lock(path: Path):
+    # Native downloads run on macOS/Linux; flock releases on process exit,
+    # including Ctrl+C. Do not let two updates append to the same partial file.
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(str(path), os.O_CREAT | os.O_RDWR | getattr(os, "O_NOFOLLOW", 0), 0o600)
+    try:
+        try:
+            if os.name == "nt":
+                import msvcrt
+
+                if not os.fstat(fd).st_size:
+                    os.write(fd, b"0")
+                os.lseek(fd, 0, os.SEEK_SET)
+                msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            raise RuntimeError("Another update is downloading this release; wait for it to finish") from exc
+        yield
+    finally:
+        os.close(fd)
+
+
+def download(url: str, target: Path, *, deadline_seconds: float = 300,
+             attempts: int = 3, progress=None) -> None:
+    """Keep a partial across attempts/runs; resume only a validated byte range.
+
+    A server ignoring Range starts a fresh file. Invalid Content-Range, changed
+    total size or contradictory validators are never appended. Read in single
+    socket-buffer chunks so a trickle cannot evade the total deadline.
+    """
+    target = Path(target)
+    part = target.with_name(target.name + ".part")
+    state = target.with_name(target.name + ".part.json")
+    limit = time.monotonic() + deadline_seconds
+    last_progress = 0.0
+
+    def report(received, total, complete=False):
+        nonlocal last_progress
+        now = time.monotonic()
+        if not complete and now - last_progress < 1:
+            return
+        last_progress = now
+        if progress:
+            progress(received, total)
+        elif sys.stderr.isatty():
+            size = f"{received / 1048576:.1f} MiB"
+            if total:
+                size += f" / {total / 1048576:.1f} MiB ({min(100, received * 100 // total)}%)"
+            print(f"\rDownloading {target.name}: {size}", end="\n" if complete else "", file=sys.stderr, flush=True)
+
+    with _lock(target.with_name(target.name + ".lock")):
+        try:
+            metadata = json.loads(state.read_text())
+        except (OSError, ValueError):
+            metadata = {}
+        if metadata.get("url") != url:
+            part.unlink(missing_ok=True)
+            metadata = {"url": url}
+        for attempt in range(attempts):
+            left = limit - time.monotonic()
+            if left <= 0:
+                raise DownloadTimeout("Download exceeded its total deadline; partial retained for the next update")
+            offset = part.stat().st_size if part.is_file() else 0
+            headers = {"User-Agent": "aria-code-updater", "Accept": "*/*", "Accept-Encoding": "identity"}
+            if offset:
+                headers["Range"] = f"bytes={offset}-"
+                if metadata.get("validator"):
+                    headers["If-Range"] = metadata["validator"]
+            try:
+                request = urllib.request.Request(url, headers=headers)
+                with urllib.request.urlopen(request, timeout=min(15, left)) as response:
+                    response_headers = getattr(response, "headers", {})
+                    status = getattr(response, "status", 200)
+                    etag = response_headers.get("ETag", "")
+                    validator = (etag if etag and not etag.startswith("W/") else response_headers.get("Last-Modified"))
+                    total = None
+                    mode = "wb"
+                    if status == 206:
+                        match = re.fullmatch(r"bytes (\d+)-(\d+)/(\d+)", response_headers.get("Content-Range", ""))
+                        if not match or int(match[1]) != offset or int(match[2]) < offset:
+                            raise ValueError("Release server returned an invalid resume range")
+                        total = int(match[3])
+                        if int(match[2]) >= total or (metadata.get("total") and metadata["total"] != total):
+                            raise ValueError("Release size changed during a resumed download")
+                        if metadata.get("validator") and validator and metadata["validator"] != validator:
+                            raise ValueError("Release changed during a resumed download")
+                        mode = "ab"
+                    else:
+                        offset = 0
+                        length = response_headers.get("Content-Length")
+                        total = int(length) if length else None
+                    metadata = {"url": url, "validator": validator, "total": total}
+                    state.write_text(json.dumps(metadata))
+                    received = offset
+                    with part.open(mode) as output:
+                        reader = getattr(response, "read1", response.read)
+                        while True:
+                            if time.monotonic() >= limit:
+                                raise DownloadTimeout("Download exceeded its total deadline; partial retained")
+                            chunk = reader(65536)
+                            if time.monotonic() >= limit:
+                                raise DownloadTimeout("Download exceeded its total deadline; partial retained")
+                            if not chunk:
+                                break
+                            output.write(chunk)
+                            received += len(chunk)
+                            report(received, total)
+                    if total is not None and received != total:
+                        raise OSError("Incomplete release transfer")
+                    os.replace(part, target)
+                    state.unlink(missing_ok=True)
+                    report(received, total, True)
+                    return
+            except urllib.error.HTTPError as exc:
+                if exc.code == 416:
+                    # A stale/complete partial is not trusted as a completed
+                    # response. Re-fetch it; the outer installer checks its hash.
+                    part.unlink(missing_ok=True)
+                    state.unlink(missing_ok=True)
+                    metadata = {"url": url}
+                elif exc.code not in {408, 429, 500, 502, 503, 504}:
+                    raise
+                if attempt + 1 == attempts:
+                    raise
+            except DownloadTimeout:
+                raise
+            except ValueError:
+                part.unlink(missing_ok=True)
+                state.unlink(missing_ok=True)
+                raise
+            except (OSError, urllib.error.URLError, http.client.HTTPException):
+                if attempt + 1 == attempts:
+                    raise
+            delay = min(2 ** attempt, max(0, limit - time.monotonic()))
+            time.sleep(delay)
+        raise OSError("Release download did not complete")

{aria_code-0.110.0 → aria_code-0.111.0}/src/aria_code/apps/cli/update_check.py

@@ -31,6 +31,14 @@ _CACHE_FILE    = aria_home() / "update_check.json"
 _CACHE_TTL_S   = 86_400      # 24 hours
 _FETCH_TIMEOUT = 4           # seconds — fail cleanly on slow networks
 
+# These are the project's historical PyPI releases (June–August 2026),
+# published before the current 0.x line. Do not treat arbitrary future 4.x
+# versions as legacy, or recommend these old artifacts to a current install.
+_LEGACY_VERSIONS = frozenset({
+    (4, 1, 3), (4, 1, 4), (4, 1, 7), (4, 2, 0),
+    (4, 3, 0), (4, 4, 0), (4, 4, 1), (4, 4, 2),
+})
+
 _notice: Optional[str] = None
 _lock   = threading.Lock()
 
@@ -46,7 +54,13 @@ def _parse(v: str) -> tuple[int, int, int] | None:
 
 def _newer(latest: str, current: str) -> bool:
     parsed_latest, parsed_current = _parse(latest), _parse(current)
-    return parsed_latest is not None and parsed_current is not None and parsed_latest > parsed_current
+    if parsed_latest is None or parsed_current is None:
+        return False
+    if parsed_current in _LEGACY_VERSIONS and parsed_latest[0] == 0:
+        return True
+    if parsed_latest in _LEGACY_VERSIONS and parsed_current[0] == 0:
+        return False
+    return parsed_latest > parsed_current
 
 
 # ── Cache helpers ─────────────────────────────────────────────────────────────