neuroncli 7.0.0a4__tar.gz → 7.0.0a5__tar.gz

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/NOTICE

@@ -18,7 +18,9 @@ the `neuron` binary), the Python porting workspace under src/ and tests/, and
 the parity documents were imported from Claw Code and have since been modified.
 The Claw Code copyright and permission notice is reproduced in LICENSE and must
 be kept in all copies or substantial portions of the software. See
-docs/PROVENANCE.md for the code lineage.
+docs/PROVENANCE.md for the code lineage. Fixes ported from later Claw Code
+commits (fork point about 00d0eb6, reviewed up to 51cfca1) are listed with their
+upstream commit SHAs under "Later ports from Claw Code" in docs/PROVENANCE.md.
 
 Full-screen UI (neuron-tui)
 ---------------------------
@@ -80,12 +82,15 @@ locally with:
 
     node scripts/generate-third-party-notices.mjs
 
-npm package dependencies
-------------------------
+Default MCP servers
+-------------------
 
-The npm package @zero-x.live/neuron installs, but does not bundle,
-codebase-memory-mcp (MIT License) and @playwright/mcp (Apache License 2.0).
-npm installs them with their own license files.
+Neither the npm package @zero-x.live/neuron nor the binary bundles the
+default MCP servers. On first use Neuron downloads @playwright/mcp (Apache
+License 2.0) and its dependencies from the npm registry, with their own
+license files, and the codebase-memory-mcp release binary (MIT License) from
+the project's GitHub release, and checks each against the hash its connector
+catalog pins.
 
 Trademarks and affiliation
 --------------------------

{neuroncli-7.0.0a4/neuroncli.egg-info → neuroncli-7.0.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroncli
-Version: 7.0.0a4
+Version: 7.0.0a5
 Summary: Neuron - terminal coding agent powered by the Zero-X gateway
 Author: RAHUL S / Zero-X
 License-Expression: MIT
@@ -36,7 +36,7 @@ By default Neuron talks to models through the [Zero-X gateway](https://zero-x.li
 You sign in once with `neuron auth login`; the provider API keys stay on the gateway
 and never reach your machine. You can also use your own provider key instead.
 
-> 7.0.0-alpha.4 is Neuron's fourth alpha, built and published by this repository's
+> 7.0.0-alpha.5 is Neuron's fifth alpha, built and published by this repository's
 > release pipeline. Its known limitations are listed in
 > the [changelog](https://github.com/RAHUL-DevelopeRR/neuron-v2/blob/HEAD/CHANGELOG.md).
 > It is a GitHub prerelease, so the install scripts need the versioned commands below.
@@ -56,25 +56,25 @@ and there is none until the first stable release is out.
 **macOS and Linux**
 
 ```sh
-curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.sh | sh -s -- --version 7.0.0-alpha.4
+curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.sh | sh -s -- --version 7.0.0-alpha.5
 ```
 
 The script installs to `~/.local/bin` and tells you if that directory is not on your
 `PATH`. Pass options after `sh -s --`, for example
-`sh -s -- --version 7.0.0-alpha.4 --install-dir "$HOME/bin"`, or set `NEURON_VERSION`
+`sh -s -- --version 7.0.0-alpha.5 --install-dir "$HOME/bin"`, or set `NEURON_VERSION`
 and `NEURON_INSTALL_DIR`.
 
 **Windows (PowerShell 5.1 or 7)**
 
 ```powershell
-& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.ps1))) -Version 7.0.0-alpha.4
+& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.ps1))) -Version 7.0.0-alpha.5
 ```
 
 The script installs to `%LOCALAPPDATA%\Programs\Neuron\bin` and only changes your
 `PATH` if you ask it to:
 
 ```powershell
-& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.ps1))) -Version 7.0.0-alpha.4 -AddToPath
+& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.ps1))) -Version 7.0.0-alpha.5 -AddToPath
 ```
 
 **npm** (Node.js 22.14 or later)
@@ -91,9 +91,9 @@ pip install --pre neuroncli
 ```
 
 The registry packages are published after the GitHub release, so check them first:
-`npm view @zero-x.live/neuron version` should print `7.0.0-alpha.4`, and
-`pip index versions neuroncli --pre` should list `7.0.0a4`. If they still show the
-previous alpha (`7.0.0-alpha.3`, or `7.0.0a3` on PyPI), use the install scripts above
+`npm view @zero-x.live/neuron version` should print `7.0.0-alpha.5`, and
+`pip index versions neuroncli --pre` should list `7.0.0a5`. If they still show the
+previous alpha (`7.0.0-alpha.4`, or `7.0.0a4` on PyPI), use the install scripts above
 for this one. 6.2.0 (npm) and 6.2.4 (PyPI) are old, unsupported builds.
 
 The npm and pip packages are small launchers that download the binaries for the
@@ -108,16 +108,18 @@ uses a binary from that cache when its `bin/native` folder has none, and downloa
 the cache only when that folder is read-only. After that, Neuron starts without network
 access. Ctrl+C goes to Neuron, and the launcher exits with Neuron's exit code.
 
-With the installers or pip, the two default MCP servers (CodebaseMap, which `/mcp`
-lists as `codebase-memory`, and Playwright) start through `npx -y`, so they need
-Node.js; the npm package installs them with Neuron.
+The two default MCP servers (CodebaseMap, which `/mcp` lists as `codebase-memory`,
+and Playwright) never start through `npx -y`: on first use Neuron installs each into
+`~/.neuron/mcp` from downloads whose hashes its connector catalog pins, and later
+starts are offline. Playwright needs Node.js (the npm launcher passes its own).
 
 On a terminal, `neuron` with no prompt opens the full-screen UI, `neuron-tui`. The
 installers put it beside `neuron`, and the launchers fetch it the same way, verified
 by checksum. `neuron --no-tui` (or `NEURON_NO_TUI=1`) keeps the line REPL. Without
 the UI, for example after a failed download, `neuron` runs the line REPL as
-before. Prompts (`neuron "fix the test"`, `neuron -p ...`) and subcommands never
-start it.
+before. On a terminal, `neuron "fix the test"` opens it with that prompt and
+`neuron --resume SESSION` on that session; `neuron -p ...`, `neuron prompt ...` and
+subcommands never start it.
 
 **From source**
 

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/README.md

@@ -10,7 +10,7 @@ By default Neuron talks to models through the [Zero-X gateway](https://zero-x.li
 You sign in once with `neuron auth login`; the provider API keys stay on the gateway
 and never reach your machine. You can also use your own provider key instead.
 
-> 7.0.0-alpha.4 is Neuron's fourth alpha, built and published by this repository's
+> 7.0.0-alpha.5 is Neuron's fifth alpha, built and published by this repository's
 > release pipeline. Its known limitations are listed in
 > the [changelog](https://github.com/RAHUL-DevelopeRR/neuron-v2/blob/HEAD/CHANGELOG.md).
 > It is a GitHub prerelease, so the install scripts need the versioned commands below.
@@ -30,25 +30,25 @@ and there is none until the first stable release is out.
 **macOS and Linux**
 
 ```sh
-curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.sh | sh -s -- --version 7.0.0-alpha.4
+curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.sh | sh -s -- --version 7.0.0-alpha.5
 ```
 
 The script installs to `~/.local/bin` and tells you if that directory is not on your
 `PATH`. Pass options after `sh -s --`, for example
-`sh -s -- --version 7.0.0-alpha.4 --install-dir "$HOME/bin"`, or set `NEURON_VERSION`
+`sh -s -- --version 7.0.0-alpha.5 --install-dir "$HOME/bin"`, or set `NEURON_VERSION`
 and `NEURON_INSTALL_DIR`.
 
 **Windows (PowerShell 5.1 or 7)**
 
 ```powershell
-& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.ps1))) -Version 7.0.0-alpha.4
+& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.ps1))) -Version 7.0.0-alpha.5
 ```
 
 The script installs to `%LOCALAPPDATA%\Programs\Neuron\bin` and only changes your
 `PATH` if you ask it to:
 
 ```powershell
-& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.ps1))) -Version 7.0.0-alpha.4 -AddToPath
+& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.ps1))) -Version 7.0.0-alpha.5 -AddToPath
 ```
 
 **npm** (Node.js 22.14 or later)
@@ -65,9 +65,9 @@ pip install --pre neuroncli
 ```
 
 The registry packages are published after the GitHub release, so check them first:
-`npm view @zero-x.live/neuron version` should print `7.0.0-alpha.4`, and
-`pip index versions neuroncli --pre` should list `7.0.0a4`. If they still show the
-previous alpha (`7.0.0-alpha.3`, or `7.0.0a3` on PyPI), use the install scripts above
+`npm view @zero-x.live/neuron version` should print `7.0.0-alpha.5`, and
+`pip index versions neuroncli --pre` should list `7.0.0a5`. If they still show the
+previous alpha (`7.0.0-alpha.4`, or `7.0.0a4` on PyPI), use the install scripts above
 for this one. 6.2.0 (npm) and 6.2.4 (PyPI) are old, unsupported builds.
 
 The npm and pip packages are small launchers that download the binaries for the
@@ -82,16 +82,18 @@ uses a binary from that cache when its `bin/native` folder has none, and downloa
 the cache only when that folder is read-only. After that, Neuron starts without network
 access. Ctrl+C goes to Neuron, and the launcher exits with Neuron's exit code.
 
-With the installers or pip, the two default MCP servers (CodebaseMap, which `/mcp`
-lists as `codebase-memory`, and Playwright) start through `npx -y`, so they need
-Node.js; the npm package installs them with Neuron.
+The two default MCP servers (CodebaseMap, which `/mcp` lists as `codebase-memory`,
+and Playwright) never start through `npx -y`: on first use Neuron installs each into
+`~/.neuron/mcp` from downloads whose hashes its connector catalog pins, and later
+starts are offline. Playwright needs Node.js (the npm launcher passes its own).
 
 On a terminal, `neuron` with no prompt opens the full-screen UI, `neuron-tui`. The
 installers put it beside `neuron`, and the launchers fetch it the same way, verified
 by checksum. `neuron --no-tui` (or `NEURON_NO_TUI=1`) keeps the line REPL. Without
 the UI, for example after a failed download, `neuron` runs the line REPL as
-before. Prompts (`neuron "fix the test"`, `neuron -p ...`) and subcommands never
-start it.
+before. On a terminal, `neuron "fix the test"` opens it with that prompt and
+`neuron --resume SESSION` on that session; `neuron -p ...`, `neuron prompt ...` and
+subcommands never start it.
 
 **From source**
 

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/neuron_cli/__init__.py

@@ -1,9 +1,11 @@
 """NeuronCLI - Python launcher for the native Neuron binary.
 
 The first launch downloads the release binary that matches this package
-version, verifies it against the release's SHA-256 file and caches it together
-with a ``.sha256`` sidecar. Later launches run the cached binary without any
-network access.
+version, verifies it against the release's SHA-256 file *and* the release's
+``SHA256SUMS`` and caches it together with a ``.sha256`` sidecar and a
+``.verified`` stamp (size and mtime). Later launches run the cached binary
+without any network access; a binary whose size or mtime changed since it was
+verified is hashed again and refused when it no longer matches its sidecar.
 
 On a terminal, a bare ``neuron`` opens Neuron's full-screen UI: the launcher
 gets ``neuron-tui`` the same way (once, verified and cached) and tells
@@ -14,6 +16,8 @@ Environment:
     NEURON_BINARY_PATH     run this native binary instead (development)
     NEURON_CACHE_DIR       cache root (default: the platform user cache)
     NEURON_DOWNLOAD_BASE   release download base URL (HTTPS, or loopback HTTP)
+    NEURON_CHECKSUMS_BASE  where SHA256SUMS comes from (default: the GitHub
+                           release, even when a mirror serves the binary)
     NEURON_NO_TUI          1 keeps the line REPL and skips the UI download
     NEURON_TUI_BIN         the full-screen UI to use (passed on unchanged)
 """
