@bendyline/gezel-service 1.0.4 → 1.0.6

package/dist/handboek-content/conceptual/connected-apps.md

@@ -20,9 +20,11 @@ Apps speak to gezel using the same "OpenAI-style" language most AI tools already
 
 ## Codex and other agent harnesses
 
-The authenticated address also serves the OpenAI **Responses API** at `/v1/responses`. That lets a harness such as Codex keep ownership of its coding tools, sandbox, approvals, and conversation loop while a model installed in gezel supplies the inference.
+The authenticated address also serves the OpenAI **Responses API** at `/v1/responses`. That lets a harness such as Codex keep ownership of its coding tools, sandbox, approvals, and conversation loop while a model installed in gezel supplies the inference. VS Code, OpenCode, and [pi](https://pi.dev) connect the same way through the chat endpoint — see [VS Code](#vs-code), [OpenCode](#opencode), and [pi](#pi) below.
 
-For Codex, use **Use a gezel in Codex** in this Settings screen. Gezel creates an isolated `gezel-local` Codex profile, a model catalog, and a dedicated revocable credential. It does not edit Codex's main configuration, authentication, conversations, sandbox rules, or approval settings. Start Codex with the command shown on the card (`codex --profile gezel-local`).
+For Codex, use **Use Gezel in Codex** in this Settings screen. Gezel creates an isolated `gezel-local` Codex profile, a model catalog, and a dedicated revocable credential. It does not edit Codex's main configuration, authentication, conversations, sandbox rules, or approval settings. Start Codex with the command shown on the card (`codex --profile gezel-local`).
+
+If the card says **Needs attention**, the `gezel-local` profile on disk was hand-edited or was written by a different Gezel installation, so gezel will not touch it. **Repair Codex setup** writes a fresh profile pointed at this copy of gezel and keeps the old file beside it as `gezel-local.config.toml.backup`. The one conflict repair cannot resolve is another connected app holding the Codex credential identity — revoke that app first.
 
 Keep Gezel running while Codex uses the local model. If you want the model bridge available without keeping the desktop window open, turn on Gezel's daemon autostart setting.
 
@@ -34,8 +36,68 @@ Codex custom providers use `wire_api = "responses"`. The managed profile also se
 
 The setup card puts eligible gezels first. Choosing one gives Codex that gezel's character (`about.md`), effective local model, and tuning while Codex keeps its own tools, sandbox, approvals, and conversation loop. The profile stores the stable gezel id, so renaming the gezel does not break the connection. Raw installed models remain available in a separate fallback group for users who want inference without a gezel persona.
 
+The gezel you choose on the card is the profile's *default*, not its only option: gezel writes a model catalog listing every eligible gezel and local model, so Codex's own model picker shows the whole crew and you can switch between them inside a Codex session.
+
 A gezel appears here only when its effective local model is installed and can participate in Codex's caller-executed tool loop. The facade does not attach Gezel chat sessions, memories, project context, or MCP tools, and it does not silently route unknown aliases through the fallback gezel. It also refuses `codex-cli:` / `anthropic-cli:` targets because those are full nested agent harnesses rather than inference providers.
 
+## VS Code
+
+**Use Gezel in VS Code** uses VS Code's built-in custom-endpoint support, so it does not install or require the Gezel VSIX. Gezel adds one provider named `Gezel` to the selected VS Code profile's `chatLanguageModels.json`. Every eligible gezel and raw local model then appears in VS Code's native model picker while VS Code keeps control of its agent tools, permissions, and conversations.
+
+This is a shared profile file, so setup uses a narrow merge: entries belonging to other providers are preserved, and **Remove setup** removes only Gezel's entry. Named VS Code profiles have separate files; choose the profile you want before setup. To move the integration later, clear it and set up the other profile.
+
+There is one important tradeoff. Without an extension, VS Code cannot give Gezel access to its encrypted extension secret store. The dedicated VS Code credential is therefore written as plain text in `chatLanguageModels.json`. Gezel limits the effect of that exposure: the credential has inference-only scope, talks to a VS Code-only listener on `127.0.0.1`, reaches only chat completions and model discovery, and is individually revocable. It cannot read Gezel projects, files, terminals, chats, or settings. The profile file is written with private file permissions where the operating system supports them.
+
+The listener's port stays stable even though the ordinary Gezel daemon port can rotate. Keep Gezel running while VS Code uses the models; daemon autostart makes that available without keeping the desktop window open. Gezel periodically reconciles the provider entry, so installing or removing a model, changing a gezel, or changing an effective context limit updates VS Code's model picker automatically.
+
+If the card says **Needs attention**, Gezel could not prove it owns the existing provider entry or could not safely parse the shared file. **Repair VS Code setup** first saves the complete existing file beside it as `chatLanguageModels.json.backup`, then replaces the conflicting Gezel entry. Other parseable provider entries remain in place. If the entire file is damaged, the backup is the recoverable original and the repaired file contains only the working Gezel provider.
+
+## OpenCode
+
+[OpenCode](https://opencode.ai) connects the same way, through **Use Gezel in OpenCode** in this Settings screen. Gezel writes its own settings file, a model list covering your eligible crew, and a dedicated revocable credential. It never edits your own OpenCode configuration, sessions, or permissions — instead it hands you a command that points OpenCode at the Gezel-owned file for that run:
+
+```
+OPENCODE_CONFIG=<path shown on the card> opencode
+```
+
+On Windows the card shows the PowerShell form of the same command. OpenCode merges configuration files rather than replacing them, so your own settings still apply; Gezel only adds a provider named `gezel`.
+
+The gezel you choose is the one OpenCode starts with. Every eligible gezel and local model is listed in the file, so OpenCode's own model picker shows the whole crew and you can switch inside a session. Gezel also pins OpenCode's *small* model — the one it uses for titles and summaries — to the same choice, so a machine set up for local inference never quietly reaches for a cloud provider you have not configured.
+
+### Without the command
+
+**Add to OpenCode** writes one further file — `gezel.js`, in OpenCode's own `plugins` folder — and from then on the `gezel` provider is in every OpenCode session on that computer, no command needed. This is the one file Gezel places outside its own home, so it is worth being precise about what it is: a file Gezel *adds and owns*, never an edit to a file of yours. It holds no password. It reads Gezel's settings and credential when OpenCode starts, and does nothing at all when Gezel is not running or not set up — an unrelated OpenCode session is never affected either way. `opencode --pure` starts without it, and without any other plugin.
+
+It deliberately does not change which model OpenCode starts with: that stays your choice in OpenCode's own model picker, because this file loads in every project. To check it took effect, run `opencode models` — the crew appears under `gezel/`.
+
+**Remove from OpenCode** deletes it, and removing the whole setup deletes it too. If a `gezel.js` written by a different Gezel installation — or edited by hand — is already there, Gezel says so and leaves it exactly as it is; **Replace OpenCode plugin** keeps the old one beside it as `gezel.js.backup`.
+
+If the card says **Needs attention**, the managed file was hand-edited or was written by a different Gezel installation, so gezel will not touch it. **Repair OpenCode setup** writes a fresh file and keeps the old one beside it as `opencode.json.backup`. The one conflict repair cannot resolve is another connected app holding the OpenCode credential identity — revoke that app first.
+
+Because the credential lives in its own file and the config references it by path, revoking the OpenCode entry under Connected Apps immediately stops it from using the bridge, and no secret is ever copied into a project or shell profile.
+
+As with Codex, a gezel appears here only when its effective local model is installed and can take part in a caller-executed tool loop, one-click setup needs the desktop and the Gezel service on the same computer, and Gezel must stay running while OpenCode uses the model. The bridge carries only inference: the credential grants no access to Gezel projects, files, terminals, or settings.
+
+## pi
+
+[pi](https://pi.dev) is a coding agent that keeps its own tools, permissions, and conversation loop, and lets a provider supply the model. Gezel writes a small **extension** of its own — plus the model list that extension reads — and hands you a command that loads it for that run:
+
+```
+pi -e <path shown on the card>
+```
+
+Both files live in Gezel's own folder, so this mode writes nothing into pi at all. `pi` merges what an extension registers with your own configuration; Gezel only adds a provider named `gezel`, and never touches your `models.json`, settings, or sessions.
+
+### Without the command
+
+**Add to pi** copies that same extension into pi's own `extensions` folder, and from then on the `gezel` provider is in every pi session on that computer. It is a file Gezel *adds and owns*, never an edit to a file of yours. It holds no password: it reads Gezel's model list and credential when pi starts, and quietly does nothing when Gezel is not running. `pi -ne` starts without it, and without any other extension.
+
+To check it took effect, run `pi --list-models` — the crew appears under `gezel/`. **Remove from pi** deletes it, and removing the whole setup deletes it too. If a `gezel.js` written by a different Gezel installation — or edited by hand — is already there, Gezel says so and leaves it alone; **Replace pi extension** keeps the old one beside it as `gezel.js.backup`.
+
+Unlike the Codex profile, nothing here pins pi's own default model. The extension loads in every project, so which model pi starts with stays your choice in its model picker. If you point pi somewhere else with `PI_CODING_AGENT_DIR` in your shell, note that the gezel service cannot see a variable set only in your login shell — the card shows the folder it actually resolved.
+
+As with the others, a gezel appears here only when its effective local model is installed and can take part in a caller-executed tool loop, one-click setup needs the desktop and the Gezel service on the same computer, and Gezel must stay running while pi uses the model.
+
 ## Who answers: gezel choices and the fallback
 
 Gezel presents your crew to connected apps as model choices, including each gezel's name and role. When an app chooses one, that gezel answers with their character, model, and settings.

package/dist/handboek-content/conceptual/night-shift.md

@@ -13,8 +13,13 @@ you. Reviews get written, indexes get refreshed, translations catch up.
 In the morning there's a report waiting instead of a backlog.
 
 The moon in the title bar shows when a shift is running and what it's
-working on. You can also start one manually — stepping out for lunch is a
-perfectly good night.
+working on. It also says **when the period started and when it ends** —
+a scheduled shift closes with its window, a manual one runs until the
+work is done — and keeps a **running tally** of what the shift has got
+through: tasks finished, files indexed and reviewed, files written,
+questions raised for you. During the day the same line tells you when
+the next window opens. You can start a shift manually too — stepping out
+for lunch is a perfectly good night.
 
 ## Roles that bring their own night work
 
@@ -47,6 +52,21 @@ language, for instance, is a **project property** — set once in project
 Settings (or the first time you enable the translation run) and reused by
 every run after that.
 
+## Keeping your subscription quota safe
+
+Night work on a Claude, Codex, or Copilot subscription spends the same
+quota you use during the day, so the Night Shift keeps a **quota
+reserve**: by default it stops sending work to a subscription once you're
+within 20% of a quota, leaving the rest for you. You can adjust that
+floor in Settings → Night Shift, or add a daily reserve that scales with
+the time left — 10% a day with four days until your quota resets keeps
+the last 40% for you.
+
+Work that's already running always finishes; only new work is held. Held
+work resumes on its own when a quota window resets (if the machine is
+awake) or the next night, and the moon menu says what's being protected
+and why. Gezels on local models spend nothing and are never held.
+
 ## The morning review
 
 When the window closes, gezel gathers what the shift accomplished and

package/dist/handboek-content/conceptual/welcome.md

@@ -9,6 +9,8 @@ summary: A crew of AI companions that works for you, from your own computer.
 
 ![gezel-mark](../assets/gezel-mark.png)
 
+[Watch the Gezel playlist on YouTube](https://www.youtube.com/watch?v=KCdgV5YFDzI&list=PLaD2JMwhPJ3w) for a quick introduction and guided tours.
+
 *Gezel* is Dutch for a companion journeyman. A **gezel** is an AI teammate who works for you: each one has a name, a face, a role, a set of tools, and its own story that shapes how it thinks. They remember what you've done together and get better over time as you work with them.
 
 ## A crew, not a chat

package/dist/handboek-content/technical/where-files-live.md

@@ -28,6 +28,8 @@ Everything gezel knows lives in one folder — the **gezel home** — as plain f
                       pictures, and recordings (rebuilt automatically —
                       safe to delete, not a place to put your own files)
   documents/          the shared library
+  ambient/            ambient dashboard images (dated PNGs + latest.png),
+                      made to be shown as wallpaper or lock screen
   history.jsonl       the audit log
   logs/               service logs (rolling)
 ```
@@ -38,4 +40,4 @@ Everything gezel knows lives in one folder — the **gezel home** — as plain f
 - **Back up or sync the whole folder.** Copying the folder copies your entire workshop.
 - **Edit with care.** Character files (`about.md`) and documents are meant to be edited — from the app or any text editor. For structured files (`config.json`, thread files), prefer the app so nothing gets malformed.
 
-A few subfolders are machinery rather than your data — `runtime/`, `service/`, `bin/`, `index/`, `logs/` hold the service's own working state and rebuildable caches. Leave those to gezel; deleting them is at worst an inconvenience, never data loss.
+A few subfolders are machinery rather than your data — `runtime/`, `service/`, `bin/`, `index/`, `logs/` hold the service's own working state and rebuildable caches. Leave those to gezel; deleting them is at worst an inconvenience, never data loss. The `ambient/` folder is regenerated too — point your wallpaper or lock-screen slideshow at it freely, but don't store your own images there.

package/dist/handboek-content/whats-new/1.26226.md

@@ -15,17 +15,14 @@ Also: a new model - Qwen 3.8 27B Q4 - is now available. We're doing more testing
 
 ## Problems in your files became work you can hand off
 
-Gezel's *boekwachter* — the keeper of the books, the crew member who reads through a project and notes what looks wrong — used to produce a list. You read it, and then it was on you.
-
-Now each finding is a tracked issue with its own reference (`BW-1`, `BW-2`, and so on) that survives restarts and re-scans. Each one is **open**, **in progress**, **resolved** or **dismissed**, and you move it between those yourself. Closed ones fold away until you ask to see them.
-
-The part that matters: there is now a **Fix this** button. Press it and gezel opens a dialog that has already worked out what kind of gezel this file needs — a writer for a document, a designer for an image, a developer for code, a researcher for a spreadsheet — and offers you the ones on your crew who fit. Choose one and it becomes a task, linked back to the issue, so the file, the finding and the work are the same thread rather than three things you hold in your head. Each file also shows a plain health score out of ten and the reason behind it.
+Gezel's *bo
+re is now a **Fix this** button. Press it and gezel opens a dialog that has already worked out what kind of gezel this file needs — a writer for a document, a designer for an image, a developer for code, a researcher for a spreadsheet — and offers you the ones on your crew who fit. Choose one and it becomes a task, linked back to the issue, so the file, the finding and the work are the same thread rather than three things you hold in your head. Each file also shows a plain health score out of ten and the reason behind it.
 
 ## The terminal app caught up
 
 If you use `gezel` from a terminal, this release is mostly for you.
 
-- Many stability fixes for the npm '@bendyline/gezel-cli' package and command line
+- Many stability fixes for the npm '@bendyline/gezel-cli' package and command line. See the docs at https://gezel.com/docs/cli-reference/ for more information.
 - `/open` — type it in a chat and gezel offers you the files that conversation just touched, plus the project's artifacts and workspace folders, and opens the one you pick. This works in the desktop app's message box too.
 - `gezel mode <read-only|reactive|reactive+tasks|full-play>`, or `/mode` inside a session — the same four settings for how much gezel is allowed to do on its own that the app has, now in one word from the command line.
 - `gezel do <craftbook>` and `/do` — start a piece of standard work (a *craftbook* is gezel's word for a written-down procedure) without leaving the terminal.
@@ -80,7 +77,7 @@ While you are on the models screen, every catalog model now says **who made it a
 - **The Output Pane API (**`window.gezel`**) is documented and at version 1.** Interactive pages pinned into a project's Output pane get a frozen `gezel` object with `page`, `tools`, `data` and `ui` — reads are declared in the project type's manifest and enforced per request on the server, so a page can never read past its declaration. The earlier hand-rolled postMessage pattern keeps working.
 - **Pull request files and diffs are properly paginated** for tools that read them, so a large PR no longer silently loses its later files.
 - **Dependency operations in the repository are leased.** `pnpm deps:status` diagnoses, `pnpm deps:install` adds only what is genuinely missing, and `pnpm deps:repair` is the one explicit reconciliation path; builds and tests hold a shared read lease and can run alongside each other.
-- `node-pty`** is now an optional dependency**, so an npm install of gezel no longer fails on machines without a build toolchain.
+- `node-pty`\*\* is now an optional dependency\*\*, so an npm install of gezel no longer fails on machines without a build toolchain.
 
 ## Anything to do?
 

package/dist/handboek-content/whats-new/1.26230.md

@@ -0,0 +1,100 @@
+---
+id: whats-new/1.26230
+title: 1.26230 — 18 August 2026
+order: -26230
+summary: A live dashboard on your desktop wallpaper, disk space you can see and reclaim, backup and restore, your local models inside VS Code, and Qwen 3.8 27B tops the scorecard.
+---
+
+# 1.26230 — 18 August 2026
+
+Four days since **1.26226**, and a big four days.
+
+If you read only one thing: gezel can now paint a picture of your whole workshop onto your desktop wallpaper, you can finally see what is using your disk and get it back, and the models running on your own machine can be used from VS Code, OpenCode and pi without leaving those apps.
+
+## Your desktop can show you the workshop
+
+This is new, and it is easier to see than to describe.
+
+Turn on **Settings → Ambient dashboard** and the *meester* — the gezel who acts as your guildmaster and front door — periodically composes a single-page summary of everything going on: your projects, what the crew has been doing, what is waiting on you. It renders to an image. On the desktop app, that image then becomes your wallpaper, and it keeps itself current.
+
+It is off by default and stays off until you ask, because each render costs a model call and a page render. When you do turn it on, gezel captures your existing wallpaper first and puts it back if you ever turn the feature off.
+
+It also takes the picture seriously. The image is built at your primary display's exact physical pixel size, so your desktop's Fill or Zoom setting cannot crop it, and the content is kept clear of menu bars, notches, docks and taskbars while the artwork still runs to the edges. There are eleven visual themes to pick from — the default is *gezellig*, a warm dark one — and you can choose the refresh interval, starting at every fifteen minutes.
+
+## Disk space you can see, clean up, and back up
+
+Gezel keeps models, engines, caches, projects and conversations on your computer, which is the point, but until now the only way to find out what that cost you was to go looking in folders.
+
+**Settings → About** now has a storage card that breaks the whole install down by category — downloaded models, native engines, engine caches, toolsets, projects, gezels, documents, git checkouts, derived caches, backups — with a size against each. From there:
+
+- **Clean up** walks you through what is safe to remove, category by category, with the space you would get back shown before you commit. Anything gezel can rebuild on its own is offered first; the things that are genuinely yours are the ones it asks hardest about.
+- **Back up** writes your crew, projects, documents and settings to a single file you choose.
+- **Restore** reads one of those files back, shows you exactly what it found and what it would change, and only then applies it.
+
+If you use gezel from a terminal, the same three are there as `gezel cleanup`, `gezel backup <file>` and `gezel restore <file>`, each with a preview and a confirmation before anything is written or deleted.
+
+And if you ever uninstall gezel, the prompts now point you at both of these first, rather than letting you find out afterwards.
+
+## The document library is a real project now
+
+The shared document library — the folder where you keep the things that should be true for every project, like a mission statement or house style — used to be indexed by a separate, thinner mechanism than your projects were. That is gone. The library is now a project in its own right, and inherits everything projects get.
+
+In practice that means library documents are searched the same way project files are: full content indexing, Office documents converted so their text is findable, meaning-based search alongside keyword search, a watcher that notices your edits, and idle-time enrichment. A **Boekwachter** — a librarian gezel — is recruited to the library once, and its presence is what opts the library into the parts that use a model.
+
+Two deliberate limits. The library cannot be deleted or archived, and it does not appear in your list of projects, because it is not a job you work on. And nothing gezel generates is ever written into your documents folder — the search index and any converted copies are kept in gezel's own home. That matters if your documents folder is synced to a cloud drive, which is a normal thing to want and was previously a way to get a database file synced across your machines.
+
+Alongside this, the file browsers throughout the app are now one thing rather than three. Documents, a project's workspace and a project's artifacts all use the same pane, so drag-and-drop import, resizing and collapsing, the list and grid views, previews for files that are not text, and editing with autosave work identically wherever you are. There is also a **show hidden files** toggle, and it remembers your choice.
+
+## Your local models, inside VS Code, OpenCode and pi
+
+Gezel could already lend a model to Codex. Three more join it, each set up from **Settings → Connected Apps** with one button.
+
+**VS Code** needs no extension — it uses VS Code's own support for custom model endpoints, so your crew simply appears in VS Code's native model picker while VS Code keeps its own tools, permissions and conversations. Gezel adds exactly one provider entry to the profile you choose and leaves every other entry alone. One tradeoff is worth knowing before you press it: without an extension, VS Code cannot offer gezel its encrypted secret store, so the credential is written in plain text. Gezel keeps that credential inference-only — it can ask for a completion and list models, and it cannot read your projects, files, terminals, chats or settings — and you can revoke it on its own at any time.
+
+**OpenCode** and **pi** work the same way, and both offer a choice. By default gezel writes its own configuration file and hands you a command that points the tool at it for that run, touching nothing of yours. Or you can press **Add to OpenCode** / **Add to pi**, which installs one small gezel-owned file into that tool's own plugin folder so your crew is available in every session without a command. That file holds no password, does nothing when gezel is not running, and is removed when you remove the setup.
+
+For all four, gezel will not silently overwrite something it did not write. If a file was hand-edited or came from a different gezel installation, the card says **Needs attention** and does nothing until you pick **Repair**, which keeps the original beside it as a `.backup`.
+
+The full detail is in [Connected apps](../conceptual/connected-apps.md).
+
+## Qwen 3.8 27B is measured, and it leads
+
+The [model scorecard](../technical/model-scorecard.md) has a tenth entry, and it is the new best on the board: **qwen3.8-27b-q4** scores 8.2 on the general set and 7.1 on the office-and-knowledge set, ahead of every other model measured on both. That is the follow-up promised in the last release, run the same way as the rest — every job three times on a real machine, checked by a program and read by a separate judge.
+
+Its speed is ordinary for its size, so the choice against something like gemma4-26b is still the usual one: gemma4-26b answers roughly four times faster, qwen3.8-27b answers considerably better. [How we test models](../technical/how-we-test-models.md) explains what these numbers do and do not tell you.
+
+Two accuracy fixes land with it. Gezel's estimate of how much memory a model will actually need is now measured rather than assumed on Apple Silicon, and on the other engines it accounts for the extra memory an image-capable model needs — so a model that fits now reliably fits, and one that does not is refused before it wastes your time. And on Apple Silicon, a model's private "thinking" no longer leaks into the answer you read, and no longer runs several times longer than it should have; on one measured model that was seven times more thinking than the same model on the other engine, for no benefit.
+
+## Smaller things
+
+- **Projects have icons.** A small maker's mark by project type, inherited automatically and overridable per project, in the sidebar and everywhere a project is named.
+- **Messages gezel wrote to itself are labeled "System", not "You"** — handoffs and dispatched work no longer look like something you typed.
+- **Search from the title bar opens instantly** with a loading state, finds names before it finishes searching content, tells you when a lookup failed rather than showing an empty result, matches on a gezel's role as well as its name, and stops repeating the same memory snippet back at you.
+- **The History detail pane is readable.** Labeled sections for context, details, changes and timing, with real dates and durations, instead of a block of raw data.
+- **Night Shift shows a tally** of what the crew actually got through, both so far tonight and last night, in the moon menu.
+- **Task descriptions save as you type**, like every other long-form editor in the app. No more losing a description to a missed Save button.
+- **File mentions in chat now cover workspace files, not only artifacts** — gezel links what it names, and you can open it from the message.
+- **Live speed readings are exact**, per model and per engine, rather than estimated.
+- **Changing a setting no longer kills a running model.** Idle engines are released; work in progress is left alone. Only emergency stop and shutdown still stop everything, and if an engine does go away mid-answer the message now says whether gezel stopped it or it crashed.
+- **Models installed for the whole machine are shown as read-only** rather than offering you a Delete that could not work.
+- **Preview panes follow your theme**, including when it is set to follow the system.
+- **Voice output no longer hangs** on a stalled load or stream; it gives up and says so.
+- **Folder moves keep a snapshot**, listed in Settings with the details openable.
+- **A stale meester pointer now prefers an existing gezel who has the Meester role**, instead of picking whoever came first.
+- Refreshed editor and catalog content packages (squisq 2.8.0, gilde 0.1.36).
+
+## For developers
+
+- **Multi-turn file edits.** MCP file-edit tools take `partial: true` to open a path as a draft: intermediate states are not validated, so a model can build a file larger than one turn's output — and `advance_task_step` / `verify_outcome` stay blocked until the file parses again.
+- **Task gates got much stricter.** Launch parameters interpolate through every gate field, an unresolved `{{param}}` is now an infrastructure error rather than a silent miss, gate attempt budgets survive self-loop reactivation, and a tool failure that never recovered is surfaced in the thread instead of being inferred from a stalled step.
+- **Deterministic fan-out work moved out of prompts.** `publishCorpusBatches` in the script standard library replaces asking a model to retype a batch manifest, and the fan-out input is checked against its source.
+- **Catalog schemas have one export source** plus a freshness test, so a core schema change can no longer drift from committed gilde schemas without failing.
+- **Packaged POSIX launches reuse the installer's service tree** when it matches the shipped bundle and is not writable by the calling account, instead of unpacking a byte-identical copy per account.
+- **New endpoints**: `/api/ambient-dashboard`, `/api/storage/*`, `/api/vscode-setup`, `/api/opencode-setup`, `/api/pi-setup`, all with client methods.
+- **Linux `.deb` packages are verified to be zstd-compressed** at release time, and release manifests are formatted by a script rather than by hand.
+
+## Anything to do?
+
+No. Update when you are offered it.
+
+Three things are worth a visit. **Settings → About** now tells you what gezel is using on disk, and it is worth a look if you have been downloading models. **Settings → Ambient dashboard** is the new wallpaper feature, and it is off until you turn it on. And if you use VS Code, OpenCode or pi, **Settings → Connected Apps** will put your own models in them in about one click.

package/dist/handboek.js

@@ -975,7 +975,12 @@ async function installedModels(_attrs, ctx) {
 async function modelScorecard(attrs, ctx) {
   const suiteId = attrs.suite?.trim();
   if (!suiteId) return "";
-  return renderScorecardMarkdown(SCORECARD, suiteId, { includeTaskCount: ctx.mode !== "site" });
+  return renderScorecardMarkdown(SCORECARD, suiteId, {
+    includeTaskCount: ctx.mode !== "site",
+    // Agent mode hands this text to a model, where a `<br>` inside an id is
+    // noise the model can quote back as part of the model name.
+    breakLabels: ctx.mode !== "agent"
+  });
 }
 function renderScorecardMarkdown(dataset, suiteId, opts) {
   const board = buildSuiteScoreboard(dataset, suiteId);
@@ -996,7 +1001,7 @@ function renderScorecardMarkdown(dataset, suiteId, opts) {
     )}**`
   );
   lines.push("");
-  lines.push(...scoreTable(publishable));
+  lines.push(...scoreTable(publishable, opts.breakLabels ?? false));
   if (withheld.length > 0) {
     lines.push("");
     lines.push("Not published \u2014 some tasks could not be measured on this round:");
@@ -1020,7 +1025,7 @@ function renderScorecardMarkdown(dataset, suiteId, opts) {
       )}**${why.length > 0 ? ` \u2014 ${why.join(", ")}` : ""}`
     );
     lines.push("");
-    lines.push(...scoreTable(scores));
+    lines.push(...scoreTable(scores, opts.breakLabels ?? false));
   }
   if (opts.includeTaskCount) {
     lines.push("");
@@ -1029,7 +1034,12 @@ function renderScorecardMarkdown(dataset, suiteId, opts) {
   return lines.join("\n");
 }
 var PRIOR_ROUNDS_SHOWN = 2;
-function scoreTable(scores) {
+var NB = "\xA0";
+function breakModelLabel(label) {
+  const match = /^(.*-)(\d+(?:\.\d+)?[bm]\b.*)$/i.exec(label);
+  return match ? `${match[1]}<br>${match[2]}` : label;
+}
+function scoreTable(scores, breakLabels) {
   const anySpeed = scores.some((score) => !!score.result.performance);
   const anyRuntime = scores.some((score) => !!score.result.runtime);
   const anyJudge = scores.some((score) => !!score.result.judge);
@@ -1039,26 +1049,26 @@ function scoreTable(scores) {
   if (anyRuntime) cols.push("Context", "Memory used");
   const rows = scores.map((score) => {
     const cells = [
-      score.result.label,
+      breakLabels ? breakModelLabel(score.result.label) : score.result.label,
       score.result.parameterSize ?? score.result.tier,
       score.claim
     ];
     if (anyJudge) {
       const judge = score.result.judge;
-      cells.push(judge ? `${judge.meanScore}/10 (${judge.artifacts} pieces)` : "\u2014");
+      cells.push(judge ? `${judge.meanScore}/10 (${judge.artifacts}${NB}pieces)` : "\u2014");
     }
     if (anySpeed) {
       const perf = score.result.performance;
       cells.push(
-        perf ? `${perf.prefillTokensPerSec.toLocaleString()} tok/s` : "\u2014",
-        perf ? `${perf.decodeTokensPerSec} tok/s` : "\u2014"
+        perf ? `${perf.prefillTokensPerSec.toLocaleString()}${NB}tok/s` : "\u2014",
+        perf ? `${perf.decodeTokensPerSec}${NB}tok/s` : "\u2014"
       );
     }
     if (anyRuntime) {
       const runtime = score.result.runtime;
       cells.push(
         runtime ? `${Math.round(runtime.contextTokens / 1024)}K` : "\u2014",
-        runtime ? `${(runtime.peakMemoryMb / 1024).toFixed(1)} GB` : "\u2014"
+        runtime ? `${(runtime.peakMemoryMb / 1024).toFixed(1)}${NB}GB` : "\u2014"
       );
     }
     return `| ${cells.join(" | ")} |`;