euron-code 0.4.1__tar.gz → 0.5.0__tar.gz

{euron_code-0.4.1 → euron_code-0.5.0}/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 0.5.0 (2026-11-05)
+
+### Build from references (V5 contract section 1)
+- New tools `oss_search` (repos or code), `oss_tree` and `oss_read` through Euron:
+  every result shows its licence; only MIT, Apache-2.0, BSD, ISC, 0BSD, Unlicense, MPL-2.0, CC0 and Zlib.
+  A `license_not_permitted` answer tells the model plainly it must not use that code, and the client drops
+  any non-permitted result it might still receive. MPL-2.0 is flagged as file-level copyleft.
+- `add_third_party_notice` records each reused source in the project's `THIRD_PARTY_NOTICES.md`.
+- Reuse-first is the default for "build me X" and UI work (system prompt + built-in skill
+  `build-from-reference`): Euron's index first (typescript for UI), then permissive open source, one or two
+  references, read only the needed files, adapt with attribution, generate only what is missing; prefer the
+  project's existing component system. Budget notes after 4 searches and 6 reads.
+- `/reference <what>` shows candidates from both sources with licences. The completion report and `-p` JSON
+  list what was reused (`Reused: repo/path (MIT)`, `"reused": [...]`).
+
+### Error log (V5 contract section 2)
+- Service and network errors, tool errors, crashes (fingerprint: type + top frame), hook failures and slash
+  command failures are reported, scrubbed (no prompts, file contents, command text, env values or secrets;
+  quoted text removed, home and project paths masked, key-like strings redacted), batched (20 per request,
+  under 8 KB) and sent in the background with a 3 s timeout; never blocks or fails what you are doing.
+- Offline queue in `~/.euron/errors.jsonl` (at most 500), sent next time; `/bug` lists the last 10 with ids.
+- Off with `errorReporting: false` or `EURON_NO_ERROR_REPORTS=1`. Disclosed in the README.
+- An unexpected crash now prints a short message with an error id instead of a traceback.
+
+### Reuse engine client (V6 contract section 6)
+- `find_reusable(requirement, components, allow_external)`: the first step for build-type requests (a
+  heuristic adds a short note to the request; bug fixes, small edits and questions skip it). The model
+  splits the request into 1-8 components; Euron decides REUSE / ADAPT / GENERATE per component and
+  the CLI shows the table (component, decision, repository@sha, licence, confidence). The client re-checks
+  every decision: a non-permitted licence or a failed security scan always becomes GENERATE, unverified
+  security turns REUSE into ADAPT.
+- The activity line shows the engine's states (searching, found, checking licence, validating security,
+  reusing, adapting, generating, running tests, integration completed), driven by the real tool calls.
+- After tests pass on reused or adapted code, its metadata (never code) goes to the student's private
+  component library (`POST /v1/components`); `/components` lists it.
+- Settings `reuse.enabled` and `reuse.external` (both default true), `--no-reuse`. A reuse engine or GitHub
+  failure never fails the turn: it generates instead, with a dim note.
+- `-p --output-format json` gains `reuse` and `task_id`; the completion report adds "Reuse plan: ...".
+
+### From the first live build test
+- Reuse no longer depends on the model choosing it: for a build request the CLI splits the request into
+  components locally (no model call) and calls `/v1/reuse/plan` before the first model call, then puts
+  the decisions, files and licences into that first message and shows the table. Websites and UI ask for
+  Euron's TypeScript / TSX components. `find_reusable` stays available for more.
+- The details the user gives are used: a system-prompt rule, an attached local photo is copied into
+  `assets/` (or `public/`) and referenced, and once per prompt the changed files are checked for
+  "Your Name", "Lorem ipsum", "example@example.com" and "TODO: replace", with one nudge to fix them.
+- "Context was N% full ..." is printed only when it freed at least 2,000 tokens or the context was
+  60% full or more.
+- The error-report note moved from the privacy section to Settings.
+
+### Branding
+- README top: the official Euron Code definition, the 3-step start, "Everything you need to build" and
+  the daily allowance with its fair-use note; usage at `euron usage`, `/usage` and euron.one.
+- No vendor or model names, and no internal service details, anywhere a student can see. The `/usage`
+  value line reads "at reference market API prices". `/status`, `/cost`, `/context` and `euron doctor` show
+  percentages and plain words instead of internal sizes and addresses.
+
+### Fewer tokens per request
+- Tool descriptions shortened (about 730 fewer tokens on every request).
+
+## 0.4.2 (2026-11-05)
+
+### Changed
+- Documentation and messages describe what Euron Code does for you, without internal service details.
+
 ## 0.4.1 (2026-11-05)
 
 ### Fixed
