chutes-build 0.4.0 → 0.4.1

package/PRIVACY.md

@@ -36,6 +36,8 @@ image/video decoding uses local image codecs and FFmpeg tools when installed,
 and audio uses `ffplay` or the operating system's default player. Preview work
 is bounded, off-thread, serialized, and deferred while inference is active. No
 remote preview, thumbnail, codec, waveform, or playback service is used.
+Non-JSON media downloads stream through local temporary files and are removed
+after persistence or failure; error and JSON bodies remain memory-bounded.
 
 ## Outbound connections
 
@@ -47,9 +49,9 @@ explicit hosted feature:
 | `model-router-ten.vercel.app` | default Chutes-compatible model routing | prompts, selected context/tool schemas, model inputs, Chutes API credential |
 | `llm.chutes.ai` | Chutes inference, model catalog, semantic memory, voice transcription, OCR, and vision | model requests and the selected inputs: prompts/context, memory chunks, audio, images, PDF pages, or sampled video frames; Chutes API credential |
 | `api.chutes.ai` | Chutes account and media APIs | account requests, media parameters and user-selected media assets; Chutes API credential |
-| `api.chutes.ai/idp` | OAuth sign-in and refresh | authorization code or refresh token, PKCE verifier, public/custom client ID, and a custom client secret only when configured |
+| `api.chutes.ai/idp` | OAuth sign-in and refresh | authorization code or refresh token, PKCE verifier, registered client ID, and a client secret only when configured |
 | `chutes.ai/docs`, `chutes.ai/news` | mandatory primary-source verification for Chutes topics | requested official page URLs; no Chutes API credential |
-| `context7.com` | current library documentation | library names and documentation queries; credentials and known secrets are rejected |
+| `context7.com` | current library documentation | library names and documentation queries; known secrets are rejected and an optional Context7 key is sent only to the official HTTPS service |
 | DuckDuckGo or Brave Search | web search | search query; Brave receives only its dedicated key |
 | User-selected web pages | web fetch/browser automation | normal HTTP/browser traffic required by the requested action |
 | User-configured MCP servers/plugins | external tools | data required by the selected tool and its own configuration |
@@ -61,6 +63,12 @@ browser automation. Custom inference models must declare a dedicated
 `api_key`/`env_key`; a custom model-catalog endpoint uses
 `CHUTES_MODELS_API_KEY`.
 
+Local endpoint overrides are rejected unless they pass the official-host HTTPS
+policy or the operator explicitly enables the development-only insecure
+endpoint opt-in. That opt-in relaxes URL/DNS trust for a controlled local fork;
+it does not attach ambient Chutes credentials to arbitrary custom models.
+Likewise, a custom Context7 endpoint never receives `CONTEXT7_API_KEY`.
+
 Model catalog and account usage requests may run during startup after
 authentication. Prompts and repository content are not sent by those discovery
 requests. They leave the machine only in a model/tool request that needs them.

package/README.md

@@ -1,57 +1,38 @@
 # Chutes Build
 
