isorite 0.11.0 → 0.12.0

package/docs/setup-for-agents.md

@@ -1,14 +1,8 @@
 # Setting isorite up: for an AI helping someone
 
-You're helping someone set up isorite: a local web app over a folder of Markdown notes (the browser), an agent in it
-called Iso, and `isorite term`, which runs OpenCode 2 beside the notes. This is everything isorite reads, writes and
-runs for the setup, and how each failure shows. `isorite help setup` prints this file.
+You're helping someone set up isorite: a local web app over a folder of Markdown notes (the browser), an agent in it called Iso, and `isorite term`, which runs OpenCode 2 beside the notes. This is everything isorite reads, writes and runs for the setup, and how each failure shows. `isorite help setup` prints this file.
 
-**Start here:** ask them to run `isorite doctor --report` (add the notes folder if they have one) and paste what it
-prints. It shows isorite's and Node's versions, the platform, the configuration with secrets replaced by their
-lengths, the environment variables isorite reads, and a line for each check, ✓ passed, ✗ failed, ! a warning, –
-skipped. Most failures say what to change. Never ask them to paste a key or passphrase, and don't ask them to
-turn off certificate checking (`NODE_TLS_REJECT_UNAUTHORIZED=0`).
+**Start here:** ask them to run `isorite doctor --report` (add the notes folder if they have one) and paste what it prints. It shows isorite's and Node's versions, the platform, the configuration with secrets replaced by their lengths, the environment variables isorite reads, and a line for each check, ✓ passed, ✗ failed, ! a warning, – skipped. Most failures say what to change. Never ask them to paste a key or passphrase, and don't ask them to turn off certificate checking (`NODE_TLS_REJECT_UNAUTHORIZED=0`).
 
 ## Commands
 
@@ -44,9 +38,7 @@ isorite never reads or changes the person's own OpenCode settings (`~/.config/op
 
 ## config.toml
 
-The person can set all of this from Iso's settings in the browser (M18: on `localhost` only; checked as `doctor`
-checks it, kept into use without a restart). The page writes the same fields; it drops comments, keeping the file
-as it was once as `config.toml.bak`. Writing it by hand needs the server restarted.
+The person can set all of this from Iso's settings in the browser (M18: on `localhost` only; checked as `doctor` checks it, kept into use without a restart). The page writes the same fields; it drops comments, keeping the file as it was once as `config.toml.bak`. Writing it by hand needs the server restarted.
 
 ```toml
 [provider]
@@ -81,8 +73,7 @@ max = "…"                             # most able
 
 Rules:
 
-- With `url` set and no `[tiers]`, OpenRouter's names are used (`anthropic/claude-…`). A gateway usually answers
-  404 to them. Doctor warns: name the gateway's models under `[tiers]`.
+- With `url` set and no `[tiers]`, OpenRouter's names are used (`anthropic/claude-…`). A gateway usually answers 404 to them. Doctor warns: name the gateway's models under `[tiers]`.
 - `pfx` and `cert` can't both be named. `cert` and `cert_key` go together.
 - A `"$NAME"` value whose variable isn't set is an error naming both.
 - Certificates are used only over https, and only for the provider's own address.
@@ -103,22 +94,11 @@ Rules:
 
 ## How requests reach the provider
 
-- **Iso** (in the isorite server) posts to `<url>/chat/completions?<query>`, streaming, with the key (in
-  `Authorization: Bearer` or `key_header`), `headers`, and `stream_options` unless `stream_usage = false`. With a
-  certificate or `ca`, it goes by `node:https` with them, through `HTTPS_PROXY` if set. Otherwise it uses Node's
-  fetch.
-- **The terminal**: OpenCode is configured with the provider at `http://127.0.0.1:<port>/api/gateway`, the isorite
-  server's relay, and with the server's token as its key. The relay adds the real key, certificate, headers and
-  query, and passes `/chat/completions` and `/models` on. So whatever works for Iso works for the terminal. The
-  relay answers only on 127.0.0.1, and only that token.
-- **Retries.** A 502, 503 or 504, a dropped connection or a timeout is asked again up to 3 times (after about 1, 2
-  and 4 s), and a 429 once (after its `Retry-After`, if 10 s or less), but only before any of the reply has come.
-  The relay does the same before it passes anything to OpenCode (which retries on its own as well). 4xx answers
-  and names not found are the settings', and are not asked again.
-- **An empty reply.** A reply cut off at its length limit with nothing written (a reasoning model that spent the
-  budget thinking) is asked once more with three times the room.
-- With no key and no certificate in `config.toml`, and no `ISORITE_GATEWAY_*`, OpenCode uses its own models.
-  `isorite term` prints which models it uses, and from where.
+- **Iso** (in the isorite server) posts to `<url>/chat/completions?<query>`, streaming, with the key (in `Authorization: Bearer` or `key_header`), `headers`, and `stream_options` unless `stream_usage = false`. With a certificate or `ca`, it goes by `node:https` with them, through `HTTPS_PROXY` if set. Otherwise it uses Node's fetch.
+- **The terminal**: OpenCode is configured with the provider at `http://127.0.0.1:<port>/api/gateway`, the isorite server's relay, and with the server's token as its key. The relay adds the real key, certificate, headers and query, and passes `/chat/completions` and `/models` on. So whatever works for Iso works for the terminal. The relay answers only on 127.0.0.1, and only that token.
+- **Retries.** A 502, 503 or 504, a dropped connection or a timeout is asked again up to 3 times (after about 1, 2 and 4 s), and a 429 once (after its `Retry-After`, if 10 s or less), but only before any of the reply has come. The relay does the same before it passes anything to OpenCode (which retries on its own as well). 4xx answers and names not found are the settings', and are not asked again.
+- **An empty reply.** A reply cut off at its length limit with nothing written (a reasoning model that spent the budget thinking) is asked once more with three times the room.
+- With no key and no certificate in `config.toml`, and no `ISORITE_GATEWAY_*`, OpenCode uses its own models. `isorite term` prints which models it uses, and from where.
 
 ## What working looks like
 
