@bendyline/gezel-service 1.0.3 → 1.0.5

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

@@ -0,0 +1,89 @@
+---
+id: whats-new/1.26226
+title: 1.26226 — 14 August 2026
+order: -26226
+summary: Five more models on the scorecard, file problems you can hand straight to a gezel, a much fuller terminal app, and memory that keeps working when its index breaks.
+---
+
+# 1.26226 — 14 August 2026
+
+Two days of work since **1.26224**, and a dense two days.
+
+If you read only one thing: the problems gezel finds in your files stopped being a list you read and became work you can hand to someone, the terminal version of gezel caught up with the app, and the model scoreboard more than doubled.
+
+Also: a new model - Qwen 3.8 27B Q4 - is now available. We're doing more testing and additional tuning over the next couple days, but if Qwen 3.6 is any indication, it should be really good!
+
+## 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.
+
+## 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. 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.
+- `/allow` and `/disallow` — turn a project's write permissions on and off in place.
+- `/model download` — pick and fetch a new on-device model from inside a session.
+- First-run setup in the terminal now shows the same model information the app does, and pressing Ctrl+C actually shuts down the background service it started instead of leaving it running.
+
+The rest of the commands are in the [command-line reference](../technical/cli-reference.md).
+
+## Memory that does not give up
+
+Your gezels' memories are ordinary Markdown files, and a search index sits on top of them to make recall fast. Previously, trouble with the index could take memory down with it — a first-time download of the search model failing because you were offline was enough to turn memory off for the rest of the session.
+
+That is fixed in three places. Saving a memory now always writes the Markdown first, and reports the indexing as deferred rather than failing; the index catches up on its own afterwards. Searching falls back to plain text search when the fast path is unavailable, and tells you it did. And a failed model download is now treated as something that might clear — gezel waits a minute and tries again, instead of concluding that memory is broken.
+
+## Connectors are now an explicit preview
+
+Connectors — the things that pull a calendar, a repository or a social account into a project — have moved behind a switch in **Settings → Advanced → Show very early work-in-progress features**, and it is off. So are the project types and craftbooks that depend on them.
+
+This is a step back in visibility and a step forward in honesty. They are not finished, they change shape between releases, and having them sitting in every project's settings implied a stability they do not have yet.
+
+Behind that switch, they got considerably better. Bluesky, X, LinkedIn and Instagram joined the connectors gezel can talk to, with a deliberate three-step path to publishing anything: a gezel **drafts** a post, **queues** it, and only then can **publish** it — and publishing is denied unless you have said otherwise, one time at a time. Overnight work never publishes; it leaves things in the outbox for you. Gezel ships no social-media app credentials of its own, so connecting an account means registering your own developer app, which the connection panel now walks you through and stores the secret in your operating system's keychain. Posts and mentions that come back land in the project's artifacts and are searchable alongside everything else.
+
+## Five more models measured
+
+The [Model scorecard](../technical/model-scorecard.md) went from four models to nine.
+
+The new entries are **gemma4-26b**, **qwen3.6-27b**, **qwen3.6-35b-a3b**, **muse-glimmer-30b** and **nemotron3.5-lightning-30b**, all measured the same way as the first four: every job run three times on a real machine and checked by a program. The picture that emerges is more interesting than "bigger is better". On general capability, gemma4-26b and qwen3.6-27b both finished every job. On the office and knowledge set, the small ornith-9b still beats several models three times its size. And qwen3.6-27b and qwen3.6-35b-a3b earn the highest marks from the separate quality read, at a fraction of the memory gemma4-26b needs.
+
+[How we test models](../technical/how-we-test-models.md) explains what the numbers do and do not tell you. It is worth five minutes before you pick.
+
+While you are on the models screen, every catalog model now says **who made it and who prepared the version you download**. Those are often different organizations — a company trains the model, someone else converts and compresses it so it runs on your machine — and until now gezel showed you only one name. The terminal app shows the same line when it offers you a model.
+
+
+## Smaller things
+
+- **A job's single gezel is now called the Builder** rather than the Ambachtsman. Same gezel, a more simple word.
+- **Codex and Claude sessions have their own permission setting per project**, separate from what gezel's own tools may do — so you can let one edit and keep the other reading.
+- **Settings → About lists your running local engines** and, for each, the context window it actually got at launch. A model that suddenly seems to have lost the plot is very often one whose window came out smaller than the instructions it carries; this turns that from a log hunt into a glance.
+- **The "stop everything" button now also unloads local engines** and drops gezel to Reactive, and it is reachable from Settings as well as the engine pill.
+- **Model files gezel cannot read appear under "Models needing attention"** with their size and an Update or Remove button, instead of vanishing while still using your disk.
+- **App updates show a real download progress bar** rather than an unmoving "downloading".
+- **If gezel itself crashes, you get a plain dialog** offering to open a pre-filled report in your browser. Nothing is sent anywhere unless you press it.
+- **Your graphics setup is re-checked at every launch**, so installing or removing a driver is noticed instead of remembered wrongly from the first run.
+- **The prompt cache display no longer counts shared groundwork as conversations**, so the number matches what you have open.
+- **Craftbooks now say what each step is supposed to produce**, and the finished result is checked against that rather than against the attempt.
+- **Asking for the same piece of work twice in one turn returns the task already running** instead of starting a duplicate.
+- Refreshed underlying editor and catalog content packages (squisq 2.7.2, gilde 0.1.28).
+
+## For developers
+
+- **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.
+
+## Anything to do?
+
+No. Update when you are offered it.
+
+Two settings are worth a visit. If connectors disappeared from your projects, they are behind **Settings → Advanced → Show very early work-in-progress features** — turn it on and they come back exactly as they were. And if you run models on your own machine, the new scorecard entries may change which one you want: start at the [Model scorecard](../technical/model-scorecard.md).