@@ -34,7 +38,7 @@ from urllib.error import HTTPError, URLError
 from urllib.parse import urlsplit
 from urllib.request import urlopen
 
-PACKAGE_VERSION = "7.0.0-alpha.4"
+PACKAGE_VERSION = "7.0.0-alpha.5"
 REPOSITORY = "https://github.com/RAHUL-DevelopeRR/neuron-v2"
 DEFAULT_DOWNLOAD_BASE = f"{REPOSITORY}/releases/download"
 CHECKSUM_TIMEOUT_SECONDS = 30
@@ -118,6 +122,30 @@ def _download_base() -> str:
     raise LauncherError(f"NEURON_DOWNLOAD_BASE must be an HTTPS URL (or loopback HTTP): {base}")
 
 
+def _checksums_base() -> str:
+    """Where SHA256SUMS comes from: the GitHub release unless NEURON_CHECKSUMS_BASE says otherwise."""
+    base = (os.environ.get("NEURON_CHECKSUMS_BASE") or DEFAULT_DOWNLOAD_BASE).rstrip("/")
+    parts = urlsplit(base)
+    if parts.scheme == "https" or (parts.scheme == "http" and _is_loopback(parts.hostname or "")):
+        return base
+    raise LauncherError(f"NEURON_CHECKSUMS_BASE must be an HTTPS URL (or loopback HTTP): {base}")
+
+
+def _parse_sums(text: str, asset: str) -> Optional[str]:
+    """The hash listed for ``asset`` in a SHA256SUMS file (``<hash>  <name>`` or ``<hash> *<name>``)."""
+    for line in text.splitlines():
+        fields = line.strip().split(None, 1)
+        if len(fields) != 2:
+            continue
+        name = fields[1].strip()
+        if name.startswith("*"):
+            name = name[1:]
+        digest = _parse_checksum(fields[0])
+        if digest is not None and name == asset:
+            return digest
+    return None
+
+
 def _digest(path: Path) -> str:
     checksum = hashlib.sha256()
     with path.open("rb") as stream:
@@ -140,17 +168,53 @@ def _sidecar(binary: Path) -> Path:
     return binary.with_name(binary.name + ".sha256")
 
 
+def _stamp_path(binary: Path) -> Path:
+    return binary.with_name(binary.name + ".verified")
+
+
+def _stamp_of(binary: Path) -> str:
+    info = binary.stat()
+    return f"{info.st_size} {info.st_mtime_ns}\n"
+
+
+def _write_stamp(binary: Path) -> None:
+    try:
+        _stamp_path(binary).write_text(_stamp_of(binary), encoding="ascii")
+    except OSError:
+        pass  # a read-only cache only costs a re-hash on the next launch
+
+
 def _cached_binary(cache: Path, asset: str) -> Optional[Path]:
-    """The cached binary when it was verified at download time (sidecar present)."""
+    """The cached binary when it was verified at download time (sidecar present).
+
+    Its size and mtime are compared with the ``.verified`` stamp; when they differ the file is
+    hashed again, and a hash that no longer matches the sidecar raises instead of running it.
+    """
     binary = cache / asset
     sidecar = _sidecar(binary)
     if not binary.is_file() or not sidecar.is_file():
         return None
     try:
-        if _parse_checksum(sidecar.read_text(encoding="ascii", errors="replace")) is None:
-            return None
+        expected = _parse_checksum(sidecar.read_text(encoding="ascii", errors="replace"))
     except OSError:
         return None
+    if expected is None:
+        return None
+    try:
+        try:
+            if _stamp_path(binary).read_text(encoding="ascii") == _stamp_of(binary):
+                return binary
+        except OSError:
+            pass  # no stamp yet: hash below
+        matches = _digest(binary) == expected
+    except OSError:
+        matches = False
+    if not matches:
+        raise LauncherError(
+            f"{binary} does not match its recorded SHA-256 ({sidecar}), so it was not run. Delete "
+            f"{binary}, {sidecar} and {_stamp_path(binary)} to download a fresh, verified copy."
+        )
+    _write_stamp(binary)
     return binary
 
 