@@ -168,11 +148,6 @@ Rules:
 
 ## Another model for search by meaning
 
-Any ONNX model that gives 384 numbers for a text, with its `tokenizer.json`, can stand in for granite:
-`isorite model --from <folder>`. It's checked by use (loaded, and asked for one vector), copied into the models
-folder, and used from then on; each base's vectors are made again with it. An optional `isorite-model.json` beside
-its files gives `{"name": "…", "pooling": "cls" | "mean"}`: `cls` (the default) takes the first token's state, as
-granite is used; `mean` averages them all, as sentence-transformers models such as all-MiniLM-L6-v2 are used.
+Any ONNX model that gives 384 numbers for a text, with its `tokenizer.json`, can stand in for granite: `isorite model --from <folder>`. It's checked by use (loaded, and asked for one vector), copied into the models folder, and used from then on; each base's vectors are made again with it. An optional `isorite-model.json` beside its files gives `{"name": "…", "pooling": "cls" | "mean"}`: `cls` (the default) takes the first token's state, as granite is used; `mean` averages them all, as sentence-transformers models such as all-MiniLM-L6-v2 are used.
 
-If the gateway isn't OpenAI-compatible (Bedrock's or Vertex's own APIs, for example), isorite can't use it directly.
-An OpenAI-compatible proxy in front of it, such as LiteLLM, can.
+If the gateway isn't OpenAI-compatible (Bedrock's or Vertex's own APIs, for example), isorite can't use it directly. An OpenAI-compatible proxy in front of it, such as LiteLLM, can.

package/docs/setup.md

@@ -1,7 +1,6 @@
 # Setting isorite up
 
-From nothing to Iso answering in the browser and OpenCode working in the terminal. If anything fails on the way,
-run `isorite doctor`: it checks each step and says what to change.
+From nothing to Iso answering in the browser and OpenCode working in the terminal. If anything fails on the way, run `isorite doctor`: it checks each step and says what to change.
 
 ## 1. Install
 
@@ -11,49 +10,35 @@ Either one file, with Node inside it:
   ```sh
   curl -fsSL https://github.com/lachlanjs/isorite/releases/latest/download/install.sh | sh
   ```
-  It goes in `~/.local/bin` (`--dir` for another folder). Each address it fetches is printed, so a machine that
-  can't reach GitHub can fetch the same files another way, or from a mirror with `--url <the executable's address>`.
-  It unpacks itself into `~/.cache/isorite/<version>/` the first time it runs. Run the installer again to update.
+  It goes in `~/.local/bin` (`--dir` for another folder). Each address it fetches is printed, so a machine that can't reach GitHub can fetch the same files another way, or from a mirror with `--url <the executable's address>`. It unpacks itself into `~/.cache/isorite/<version>/` the first time it runs. Run the installer again to update.
 
   On Windows, in PowerShell:
   ```powershell
   irm https://github.com/lachlanjs/isorite/releases/latest/download/install.ps1 | iex
   ```