@@ -20,7 +86,7 @@
 - The system prompt now says to use these for servers instead of `bash`.
 
 ### Reuse Euron's open-source code (V4 contract section 3)
-- `euron_reuse_search` and `euron_reuse_read` over the gateway's index of Euron's public MIT repos; the
+- `euron_reuse_search` and `euron_reuse_read` over Euron's public MIT repos; the
   system prompt asks to search before writing a substantial common component and to keep the licence
   notice; `/reuse <query>`.
 
@@ -34,7 +100,7 @@
 
 ### More tools and gaps closed (audit increment 6)
 - `find_symbol` (definitions and references), `delete_file` and `move_file` (both undone by `/rewind`).
-- `AGENTS.md` and `CLAUDE.md` are read alongside `EURON.md` (trust-gated like it).
+- `AGENTS.md` and other agents' instruction files are read alongside `EURON.md` (trust-gated like it).
 - Inline `<tool_call>` JSON is repaired (trailing commas, single quotes, Python literals); garbage
   becomes an error result for the model, never a crash.
 - `/rewind` works after `euron --resume`: checkpoints are kept in `~/.euron/checkpoints/<session>/`
@@ -43,9 +109,7 @@
 - `/export` warns that the file contains tool output.
 
 ### Euron-only client and privacy (V4 contract section 1, audit increment 3)
-- A 403 `client_not_supported` shows the gateway's message ("works through the euron app only").
-- README and the first image attach say where data goes: prompts on GPUs rented from Vast.ai (not
-  logged), images described by Google Gemini (not stored).
+- A 403 `client_not_supported` explains that Euron Code works through the euron app only.
 
 ### CI
 - `.github/workflows/ci.yml`: pytest on ubuntu, windows and macos x Python 3.9 and 3.12 (ripgrep on one
@@ -65,7 +129,7 @@
   1024. A request that would not fit is compacted first. The prompt estimate starts from the last
   server-reported `prompt_tokens` and adds only the new messages.
 
-### Context management for a 32k window
+### Context management
 - An output budget is reserved (min(maxOutputTokens, window/4)); percentages are of the usable rest.
 - From 50%, tool outputs are cleared biggest and oldest first until under 40% (the latest step is never
   touched). Each stub names the call (for reads: path and line range) so the model can read it again.
@@ -77,13 +141,13 @@
   2,000 lines return an outline (definitions with line numbers) unless a range is given. The system
   prompt says: search first, read ranges, edit with `edit_file`, never rewrite big files.
 
-### A live session like Claude Code
+### A live session
 - **Activity line** while the agent works: an animated glyph, a rotating verb, elapsed time, tokens
   sent and received (counted live from the stream), what is happening (`thinking`, `writing app.py`,
-  `running pytest 12s`, `waiting for a GPU slot (2 ahead)`, `retrying in 3s`) and `esc to interrupt`.
+  `running pytest 12s`, `waiting for capacity (2 ahead)`, `retrying in 3s`) and `esc to interrupt`.
   On a terminal it redraws 10 times a second; without one it prints a progress line every 15 s; in `-p`
-  mode it appears on stderr only when stderr is a terminal. The gateway's `: queued, N ahead` comments
-  are shown instead of being ignored.
+  mode it appears on stderr only when stderr is a terminal. Queue positions are shown
+  instead of being ignored.
 - **Status bar**: model and effort, mode, session tokens and their value, context %, today's and this
   week's remaining quota, session uptime. Refreshed continuously.
 - **Type while it works.** The turn runs in a worker thread and the prompt stays live. `/usage`, `/cost`,
@@ -114,8 +178,7 @@
 
 ### Plan quotas and value (V3 contract)
 - `/usage` shows the plan tier, all four periods (day, week, month, year) with bars and refill times,
