Neuron 7.0.0-alpha.2

The second Neuron alpha, and the first one on npm and PyPI: both packages now install
the new Neuron. It is still a GitHub prerelease. It says clearly when the model
declines a request, keeps the model's reasoning apart from its answer, never runs a
tool call from a reply that was refused or cut off, and lets long answers finish
streaming.

The known limitations of 7.0.0-alpha.1 still apply, except the ones about npm and PyPI.

npm and PyPI

• npm install --global @zero-x.live/neuron installs this alpha: it is npm's default
  latest version, so @next is no longer needed. Run the same command to upgrade.
• On PyPI the alpha is a pre-release, so pip needs --pre:
  pip install --pre neuroncli (pip install --upgrade --pre neuroncli to upgrade).
• The old 6.2.x builds (npm 6.2.0, PyPI 6.2.4 and earlier) were built outside the
  release pipeline and are unsupported. Upgrade with the commands above.
• The GitHub release is still a prerelease, so install.sh and install.ps1 need its
  version (--version 7.0.0-alpha.2, -Version 7.0.0-alpha.2); the README has the
  full commands.

Refusals and reasoning

• When the model declines to continue, Neuron says so instead of failing or showing an
  empty reply, and keeps whatever the model wrote before. The line REPL ends the turn
  with "The model declined to continue this request." and the provider's reason, in
  Neuron's words and without provider or model names. The full-screen UI ends the
  message with a "Declined" banner of its own, below the answer. --output-format json
  reports outcome refused and a refusal object (message, note,
  tool_calls_not_run); with --compact, the refusal line goes to standard error.
• The model's reasoning stays apart from its answer in the line REPL, the full-screen
  UI and headless output, and is never part of the JSON message. A thinking block no
  longer starts with blank lines.

Tool calls and cut-off replies

• No tool call from a refused reply, or from one cut off at the output token limit,
  runs, even when its arguments are complete. Each gets an error result saying why,
  and the full-screen UI shows such calls as not run. Sub-agents follow the same rule,
  and a sub-agent whose stream breaks off runs none of that reply's calls: it tries a
  fallback model or fails with a retryable error.
• Tool arguments that are not a JSON object, such as arguments cut off mid-stream, go
  back to the model as a tool error instead of failing the turn. They are checked
  before hooks, permissions or the tool run.
• A reply cut off at the output token limit while the model was still reasoning, before
  any answer, no longer fails the turn with "assistant stream produced no content". The
  turn continues once, telling the model that its reasoning used the whole budget; cut
  off again, it ends as output_truncated. Neuron now counts the tokens of such a
  reply, also in a restored session.

Streams

• A streamed answer has no total time limit, so long answers are no longer cut off at
  5 minutes. The connection must open within 30 seconds, and a stream that receives
  nothing for 120 seconds (keep-alive messages count) ends with a retryable error that
  names the model.
• Requests answered in one piece, such as the non-streaming fallbacks, keep their
  5-minute total limit and have no idle limit, since their reply arrives only once it
  is complete.

Packaging

• Removed a stray submodule entry (opencode) that had no .gitmodules URL. It broke
  the checkout in the release workflow's npm and PyPI jobs, which is why 7.0.0-alpha.1
  never reached npm (PyPI uploads were also paused then). A packaging test now fails on
  any such entry.
• A manual run of the release workflow chooses the npm dist-tag (npm_dist_tag:
  next, the default, or latest). A tag push still publishes a prerelease under
  next and a release under latest.

Install

• Linux / macOS: curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.2/install.sh | sh -s -- --version 7.0.0-alpha.2
• Windows (PowerShell): & ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.2/install.ps1))) -Version 7.0.0-alpha.2

Every binary has a .sha256 file; SHA256SUMS lists all assets. Verify provenance with
gh attestation verify <file> --repo RAHUL-DevelopeRR/neuron-v2. Third-party licenses: THIRD_PARTY_NOTICES.md.

Neuron 7.0.0-alpha.1

The first Neuron alpha, and the first release built and published by this repository's
release pipeline. It is a GitHub prerelease and carries the work planned as 6.3.0,
which was never released. It adds a full-screen terminal UI, signs in to the Zero-X
gateway with a device code and keeps the login in the OS credential store, makes the
agent loop survive errors, cancellation and long sessions, gates every tool call by
what it actually does, keeps secrets and untrusted workspace settings away from the
model, and sends far smaller requests. Expect rough edges; the known ones are listed
first.