-  It goes in `%LOCALAPPDATA%\isorite`, which it adds to your PATH (open a new terminal after), and unpacks itself
-  into `%LOCALAPPDATA%\isorite\<version>\` the first time it runs. The executable isn't signed, so Windows may say
-  it's from an unknown publisher. isorite's own settings are in `%USERPROFILE%\.config\isorite\`. Use Windows
-  Terminal for `isorite term`. `isorite opencode` needs npm, so Node 24 as well.
+  It goes in `%LOCALAPPDATA%\isorite`, which it adds to your PATH (open a new terminal after), and unpacks itself into `%LOCALAPPDATA%\isorite\<version>\` the first time it runs. The executable isn't signed, so Windows may say it's from an unknown publisher. isorite's own settings are in `%USERPROFILE%\.config\isorite\`. Use Windows Terminal for `isorite term`. `isorite opencode` needs npm, so Node 24 as well.
 
 Or from npm:
 
 - **Node 24** or later (`node --version`).
 - **isorite**: `npm i -g isorite`.
 
-Then, for the terminal, **OpenCode 2**: `isorite opencode` installs it for isorite alone (in
-`~/.config/isorite/opencode-cli`), leaving your global npm prefix, and any OpenCode 1 you use, as they are.
+Then, for the terminal, **OpenCode 2**: `isorite opencode` installs it for isorite alone (in `~/.config/isorite/opencode-cli`), leaving your global npm prefix, and any OpenCode 1 you use, as they are.
 
 `isorite guide` now opens the guide, a knowledge base about isorite with things to do in it. Until a provider is set up, Iso there is the guide's finder: no key, nothing sent anywhere.
 
 ## 2. A model provider
 
-Iso and the terminal need an OpenAI-compatible provider. isorite's settings are in `~/.config/isorite/config.toml`
-(or `$XDG_CONFIG_HOME/isorite/config.toml`), a file only you can read.
+Iso and the terminal need an OpenAI-compatible provider. isorite's settings are in `~/.config/isorite/config.toml` (or `$XDG_CONFIG_HOME/isorite/config.toml`), a file only you can read.
 
-**OpenRouter** is the default. Open isorite in the browser, open Iso's settings (the icon at the right of Iso's
-pane head), and paste a key there, or sign in with OpenRouter, which makes one. Nothing else is needed.
+**OpenRouter** is the default. Open isorite in the browser, open Iso's settings (the icon at the right of Iso's pane head), and paste a key there, or sign in with OpenRouter, which makes one. Nothing else is needed.
 
-**Any other provider or gateway** is set up in the same place: choose *a gateway of your own*, give its address and
-key, and open *what else it asks for* for its key's header, headers, query values, client certificate, and whether
-it reports usage. Each tier's model is picked from the gateway's own list. The pulse icon checks the setup before
-it is kept, as `isorite doctor` would, and says what to change; the tick keeps it, in use at once, without a
-restart. The clipboard icon copies `isorite doctor --report` for someone helping.
+**Any other provider or gateway** is set up in the same place: choose *a gateway of your own*, give its address and key, and open *what else it asks for* for its key's header, headers, query values, client certificate, and whether it reports usage. Each tier's model is picked from the gateway's own list. The pulse icon checks the setup before it is kept, as `isorite doctor` would, and says what to change; the tick keeps it, in use at once, without a restart. The clipboard icon copies `isorite doctor --report` for someone helping.
 
-- The setup is changed only from this machine (`localhost`). From a phone over a tailnet it is shown and checked,
-  and the key can be changed, but not the address it goes to.
+- The setup is changed only from this machine (`localhost`). From a phone over a tailnet it is shown and checked, and the key can be changed, but not the address it goes to.
 - Keeping a new address forgets the key held for the old one, unless a key is given with it.
 - Secrets (the key, the `.pfx`'s password, a header whose name looks secret) are written and never shown again.
-- The page writes `config.toml` again without its comments; the first time, the file as it was is kept beside it
-  as `config.toml.bak`.
+- The page writes `config.toml` again without its comments; the first time, the file as it was is kept beside it as `config.toml.bak`.
 - A running `isorite term` keeps the models it started with, but asks through the new address at once.
 
 The same setup can be written by hand in `config.toml`, under `[provider]`, with the models under `[tiers]`:
@@ -103,17 +88,13 @@ X-Project = "$PROJECT_ID"
 api-version = "2024-10-21"
 ```
 