-  `quota.blocked` prominently, and value lines at the reference API price ("≈ $1.07 (₹94) at Claude
-  Sonnet 5.5 API list prices · included in your plan"), plus what the allowance is worth. `/cost` and the
+  `quota.blocked` prominently, and value lines at reference market API prices, plus what the allowance is worth. `/cost` and the
   status bar show this session's value. Always labelled as a reference, never a bill.
 - New 429 codes `monthly_token_limit`, `yearly_token_limit` and `cooldown`, each with its refill time in
   local time; exit code 5 in `-p` mode.
@@ -226,8 +289,7 @@
   at turn N"; a read that reached the end of the file covers later partial reads.
 - Micro-compaction at 60% of the context: tool outputs older than the last 3 steps become one-line stubs
   (no model call); the summary still happens at 75%.
-- `/cost` and `/context` report prompt tokens sent, tokens served from the server's prefix cache
-  (`usage.prompt_tokens_details.cached_tokens`) and tokens saved by each measure. `-p --output-format
+- `/cost` and `/context` report prompt tokens sent, tokens reused from cache and tokens saved by each measure. `-p --output-format
   json` adds `cached_tokens` and `saved_tokens`.
 
 ### Changed

{euron_code-0.4.1 → euron_code-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: euron-code
-Version: 0.4.1
+Version: 0.5.0
 Summary: Euron Code: an agentic coding assistant in your terminal for Euron Plus and Super 30 students.
 Project-URL: Homepage, https://euron.one/code-agent
 Author-email: Euron <contact@euron.one>
@@ -66,9 +66,20 @@ Description-Content-Type: text/markdown
 
 # Euron Code
 
-An AI coding agent in your terminal, made for Euron students. Ask it to explain a codebase, fix a bug,
-write tests or build a feature: it reads your files, makes the changes, runs your tests and checks its
-own work. Included with **Euron Plus** and **Super 30** (get Plus at https://euron.one/plus).
+**Imagine It. Prompt It. Build Anything.**
+
+Your AI Software Engineer. Ready to Build.
+
+From a simple website to a complete AI-powered application, Euron Code turns your ideas into real,
+working software.
+
+It doesn't just write code. It thinks, plans, builds, runs, tests, finds errors, and fixes them. All from
+your terminal.
+
+No more starting from scratch. Euron Code intelligently reuses existing open-source implementations,
+writes what's missing, and brings everything together.
+
+One idea. One prompt. Endless possibilities.
 
 ## Get started in 3 steps
 
@@ -91,12 +102,37 @@ Enter.
 
 **3. Type what you want**, or type `/` to see every command:
 
-- `explain how authentication works here`
+- `build me a todo app with a FastAPI backend and tests`
 - `the tests fail, find out why and fix them`
-- `/model` to pick a model, `/usage` to see your quota and what it is worth
+- `/usage` to see your tokens today, this week, month and year
 
 That's it. Press **Esc** to stop it, **Ctrl-D** to quit.
 
+## Everything you need to build
+
+- 🧠 **Thinks Before It Codes**: understands your requirements and plans the implementation.
+- ⚡ **Builds Complete Applications**: websites, SaaS products, AI agents, APIs, dashboards, automations,
+  and more.
+- 🛠️ **Writes, Runs & Fixes**: creates files, executes commands, runs tests, and fixes errors.
+- 🔍 **Reuses Proven Code**: discovers reusable Euron and approved open-source components to build faster.
+- 🔄 **Works Across Your Project**: understands existing code and makes changes without unnecessarily
+  rebuilding everything.
+- 🚀 **From Idea to Working Software**: helps you build, test, and prepare real applications for
+  deployment.
+
+## 10 million AI tokens every day
+
+Build more. Experiment more. Create without constantly worrying about tokens.
+
+*Up to 10 million tokens per day, subject to fair-use policies, model availability, and plan limits.*
+
+Included with **Euron Plus** and **Super 30** (get Plus at https://euron.one/plus).
+
+Track your usage any time: `euron usage` in a terminal, `/usage` in a session, or
+https://euron.one/code-agent/usage.
+
+*Euron Code: You Imagine. We Code. You Create.*
+
 ## What happens automatically
 
 - **Project setup.** The first time in a folder it writes `EURON.md` (your stack, build and test
@@ -105,14 +141,15 @@ That's it. Press **Esc** to stop it, **Ctrl-D** to quit.
   improve `EURON.md`.
 - **Context management.** Old tool output is cleared and long conversations are summarised before
   they fill the context, so it never runs out mid-task. Long answers continue by themselves.
-- **Token saving.** Unchanged files are not re-read, big files are read in parts, the prompt is kept
-  cache-friendly for the servers.
+- **Token saving.** Unchanged files are not re-read and big files are read in parts.
 - **Local cache.** `.euron/cache/` remembers the repo map and file list, so new sessions start fast.
   Safe to delete; never holds secrets; git-ignored.
 - **Runs your app.** It can start your dev server in the background, check it answers
   (`check_app`, optionally in a headless browser), read its logs and stop it again.
-- **Reuses Euron's code.** Before writing a common component (auth, payments, RAG, ...) it searches
-  Euron's open-source repos (MIT) and adapts what fits, keeping the licence notice. Try `/reuse <query>`.
+- **Builds from references, not from scratch.** For "build me X" and for UI work it first searches
+  Euron's open-source repos, then permissively licensed projects on GitHub, reads only the files it needs,
+  adapts them (keeping the licence notice and recording each source in `THIRD_PARTY_NOTICES.md`) and
+  writes only what is missing. Faster, and far fewer tokens. Try `/reference <what you want to build>`.
 - **Live progress.** While it works you see what it is doing, the time, tokens and an `esc to interrupt`
   line, and you can keep typing (see below).
 
@@ -127,7 +164,9 @@ Type `/` and pick from the menu. The most useful:
 | `/status` | account, key, model, mode, session time and quota at a glance |
 | `/cost`, `/context` | tokens of this session and what fills the context |
 | `/attach <files>` | attach files, folders, Word/Excel/PowerPoint/PDF documents or images |
+| `/reference <what>` | references to build from: Euron's repos + permissive open source, with licences |
 | `/reuse <query>` | search Euron's open-source repos for code to reuse |
+| `/components` | your component library: reused code whose tests passed in your projects |
 | `/ps` | background processes (dev servers) it started; `/ps stop` |
 | `/plan` | plan mode: it explores and proposes a plan, changes nothing |
 | `/review` | review your uncommitted changes |
@@ -165,23 +204,52 @@ how full the context is, what is left today and this week, and how long the sess
 Shift+Tab cycles default -> acceptEdits -> plan, and reaches bypass only if you started with it.
 `--add-dir ../shared` lets it also work in another folder.
 
-## Where your data goes
+## Your code and your account
 
-- Your code stays on your computer. Euron Code runs on Euron's GPUs.
-- Images you attach are turned into a text description by Euron's image understanding and are not stored.
+- Your code stays on your computer.
 - One login at a time: signing in on another computer signs this one out.
 - Don't paste passwords or API keys into prompts.
 
-## Limits and value
+## How Euron Code reuses proven code
+
+Search first, reuse second, modify third, generate only what is missing. When you ask it to build an app,
+a feature, a UI or an integration, Euron Code itself splits the request into a few components and asks
+Euron for proven code for each one before the model starts (the model can ask for more with
+`find_reusable`): Euron's own repositories, your own component library and approved open-source
+projects. You see a decision table
+(component, REUSE / ADAPT / GENERATE, repository@commit, licence, confidence). REUSE reads the pinned files
+and integrates them with minimal edits, ADAPT reads and modifies them, GENERATE writes the part itself.
+For websites and UI it asks for Euron's TypeScript / TSX components. Small edits, bug fixes and questions
+skip this step. The details you give (your name, photo, email, links) go into the files; an attached
+photo is copied into the project's `assets/` (or `public/`) folder, and if a changed file still says
+"Your Name" or "Lorem ipsum" Euron Code is asked once to fix it. If that search is unavailable it simply generates,
+with a short note. When the tests pass on reused or adapted code, the component is added to
+your private library (its name, source, commit, licence and test result; never your code): `/components`
+lists it. Turn reuse off with `--no-reuse` for one run, `reuse.enabled false`, or keep it to Euron's own
+code with `reuse.external false`.
+
+Licence rules: only MIT, Apache-2.0, BSD, ISC, 0BSD, Unlicense, MPL-2.0, CC0 and Zlib code is reused (see
+below); a candidate whose licence or security scan fails is always turned into GENERATE by the CLI itself,
+whatever the server says.
+
+## Reusing open source safely
+
+Only code under MIT, Apache-2.0, BSD-2/3-Clause, ISC, 0BSD, Unlicense, MPL-2.0, CC0-1.0 or Zlib is used.
+GPL, AGPL, LGPL, SSPL and unlicensed code is never copied: Euron does not serve it and the CLI checks
+again. MPL-2.0 files stay separate files under their own licence. Every reused source is recorded in
+your project's `THIRD_PARTY_NOTICES.md`, and the completion report lists it (`Reused: owner/repo/path
+(MIT)`).
 
-**10 million AI tokens. Every day.** Build more. Experiment more. Create without constantly worrying
-about tokens. Included with Euron Plus and Super 30.
+## Limits and value
 
-<sub>Up to 10 million tokens per day, subject to fair-use policies, model availability, and plan limits.</sub>
+Your plan has a token allowance per **day**, **week**, **month** and **year**, the same for Euron Plus
+and Super 30.
+`/usage` (or `euron usage`) shows each with a bar, what is left and when it refills, in your local time.
+Days, weeks (Monday), months and years start at midnight IST. If a limit is reached, Euron Code says
+which one and when it refills; nothing else breaks.
 
-Track everything with `/usage` (or `euron usage`) and at https://euron.one/code-agent/usage: what you
-used today, this week, this month and this year, what is left and when it refills, in your local time.
-If a limit is reached, Euron Code says which one and when it refills; nothing else breaks.
+It also shows what your own usage would cost at reference market API prices. **It is not a bill: you
+pay nothing extra.** The same numbers are on https://euron.one/code-agent/usage.
 
 ## Run and check your app
 
@@ -219,7 +287,7 @@ running Euron Code in another terminal, you are asked whether to take over (`-p
 The approval page approves for whichever Euron account is signed in on euron.one in that browser, so
 to switch accounts sign in there with the other account first (or open the link in a private window).
 If no browser opens (SSH, WSL), copy the link it prints. The key is kept in the system keychain, or in
-`~/.euron/credentials.json` (readable only by you). To revoke a key on the server, delete it at
+`~/.euron/credentials.json` (readable only by you). To revoke a login, remove it at
 https://euron.one/code-agent.
 
 Optional extras: `pip install "euron-code[images]"` (image resizing, clipboard), `"euron-code[postgres]"`,
@@ -242,7 +310,7 @@ Optional extras: `pip install "euron-code[images]"` (image resizing, clipboard),
 | `/help` | list commands, your own commands and skills, and the shortcuts |
 | `/status`, `/whoami` | account, key, API, model, mode, session, uptime, quota |
 | `/usage` (`/users`) | quota per period, refill times, value, sessions, tasks, cache share, last 30 days |
-| `/cost`, `/context` | session tokens, server cache, savings, session value; what fills the context |
+| `/cost`, `/context` | what this session used; what fills the context |
 | `/model [id]`, `/effort` | pick or set the model; reasoning effort |
 | `/compact [focus]`, `/clear` | summarise to free context; start fresh |
 | `/resume [id]`, `/rewind`, `/export [file]` | saved sessions; undo the last turn; save as Markdown |
@@ -274,7 +342,7 @@ prompt back in the input line. Files you changed again after that turn are skipp
 
 ### Continue later
 
-Every session is saved under `~/.euron/sessions/` (text only; attached images are not stored).
+Every session is saved under `~/.euron/sessions/` (text only, without attached images).
 
 ```bash
 euron --continue     # pick up the latest session in this folder
@@ -391,7 +459,7 @@ Hooks are your own shell commands that run at fixed points. Put them in `setting
 | `Stop` | when the model finishes its answer | stderr goes to the model and it continues (at most twice) |
 
 Any other non-zero exit is shown as a warning and blocks nothing. `matcher` is a regular expression
-over the tool name; common names (`Edit`, `Write`, `MultiEdit`, `Read`, `Bash`, `Grep`, `Glob`,
+over the tool name; the common short names (`Edit`, `Write`, `MultiEdit`, `Read`, `Bash`, `Grep`, `Glob`,
 `WebFetch`) and Euron Code names (`edit_file`, `bash`, ...) both work. The command runs in the project
 folder with `cmd.exe` on Windows and `sh` elsewhere, and gets one JSON object on stdin: `event`,
 `session_id`, `cwd`, `tool_name`, `tool_input`, `tool_output` (PostToolUse) or `prompt`. Environment:
@@ -406,31 +474,22 @@ always run.
 
 ## Context and tokens (automatic)
 
-The default model has a 32k-token context and writes at most about 8k tokens per step. Euron Code
-manages that for you, with nothing to set up:
-
-- **Room for the answer.** An output budget (about 8k) is always kept free; "100% full" means the
-  prompt leaves no more than that. Each request asks for as many output tokens as really fit, and a
-  request that would not fit is compacted first.
-- **Clearing.** From 50% full, tool outputs are replaced with one-line stubs, biggest and oldest first,
-  until it is under 40%. The latest step is never touched, and each stub says what to re-read (for
-  example `read_file src/app.py lines 1-200`). The note shows real numbers: "freed 9,400 tokens,
-  now 38%".
-- **Summary.** At 70%, or when the next request would not fit, older messages are summarised: the task,
-  decisions, files changed, commands and results, the last error and open todos.
-- **Long answers and big edits.** An answer cut by the output limit continues by itself. A tool call cut
-  in the middle (a huge file write) is never run; the model is asked to make the change in smaller
-  steps. If the model spent its whole budget thinking, it retries with less reasoning.
+Euron Code manages the conversation for you, with nothing to set up:
+
+- **Always room to answer.** Each request leaves space for the reply; a conversation that is getting
+  full is tidied up first.
+- **Clearing.** Old tool output is replaced with one-line notes that say what to re-read (for example
+  `read_file src/app.py lines 1-200`), so the agent keeps going without losing track.
+- **Summary.** Long conversations are summarised: the task, decisions, files changed, commands and
+  results, the last error and open todos.
+- **Long answers and big edits.** An answer that gets cut off continues by itself. A huge edit that gets
+  cut off is never applied half-way; the change is made in smaller steps instead.
 - **Reasoning effort** is `medium` by default and `low` for quick follow-ups ("thanks", "continue");
   change it with `/effort low|medium|high`.
-- **Reads.** `read_file` reads 200 lines at a time and stops before about 6k tokens; a file over 2,000
-  lines returns an outline of its definitions first. Re-reading an unchanged file returns a one-line
-  note instead of the content.
-- **Cache-friendly.** The system prompt and tool list never change during a session, so the servers can
-  reuse their prefix cache; changing data goes at the end of your message.
+- **Reads.** Files are read in parts; a very large file returns an outline first. Re-reading an
+  unchanged file returns a one-line note instead of the content.
 
-`/cost` and `/context` show what was sent, how much the server served from its cache, and how many
-tokens these measures kept out of the context.
+`/cost` and `/context` show what this session used and what fills the context.
 
 ## Non-interactive use (scripts, CI)
 
@@ -447,6 +506,9 @@ folder or container.
 
 `--permission-mode plan` gives a read-only run that ends with a plan.
 
+With `--output-format json` the result also has `reuse` (one entry per planned component: `component`,
+`decision`, `repo`, `license`), `reused` (files read from references) and `task_id`.
+
 Exit codes: `0` ok, `1` error, `2` bad usage, `3` no Euron Plus / Super 30 access, `4` not logged in or
 key rejected, `5` a token allowance used (day, week, month, year) or a cooldown, `6` `--max-turns` reached,
 `130` interrupted.
@@ -489,11 +551,18 @@ the connection itself is opened read-only. To let it write (local dev databases
 | `toolOutputMaxChars` | `12000` | longer tool output is cut to head + tail |
 | `hooks` | `{}` | see [Hooks](#hooks) |
 | `webFetch` | `true` | allow the web page tool (it still asks per site) |
+| `reuse.enabled` | `true` | look for reusable code before building (`--no-reuse` for one run) |
+| `reuse.external` | `true` | also search permissively licensed GitHub projects, not only Euron's |
+| `errorReporting` | `true` | send a short error report when something fails (see below) |
 | `db.connections.<name>` | | database DSNs |
 
-Environment variables: `EURON_CODE_API` (gateway URL, default
-`https://api.euron.one/api/v1/code-agent`), `EURON_API_KEY` (use a key without logging in, for CI),
-`EURON_HOME` (instead of `~/.euron`), `EURON_NO_BROWSER=1`.
+**Error reports.** When something fails, Euron Code sends Euron a short error report (the error kind and
+code, the tool or command name, version and OS; never your prompts, code or secrets) so it can be fixed.
+`/bug` shows your last ones. Turn it off with `euron config set errorReporting false` or
+`EURON_NO_ERROR_REPORTS=1`.
+
+Environment variables: `EURON_API_KEY` (use a key without logging in, for CI), `EURON_HOME` (instead of
+`~/.euron`), `EURON_NO_BROWSER=1`.
 
 ## In VS Code
 
@@ -529,13 +598,9 @@ and the keychain.
 
 ## Privacy and safety
 
-- Your code stays on your computer: only the parts the agent reads are sent, as part of the conversation
-  with Euron's model. Attached images are turned into text by Euron's image understanding and are not
-  stored.
+- Your code stays on your computer; the agent works on it from your terminal.
 - Your key is never printed in full and never logged.
 - Edits and commands ask first. Files outside the project folder always ask, even to read.
-- Each request carries a random session id and task id so your usage page can count sessions and
-  tasks. Nothing else about the conversation is stored by the gateway.
 - Hooks are commands you configure; project hooks only run after you trust them.
 - Text inside your files, web pages and command output is treated as data, not instructions.