Known limitations

• A prerelease never becomes "Latest", so releases/latest links, the install scripts
  run without a version and npm install @zero-x.live/neuron do not reach it. Install
  it by version:
  curl -fsSL https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.1/install.sh | sh -s -- --version 7.0.0-alpha.1,
  or in PowerShell
  & ([scriptblock]::Create((irm https://github.com/RAHUL-DevelopeRR/neuron-v2/releases/download/v7.0.0-alpha.1/install.ps1))) -Version 7.0.0-alpha.1.
  Once the alpha is published to npm, it is @zero-x.live/neuron@next there.
• PyPI uploads are paused, so the alpha is not on PyPI; the Python launcher follows
  later.
• The binaries are not code-signed (Windows) or notarized (macOS).
• The full-screen UI's hands-on console checks ran on Windows; this release is its
  first build and install test on Linux and macOS. neuron --no-tui keeps the line
  REPL.
• In the full-screen UI, shell commands (!cmd, /bash) are not available yet, the
  DEFAULT/LITE/MAX/PLAN mode toggle changes only how a turn is shown, the footer's token
  and git counters update when a turn ends, and a key typed in the first moment after
  the UI appears can be lost.
• The full-screen UI cannot trust a folder yet. Run neuron --no-tui in the folder once
  and press 1 when it asks, or add the folder (or one above it) to trustedRoots in
  ~/.neuron/settings.json, then restart Neuron. Until then the folder's own settings,
  hooks and MCP servers are ignored.
• In the full-screen UI, a PATH change from an allowed .envrc reaches the engine, so
  the engine's own tool lookups (such as node and npx for MCP servers) use the
  imported PATH and can find a project's tools first, as in a shell that loaded
  direnv. That includes commands Neuron runs without asking, such as git status: a
  folder the .envrc adds to PATH can run that repository's own programs without a
  prompt. Only allow an .envrc you have read.
• Hooks run with Neuron's own environment: they inherit every variable Neuron has,
  including a session token or key in NEURON_TOKEN and provider keys you exported.
  They also get the event as JSON on standard input and have no timeout, and Ctrl+C
  stops only the hook's own process. Add only hooks you trust.

Full-screen UI

• On a terminal, neuron with no prompt opens a full-screen UI, neuron-tui. It is a
  port of the Codebuff/Freebuff terminal UI (Apache-2.0; OpenTUI and React on Bun),
  with Codebuff's services, ads, billing and telemetry removed. It runs the Rust
  neuron as its engine over neuron engine --stdio. It shows streamed replies,
  tool calls with their output, a permission dialog (allow once, allow for the
  session, deny, deny with a note; Esc denies, Ctrl+C denies and interrupts the turn),
  the Zero-X sign-in with the device code (/login), a model picker (/model) and a
  footer with the model, git state, tokens and context use.
• Releases ship neuron-tui-<target> beside each neuron-<target>, with checksums and
  build provenance. The installers and the npm and pip launchers put it beside
  neuron (verified, and never failing the install). --no-tui or NEURON_NO_TUI=1
  keeps the line REPL, and without the UI neuron runs the line REPL as before.
• The UI imports an allowed .envrc through direnv, minus the variables that would
  reconfigure Neuron: NEURON_*, CLAW_*, CLAWD_* and the engine's other
  compatibility variables (such as the one that sets its default permission mode),
  the providers' keys and endpoints (OPENAI_*, ANTHROPIC_* and the like), HOME,
  USERPROFILE, XDG_CONFIG_HOME, GIT_CONFIG*, and the Node, Bun, TLS and preload settings
  (NODE_OPTIONS, NODE_EXTRA_CA_CERTS, SSL_CERT_FILE, LD_PRELOAD and the like).
  The UI's log names what was dropped. The engine is found on the PATH from before
  the import.
• The React/Ink prototype in ui/react-tui is removed.
• neuron --continue [CHAT] reopens a chat in the UI (the latest one for this folder,
  or CHAT) in the chat's own folder and on its own model, also after a turn that was
  interrupted. Chats are kept per project path, chats with only slash commands in them
  are skipped, and the UI keeps its chats, settings and logs in ~/.neuron/tui
  ($NEURON_HOME/tui when NEURON_HOME is set). The --continue hint printed on exit
  stays on screen.
• NeuronCLI's brand colours: the NEURON logo draws each letter in its colour, as
  neuron's banner does, with blue accents and borders, an orange user line, cyan links
  and inline code, green success and red errors. The light theme uses a darker cyan and
  orange that stay readable on white.
• In a classic Windows console window (Windows PowerShell 5.1 or cmd on Windows 10) the
  UI draws with characters the console fonts have (square corners, √ ×, ► ▼ ▲,
  ASCII for emoji) instead of ? boxes; NEURON_TUI_ASCII=1 or 0 overrides the
  choice. The window is titled "Neuron" while the UI runs and gets its own title back at
  exit, and a TrueType font that a PowerShell start had switched to the raster font is
  restored.
• Quitting (/exit, Ctrl+C twice) keeps a classic console window and its shell open.
  A command typed right after quitting reaches the shell whole and runs, and neuron
  gives the console its input mode back after the UI exits, even when the UI was
  killed, so cmd's Up arrow keeps working.
• While the UI runs, neuron watches the terminal and resets it if the UI dies.
• Keys that arrive faster than the screen redraws (a held Backspace, a burst from the
  console, Enter right after the last character) act on the latest text, so quick
  Backspaces delete every character and Enter sends the whole prompt. The chat input
  takes keys even while the terminal last reported that it lost the focus.
• Retry notices appear above the answer, and a retry replaces the failed attempt's
  text. Failed or refused tools say how they ended (exit code, timed out, killed,
  interrupted, blocked) and show their output; an interrupted tool reads "stopped
  (interrupted)". A question from the model (AskUserQuestion) is shown in place with
  its answer. Markdown keeps soft line breaks, nested list indentation and Windows
  backslashes.
• /status shows the Zero-X account and, in an untrusted folder, what that means and
  how to trust it. The footer shows the account email and drops parts by priority on a
  narrow terminal; an expired or revoked login says so. The model picker opens on the
  current model, greys out unavailable models with the reason and marks degraded and
  busy ones. The sign-in link keeps https:// and is clickable.
• An engine that crashes is reported once, and the UI then exits with code 1.

Zero-X gateway and sign-in

• neuron login signs in with a device code: it prints
  https://neuron.zero-x.live/device and a short code, opens the browser when the
  machine has one (never over SSH, in containers or with --no-browser /
  NEURON_NO_BROWSER), and polls until the code is approved on that page. No local port
  is opened, so it works over SSH, in WSL and in containers. The answer from the gateway
  is checked before anything is printed (code format, an https link on a Zero-X host),
  and only a CLI session is accepted from it. This replaces the browser callback on a
  loopback port.
• neuron login --with-token (reads a ses_ session or nzx_ API key from standard
  input), neuron auth status (checks the credential with the gateway and prints plan,
  expiry and today's usage; an expired or revoked login reads as signed out and exits
  1. and neuron logout (revokes the session on the gateway). neuron auth login|logout still work. /login and /logout run the same flows in a session.
     auth, login, logout, usage and upgrade are found after global flags, and
     --output-format json gives JSON results for them.
• The login is kept in the macOS Keychain or Windows Credential Manager, otherwise in
  ~/.neuroncli/credentials.json (owner-only) with a one-time warning; isolated homes
  (NEURON_HOME, a redirected HOME/USERPROFILE) never touch the OS store, and
  NEURON_CREDENTIAL_STORE forces a backend. The old self-decrypting gateway.enc is
  migrated once and deleted. A corrupt entry warns and reads as signed out.
• Provider selection: NEURON_TOKEN, then --provider / NEURON_PROVIDER / the
  provider setting, then the stored Zero-X login, then provider keys in the
  environment. One startup line names the provider, the credential source and why it
  was chosen. Credentials are handed to the HTTP client in memory and are no longer
  exported into the process environment.
• The model catalog (GET /v1/models) is fetched once and cached for 10 minutes per
  credential; /model lists it with availability, tiers and context windows, warns
  about unknown or unavailable ids and completes catalog ids.
• The full-screen UI's model list refreshes availability from /v1/models/status at
  most every 30 seconds, falling back to the catalog, and a model whose
  available_again_at has passed reads as available. The openai/ routing prefix is
  no longer shown in model names, /status, the context report or JSON output.
• neuron usage and /usage show plan, today's usage with the reset time and
  credits...