-Paths may start with `~`, or are taken from `config.toml`'s folder. Any value written `"$NAME"` is read from that
-environment variable.
+Paths may start with `~`, or are taken from `config.toml`'s folder. Any value written `"$NAME"` is read from that environment variable.
 
 ### Proxies and the company's certificates
 
-The `isorite` command uses `HTTPS_PROXY` (and `NO_PROXY`) when they're set, and trusts the system's certificate
-authorities as well as Node's own, so a company's authority installed on the machine is trusted. Node does neither
-by itself. Set `ISORITE_NODE_DEFAULTS=0` to leave Node as it is.
+The `isorite` command uses `HTTPS_PROXY` (and `NO_PROXY`) when they're set, and trusts the system's certificate authorities as well as Node's own, so a company's authority installed on the machine is trusted. Node does neither by itself. Set `ISORITE_NODE_DEFAULTS=0` to leave Node as it is.
 
-If the company's authority isn't installed on the machine, name its certificate as `ca` above, or in
-`NODE_EXTRA_CA_CERTS`.
+If the company's authority isn't installed on the machine, name its certificate as `ca` above, or in `NODE_EXTRA_CA_CERTS`.
 
 ## 3. Your notes
 
@@ -124,12 +105,9 @@ isorite new ~/notes/my-project
 isorite serve ~/notes/my-project
 ```
 
-`isorite new` makes the folder, empty but for isorite's own `.isorite/`. A folder of notes you have already is
-opened as it is, with `isorite serve`.
+`isorite new` makes the folder, empty but for isorite's own `.isorite/`. A folder of notes you have already is opened as it is, with `isorite serve`.
 
-How you want the base kept (your notation, the level, the language, how notes are named) goes in `AGENTS.md` at
-the top of the notes, which Iso and the terminal's agent are both given. Edit it in Iso's settings, the icon at the
-right of its pane's header, or in any editor. Iso may offer a line for it when you say how you want things done.
+How you want the base kept (your notation, the level, the language, how notes are named) goes in `AGENTS.md` at the top of the notes, which Iso and the terminal's agent are both given. Edit it in Iso's settings, the icon at the right of its pane's header, or in any editor. Iso may offer a line for it when you say how you want things done.
 
 It prints a link to click: `http://localhost:4767/`. isorite keeps what it needs in the folder's `.isorite/`.
 
@@ -140,8 +118,7 @@ cd ~/code/my-project
 isorite term ~/notes/my-project
 ```
 
-It prints the same link, and which models the terminal uses. OpenCode uses the provider above, through isorite. More
-is in [terminal.md](terminal.md).
+It prints the same link, and which models the terminal uses. OpenCode uses the provider above, through isorite. More is in [terminal.md](terminal.md).
 
 ## 5. Several bases, and the agent's memory (optional)
 
@@ -151,11 +128,7 @@ isorite bases               # the bases this machine knows: each one is listed t
 isorite bases lend <name>   # lend one to every session (isorite bases keep <name> stops)
 ```
 
-One isorite server holds every base it is asked for. Each base's page is the same link with `?base=<name>`, and the
-base's name before the first pane's name switches between them; Ctrl-click opens one in a tab of its own. A base
-**lent** to every session can be read by every base's agent and Iso, and written by the agent, its words marked as
-its own. The memory is one: what the agent learns about you and your tools, kept across projects, as its
-`AGENTS.md` says. The list is in `~/.config/isorite/bases.toml`, beside `config.toml`:
+One isorite server holds every base it is asked for. Each base's page is the same link with `?base=<name>`, and the base's name before the first pane's name switches between them; Ctrl-click opens one in a tab of its own. A base **lent** to every session can be read by every base's agent and Iso, and written by the agent, its words marked as its own. The memory is one: what the agent learns about you and your tools, kept across projects, as its `AGENTS.md` says. The list is in `~/.config/isorite/bases.toml`, beside `config.toml`:
 
 ```toml
 [memory]
@@ -169,30 +142,16 @@ lend = true
 isorite model
 ```
 