-**A privacy-first, open-source coding agent built for the [Chutes](https://chutes.ai) ecosystem.**
+**A privacy-first, open-source coding agent built for the
+[Chutes](https://chutes.ai) ecosystem.**
 
 [![CI](https://github.com/TheStreamCode/chutes-build/actions/workflows/ci.yml/badge.svg)](https://github.com/TheStreamCode/chutes-build/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/chutes-build.svg)](https://www.npmjs.com/package/chutes-build)
 [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
-![Chutes Build](assets/chutes/video/chutes-build-hero.gif)
+Chutes Build combines a polished terminal interface, a production-grade agent
+runtime, Chutes-native model routing, subagents, local memory, multimodal tools,
+web research, and browser automation. Telemetry, remote trace upload, upstream
+session sharing, and phone-home updates are disabled by product policy.
 
-One CLI, no compromises: an interactive terminal UI, a full coding agent
-runtime, native Chutes model routing, parallel subagents, multimodal
-generation, web research, browser automation, and local memory — with
-telemetry, remote trace upload, and phone-home update checks disabled.
+![Chutes Build terminal interface](assets/chutes/screenshot/chutes-build.png)
 
-![Chutes Build terminal UI](assets/chutes/screenshot/chutes-build.png)
+> **Development preview:** Chutes Build is under active development. Review
+> commands and file changes before approving them, especially in unfamiliar
+> repositories.
 
-> **Development preview:** the project is under active development. Build it
-> from source and review agent actions before approving changes.
+## Why Chutes Build
 
-## Contents
-
-- [Highlights](#highlights)
-- [Quick start](#quick-start)
-- [Features](#features)
-- [Configuration](#configuration)
-- [CLI reference](#cli-reference)
-- [Privacy & security](#privacy--security)
-- [Project](#project)
-
-## Highlights
-
-- 🔒 **Privacy by construction** — telemetry, remote error reporting, automatic
-  update checks, remote trace upload, and upstream session sharing are all
-  disabled at the product-policy level.
-- ⚡ **Chutes-native inference** — live model discovery, `Auto (Chutes Router)`
-  as the default, and automatic fallback when a model is temporarily
-  unavailable.
-- 🧭 **Advisor** — an on-demand reasoning agent that reviews plans, blockers,
-  and completion claims without ever taking over the executor loop.
-- 🧩 **Subagent orchestration** — concurrent fan-out with isolated worktrees
-  for real parallel decomposition, not just sequential delegation.
-- 🎨 **Multimodal, natively** — image, video, music, speech, and on-demand OCR,
-  built directly into the Rust runtime instead of a bolted-on MCP process.
-- 🧠 **Hybrid memory & voice** — full-text plus semantic vector recall, and
-  hold-to-record voice dictation, both on by default.
-
-See [Features](#features) below for the complete list.
+| Principle | What it means |
+| --- | --- |
+| **Chutes-native** | Live model discovery, `Auto (Chutes Router)`, model-aware reasoning controls, account usage, OCR, voice, and media generation are integrated directly into the Rust runtime. |
+| **Private by default** | Sessions, memory, traces, logs, configuration, and exports stay local. Cloud features run only when their documented provider call is needed. |
+| **Built for real repositories** | Planning, permission controls, worktrees, MCP, skills, background tasks, advisor review, and parallel subagents share one coherent session model. |
+| **Transparent fork** | Chutes-specific product code is separated from retained `grok-build` infrastructure, with documented upstream review and Apache-2.0 attribution. |
 
 ## Quick start
 
-### Install with npm
+### Install
 
-Release builds install without a Rust toolchain:
+The npm package selects the native binary for Windows, macOS, or Linux. A Rust
+toolchain is not required.
 
 ```powershell
 npm install -g chutes-build
@@ -64,305 +45,158 @@ For one-off use:
 npx chutes-build
 ```
 
-The npm launcher selects a native binary for Windows, macOS, or Linux. It does
-not collect telemetry and does not download executables from an install script.
-
-### Build from source
+The launcher does not download executables from a lifecycle script.
 
-Prerequisites:
+### Authenticate
 
-- Rust stable (`rustup` is recommended)
-- Git
-- a platform C/C++ build toolchain supported by Rust
-
-Protocol Buffer tooling is vendored for normal builds; a separate `protoc`
-installation is not required.
+An API key is the most reliable way to start. Create one in the Chutes
+dashboard, then press `k` on the welcome screen, run `/apikey`, or store it
+through the hidden-input CLI flow:
 
 ```powershell
-git clone https://github.com/TheStreamCode/chutes-build.git
-cd chutes-build
-cargo build -p chutes-build --release
+chutes-build login
+chutes-build
 ```
 
-The Windows executable is `target\release\chutes-build.exe`; on macOS and
-Linux it is `target/release/chutes-build`.
-
-### First run
-
-Run `chutes-build` with no prior setup and log in from the welcome screen:
-press `l` for "Login with Chutes" (opens your browser) or `k` to paste a
-Chutes API key directly. `/login` reopens this choice at any time and
-`/apikey` jumps straight to the API-key prompt.
-
-To provide a key non-interactively instead, create one in Chutes and either
-expose it only to the current process:
+For a process-local credential:
 
 ```powershell
 $env:CHUTES_API_KEY = "your-api-key"
 chutes-build
 ```
 
-or store it using the hidden-input login flow:
+Browser-based OAuth with PKCE is available through `l` or `/login`. Chutes
+OAuth applications may require registered client credentials; see
+[Authentication](docs/getting-started.md#authentication) for the supported
+fallbacks and environment variables.
+
+### Choose a model
+
+`Auto (Chutes Router)` is the default when no model preference has been saved.
+Use `/model` interactively or inspect the live catalog from the CLI:
 
 ```powershell
-chutes-build login
-chutes-build
+chutes-build models
+chutes-build models --json
+chutes-build --model model-router
 ```
 
-`Auto (Chutes Router)` is the first entry in the model picker and the default
-when no preference has been saved. Select a concrete model with `/model` or
-`chutes-build --model <model-id>`. Inspect the resolved catalog with
-`chutes-build models` or machine-readable `chutes-build models --json`.
-
-## Features
-
-### Agent & coding
-
-- **Coding agent runtime:** repository inspection, edits, shell commands,
-  planning, goals, MCP servers, skills, sessions, worktrees, and permission
-  controls inherited from the mature upstream runtime.
-- **Local session lifecycle:** list, search, resume, fork, export, trace, and
-  delete sessions without a remote registry. Machine-readable list/search
-  output is available with `--json`; destructive commands require confirmation
-  unless `--yes` is supplied.
-- **Advisor:** a read-only, on-demand reasoning agent that reviews plans,
-  difficult decisions, blockers, and completion claims without taking over the
-  executor loop. Reasons at maximum effort by default. `/advisor on|off`
-  toggles it; `/advisor <model>` pins a specific model (e.g. your largest or
-  highest-tier available one — Chutes' catalog carries no price/size metadata
-  to pick one automatically); `/advisor default` clears the pin.
-- **Subagent orchestration:** foreground and background workers, concurrent
-  fan-out, multi-worker waits, bounded nesting, and isolated worktrees. The
-  `chutes-build-orchestrator` preset is tuned for parallel decomposition.
-
-### Chutes integration
-
-- **Chutes-native inference:** API-key authentication, live model discovery,
-  `Auto (Chutes Router)` as the first model choice, configurable fallback
-  chains, and automatic retry when a selected model is temporarily unavailable.
-- **Chutes account:** read-only subscription, quota, and usage access through
-  `get_chutes_usage`, a compact plan/quota indicator in the TUI, and detailed
-  `/usage` output. Per-model statistics remain disabled unless requested.
-- **Chutes media:** live discovery and invocation for image generation and
-  editing, video, music, speech, and other supported Chutes media models through
-  `list_media_models`, `describe_media_model`, and `generate_media`. This is the
-  native Rust integration of the `chutes-media-mcp` workflow, so Chutes Build
-  does not need to spawn a separate Node/MCP process for its core media tools.
-  Generated output crosses the tool/ACP/TUI boundary as a typed artifact:
-  images use bounded lazy previews, videos use a two-frame rolling decoder,
-  and music/speech expose local pause/resume, seek, volume, duration, and
-  waveform controls with native-player fallback. Media work starts only while
-  inference is idle, never autoplays, and stays off the TUI render thread.
-- **Capability routing:** image inputs stay with the selected model when it
-  supports vision and are otherwise delegated to a vision-capable Chutes route.
-- **On-demand OCR:** the `ocr_page` tool extracts text verbatim from a single
-  image or PDF page via a dedicated Chutes vision model, independent of the
-  active chat model's vision support. Returns extracted text only — the image
-  itself is never added to the conversation.
-
-### Research & tools
-
-- **Current coding documentation:** Context7 search and documentation tools are
-  built in and avoid sending credentials or known secrets.
-- **Official Chutes research:** before answering Chutes-specific questions, the
-  main agent and subagents consult both the official
-  [documentation](https://chutes.ai/docs) and [news](https://chutes.ai/news),
-  treating directly relevant official pages as primary authority.
-- **Research and browser tools:** native web search (DuckDuckGo by default,
-  optionally Brave) plus agentic Chrome/Edge control through a local DevTools
-  connection and an isolated temporary browser profile. Browser actions accept
-  either CSS selectors or the numeric element indices shown by snapshots.
-
-### Memory & voice
-
-- **Local memory:** Chutes Build maintains a secret-filtered `memories.md` file
-  and can be launched with `--no-memory` when a stateless session is preferred.
-  Recall is hybrid by default — full-text search combined with semantic vector
-  search against a built-in Chutes-hosted embedding model. Semantic recall
-  sends the selected memory chunks to that Chutes embedding endpoint; use
-  `--no-memory` when this is not appropriate.
-- **Voice input:** hold-to-record dictation transcribes speech into the prompt
-  box. Enabled by default; activation is always manual (mic icon, `/voice`, or
-  Ctrl+Space) — Chutes Build never records without an explicit press.
-- **Time awareness and wellness:** the agent receives the local date, time, and
-  timezone and can suggest a break after long or late sessions.
-
-### Privacy by construction
-
-Telemetry, remote error reporting, automatic update checks, remote trace
-upload, upstream session sharing, and remote workspace exposure are disabled.
-Updates are installed manually from npm or a release artifact. See
-[Privacy & security](#privacy--security) below for the full data boundary.
-
-## Configuration
-
-### State root
-
-User state defaults to `~/.chutes-build`. Set `CHUTES_BUILD_HOME` to relocate
-the complete state tree, including configuration, credentials, sessions, logs,
-trace exports, plugins, user roles/personas, and the managed bundled-agent
-cache. Chutes Build does not combine roles or bundle data from the default home
-with a custom state root.
-
-Project-scoped `.chutes-build` directories remain inside their repositories and
-continue to take precedence over user and bundled agent definitions.
-
-### Model selection, reasoning, and routing
-
-Auto sends `model-router` requests to the Chutes router endpoint, allowing the
-service to select a model for the task and handle cold or unavailable capacity.
-A concrete model remains pinned unless a qualifying pre-stream failure advances
-the explicit fallback chain.
-
-Reasoning is model-specific. The model picker exposes only the controls
-supported by the exact deployed generation: binary `Instant`/`Thinking` modes,
-GLM-5.2's three modes, or no selector for fixed and non-reasoning models. Use
-`/effort` interactively or `--effort <option-id>` in headless invocations. The
-published model default is preserved unless the user explicitly changes it.
-
-See [Model reasoning compatibility](docs/model-reasoning-compatibility.md) for
-the current model matrix and forward-compatibility rules.
+## What is included
 
-```powershell
-# Ordered comma-separated fallback chain. model-router is appended as the
-# final Chutes fallback unless strict mode is enabled.
-$env:CHUTES_FALLBACK_MODELS = "model-a,model-b"
+| Area | Capabilities |
+| --- | --- |
+| **Agent runtime** | Repository inspection, edits, shell commands, plans, goals, permissions, sandbox profiles, local sessions, worktrees, and structured headless output. |
+| **Model routing** | Live Chutes catalog, automatic routing, explicit fallback chains, exact-generation reasoning controls, and vision-capability delegation. |
+| **Orchestration** | Read-only advisor, foreground/background subagents, concurrent fan-out, bounded nesting, grouped waits, and isolated worktrees. |
+| **Knowledge** | Context7 library documentation, official Chutes source checks, web search, local full-text memory, and Chutes-hosted semantic recall. |
+| **Multimodal** | Image and PDF OCR, image/video understanding, voice dictation, and typed image, video, music, and speech generation artifacts. |
+| **Automation** | MCP servers, plugins, skills, background tasks, and isolated Chrome/Edge control through local DevTools. |
 
-# Never change the selected model automatically.
-$env:CHUTES_STRICT_MODEL = "1"
-```
+Generated media is streamed to bounded temporary storage and persisted with
+create-new semantics. Inline previews remain local; unsupported terminals use
+safe text cards and native-player fallbacks.
+
+## Privacy contract
+
+| Boundary | Policy |
+| --- | --- |
+| **Local state** | Configuration, credentials, sessions, memory, logs, traces, exports, plugins, and agent definitions live under `~/.chutes-build` or `CHUTES_BUILD_HOME`. |
+| **Hosted inference** | Prompts and selected context leave the machine only for the Chutes model request that needs them. Semantic memory sends selected memory chunks to the configured Chutes embedding route. |
+| **Explicit tools** | OCR, voice, media, web, browser, MCP, and plugin actions send only the inputs required by the selected operation and provider. |
+| **Disabled surfaces** | Product telemetry, remote error reporting, automatic trace upload, upstream session sharing/search, remote workspace exposure, and automatic updates cannot be enabled through normal configuration. |
+| **Credentials** | Ambient Chutes credentials are restricted to allowlisted official HTTPS hosts. Custom endpoints require dedicated credentials and explicit trust configuration. |
+
+Read [Privacy](PRIVACY.md) for the complete data-flow inventory and
+[Security](SECURITY.md) for the threat boundaries and reporting process.
 
-Fallback happens only for transient availability/capability responses and only
-before response streaming begins. Chutes Build does not redirect requests or
-credentials to a non-Chutes inference endpoint.
-
-Ambient Chutes credentials are attached only to official Chutes/router
-endpoints. Custom inference models must declare their own `api_key` or
-`env_key`; a custom model-catalog endpoint uses the dedicated
-`CHUTES_MODELS_API_KEY`. Neither receives `CHUTES_API_KEY` or a cached Chutes
-session token implicitly.
-
-The inference client shares pooled HTTP connections, enables TCP no-delay, and
-forwards parsed SSE events without an application-level streaming buffer. Cold
-starts and model-side generation can still dominate latency. Auto is the
-recommended default when a particular model is not required. The client does
-not apply reduced-quality generation settings; target selection and quality
-remain router decisions.
-Selecting `Instant` can reduce reasoning latency, but it intentionally changes
-the model's reasoning behavior and is never enabled silently.
-
-### Account plan and quota
-
-When authenticated, Chutes Build fetches subscription usage, plan metadata, and
-quota data concurrently. The TUI status bar shows the plan plus the rolling
-four-hour and monthly percentages when available; its color follows the most
-constrained active window and changes at 80% and 100%. Click the indicator or
-run `/usage` for every active window, percentage, and reset time. If aggregate
-quota usage is unavailable, the client falls back concurrently to the
-documented per-chute quota endpoints.
-
-### OAuth login (Sign in with Chutes)
-
-Pressing `l` at the welcome screen (or `/login`) runs a standard OAuth 2.0 +
-PKCE flow against Chutes' own identity provider. The built-in app is a public
-client and does not bundle or require a client secret. Custom confidential
-clients can be configured under
-[Chutes' developer settings](https://chutes.ai/app/api):
+## Common workflows
+
+Start an interactive session in the current repository:
 
 ```powershell
-$env:CHUTES_BUILD_OAUTH2_CLIENT_ID = "cid_..."
-$env:CHUTES_BUILD_OAUTH2_CLIENT_SECRET = "csc_..."   # only if your app has one
 chutes-build
 ```
 
-Both variables are read from the environment and are never written to
-`config.toml` or any other file on disk. The custom secret is included in both
-the initial token exchange and refresh requests. `k` / `/apikey` (pasting a
-Chutes API key directly) needs no app registration.
+Run one headless task:
 
-### Optional web and browser configuration
+```powershell
+chutes-build -p "Review this repository and report only actionable findings"
+```
 
-Web search uses DuckDuckGo without a dedicated key. For Brave Search:
+Create an isolated worktree session:
 
 ```powershell
-$env:BRAVE_SEARCH_API_KEY = "your-brave-key"
-$env:CHUTES_WEB_SEARCH_PROVIDER = "brave"
+chutes-build --worktree feature-auth
 ```
 
-Browser automation discovers Chrome or Edge automatically. Overrides:
+Resume the latest session for the current directory:
 
 ```powershell
-$env:CHUTES_BROWSER_EXECUTABLE = "C:\Program Files\Google\Chrome\Application\chrome.exe"
-$env:CHUTES_BROWSER_HEADFUL = "1" # optional; default is headless
+chutes-build --continue
 ```
 
-Browser screenshots may only be written inside the active workspace. The
-automation profile is temporary, isolated from the user's normal browser
-profile, and launched with sync and background-update features disabled.
+Use `chutes-build --help` for the installed version's authoritative option
+set. See the [CLI reference](docs/cli-reference.md) and
+[slash-command reference](docs/slash-commands.md) for the maintained overview.
 
-Video attachments are sampled locally with FFmpeg and routed as representative
-frames through the same Chutes vision path. Set `CHUTES_FFMPEG_EXECUTABLE` when
-FFmpeg is not discoverable on `PATH`; restart Chutes Build after installing or
-changing FFmpeg so the per-process capability cache is refreshed.
+## Documentation
 
-Media behavior can be tuned with the compatible `chutes-media-mcp` variables
-`CHUTES_OUTPUT_DIR`, `CHUTES_WARMUP`, `CHUTES_COLD_START_RETRIES`,
-`CHUTES_ALLOW_UNKNOWN_PARAMS`, and `CHUTES_PROVENANCE`. Downloaded media is
-limited to 512 MiB by default (`CHUTES_MAX_MEDIA_BYTES`, hard ceiling 2 GiB),
-while workspace inputs are limited to 64 MiB by default
-(`CHUTES_MAX_INPUT_ASSET_BYTES`, hard ceiling 512 MiB).
+- [Getting started](docs/getting-started.md) — installation, authentication,
+  first session, models, and troubleshooting.
+- [Configuration](docs/configuration.md) — state paths, routing, credentials,
+  web/browser options, media limits, and development-only endpoint overrides.
+- [CLI reference](docs/cli-reference.md) and
+  [slash commands](docs/slash-commands.md) — public command surfaces.
+- [Architecture](docs/ARCHITECTURE.md) — runtime layers and ownership map.
+- [Privacy](PRIVACY.md), [security policy](SECURITY.md), and
+  [security review](docs/security-review.md) — operational trust boundaries.
+- [Documentation index](docs/README.md) — complete user, maintainer, and design
+  reference map.
 
-## CLI reference
+The concise guides available through `/docs` are embedded from
+`crates/codegen/xai-grok-pager/docs/user-guide/`.
 
-The complete command and option reference is in
-[docs/cli-reference.md](docs/cli-reference.md). Interactive slash commands are
-documented in [docs/slash-commands.md](docs/slash-commands.md). Installed
-binaries remain authoritative for the exact version: use
-`chutes-build --help` and `chutes-build <command> --help`.
+## Build from source
 
-## Privacy & security
+Prerequisites are Rust stable, Git, and the native C/C++ toolchain required by
+Rust on your platform. Protocol Buffer tooling is vendored for normal builds.
 
-### Local data
+```powershell
+git clone https://github.com/TheStreamCode/chutes-build.git
+cd chutes-build
+cargo build -p chutes-build --release
+```
 
-User-level state defaults to `~/.chutes-build` or the directory set in
-`CHUTES_BUILD_HOME`. Project memory is stored in `memories.md`. Configuration,
-sessions, logs, exports, credentials, plugins, user roles/personas, and bundled
-agent definitions remain local. Prompts, selected repository content, memory
-embeddings, voice recordings, OCR/media inputs, and browser traffic leave the
-machine only when their corresponding hosted feature is invoked.
+The executable is `target\release\chutes-build.exe` on Windows and
+`target/release/chutes-build` on macOS/Linux.
 
-See [PRIVACY.md](PRIVACY.md) for the exact network and data boundaries.
+### Repository map
 
-### Security model
+| Path | Ownership |
+| --- | --- |
+| `crates/chutes-build-core/` | Chutes routing, endpoint policy, catalog, reasoning, account, media, privacy, and product policy. |
+| `crates/codegen/` | Retained and adapted upstream runtime crates. Keep crate names stable to make upstream review practical. |
+| `npm/` | Native launcher, platform-package assembly, and npm verification. |
+| `docs/` | Public technical references, maintainer procedures, and design records. |
+| `.github/workflows/` | CI, dependency review, upstream monitoring, and release packaging. |
+| `prod/` and `third_party/` | Shared protocol sources and retained attribution/material from upstream. |
 
-Chutes Build is an agent capable of reading files, running commands, editing
-code, and controlling an isolated browser. Use it only in repositories you
-trust, review proposed commands, and keep the default permission checks enabled
-for sensitive work. Never place API keys in prompts, source files, or committed
-configuration. See the [security review](docs/security-review.md) for release
-controls, trust boundaries, and tracked dependency exceptions.
+The root `Cargo.toml` is generated and treated as read-only. Make dependency
+changes in the owning crate manifest or generator source instead of manually
+reorganizing the generated workspace.
 
 ## Project
 
-### Provenance
-
 Chutes Build is a substantially modified fork of
-[`xai-org/grok-build`](https://github.com/xai-org/grok-build). The upstream
-project is licensed under Apache License 2.0; this fork retains the upstream
-license and third-party notices.
-
-See [NOTICE](NOTICE), [LICENSE](LICENSE), and
-[THIRD-PARTY-NOTICES](THIRD-PARTY-NOTICES) for attribution.
-
-New upstream releases and commits are detected by a read-only scheduled check
-and reviewed through the documented [upstream synchronization
-procedure](docs/upstream-sync.md); upstream changes are never merged or released
-automatically.
-
-### Contributing
+[`xai-org/grok-build`](https://github.com/xai-org/grok-build). Upstream changes
+are reviewed and ported selectively; they are never merged or released
+automatically. See [Upstream synchronization](docs/upstream-sync.md).
 
 Issues and focused pull requests are welcome. Read
-[CONTRIBUTING.md](CONTRIBUTING.md), [SECURITY.md](SECURITY.md), and
-[CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) before contributing.
+[CONTRIBUTING.md](CONTRIBUTING.md), [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md),
+and [SECURITY.md](SECURITY.md) before contributing.
+
+Apache-2.0 licensing and attribution are documented in [LICENSE](LICENSE),
+[NOTICE](NOTICE), and [THIRD-PARTY-NOTICES](THIRD-PARTY-NOTICES).
 
 Copyright 2026 Michael Gasperini (Mikesoft).

package/npm/README.md

@@ -1,4 +1,4 @@
-# npm distribution
+# npm distribution and native packages
 
 The public `chutes-build` package is a dependency-free Node.js launcher. Its
 optional dependencies contain the native Rust executable for each supported
@@ -11,6 +11,9 @@ Supported release targets:
 - macOS x64 and ARM64
 - Linux glibc x64 and ARM64
 
+For installation and first-run instructions, see the repository
+[`README`](../README.md) and [getting-started guide](../docs/getting-started.md).
+
 ## Prepare a platform package
 
 Build the release executable for the target first, then stage its npm package:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chutes-build",
-  "version": "0.4.0",
-  "description": "Privacy-first coding agent optimized for the Chutes ecosystem",
+  "version": "0.4.1",
+  "description": "Privacy-first, open-source coding agent for the Chutes ecosystem",
   "license": "Apache-2.0",
   "author": "Michael Gasperini (Mikesoft)",
   "homepage": "https://github.com/TheStreamCode/chutes-build#readme",
@@ -34,17 +34,25 @@
     "verify:release": "node npm/scripts/verify-release.mjs"
   },
   "optionalDependencies": {
-    "chutes-build-darwin-arm64": "0.4.0",
-    "chutes-build-darwin-x64": "0.4.0",
-    "chutes-build-linux-arm64-gnu": "0.4.0",
-    "chutes-build-linux-x64-gnu": "0.4.0",
-    "chutes-build-win32-arm64": "0.4.0",
-    "chutes-build-win32-x64": "0.4.0"
+    "chutes-build-darwin-arm64": "0.4.1",
+    "chutes-build-darwin-x64": "0.4.1",
+    "chutes-build-linux-arm64-gnu": "0.4.1",
+    "chutes-build-linux-x64-gnu": "0.4.1",
+    "chutes-build-win32-arm64": "0.4.1",
+    "chutes-build-win32-x64": "0.4.1"
   },
   "keywords": [
     "ai",
+    "ai-agents",
     "chutes",
     "cli",
-    "coding-agent"
+    "coding-agent",
+    "developer-tools",
+    "mcp",
+    "multimodal",
+    "privacy",
+    "rust",
+    "terminal",
+    "tui"
   ]
 }