package/dist/index.d.ts

@@ -1808,11 +1808,10 @@ interface PublishScope {
  * History is bus-side only: cleared on `done` so completed turns don't get
  * re-delivered when a new subscriber connects after the fact.
  *
- * The early `fail()` path in `ChatManager.send` (when `ensureState` itself
- * fails before we have a record) doesn't know the gezelId/projectId, so it
- * publishes session-scoped only via `publishSessionOnly`. Project + global
- * subscribers don't see those failures — only the session's SSE listener
- * does, which is the only listener that cares about that scope.
+ * If a send truly cannot resolve its session record, it does not know the
+ * gezelId/projectId and publishes session-scoped via `publishSessionOnly`.
+ * Once a record is known, even provider-start failures use `publish` so
+ * project/global clients receive the error.
  */
 declare class ChatEventBus {
     private readonly sessionBuses;
@@ -2293,6 +2292,17 @@ interface PromptCtx extends ModelCtx {
 interface TurnCtx extends ModelCtx {
     sessionId: string;
     isMeester: boolean;
+    /** Project receiving this turn. `default` is the unscoped front-door context. */
+    projectId: string;
+    /**
+     * Provenance of the user-role message. Provider schemas use `user` for
+     * human composer turns, question answers, gezel handoffs, and service
+     * nudges alike; behaviors need this stronger signal before applying
+     * user-intent routing such as the Meester new-project prelude.
+     */
+    messageOrigin: 'direct-user' | 'question-answer' | 'cross-gezel' | 'background-nudge' | 'system';
+    /** Canonical/unqualified plus provider-advertised live tool names. */
+    availableToolNames: ReadonlyArray<string>;
     /** Verbatim user-message text for this turn. */
     userText: string;
     /** Tool calls that drained from the per-turn accumulator. */
@@ -5287,6 +5297,12 @@ interface SearchResult {
 
 interface SaveOutcome {
     status: 'saved' | 'duplicate';
+    /** False means Markdown is durable and the derived vector cache needs repair. */
+    indexed?: boolean;
+    degraded?: {
+        code: 'semantic_index_unavailable';
+        message: string;
+    };
     /** Populated on 'duplicate': what it matched and how. */
     match?: {
         text: string;
@@ -5294,6 +5310,16 @@ interface SaveOutcome {
         via: 'exact' | 'vector';
     };
 }
+type MemorySearchMode = 'semantic' | 'hybrid' | 'lexical';
+interface MemorySearchOutcome {
+    results: SearchResult[];
+    mode: MemorySearchMode;
+    /** Present when a semantic-search failure forced the source-text fallback. */
+    degraded?: {
+        code: 'semantic_search_unavailable';
+        message: string;
+    };
+}
 interface MemoryManagerOptions {
     /** Override {@link MEMORY_DEDUP_THRESHOLD} (tests). */
     dedupThreshold?: number;
@@ -5315,8 +5341,8 @@ declare class MemoryManager {
      * that text dedups, so we accept the race rather than lock.
      *
      * Degraded mode (embeddings disabled): markdown is still appended (it is
-     * the source of truth and the index self-heals on rebuild) and the
-     * EmbeddingsDisabledError propagates, preserving the pre-dedup contract.
+     * the source of truth) and the outcome reports deferred indexing. The health
+     * monitor self-heals the derived index once embeddings recover.
      */
     save(scope: 'gezel' | 'project', id: string, text: string, kind?: MemoryKind): Promise<SaveOutcome>;
     /**
@@ -5347,6 +5373,15 @@ declare class MemoryManager {
      */
     hasIndex(scope: 'gezel' | 'project', id: string): boolean;
     searchAll(gezelId: string, projectId: string, query: string, topK?: number): Promise<SearchResult[]>;
+    /**
+     * Search both scopes with one query embedding. Missing indexes fall back to
+     * the daily Markdown source; an unavailable/corrupt semantic cache does the
+     * same and reports a degraded mode instead of turning an optional feature
+     * into an HTTP 500.
+     */
+    searchAllDetailed(gezelId: string, projectId: string, query: string, topK?: number): Promise<MemorySearchOutcome>;
+    private searchAllLexical;
+    private searchLexical;
     listDays(scope: 'gezel' | 'project', id: string): Promise<string[]>;
     readDay(scope: 'gezel' | 'project', id: string, day: string): Promise<string>;
     /**
@@ -8488,6 +8523,7 @@ interface TaskBudgetSnapshot {
     inputTokens: number;
 }
 
+type TurnMessageOrigin = 'direct-user' | 'question-answer' | 'cross-gezel' | 'background-nudge' | 'system';
 interface GateScriptDiagnostic {
     scriptName: string;
     runId?: string;
@@ -8783,10 +8819,12 @@ declare class ChatManager {
      */
     private readonly afterSessionIdle;
     /**
-     * One live async file handoff per sender/target/project/path. Models can
+     * One live async file handoff per sender/target/project/path/intent. Models can
      * emit the same `message_gezel` call several times while the sender turn
      * is still active; joining that work prevents a parked-send burst from
-     * replaying the same assignment into the recipient session.
+     * replaying the same assignment into the recipient session. A later
+     * validator repair for a file that was originally missing is distinct work
+     * and must never join the older create request.
      */
     private readonly inflightFileHandoffs;
     /** Set once {@link shutdown} starts so deferred watchdogs don't fire into a tearing-down manager. */
@@ -9597,6 +9635,8 @@ declare class ChatManager {
          * advanced, carry on" instead of naming the recipient as the sender.
          */
         fromGezelId?: string;
+        /** Naming presentation inherited from the task's launching session. */
+        roleBasedNameOnlyMode?: boolean;
         /**
          * `'entry'` is a fresh launch (e.g. the command launcher created the
          * task and is starting its entry step) — there is no prior step, so
@@ -9653,6 +9693,8 @@ declare class ChatManager {
         toGezelIdOrName: string;
         projectId?: string;
         text: string;
+        /** One-way feedback that must not wake the sender with the recipient's reply. */
+        suppressReply?: boolean;
         /** Internal task context for scheduler re-drives. */
         taskRef?: string;
         /** Exact step paired with taskRef when re-driving task work. */
@@ -10064,6 +10106,8 @@ declare class ChatManager {
          * the message never queued, so it renders as a normal send.
          */
         nudge?: boolean;
+        /** Strong provenance used by per-turn behavior hooks. */
+        messageOrigin?: TurnMessageOrigin;
     }): Promise<ChatMessage>;
     /**
      * Wrap {@link runSend} so its completion — success or error — triggers
@@ -12141,6 +12185,8 @@ interface TaskRunnerDispatcher {
         fromGezelName?: string;
         fromGezelId?: string;
         kind?: 'handoff' | 'entry';
+        /** Naming presentation pinned by the task that owns this handoff. */
+        roleBasedNameOnlyMode?: boolean;
         /**
          * Queue lane for the dispatched turn. Task handoffs travel
          * `'background'` so a typed chat always drains first; Night Shift also
@@ -12292,6 +12338,11 @@ declare class TaskRunner {
     };
     /** Run one serialized dispatch pass now, sharing the interval's overlap guard. */
     wake(): Promise<void>;
+    /**
+     * Public test/operator entry point. Keep it serialized with the interval:
+     * callers may drive a real, already-started service whose ticker is active.
+     */
+    tick(): Promise<void>;
     /**
      * Scan every `active` task and enqueue a handoff for any whose
      * current step has an effective gezel owner. Call on service boot and
@@ -12309,9 +12360,9 @@ declare class TaskRunner {
     /**
      * One dispatch pass. Walks pending in FIFO order; dispatches any
      * whose target provider has a free slot; skips items for tasks
-     * that are no longer active. Public for test-driven ticks.
+     * that are no longer active.
      */
-    tick(): Promise<void>;
+    private tickOnce;
     private pruneActiveDispatches;
 }
 
@@ -13374,6 +13425,8 @@ declare class ChatModelInstallRegistry<E extends ChatInstallEventBase, O> {
 interface GgufInstallOpts {
     skipSha: boolean;
     includeMmproj: boolean;
+    /** Whether a text-only chat install should also pull the default image reader. */
+    installCompanion: boolean;
 }
 interface MlxInstallOpts {
     skipSha: boolean;