-It says which model is installed and where, or fetches it (53 MB, once): from npm, else from a release on GitHub,
-else from Hugging Face. Without it, Iso searches by words and follows links. A mirror of the release is tried
-first when `ISORITE_MODEL_BASE_URL` names the folder its `.tgz` is in, and `isorite model --url <address>` fetches
-from that one address alone. Where none of those can be reached, `isorite model` prints the file's address and
-SHA-256: fetch it another way, and run `isorite model --from <the .tgz>`. Or copy the model's folder from a machine
-that has it (`isorite model` there says where it is) and run `isorite model --from <folder>`. Any compatible model works the same way: an ONNX model that gives 384 numbers,
-with its `tokenizer.json` (for example all-MiniLM-L6-v2, with `{"pooling": "mean"}` in an `isorite-model.json`
-beside it).
+It says which model is installed and where, or fetches it (53 MB, once): from npm, else from a release on GitHub, else from Hugging Face. Without it, Iso searches by words and follows links. A mirror of the release is tried first when `ISORITE_MODEL_BASE_URL` names the folder its `.tgz` is in, and `isorite model --url <address>` fetches from that one address alone. Where none of those can be reached, `isorite model` prints the file's address and SHA-256: fetch it another way, and run `isorite model --from <the .tgz>`. Or copy the model's folder from a machine that has it (`isorite model` there says where it is) and run `isorite model --from <folder>`. Any compatible model works the same way: an ONNX model that gives 384 numbers, with its `tokenizer.json` (for example all-MiniLM-L6-v2, with `{"pooling": "mean"}` in an `isorite-model.json` beside it).
 
 ## When something fails
 
-If a gateway is down for a moment (it answers 502, 503 or 504, or drops the connection), Iso and the terminal ask
-it again, up to three times. When it stays down, Iso says it's likely the gateway, not your settings, and the ↻
-under the turn sends it again.
+If a gateway is down for a moment (it answers 502, 503 or 504, or drops the connection), Iso and the terminal ask it again, up to three times. When it stays down, Iso says it's likely the gateway, not your settings, and the ↻ under the turn sends it again.
 
 ```sh
 isorite doctor ~/notes/my-project
 ```
 
-It checks, in turn: the configuration, how Node reaches the network (the proxy, the authorities), the provider
-(its list of models, a reply of a few words from each model, and a tool call: a few hundred tokens in all), the
-terminal (OpenCode 2, the port, the models it will use), and the notes. Each line says what failed, and what to
-change. `--offline` asks the provider nothing.
+It checks, in turn: the configuration, how Node reaches the network (the proxy, the authorities), the provider (its list of models, a reply of a few words from each model, and a tool call: a few hundred tokens in all), the terminal (OpenCode 2, the port, the models it will use), and the notes. Each line says what failed, and what to change. `--offline` asks the provider nothing.
 
-`isorite doctor --report` gives all of it as one block, with the configuration and the environment it read. The
-key, passphrases and any other secrets are shown only by their length. Paste it to whoever is helping, or to an AI
-helping you: [setup-for-agents.md](setup-for-agents.md) is written for it, and `isorite help setup` prints it.
+`isorite doctor --report` gives all of it as one block, with the configuration and the environment it read. The key, passphrases and any other secrets are shown only by their length. Paste it to whoever is helping, or to an AI helping you: [setup-for-agents.md](setup-for-agents.md) is written for it, and `isorite help setup` prints it.

package/docs/terminal.md

@@ -1,8 +1,6 @@
 # isorite beside your code: the terminal
 
-How to use isorite on a project of your own. OpenCode 2 is the coding agent in your terminal; isorite gives it your
-notes, and shows its session in Iso's pane in the browser. From there you can ask it things, give it notes and
-passages, stop it, and answer what it asks before it acts.
+How to use isorite on a project of your own. OpenCode 2 is the coding agent in your terminal; isorite gives it your notes, and shows its session in Iso's pane in the browser. From there you can ask it things, give it notes and passages, stop it, and answer what it asks before it acts.
 
 Setting isorite up the first time, or at work behind a company's gateway, is in [setup.md](setup.md).
 
@@ -10,19 +8,12 @@ Setting isorite up the first time, or at work behind a company's gateway, is in
 
 - **Node 24** or later.
 - **isorite**: `npm i -g isorite`.
-- **OpenCode 2**: `isorite opencode` installs the version isorite is tested with in `~/.config/isorite/opencode-cli`,
-  for isorite alone, leaving the global npm prefix (and an OpenCode 1 you use) as it is. `isorite term` offers to
-  when it finds none. One installed yourself (`npm i -g @opencode/cli`, as `opencode2`) is found too, or name one
-  with `ISORITE_OPENCODE=/path/to/opencode`.
-- A model provider, set once in `~/.config/isorite/config.toml`: see [setup.md](setup.md). `isorite doctor` checks
-  all of this.
+- **OpenCode 2**: `isorite opencode` installs the version isorite is tested with in `~/.config/isorite/opencode-cli`, for isorite alone, leaving the global npm prefix (and an OpenCode 1 you use) as it is. `isorite term` offers to when it finds none. One installed yourself (`npm i -g @opencode/cli`, as `opencode2`) is found too, or name one with `ISORITE_OPENCODE=/path/to/opencode`.
+- A model provider, set once in `~/.config/isorite/config.toml`: see [setup.md](setup.md). `isorite doctor` checks all of this.
 
 ## Your notes for the project
 