@@ -186,6 +250,7 @@ def _download_binary(version: str, asset: str, cache: Path, label: str = "Neuron
     base = f"{_download_base()}/v{version}"
     binary_url = f"{base}/{asset}"
     checksum_url = f"{binary_url}.sha256"
+    sums_url = f"{_checksums_base()}/v{version}/SHA256SUMS"
     destination = cache / asset
     try:
         cache.mkdir(parents=True, exist_ok=True)
@@ -193,6 +258,16 @@ def _download_binary(version: str, asset: str, cache: Path, label: str = "Neuron
         raise LauncherError(f"Cannot create the Neuron cache directory {cache}: {error}. Set NEURON_CACHE_DIR.") from error
 
     print(f"Downloading {label} {version} ({asset}) to {cache} ...", file=sys.stderr, flush=True)
+    try:
+        with urlopen(sums_url, timeout=CHECKSUM_TIMEOUT_SECONDS) as response:
+            sums_text = response.read(1024 * 1024).decode("utf-8", errors="replace")
+    except (HTTPError, URLError, OSError) as error:
+        raise _network_error(sums_url, version, cache, error) from error
+    listed = _parse_sums(sums_text, asset)
+    if listed is None:
+        raise LauncherError(
+            f"The release SHA256SUMS ({sums_url}) is empty or does not list {asset}. Nothing was cached."
+        )
     try:
         with urlopen(checksum_url, timeout=CHECKSUM_TIMEOUT_SECONDS) as response:
             checksum_text = response.read(4096).decode("ascii", errors="replace")
@@ -225,6 +300,11 @@ def _download_binary(version: str, asset: str, cache: Path, label: str = "Neuron
                 f"Neuron {version} ({asset}) failed its SHA-256 check: expected {expected}, got {actual}. "
                 "The download was discarded; nothing was cached."
             )
+        if actual != listed:
+            raise LauncherError(
+                f"Neuron {version} ({asset}) is not what the release SHA256SUMS ({sums_url}) lists: it lists "
+                f"{listed}, got {actual}. The download was discarded; nothing was cached."
+            )
         if os.name != "nt":
             temporary.chmod(0o755)
 
@@ -235,6 +315,7 @@ def _download_binary(version: str, asset: str, cache: Path, label: str = "Neuron
             _sidecar(destination),
             lambda temporary: temporary.write_text(f"{expected}  {asset}\n", encoding="ascii"),
         )
+        _write_stamp(destination)
     except OSError as error:
         raise LauncherError(
             f"Cannot write Neuron to {cache}: {error}. Free some disk space or set NEURON_CACHE_DIR."

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5/neuroncli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuroncli
-Version: 7.0.0a4
+Version: 7.0.0a5
 Summary: Neuron - terminal coding agent powered by the Zero-X gateway
 Author: RAHUL S / Zero-X
 License-Expression: MIT
@@ -36,7 +36,7 @@ By default Neuron talks to models through the [Zero-X gateway](https://zero-x.li
 You sign in once with `neuron auth login`; the provider API keys stay on the gateway
 and never reach your machine. You can also use your own provider key instead.
 
-> 7.0.0-alpha.4 is Neuron's fourth alpha, built and published by this repository's
+> 7.0.0-alpha.5 is Neuron's fifth alpha, built and published by this repository's
 > release pipeline. Its known limitations are listed in
 > the [changelog](https://github.com/RAHUL-DevelopeRR/neuron-v2/blob/HEAD/CHANGELOG.md).
 > It is a GitHub prerelease, so the install scripts need the versioned commands below.
@@ -56,25 +56,25 @@ and there is none until the first stable release is out.
 **macOS and Linux**
 
 ```sh
-curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.sh | sh -s -- --version 7.0.0-alpha.4
+curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.sh | sh -s -- --version 7.0.0-alpha.5
 ```
 
 The script installs to `~/.local/bin` and tells you if that directory is not on your
 `PATH`. Pass options after `sh -s --`, for example
-`sh -s -- --version 7.0.0-alpha.4 --install-dir "$HOME/bin"`, or set `NEURON_VERSION`
+`sh -s -- --version 7.0.0-alpha.5 --install-dir "$HOME/bin"`, or set `NEURON_VERSION`
 and `NEURON_INSTALL_DIR`.
 
 **Windows (PowerShell 5.1 or 7)**
 
 ```powershell
-& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.ps1))) -Version 7.0.0-alpha.4
+& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.ps1))) -Version 7.0.0-alpha.5
 ```
 
 The script installs to `%LOCALAPPDATA%\Programs\Neuron\bin` and only changes your
 `PATH` if you ask it to:
 
 ```powershell
-& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.4/install.ps1))) -Version 7.0.0-alpha.4 -AddToPath
+& ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.5/install.ps1))) -Version 7.0.0-alpha.5 -AddToPath
 ```
 
 **npm** (Node.js 22.14 or later)
@@ -91,9 +91,9 @@ pip install --pre neuroncli
 ```
 
 The registry packages are published after the GitHub release, so check them first:
-`npm view @zero-x.live/neuron version` should print `7.0.0-alpha.4`, and
-`pip index versions neuroncli --pre` should list `7.0.0a4`. If they still show the
-previous alpha (`7.0.0-alpha.3`, or `7.0.0a3` on PyPI), use the install scripts above
+`npm view @zero-x.live/neuron version` should print `7.0.0-alpha.5`, and
+`pip index versions neuroncli --pre` should list `7.0.0a5`. If they still show the
+previous alpha (`7.0.0-alpha.4`, or `7.0.0a4` on PyPI), use the install scripts above
 for this one. 6.2.0 (npm) and 6.2.4 (PyPI) are old, unsupported builds.
 
 The npm and pip packages are small launchers that download the binaries for the
@@ -108,16 +108,18 @@ uses a binary from that cache when its `bin/native` folder has none, and downloa
 the cache only when that folder is read-only. After that, Neuron starts without network
 access. Ctrl+C goes to Neuron, and the launcher exits with Neuron's exit code.
 
-With the installers or pip, the two default MCP servers (CodebaseMap, which `/mcp`
-lists as `codebase-memory`, and Playwright) start through `npx -y`, so they need
-Node.js; the npm package installs them with Neuron.
+The two default MCP servers (CodebaseMap, which `/mcp` lists as `codebase-memory`,
+and Playwright) never start through `npx -y`: on first use Neuron installs each into
+`~/.neuron/mcp` from downloads whose hashes its connector catalog pins, and later
+starts are offline. Playwright needs Node.js (the npm launcher passes its own).
 
 On a terminal, `neuron` with no prompt opens the full-screen UI, `neuron-tui`. The
 installers put it beside `neuron`, and the launchers fetch it the same way, verified
 by checksum. `neuron --no-tui` (or `NEURON_NO_TUI=1`) keeps the line REPL. Without
 the UI, for example after a failed download, `neuron` runs the line REPL as
-before. Prompts (`neuron "fix the test"`, `neuron -p ...`) and subcommands never
-start it.
+before. On a terminal, `neuron "fix the test"` opens it with that prompt and
+`neuron --resume SESSION` on that session; `neuron -p ...`, `neuron prompt ...` and
+subcommands never start it.
 
 **From source**
 

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "neuroncli"
-version = "7.0.0-alpha.4"
+version = "7.0.0-alpha.5"
 description = "Neuron - terminal coding agent powered by the Zero-X gateway"
 readme = "README.md"
 license = "MIT"

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/tests/test_install_scripts.py

@@ -126,6 +126,7 @@ class InstallShTests(unittest.TestCase):
         environment.update(
             HOME=shell_path(self.root / "home"),
             NEURON_DOWNLOAD_BASE=self.server.base_url,
+            NEURON_CHECKSUMS_BASE=self.server.base_url,
             NEURON_RELEASES_API=f"{self.server.base_url}/repos/neuron/releases/latest",
             NEURON_INSTALL_DIR=shell_path(self.install_dir),
             # The full-screen UI step has its own tests; NEURON_NO_TUI="" turns it on.
@@ -188,7 +189,7 @@ class InstallShTests(unittest.TestCase):
                 self.assertIn("is not on your PATH", result.stderr)
                 self.assertEqual(
                     self.server.paths(),
-                    [f"/v{VERSION}/neuron-linux-x64.sha256", f"/v{VERSION}/neuron-linux-x64"],
+                    [f"/v{VERSION}/SHA256SUMS", f"/v{VERSION}/neuron-linux-x64.sha256", f"/v{VERSION}/neuron-linux-x64"],
                 )
                 self.assertEqual(self.installed().read_bytes(), posix_dummy(VERSION))
                 self.assertIn(f"neuron-dummy {VERSION}", self.run_installed("--version"))
@@ -204,6 +205,7 @@ class InstallShTests(unittest.TestCase):
         self.assertEqual(
             self.server.paths(),
             [
+                f"/v{VERSION}/SHA256SUMS",
                 f"/v{VERSION}/neuron-linux-x64.sha256",
                 f"/v{VERSION}/neuron-linux-x64",
                 f"/v{VERSION}/neuron-tui-linux-x64.sha256",
@@ -295,6 +297,32 @@ class InstallShTests(unittest.TestCase):
         self.assertIn("Nothing was installed", result.stderr)
         self.assertEqual(self.installed().read_bytes(), b"previous neuron")
 
+    def test_release_sums_that_disagree_or_are_missing_fail_closed(self) -> None:
+        fake_release.write_executable(self.installed(), b"previous neuron")
+        fake_release.stage_release(self.releases, VERSION, "neuron-linux-x64", posix_dummy(VERSION))
+        sums = self.releases / f"v{VERSION}" / "SHA256SUMS"
+        sums.write_text(f"{'c' * 64}  neuron-linux-x64\n", encoding="ascii")
+        wrong = self.run_installer(NEURON_VERSION=VERSION)
+        self.assertEqual(wrong.returncode, 1)
+        self.assertIn("SHA256SUMS", wrong.stderr)
+        self.assertIn("Nothing was installed", wrong.stderr)
+        sums.write_text(f"{'c' * 64}  some-other-asset\n", encoding="ascii")
+        unlisted = self.run_installer(NEURON_VERSION=VERSION)
+        self.assertEqual(unlisted.returncode, 1)
+        sums.unlink()
+        missing = self.run_installer(NEURON_VERSION=VERSION)
+        self.assertEqual(missing.returncode, 1)
+        self.assertEqual(self.installed().read_bytes(), b"previous neuron")
+
+    def test_checksums_come_from_their_own_base_not_the_mirror(self) -> None:
+        fake_release.stage_release(self.releases, VERSION, "neuron-linux-x64", posix_dummy(VERSION))
+        result = self.run_installer(NEURON_VERSION=VERSION, NEURON_CHECKSUMS_BASE=fake_release.unused_loopback_url())
+        self.assertEqual(result.returncode, 1)
+        self.assertNotIn(f"/v{VERSION}/SHA256SUMS", self.server.paths())
+        insecure = self.run_installer(NEURON_VERSION=VERSION, NEURON_CHECKSUMS_BASE="http://downloads.example.com")
+        self.assertEqual(insecure.returncode, 1)
+        self.assertIn("NEURON_CHECKSUMS_BASE must be an HTTPS URL", insecure.stderr)
+
     def test_malformed_checksum_file_is_rejected(self) -> None:
         fake_release.stage_release(self.releases, VERSION, "neuron-linux-x64", posix_dummy(VERSION), checksum="oops\n")
         result = self.run_installer(NEURON_VERSION=VERSION)
@@ -316,6 +344,18 @@ class InstallShTests(unittest.TestCase):
         self.assertIn("Next steps:", result.stderr)
         self.assertEqual(self.installed().read_bytes(), STDIN_READING_BINARY)
 
+    def test_every_curl_call_refuses_a_redirect_away_from_https(self) -> None:
+        # A mirror or release redirecting to plain HTTP must not be followed (--proto-redir
+        # only limits redirects; a loopback http base given on purpose still works).
+        calls = [
+            line.strip()
+            for line in INSTALL_SH.read_text(encoding="utf-8").splitlines()
+            if line.lstrip().startswith("curl ") and "--fail" in line
+        ]
+        self.assertGreaterEqual(len(calls), 2, calls)
+        for call in calls:
+            self.assertIn("--proto-redir =https", call)
+
     def test_unpublished_version_points_at_the_releases_page(self) -> None:
         result = self.run_installer(NEURON_VERSION="9.9.9")
         self.assertEqual(result.returncode, 1)
@@ -323,7 +363,7 @@ class InstallShTests(unittest.TestCase):
         self.assertIn("releases", result.stderr)
 
     def test_network_failure_is_not_reported_as_a_missing_release(self) -> None:
-        result = self.run_installer(NEURON_VERSION=VERSION, NEURON_DOWNLOAD_BASE=fake_release.unused_loopback_url())
+        result = self.run_installer(NEURON_VERSION=VERSION, NEURON_DOWNLOAD_BASE=fake_release.unused_loopback_url(), NEURON_CHECKSUMS_BASE=fake_release.unused_loopback_url())
         self.assertEqual(result.returncode, 1)
         self.assertIn("Check your network", result.stderr)
         self.assertNotIn("may not be published", result.stderr)
@@ -364,15 +404,16 @@ class InstallShTests(unittest.TestCase):
         self.assertIn("https://api.github.com/repos/RAHUL-DevelopeRR/neuron-v2/releases/latest", calls[0])
         self.assertNotIn(GITHUB_TOKEN, calls[0])
         self.assertEqual(stdin_log.read_text(encoding="utf-8"), f'header = "Authorization: Bearer {GITHUB_TOKEN}"\n')
-        self.assertEqual(self.server.paths(), [f"/v{VERSION}/neuron-linux-x64.sha256", f"/v{VERSION}/neuron-linux-x64"])
-        self.assertEqual(self.server.authorization, [None, None])
+        self.assertEqual(self.server.paths(), [f"/v{VERSION}/SHA256SUMS", f"/v{VERSION}/neuron-linux-x64.sha256", f"/v{VERSION}/neuron-linux-x64"])
+        self.assertEqual(self.server.authorization, [None, None, None])
 
     def test_github_token_is_not_sent_to_another_releases_api(self) -> None:
         fake_release.stage_release(self.releases, VERSION, "neuron-linux-x64", posix_dummy(VERSION))
         result = self.run_installer(GITHUB_TOKEN=GITHUB_TOKEN)
         self.assertEqual(result.returncode, 0, result.stderr)
         self.assertEqual(self.server.paths()[0], "/repos/neuron/releases/latest")
-        self.assertEqual(self.server.authorization, [None, None, None])
+        # The releases lookup, then SHA256SUMS, the .sha256 file and the binary: none carries the token.
+        self.assertEqual(self.server.authorization, [None, None, None, None])
 
     def test_self_check_runs_the_binary_from_the_install_directory(self) -> None:
         # The temporary directory may be mounted noexec; the binary has to run from the install directory anyway.
@@ -470,6 +511,7 @@ class InstallPs1Tests(unittest.TestCase):
         environment = clean_environment()
         environment.update(
             NEURON_DOWNLOAD_BASE=self.server.base_url,
+            NEURON_CHECKSUMS_BASE=self.server.base_url,
             NEURON_RELEASES_API=f"{self.server.base_url}/repos/neuron/releases/latest",
             LOCALAPPDATA=str(self.root),
             # The full-screen UI step has its own tests; NEURON_NO_TUI="" turns it on.
@@ -517,7 +559,8 @@ class InstallPs1Tests(unittest.TestCase):
                 self.assertIn("auth login", result.stdout)
                 self.assertIn("is not on your PATH", result.stdout)
                 self.assertEqual(
-                    self.server.paths(), [f"/v{VERSION}/{self.ASSET}.sha256", f"/v{VERSION}/{self.ASSET}"]
+                    self.server.paths(),
+                    [f"/v{VERSION}/SHA256SUMS", f"/v{VERSION}/{self.ASSET}.sha256", f"/v{VERSION}/{self.ASSET}"],
                 )
                 output = subprocess.run([str(self.installed()), "--version"], capture_output=True, text=True, check=True)
                 self.assertIn(f"neuron-dummy {VERSION}", output.stdout)
@@ -557,6 +600,19 @@ class InstallPs1Tests(unittest.TestCase):
         self.assertEqual(pinned.returncode, 0, pinned.stdout + pinned.stderr)
         self.assertIn("Installing Neuron 6.3.0", pinned.stdout)
 
+    def test_release_sums_that_disagree_or_are_missing_fail_closed(self) -> None:
+        fake_release.stage_release(self.releases, VERSION, self.ASSET)
+        sums = self.releases / f"v{VERSION}" / "SHA256SUMS"
+        sums.write_text(f"{'d' * 64}  {self.ASSET}\n", encoding="ascii")
+        wrong = self.run_installer("-Version", VERSION)
+        self.assertEqual(wrong.returncode, 1)
+        self.assertIn("SHA256SUMS", wrong.stdout + wrong.stderr)
+        self.assertFalse(self.installed().exists())
+        sums.unlink()
+        missing = self.run_installer("-Version", VERSION)
+        self.assertEqual(missing.returncode, 1)
+        self.assertFalse(self.installed().exists())
+
     def test_checksum_mismatch_installs_nothing(self) -> None:
         fake_release.stage_release(self.releases, VERSION, self.ASSET, checksum=f"{'b' * 64}  {self.ASSET}\n")
         result = self.run_installer("-Version", VERSION)
@@ -573,7 +629,7 @@ class InstallPs1Tests(unittest.TestCase):
         self.assertIn("must be an HTTPS URL", insecure.stdout)
 
     def test_network_failure_is_not_reported_as_a_missing_release(self) -> None:
-        result = self.run_installer("-Version", VERSION, NEURON_DOWNLOAD_BASE=fake_release.unused_loopback_url())
+        result = self.run_installer("-Version", VERSION, NEURON_DOWNLOAD_BASE=fake_release.unused_loopback_url(), NEURON_CHECKSUMS_BASE=fake_release.unused_loopback_url())
         self.assertEqual(result.returncode, 1)
         self.assertIn("Check your network", result.stdout)
         self.assertNotIn("may not be published", result.stdout)
@@ -591,7 +647,7 @@ class InstallPs1Tests(unittest.TestCase):
         result = self.run_installer(GITHUB_TOKEN=GITHUB_TOKEN)
         self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
         self.assertEqual(self.server.paths()[0], "/repos/neuron/releases/latest")
-        self.assertEqual(self.server.authorization, [None, None, None])
+        self.assertEqual(self.server.authorization, [None, None, None, None])
 
     def test_github_token_is_meant_only_for_the_github_api(self) -> None:
         cases = {
@@ -760,6 +816,7 @@ foreach ($name in @({quoted})) {{
         "Get-HttpStatus",
         "Get-NeuronDownload",
         "Get-NeuronSha256",
+        "Test-NeuronSums",
         "Get-PosixInstallCommand",
         "Assert-SupportedPlatform",
         "Resolve-NeuronVersion",

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/tests/test_npm_package.py

@@ -78,7 +78,7 @@ class NpmTarballTests(unittest.TestCase):
         self.cache = self.work / "cache"
 
     def neuron_env(self, base: str, **extra: str) -> Dict[str, str]:
-        return self.base_env(NEURON_DOWNLOAD_BASE=base, NEURON_CACHE_DIR=str(self.cache), **extra)
+        return self.base_env(NEURON_DOWNLOAD_BASE=base, NEURON_CHECKSUMS_BASE=base, NEURON_CACHE_DIR=str(self.cache), **extra)
 
     def install(self, *flags: str) -> Path:
         result = npm("install", "--global", "--prefix", str(self.prefix), *flags, str(self.tarball), cwd=self.work, env=self.base_env())
@@ -105,7 +105,7 @@ class NpmTarballTests(unittest.TestCase):
         self.assertIn(f"neuron-dummy {VERSION}", first.stdout)
         self.assertIn("Downloading Neuron", first.stderr)
         asset = fake_release.current_asset()
-        self.assertEqual(self.server.paths(), [f"/v{VERSION}/{asset}.sha256", f"/v{VERSION}/{asset}"])
+        self.assertEqual(self.server.paths(), [f"/v{VERSION}/SHA256SUMS", f"/v{VERSION}/{asset}.sha256", f"/v{VERSION}/{asset}"])
 
         offline = self.run_neuron(["prompt", "two words"], self.neuron_env(fake_release.unused_loopback_url(), NEURON_DUMMY_EXIT="7"))
         self.assertEqual(offline.returncode, 7, offline.stdout + offline.stderr)

{neuroncli-7.0.0a4 → neuroncli-7.0.0a5}/tests/test_packaged_launcher.py

@@ -189,11 +189,16 @@ class PackagedLauncherTests(unittest.TestCase):
             launcher, "PACKAGE_VERSION", version
         ), patch.dict(
             os.environ,
-            {"NEURON_BINARY_PATH": "", "NEURON_CACHE_DIR": str(self.cache), "NEURON_DOWNLOAD_BASE": server.base_url},
+            {
+                "NEURON_BINARY_PATH": "",
+                "NEURON_CACHE_DIR": str(self.cache),
+                "NEURON_DOWNLOAD_BASE": server.base_url,
+                "NEURON_CHECKSUMS_BASE": server.base_url,
+            },
         ):
             binary = launcher._find_binary()
             requested = server.paths()
-        self.assertEqual(requested, [f"/v{version}/{asset}.sha256", f"/v{version}/{asset}"])
+        self.assertEqual(requested, [f"/v{version}/SHA256SUMS", f"/v{version}/{asset}.sha256", f"/v{version}/{asset}"])
         self.assertEqual(binary, self.cache / version / asset)
         self.assertEqual(binary.read_bytes(), b"prerelease neuron")
 
@@ -241,8 +246,9 @@ class LauncherReleaseServerTests(unittest.TestCase):
             PYTHONPATH=str(self.site),
             NEURON_CACHE_DIR=str(self.cache),
             NEURON_DOWNLOAD_BASE=base,
-            **extra_env,
         )
+        environment.setdefault("NEURON_CHECKSUMS_BASE", base)
+        environment.update(extra_env)
         return environment
 
     def run_launcher(self, base: str, *args: str, **extra_env: str) -> subprocess.CompletedProcess:
@@ -268,8 +274,8 @@ class LauncherReleaseServerTests(unittest.TestCase):
         self.assertIn(f"neuron-dummy {self.version}", result.stdout)
         self.assertIn("Downloading Neuron", result.stderr)
         prefix = f"/v{self.version}/{self.asset}"
-        self.assertEqual(requested, [f"{prefix}.sha256", prefix])
-        self.assertEqual(self.cached_files(), [self.asset, f"{self.asset}.sha256"])
+        self.assertEqual(requested, [f"/v{self.version}/SHA256SUMS", f"{prefix}.sha256", prefix])
+        self.assertEqual(self.cached_files(), [self.asset, f"{self.asset}.sha256", f"{self.asset}.verified"])
         digest = hashlib.sha256(staged.read_bytes()).hexdigest()
         sidecar = (self.cache / self.version / f"{self.asset}.sha256").read_text(encoding="ascii")
         self.assertEqual(sidecar, f"{digest}  {self.asset}\n")
@@ -321,9 +327,96 @@ class LauncherReleaseServerTests(unittest.TestCase):
         fake_release.write_executable(stale, b"partial download")
         with fake_release.FakeReleaseServer(self.releases) as server:
             result = self.run_launcher(server.base_url, "--version")
-            self.assertEqual(len(server.paths()), 2)
+            self.assertEqual(len(server.paths()), 3)
         self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(self.cached_files(), [self.asset, f"{self.asset}.sha256"])
+        self.assertEqual(self.cached_files(), [self.asset, f"{self.asset}.sha256", f"{self.asset}.verified"])
+
+    def test_release_sha256sums_must_list_the_asset_with_the_same_hash(self) -> None:
+        data = fake_release.dummy_binary_bytes(self.version)
+        digest = hashlib.sha256(data).hexdigest()
+        cases = {
+            "an empty SHA256SUMS": "",
+            "a SHA256SUMS without the asset": f"{digest}  something-else\n",
+            "a SHA256SUMS with another hash": f"{'1' * 64}  {self.asset}\n",
+        }
+        for name, sums in cases.items():
+            with self.subTest(name):
+                shutil.rmtree(self.releases, ignore_errors=True)
+                shutil.rmtree(self.cache, ignore_errors=True)
+                fake_release.stage_release(self.releases, self.version, self.asset, sums=sums)
+                with fake_release.FakeReleaseServer(self.releases) as server:
+                    result = self.run_launcher(server.base_url, "--version")
+                self.assertEqual(result.returncode, 1, result.stdout)
+                self.assertIn("SHA256SUMS", result.stderr)
+                self.assertNotIn("Traceback", result.stderr)
+                self.assertEqual(self.cached_files(), [])
+        # No SHA256SUMS at all (HTTP 404).
+        shutil.rmtree(self.releases, ignore_errors=True)
+        fake_release.stage_release(self.releases, self.version, self.asset)
+        (self.releases / f"v{self.version}" / "SHA256SUMS").unlink()
+        with fake_release.FakeReleaseServer(self.releases) as server:
+            absent = self.run_launcher(server.base_url, "--version")
+        self.assertEqual(absent.returncode, 1)
+        self.assertIn("SHA256SUMS", absent.stderr)
+        self.assertEqual(self.cached_files(), [])
+        # A checksums server that is down fails closed as well, and must be HTTPS or loopback.
+        fake_release.stage_release(self.releases, self.version, self.asset)
+        with fake_release.FakeReleaseServer(self.releases) as server:
+            down = self.run_launcher(server.base_url, "--version", NEURON_CHECKSUMS_BASE=fake_release.unused_loopback_url())
+            insecure = self.run_launcher(server.base_url, "--version", NEURON_CHECKSUMS_BASE="http://downloads.example.com")
+        self.assertEqual(down.returncode, 1)
+        self.assertIn("SHA256SUMS", down.stderr)
+        self.assertEqual(insecure.returncode, 1)
+        self.assertIn("NEURON_CHECKSUMS_BASE must be an HTTPS URL", insecure.stderr)
+        self.assertEqual(self.cached_files(), [])
+
+    def test_sha256sums_comes_from_github_by_default_even_with_a_mirror(self) -> None:
+        launcher = load_launcher(self.site)
+        with patch.dict(os.environ, {"NEURON_DOWNLOAD_BASE": "https://mirror.example.com/neuron"}):
+            os.environ.pop("NEURON_CHECKSUMS_BASE", None)
+            self.assertEqual(launcher._checksums_base(), launcher.DEFAULT_DOWNLOAD_BASE)
+        with patch.dict(os.environ, {"NEURON_CHECKSUMS_BASE": "http://127.0.0.1:8/"}):
+            self.assertEqual(launcher._checksums_base(), "http://127.0.0.1:8")
+        with patch.dict(os.environ, {"NEURON_CHECKSUMS_BASE": "http://downloads.example.com"}):
+            with self.assertRaises(launcher.LauncherError):
+                launcher._checksums_base()
+        self.assertEqual(launcher._parse_sums(f"{'AB' * 32}  neuron-linux-x64\n{'c' * 64} *other\n", "neuron-linux-x64"), "ab" * 32)
+        self.assertEqual(launcher._parse_sums(f"{'c' * 64} *other\n", "other"), "c" * 64)
+        self.assertIsNone(launcher._parse_sums(f"{'c' * 64}  neuron-linux-x64-extra\n", "neuron-linux-x64"))
+        self.assertIsNone(launcher._parse_sums("", "neuron-linux-x64"))
+
+    def test_a_cached_binary_that_changed_after_it_was_verified_is_refused(self) -> None:
+        fake_release.stage_release(self.releases, self.version, self.asset)
+        with fake_release.FakeReleaseServer(self.releases) as server:
+            first = self.run_launcher(server.base_url, "--version")
+        self.assertEqual(first.returncode, 0, first.stderr)
+        offline_url = fake_release.unused_loopback_url()
+        binary = self.cache / self.version / self.asset
+        self.assertTrue(binary.with_name(binary.name + ".verified").is_file())
+        warm = self.run_launcher(offline_url, "--version")
+        self.assertEqual(warm.returncode, 0, warm.stderr)
+
+        # Same size, different bytes, new mtime.
+        original = binary.read_bytes()
+        tampered = bytearray(original)
+        tampered[-2] ^= 0x01
+        binary.write_bytes(bytes(tampered))
+        later = binary.stat().st_mtime + 5
+        os.utime(binary, (later, later))
+        refused = self.run_launcher(offline_url, "--version")
+        self.assertEqual(refused.returncode, 1)
+        self.assertIn("does not match its recorded SHA-256", refused.stderr)
+        self.assertNotIn("neuron-dummy", refused.stdout)
+        self.assertNotIn("Traceback", refused.stderr)
+
+        # A forged stamp does not excuse a changed file.
+        binary.with_name(binary.name + ".verified").write_text("garbage\n", encoding="ascii")
+        self.assertEqual(self.run_launcher(offline_url, "--version").returncode, 1)
+
+        # Restoring the verified bytes makes it run again.
+        binary.write_bytes(original)
+        restored = self.run_launcher(offline_url, "--version")
+        self.assertEqual(restored.returncode, 0, restored.stderr)
 
     def test_arguments_and_exit_code_are_forwarded(self) -> None:
         fake_release.stage_release(self.releases, self.version, self.asset)