aria-code 0.57.0__tar.gz → 0.59.0__tar.gz

{aria_code-0.57.0 → aria_code-0.59.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.57.0
+Version: 0.59.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.57.0 → aria_code-0.59.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.57.0"
+version = "0.59.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.57.0 → aria_code-0.59.0}/src/aria_code/_version.py

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

{aria_code-0.57.0 → aria_code-0.59.0}/src/aria_code/tools/local_finance_tools.py

@@ -69,7 +69,10 @@ except ImportError:
 try:
     import akshare as ak
     _HAS_AK = True
-except ImportError:
+# Not just ImportError: akshare reads bundled data files and calendars on
+# import, and a partial install (or a frozen binary without its data) raises
+# FileNotFoundError or worse. Optional means optional — never crash the CLI.
+except Exception:  # noqa: BLE001
     _HAS_AK = False
 
 

{aria_code-0.57.0 → aria_code-0.59.0}/src/aria_code/tools/macro_tools.py

@@ -36,7 +36,10 @@ except ImportError:
 try:
     import akshare as ak
     _HAS_AK = True
-except ImportError:
+# Not just ImportError: akshare reads bundled data files and calendars on
+# import, and a partial install (or a frozen binary without its data) raises
+# FileNotFoundError or worse. Optional means optional — never crash the CLI.
+except Exception:  # noqa: BLE001
     _HAS_AK = False
 
 try:

{aria_code-0.57.0 → aria_code-0.59.0}/src/aria_code/tools/realty_data_tools.py

@@ -26,7 +26,10 @@ logger = logging.getLogger(__name__)
 try:
     import akshare as ak
     _HAS_AK = True
-except ImportError:
+# Not just ImportError: akshare reads bundled data files and calendars on
+# import, and a partial install (or a frozen binary without its data) raises
+# FileNotFoundError or worse. Optional means optional — never crash the CLI.
+except Exception:  # noqa: BLE001
     _HAS_AK = False
 
 try:

{aria_code-0.57.0 → aria_code-0.59.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.57.0
+Version: 0.59.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.57.0 → aria_code-0.59.0}/src/aria_code.egg-info/SOURCES.txt

@@ -497,6 +497,8 @@ tests/test_ashare_prediction_cmds.py
 tests/test_backtest_cmds.py
 tests/test_backtest_engine.py
 tests/test_backtest_report.py
+tests/test_binary_bundles_runtime_imports.py
+tests/test_broken_akshare_is_optional.py
 tests/test_broker_automation.py
 tests/test_broker_chat_confirm_gate.py
 tests/test_broker_planning.py

aria_code-0.59.0/tests/test_binary_bundles_runtime_imports.py

@@ -0,0 +1,142 @@
+"""Every module the program loads by name at runtime must be in the frozen binary.
+
+PyInstaller follows import statements. A module loaded by name —
+
+    sys.modules[__name__] = import_module("clients.market_data_client")
+    importlib.import_module(module_path)        # from a registry table
+
+— is invisible to it. Inspected, the v0.56.0 macOS binary contained:
+
+    compatibility shim targets    0 of 26
+    broker adapters               1 of 10   (paper trading only)
+    agents loaded by name         8 of 31   (no warehouse, realty, coder, supervisor)
+
+Every one of those loaders catches ImportError and logs at debug level, so
+nothing failed. `quote` fell back to a backend at localhost:8000; the broker
+list was shorter; whole agent teams were absent.
+
+scripts/pyinstaller_collect_args.py writes a PyInstaller hook listing every
+first-party module under both import roots. These tests keep it that way
+without building anything: each runtime target must be listed under the exact
+name it is imported by (the bare and packaged roots are different modules —
+listing only one is how --collect-submodules failed), and every PyInstaller
+invocation must use the collector.
+"""
+
+from __future__ import annotations
+
+import ast
+import importlib.util
+import pathlib
+import re
+import tempfile
+import unittest
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+SRC = ROOT / "src" / "aria_code"
+WORKFLOW = ROOT / ".github" / "workflows" / "build-native-binaries.yml"
+MAC_SCRIPT = ROOT / "scripts" / "build_native_binary.sh"
+
+
+def _collector():
+    spec = importlib.util.spec_from_file_location(
+        "pyinstaller_collect_args", ROOT / "scripts" / "pyinstaller_collect_args.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _runtime_targets() -> dict[str, list[str]]:
+    shims = [m.group(1) for f in sorted(SRC.glob("*.py"))
+             if (m := re.search(r'_import_module\("([\w.]+)"\)', f.read_text(encoding="utf-8")))]
+    brokers = re.findall(r'\("(brokers\.[\w.]+)",', (SRC / "brokers" / "registry.py").read_text(encoding="utf-8"))
+    agents = re.findall(r'_try_import_builtin\(\s*"([\w.]+)"', (SRC / "agents" / "registry.py").read_text(encoding="utf-8"))
+    return {"shim": shims, "broker": brokers, "agent": agents}
+
+
+class EveryRuntimeImportIsListed(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.hidden = set(_collector().hidden_imports())
+
+    def test_the_tables_were_found(self) -> None:
+        # Guards against the parsing below silently matching nothing, which
+        # would make the next test pass vacuously.
+        targets = _runtime_targets()
+        self.assertGreaterEqual(len(targets["shim"]), 20)
+        self.assertGreaterEqual(len(targets["broker"]), 5)
+        self.assertGreaterEqual(len(targets["agent"]), 20)
+
+    def test_each_target_is_listed_under_its_exact_name(self) -> None:
+        for kind, modules in _runtime_targets().items():
+            for module in modules:
+                with self.subTest(kind=kind, module=module):
+                    self.assertIn(
+                        module, self.hidden,
+                        f"{module} is loaded by name at runtime but is not in the hook, so "
+                        f"the binary will not contain it — and the loader will swallow "
+                        f"the ImportError",
+                    )
+
+    def test_both_roots_are_listed(self) -> None:
+        self.assertIn("clients.market_data_client", self.hidden)
+        self.assertIn("aria_code.clients.market_data_client", self.hidden)
+        self.assertIn("aria_code", self.hidden)
+
+    def test_each_target_exists_on_disk(self) -> None:
+        # Listing a module still cannot supply one that is not there.
+        for kind, modules in _runtime_targets().items():
+            for module in modules:
+                parts = module.split(".")
+                if parts[0] == "aria_code":
+                    parts = parts[1:]
+                base = SRC.joinpath(*parts)
+                with self.subTest(kind=kind, module=module):
+                    self.assertTrue(
+                        base.with_suffix(".py").is_file() or (base / "__init__.py").is_file(),
+                        f"{module} does not exist",
+                    )
+
+
+class TheHookLoads(unittest.TestCase):
+    def test_written_hook_is_valid_python_with_every_name(self) -> None:
+        collector = _collector()
+        with tempfile.TemporaryDirectory() as tmp:
+            hook = collector.write_hook(pathlib.Path(tmp)) / "hook-aria_code.py"
+            tree = ast.parse(hook.read_text(encoding="utf-8"))
+        (assign,) = [n for n in tree.body if isinstance(n, ast.Assign)]
+        self.assertEqual(assign.targets[0].id, "hiddenimports")
+        self.assertEqual(ast.literal_eval(assign.value), collector.hidden_imports())
+
+    def test_hook_fires_even_if_the_entry_never_imports_aria_code(self) -> None:
+        # A hook runs only when its module is imported; without this a build
+        # whose entry skipped aria_code silently got none of the list.
+        args = _collector().collect_args()
+        self.assertIn("--additional-hooks-dir", args)
+        i = args.index("--hidden-import")
+        self.assertEqual(args[i + 1], "aria_code")
+
+    def test_printed_args_have_no_spaces(self) -> None:
+        # Spliced in by an unquoted $(...): a space would split an argument.
+        for arg in _collector().collect_args():
+            self.assertNotIn(" ", arg)
+
+
+class EveryBuildUsesTheCollector(unittest.TestCase):
+    def test_workflow_builds(self) -> None:
+        text = WORKFLOW.read_text(encoding="utf-8")
+        builds = text.count("--distpath dist-native/dist")
+        self.assertGreater(builds, 0)
+        self.assertEqual(text.count("pyinstaller_collect_args.py"), builds,
+                         "a PyInstaller build in the workflow does not use the collector")
+
+    def test_macos_script_builds(self) -> None:
+        text = MAC_SCRIPT.read_text(encoding="utf-8")
+        builds = text.count("--onedir --name")
+        self.assertGreater(builds, 0)
+        self.assertEqual(text.count("pyinstaller_collect_args.py"), builds,
+                         "a PyInstaller build in the macOS script does not use the collector")
+
+
+if __name__ == "__main__":
+    unittest.main()

aria_code-0.59.0/tests/test_broken_akshare_is_optional.py

@@ -0,0 +1,52 @@
+"""A broken akshare must disable China data, not crash the CLI.
+
+akshare reads bundled data files on import (futures/cons.py loads a calendar
+JSON). Once the native binary started bundling every first-party module,
+tools/local_finance_tools.py was in it, and with akshare present but its data
+missing every command — `quote AAPL` included — died with FileNotFoundError
+before doing anything. The guards caught only ImportError.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.abc
+import sys
+import unittest
+
+MODULES = (
+    "aria_code.tools.local_finance_tools",
+    "aria_code.tools.macro_tools",
+    "aria_code.tools.realty_data_tools",
+)
+
+
+class _BrokenAkshare(importlib.abc.MetaPathFinder):
+    def find_spec(self, name, path=None, target=None):
+        if name == "akshare" or name.startswith("akshare."):
+            raise FileNotFoundError("akshare/file_fold/calendar.json")
+        return None
+
+
+class BrokenAkshareIsOptional(unittest.TestCase):
+    def test_modules_import_with_china_data_disabled(self) -> None:
+        saved = {k: v for k, v in sys.modules.items()
+                 if k == "akshare" or k.startswith("akshare.") or k in MODULES}
+        for name in saved:
+            del sys.modules[name]
+        finder = _BrokenAkshare()
+        sys.meta_path.insert(0, finder)
+        try:
+            for name in MODULES:
+                with self.subTest(module=name):
+                    module = importlib.import_module(name)
+                    self.assertFalse(module._HAS_AK)
+        finally:
+            sys.meta_path.remove(finder)
+            for name in MODULES:
+                sys.modules.pop(name, None)
+            sys.modules.update(saved)
+
+
+if __name__ == "__main__":
+    unittest.main()

{aria_code-0.57.0 → aria_code-0.59.0}/tests/test_native_binary_entrypoints.py

@@ -3,7 +3,7 @@
 The src/ restructure moved aria_cli.py and aria_mcp_server.py to
 src/aria_code/. The release path kept passing the old root-relative names:
 
-    pyinstaller --onefile --name aria-code-bin ... aria_cli.py
+    pyinstaller --onedir --name aria-code-bin ... aria_cli.py
 
 Six places in total -- four in build-native-binaries.yml (Windows and Linux,
 CLI and MCP server) and two in scripts/build_native_binary.sh (macOS). All five
@@ -141,7 +141,7 @@ class TheFreezeCanResolveTheBareImportRoot(unittest.TestCase):
 
     def test_the_macos_script_passes_both_roots_to_every_build(self) -> None:
         text = MAC_SCRIPT.read_text(encoding="utf-8")
-        builds = text.count("--onefile --name")
+        builds = text.count("--onedir --name")
         self.assertEqual(builds, 2, "expected two PyInstaller invocations")
         args = [a.strip('"') for a in re.findall(r"--paths\s+(\S+)", text)]
         for root in self.REQUIRED_ROOTS:

aria_code-0.59.0/tests/test_native_installer.py

@@ -0,0 +1,159 @@
+"""Offline checks for the dependency-free Unix installer.
+
+Releases ship a PyInstaller --onedir build as aria-code-<os>-<arch>.tar.gz;
+releases before that switch shipped a single file named aria-code-<os>-<arch>.
+The installer must handle both, because ARIA_CODE_VERSION can pin either.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import unittest
+
+
+INSTALLER = Path(__file__).resolve().parents[1] / "scripts" / "install.sh"
+VERSION_SCRIPT = "#!/bin/sh\n[ \"$1\" = --version ] && echo v0.55.0\n"
+
+
+class NativeInstallerTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.root = Path(tempfile.mkdtemp(prefix="aria-installer-test-"))
+        self.addCleanup(shutil.rmtree, self.root)
+        self.release = self.root / "release"
+        self.release.mkdir()
+
+    def publish_onedir(self) -> Path:
+        build = self.root / "build" / "aria-code-bin"
+        (build / "_internal").mkdir(parents=True)
+        (build / "_internal" / "base_library.zip").write_bytes(b"zip")
+        exe = build / "aria-code-bin"
+        exe.write_text(VERSION_SCRIPT, encoding="utf-8")
+        exe.chmod(0o755)
+        archive = self.release / "aria-code-macos-arm64.tar.gz"
+        with tarfile.open(archive, "w:gz") as tf:
+            tf.add(build, arcname="aria-code-bin")
+        return archive
+
+    def publish_single_file(self) -> Path:
+        binary = self.release / "aria-code-macos-arm64"
+        binary.write_text(VERSION_SCRIPT, encoding="utf-8")
+        binary.chmod(0o755)
+        return binary
+
+    def run_installer(self, asset: Path, *, valid_checksum: bool = True) -> subprocess.CompletedProcess[str]:
+        digest = hashlib.sha256(asset.read_bytes()).hexdigest() if valid_checksum else "0" * 64
+        (self.release / "SHA256SUMS").write_text(f"{digest}  {asset.name}\n", encoding="utf-8")
+        fake_bin = self.root / "fake-bin"
+        fake_bin.mkdir(exist_ok=True)
+        (fake_bin / "uname").write_text(
+            "#!/bin/sh\ncase \"$1\" in -s) echo Darwin ;; -m) echo arm64 ;; esac\n",
+            encoding="utf-8",
+        )
+        (fake_bin / "curl").write_text(
+            '#!/bin/sh\nwhile [ "$1" != "-o" ]; do shift; done\n'
+            'out=$2; shift 2; url=$1\ncp "$ARIA_TEST_RELEASE/${url##*/}" "$out"\n',
+            encoding="utf-8",
+        )
+        for command in ("uname", "curl"):
+            (fake_bin / command).chmod(0o755)
+        env = os.environ.copy()
+        env.update(
+            HOME=str(self.root),
+            SHELL="/bin/zsh",
+            PATH=f"{fake_bin}:{env['PATH']}",
+            ARIA_TEST_RELEASE=str(self.release),
+            ARIA_CODE_VERSION="v0.55.0",
+        )
+        return subprocess.run(["/bin/sh", str(INSTALLER)], env=env, text=True, capture_output=True)
+
+    @property
+    def command(self) -> Path:
+        return self.root / ".local/bin/aria-code"
+
+    def test_installs_the_onedir_build_and_links_it_onto_path(self) -> None:
+        result = self.run_installer(self.publish_onedir())
+        self.assertEqual(result.returncode, 0, result.stderr)
+        app = self.root / ".local/share/aria-code/aria-code-bin"
+        self.assertTrue((app / "_internal" / "base_library.zip").is_file(),
+                        "the executable's libraries must sit beside it")
+        self.assertTrue(self.command.is_symlink())
+        self.assertEqual(self.command.resolve(), (app / "aria-code-bin").resolve())
+        run = subprocess.run([str(self.command), "--version"], capture_output=True, text=True)
+        self.assertEqual(run.stdout.strip(), "v0.55.0")
+        self.assertIn('export PATH="$HOME/.local/bin:$PATH"', (self.root / ".zprofile").read_text())
+
+    def test_reinstalling_replaces_the_previous_build(self) -> None:
+        archive = self.publish_onedir()
+        self.assertEqual(self.run_installer(archive).returncode, 0)
+        stale = self.root / ".local/share/aria-code/aria-code-bin/_internal/stale.so"
+        stale.write_bytes(b"old")
+        result = self.run_installer(archive)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertFalse(stale.exists(), "a library from the previous version survived")
+        self.assertFalse((self.root / ".local/share/aria-code/aria-code-bin.old").exists())
+
+    def test_replaces_a_single_file_install_from_before_onedir(self) -> None:
+        self.command.parent.mkdir(parents=True)
+        self.command.write_text("#!/bin/sh\necho old\n", encoding="utf-8")
+        result = self.run_installer(self.publish_onedir())
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(self.command.is_symlink())
+
+    def test_a_release_from_before_onedir_still_installs(self) -> None:
+        result = self.run_installer(self.publish_single_file())
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue(self.command.is_file())
+        self.assertFalse(self.command.is_symlink())
+
+    def test_rejects_checksum_mismatch_before_installing(self) -> None:
+        for publish in (self.publish_onedir, self.publish_single_file):
+            with self.subTest(asset=publish.__name__):
+                result = self.run_installer(publish(), valid_checksum=False)
+                self.assertNotEqual(result.returncode, 0)
+                self.assertIn("checksum mismatch", result.stderr)
+                self.assertFalse(self.command.exists())
+                self.assertFalse((self.root / ".local/share/aria-code").exists())
+
+    def test_a_release_without_this_platform_says_so(self) -> None:
+        other = self.release / "aria-code-linux-x64.tar.gz"
+        other.write_bytes(b"x")
+        result = self.run_installer(other)
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("no build for macos-arm64", result.stderr)
+
+
+class WindowsInstallerMatchesTheRelease(unittest.TestCase):
+    """No PowerShell on the macOS and Linux CI runners, so these are static:
+    the names it downloads and the layout it expects must be the ones the
+    release workflow produces."""
+
+    def setUp(self) -> None:
+        self.script = (INSTALLER.parent / "install.ps1").read_text(encoding="utf-8")
+
+    def test_downloads_the_onedir_zip_and_falls_back_to_the_old_exe(self) -> None:
+        self.assertIn("$asset = 'aria-code-windows-x64'", self.script)
+        self.assertIn('$file = "$asset.zip"', self.script)
+        self.assertIn('$file = "$asset.exe"', self.script)
+        self.assertLess(self.script.index('"$asset.zip"'), self.script.index('"$asset.exe"'),
+                        "the onedir build must be preferred")
+
+    def test_keeps_the_libraries_beside_the_executable(self) -> None:
+        self.assertIn("Join-Path $build 'aria-code-bin.exe'", self.script)
+        self.assertIn("Move-Item (Join-Path $build '_internal') $libraries", self.script)
+        self.assertIn("$libraries = Join-Path $installDir '_internal'", self.script)
+
+    def test_verifies_before_replacing_anything(self) -> None:
+        checked = self.script.index("Checksum mismatch")
+        self.assertLess(checked, self.script.index("Remove-Item -Force $destination"))
+        self.assertLess(self.script.index("& $exe --version"),
+                        self.script.index("Remove-Item -Force $destination"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{aria_code-0.57.0 → aria_code-0.59.0}/tests/test_platform_package_assembly.py

@@ -25,6 +25,7 @@ of the two shows up.
 
 from __future__ import annotations
 
+import importlib.util
 import pathlib
 import json
 import shutil
@@ -38,21 +39,38 @@ import yaml
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 WORKFLOW = ROOT / ".github" / "workflows" / "build-native-binaries.yml"
 
+_spec = importlib.util.spec_from_file_location(
+    "package_onedir", ROOT / "scripts" / "package_onedir.py")
+package_onedir = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(package_onedir)
+
 # What each platform's two artifacts are called, as the upload steps name them.
+# Each artifact is the archive of a --onedir build (scripts/package_onedir.py).
 ARTIFACTS = {
-    "darwin-arm64": ("aria-code-macos-arm64", "aria-code-bin",
-                     "aria-code-mcp-macos-arm64", "aria-code-mcp-bin"),
-    "darwin-x64":   ("aria-code-macos-x64", "aria-code-bin",
-                     "aria-code-mcp-macos-x64", "aria-code-mcp-bin"),
-    "linux-x64":    ("aria-code-linux-x64", "aria-code-bin",
-                     "aria-code-mcp-linux-x64", "aria-code-mcp-bin"),
-    "linux-arm64":  ("aria-code-linux-arm64", "aria-code-bin",
-                     "aria-code-mcp-linux-arm64", "aria-code-mcp-bin"),
-    "win32-x64":    ("aria-code-windows-x64", "aria-code-bin.exe",
-                     "aria-code-mcp-windows-x64", "aria-code-mcp-bin.exe"),
+    "darwin-arm64": ("aria-code-macos-arm64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-macos-arm64", "aria-code-mcp-bin.tar.gz"),
+    "darwin-x64":   ("aria-code-macos-x64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-macos-x64", "aria-code-mcp-bin.tar.gz"),
+    "linux-x64":    ("aria-code-linux-x64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-linux-x64", "aria-code-mcp-bin.tar.gz"),
+    "linux-arm64":  ("aria-code-linux-arm64", "aria-code-bin.tar.gz",
+                     "aria-code-mcp-linux-arm64", "aria-code-mcp-bin.tar.gz"),
+    "win32-x64":    ("aria-code-windows-x64", "aria-code-bin.zip",
+                     "aria-code-mcp-windows-x64", "aria-code-mcp-bin.zip"),
 }
 
 
+def _upload_paths() -> dict[str, str]:
+    """Artifact name -> the path its upload step sends, from the workflow."""
+    doc = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))
+    out: dict[str, str] = {}
+    for job in doc["jobs"].values():
+        for step in job.get("steps") or []:
+            if str(step.get("uses", "")).startswith("actions/upload-artifact"):
+                out[step["with"]["name"]] = step["with"]["path"]
+    return out
+
+
 def _assemble_script() -> str:
     doc = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))
     for job in doc["jobs"].values():
@@ -98,12 +116,18 @@ class _Fixture(unittest.TestCase):
 
     def place(self, platform: str, *, cli: bool = True, mcp: bool = True) -> None:
         cli_dir, cli_file, mcp_dir, mcp_file = ARTIFACTS[platform]
-        if cli:
-            (self.built / cli_dir).mkdir(parents=True, exist_ok=True)
-            (self.built / cli_dir / cli_file).write_bytes(b"\x7fELF")
-        if mcp:
-            (self.built / mcp_dir).mkdir(parents=True, exist_ok=True)
-            (self.built / mcp_dir / mcp_file).write_bytes(b"\x7fELF")
+        for wanted, directory, archive in ((cli, cli_dir, cli_file), (mcp, mcp_dir, mcp_file)):
+            if not wanted:
+                continue
+            name = archive.split(".")[0]
+            build = self.tmp / "onedir" / directory / name
+            (build / "_internal").mkdir(parents=True, exist_ok=True)
+            exe = build / (f"{name}.exe" if archive.endswith(".zip") else name)
+            exe.write_bytes(b"\x7fELF")
+            (self.built / directory).mkdir(parents=True, exist_ok=True)
+            produced = package_onedir.pack(build, self.built / directory,
+                                           use_zip=archive.endswith(".zip"))
+            assert produced.name == archive, (produced.name, archive)
 
 
 class AFullSetOfArtifactsAssembles(_Fixture):
@@ -159,6 +183,26 @@ class MissingArtifactsStopTheRelease(_Fixture):
         self.assertNotIn("ARG:", proc.stdout)
 
 
+class TheUploadsAreWhatAssemblyReads(unittest.TestCase):
+    """The assemble step names each artifact's file. If an upload step sends
+    something else, assembly finds nothing and refuses the release — after
+    five platform builds. This catches it before any of them run."""
+
+    def test_every_artifact_uploads_the_archive_assembly_expects(self) -> None:
+        env = {"${{ env.BIN_NAME }}": "aria-code-bin", "${{ env.MCP_BIN_NAME }}": "aria-code-mcp-bin"}
+        uploads: dict[str, str] = {}
+        for name, path in _upload_paths().items():
+            for placeholder, value in env.items():
+                path = path.replace(placeholder, value)
+            for arch in ("arm64", "x64"):
+                uploads[name.replace("${{ matrix.arch }}", arch)] = path
+        for cli_dir, cli_file, mcp_dir, mcp_file in ARTIFACTS.values():
+            for directory, archive in ((cli_dir, cli_file), (mcp_dir, mcp_file)):
+                with self.subTest(artifact=directory):
+                    self.assertIn(directory, uploads, f"no upload step produces {directory}")
+                    self.assertEqual(pathlib.PurePosixPath(uploads[directory]).name, archive)
+
+
 class PlatformPackagesAreSplit(_Fixture):
     def test_cli_and_mcp_have_separate_tarball_inputs(self) -> None:
         for platform in ARTIFACTS:
@@ -178,10 +222,9 @@ class PlatformPackagesAreSplit(_Fixture):
                 manifest = json.loads((package / "package.json").read_text())
                 self.assertEqual(manifest["name"], f"@artheras/aria-code-{kind}{platform}")
                 self.assertEqual(manifest["version"], "9.9.9")
-                binaries = list((package / "bin").iterdir())
-                self.assertEqual(len(binaries), 1)
+                self.assertEqual([p.name for p in (package / "bin").iterdir()], [name])
                 extension = ".exe" if platform.startswith("win32") else ""
-                self.assertEqual(binaries[0].name, f"{name}{extension}")
+                self.assertTrue((package / "bin" / name / f"{name}{extension}").is_file())
 
 
 if __name__ == "__main__":