-Keep the project's notes in a folder of their own, for example `~/notes/<project>`. It can start empty:
-`isorite new ~/notes/<project>` makes it. isorite
-keeps what it needs in the folder's `.isorite/` (the journals of every change, and its settings), made the first
-time the folder is opened. Commit `.isorite/` with the notes, if they're in git.
+Keep the project's notes in a folder of their own, for example `~/notes/<project>`. It can start empty: `isorite new ~/notes/<project>` makes it. isorite keeps what it needs in the folder's `.isorite/` (the journals of every change, and its settings), made the first time the folder is opened. Commit `.isorite/` with the notes, if they're in git.
 
 ## Starting it
 
@@ -31,8 +22,7 @@ cd ~/code/my-project
 isorite term ~/notes/my-project
 ```
 
-This starts the isorite server for the notes (unless one is running on port 4767; `--port <n>` for another), and
-OpenCode's own server, on this machine, with a password of its own. Then it opens the terminal on that server.
+This starts the isorite server for the notes (unless one is running on port 4767; `--port <n>` for another), and OpenCode's own server, on this machine, with a password of its own. Then it opens the terminal on that server.
 
 Before OpenCode takes the screen, `isorite term` prints:
 
@@ -41,11 +31,9 @@ isorite: http://localhost:4767/
   the terminal's models: work-large, work-small, as config.toml names them, through the isorite server
 ```
 
-Most terminals let you click the link. It prints the same again when OpenCode exits. Closing the terminal stops
-both servers, if `isorite term` started them.
+Most terminals let you click the link. It prints the same again when OpenCode exits. Closing the terminal stops both servers, if `isorite term` started them.
 
-The first time, the folder you started in is named as the notes' repository in `.isorite/settings.toml`, so that
-code links in the notes point into it.
+The first time, the folder you started in is named as the notes' repository in `.isorite/settings.toml`, so that code links in the notes point into it.
 
 ### Over SSH
 
@@ -55,73 +43,42 @@ code links in the notes point into it.
 ssh -L 4767:localhost:4767 <the machine>
 ```
 
-Then open `http://localhost:4767/` on your own. Over SSH, `isorite term` prints this command too. Any local port
-works (`-L 9000:localhost:4767`, then `http://localhost:9000/`).
+Then open `http://localhost:4767/` on your own. Over SSH, `isorite term` prints this command too. Any local port works (`-L 9000:localhost:4767`, then `http://localhost:9000/`).
 
 ## In the browser
 
-Open the link, or type `/web` in the terminal. OpenCode runs a web page of its own as well, on another port. It
-asks for a password nobody was given, so isorite's `/web` opens isorite's page instead (OpenCode's pairing is
-`/pair`), and `isorite term` says on which port OpenCode's page is, so that you don't open it.
-
-While the terminal runs, Iso's pane header has two more switches beside *Iso may edit the notes*:
-*Iso may edit the project's files* (Alt+F) and *Iso may run commands* (Alt+R). With either on, the pane is the
-terminal's session:
-
-- **The session:** each prompt (asked in the terminal, or from here), what the agent says, and a line for each thing
-  it does. A command opens on its output, a file on its diff, a look-up in your notes on the note.
-- **Asking from here:** what you type goes to the terminal's session, with what you gave Iso (hold a note on the
-  Atlas, or select a passage and send it to Iso): notes by name, for the agent to read with isorite's tools, and
-  passages as they are. Escape, or the square, stops it.
-- **Permissions:** when OpenCode asks before doing something, the same question is in the pane: allow once, always
-  allow, or don't allow. Answered in either place, it's gone from both.
-- **Notes the agent changes** are written at once, under its name. Turn on provenance in the Note pane's header to
-  see the agent's words marked, and the timeline to put a note back.
-
-With both off, the pane is Iso's own again. The ≡ in its header, or a click on its gauge, opens what Iso is sent:
-a row for each part, with its size. These are the notes you gave and the notes Iso read, the conversation's turns,
-and what is always sent. Iso keeps a note it read in hand, and sets it aside after three turns unused, as a line it
-can read again. A click switches a row on or off. At the head of the conversation, one icon sums the earlier turns
-up into a briefing sent instead of them, and another starts a new conversation from that briefing. Iso sums up on
-its own only when a turn would be more than the model takes.
+Open the link, or type `/web` in the terminal. OpenCode runs a web page of its own as well, on another port. It asks for a password nobody was given, so isorite's `/web` opens isorite's page instead (OpenCode's pairing is `/pair`), and `isorite term` says on which port OpenCode's page is, so that you don't open it.
+
+While the terminal runs, Iso's pane header has two more switches beside *Iso may edit the notes*: *Iso may edit the project's files* (Alt+F) and *Iso may run commands* (Alt+R). With either on, the pane is the terminal's session:
+
+- **The session:** each prompt (asked in the terminal, or from here), what the agent says, and a line for each thing it does. A command opens on its output, a file on its diff, a look-up in your notes on the note.
+- **Asking from here:** what you type goes to the terminal's session, with what you gave Iso (hold a note on the Atlas, or select a passage and send it to Iso): notes by name, for the agent to read with isorite's tools, and passages as they are. Escape, or the square, stops it.
+- **Permissions:** when OpenCode asks before doing something, the same question is in the pane: allow once, always allow, or don't allow. Answered in either place, it's gone from both.
+- **Notes the agent changes** are written at once, under its name. Turn on provenance in the Note pane's header to see the agent's words marked, and the timeline to put a note back.
+
+With both off, the pane is Iso's own again. The ≡ in its header, or a click on its gauge, opens what Iso is sent: a row for each part, with its size. These are the notes you gave and the notes Iso read, the conversation's turns, and what is always sent. Iso keeps a note it read in hand, and sets it aside after three turns unused, as a line it can read again. A click switches a row on or off. At the head of the conversation, one icon sums the earlier turns up into a briefing sent instead of them, and another starts a new conversation from that briefing. Iso sums up on its own only when a turn would be more than the model takes.
 
 ## The agent's memory, and other bases
 
-`isorite memory` makes a base for the agent's memory, lent to every session (see [setup.md](setup.md), §5). Every
-tool the agent has takes an optional `base`: one of the bases lent to it, named by `brief_base`. Without it, a tool
-acts on the base the terminal is for. A note in another base can also be named `memory:tools/opencode`. The agent is
-told which bases are lent, and each base's `AGENTS.md` says how it is kept; the memory's says what to keep, and how.
+`isorite memory` makes a base for the agent's memory, lent to every session (see [setup.md](setup.md), §5). Every tool the agent has takes an optional `base`: one of the bases lent to it, named by `brief_base`. Without it, a tool acts on the base the terminal is for. A note in another base can also be named `memory:tools/opencode`. The agent is told which bases are lent, and each base's `AGENTS.md` says how it is kept; the memory's says what to keep, and how.
 
-A second `isorite term`, for another project, on the same port, adds its base to the server that is running rather
-than starting another; a server `isorite term` started stops when the last terminal using it is done. Over MCP
-(`isorite mcp`) the tools are the same.
+A second `isorite term`, for another project, on the same port, adds its base to the server that is running rather than starting another; a server `isorite term` started stops when the last terminal using it is done. Over MCP (`isorite mcp`) the tools are the same.
 
-To watch the memory learn, open it beside the project: choose `memory` from the base's name at the left of the
-first pane's header (Ctrl-click for a tab of its own). What the agent reads there lights on its Atlas; what it
-writes appears, marked as the agent's.
+To watch the memory learn, open it beside the project: choose `memory` from the base's name at the left of the first pane's header (Ctrl-click for a tab of its own). What the agent reads there lights on its Atlas; what it writes appears, marked as the agent's.
 
 ## The models
 
-The terminal uses Iso's provider, as `config.toml` names it ([setup.md](setup.md)): the `[tiers]` models, `mid` its
-default. OpenCode asks the isorite server, which passes each request on to the provider with the key, the client
-certificate, the headers and the query `config.toml` names. OpenCode is given none of them, only the isorite
-server's token.
+The terminal uses Iso's provider, as `config.toml` names it ([setup.md](setup.md)): the `[tiers]` models, `mid` its default. OpenCode asks the isorite server, which passes each request on to the provider with the key, the client certificate, the headers and the query `config.toml` names. OpenCode is given none of them, only the isorite server's token.
 
-`ISORITE_GATEWAY_URL`, `ISORITE_GATEWAY_MODELS` (comma-separated) and `ISORITE_GATEWAY_KEY`, when set, are used
-instead, and OpenCode asks that address itself. With no key and no certificate in `config.toml`, OpenCode uses its
-own models; `isorite term` says which.
+`ISORITE_GATEWAY_URL`, `ISORITE_GATEWAY_MODELS` (comma-separated) and `ISORITE_GATEWAY_KEY`, when set, are used instead, and OpenCode asks that address itself. With no key and no certificate in `config.toml`, OpenCode uses its own models; `isorite term` says which.
 
 OpenCode doesn't know a gateway's prices, so Iso's pane shows the session's tokens rather than its cost.
 
 ## OpenCode's settings
 
-OpenCode is given the base's `AGENTS.md` (in its `instructions`), when `isorite term` is named the notes, and the
-knowledge base's ways through `brief_base`: how a note is written and linked, and how the base is kept.
+OpenCode is given the base's `AGENTS.md` (in its `instructions`), when `isorite term` is named the notes, and the knowledge base's ways through `brief_base`: how a note is written and linked, and how the base is kept.
 
-isorite keeps OpenCode's settings in `~/.config/isorite/opencode/`, rewritten at each start, so your own OpenCode
-settings are never read or changed. Anything of your own goes in `~/.config/isorite/opencode/local.json`, which is
-never rewritten, and is laid over what isorite writes. For example, to have OpenCode ask before every command (by
-default it runs them):
+isorite keeps OpenCode's settings in `~/.config/isorite/opencode/`, rewritten at each start, so your own OpenCode settings are never read or changed. Anything of your own goes in `~/.config/isorite/opencode/local.json`, which is never rewritten, and is laid over what isorite writes. For example, to have OpenCode ask before every command (by default it runs them):
 
 ```json
 { "permissions": [{ "action": "shell", "resource": "*", "effect": "ask" }] }
@@ -129,20 +86,11 @@ default it runs them):
 
 ## Without the internet
 
-Once installed, isorite needs no network, as long as the model's address in `config.toml` is one you can reach (a
-gateway, or a model served on your own machine). What it fetches, it fetches once:
+Once installed, isorite needs no network, as long as the model's address in `config.toml` is one you can reach (a gateway, or a model served on your own machine). What it fetches, it fetches once:
 
 - isorite and OpenCode, from npm: through your company's npm mirror, if it has one.
-- The model for search by meaning (optional): `isorite model` gets it from npm too (`isorite-model-granite`), so the
-  same mirror serves it; else from its release on GitHub, else from Hugging Face. On a machine with none of them,
-  copy its folder from one that has it (`isorite model` there says where), or download the package from
-  `https://github.com/lachlanjs/isorite/releases/tag/model-granite-1.0.0` and unpack it, then
-  `isorite model --from <folder>`. Granite's files are checked against their SHA-256; any other compatible model is
-  checked by use ([setup-for-agents.md](setup-for-agents.md) says which).
+- The model for search by meaning (optional): `isorite model` gets it from npm too (`isorite-model-granite`), so the same mirror serves it; else from its release on GitHub, else from Hugging Face. On a machine with none of them, copy its folder from one that has it (`isorite model` there says where), or download the package from `https://github.com/lachlanjs/isorite/releases/tag/model-granite-1.0.0` and unpack it, then `isorite model --from <folder>`. Granite's files are checked against their SHA-256; any other compatible model is checked by use ([setup-for-agents.md](setup-for-agents.md) says which).
 
 ## Who can reach it
 
-OpenCode's server listens on this machine only (127.0.0.1), and only the isorite server talks to it. The isorite
-server listens on this machine only too, unless you put it on your tailnet (`tailscale serve`). Then anyone on your
-tailnet who opens the page can ask the agent to act in your project, as they could already edit your notes. The
-provider is passed on to OpenCode only on this machine, never over the tailnet.
+OpenCode's server listens on this machine only (127.0.0.1), and only the isorite server talks to it. The isorite server listens on this machine only too, unless you put it on your tailnet (`tailscale serve`). Then anyone on your tailnet who opens the page can ask the agent to act in your project, as they could already edit your notes. The provider is passed on to OpenCode only on this machine, never over the tailnet.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isorite",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "An agentic harness for understanding: your notes as a knowledge base, an Atlas of them, an agent that reads them, and study.",
   "license": "MIT",
   "type": "module",