@otto-code/brain 0.8.13 → 0.8.14

package/dist/commands/pull.d.ts

@@ -1,7 +1,7 @@
 /**
  * `otto brain pull <model>` - download a model from the catalog into the managed
  * models directory, using only Node's fetch (no external downloader). The catalog
- * is the same one seeded from docs/candidate-models.md. `--list-quants` shows what
+ * is the same one seeded from docs/brain-model-catalog.md. `--list-quants` shows what
  * quantizations the repo offers and `--quant <label>` downloads a specific one.
  */
 import type { Command } from "commander";

package/dist/service/activity.d.ts

@@ -73,6 +73,41 @@ export interface InferenceActivitySnapshot {
      */
     slotStages?: Record<string, InferenceStage>;
 }
+/**
+ * A caller's exclusive claim on one tracked request.
+ *
+ * Handed out by `ReasoningTracker.begin` and released exactly once. Releasing
+ * is terminal: every method on a released lease is a no-op, so a chunk that
+ * arrives after the client has gone cannot revive the request it names. That is
+ * not a theoretical concern - it is the shape of the bug this type exists to
+ * make impossible (see `begin`).
+ */
+export interface InferenceLease {
+    /** This request's id, for logs and for joining to an engine slot. */
+    readonly id: string;
+    observe(text: string): void;
+    setSlot(slotId: number): void;
+    /** Idempotent, and safe to call from every branch that can end a stream. */
+    end(): void;
+}
+/** What the engine says about itself, for `ReasoningTracker.reconcile`. */
+export interface EngineSlotTruth {
+    /**
+     * Slot ids llama-server reports as actively processing, or null when this
+     * build reports a count but no per-slot rows. Null demotes every request to
+     * the conservative unpinned rule.
+     */
+    busySlots: ReadonlySet<number> | null;
+    /** How many slots are busy, or null when the sample failed - which reaps nothing. */
+    busyCount: number | null;
+}
+/** One request the reaper cleared, and the evidence worth logging about it. */
+export interface ReapedRequest {
+    id: string;
+    stage: InferenceStage;
+    slotId: number | null;
+    ageMs: number;
+}
 /**
  * Which in-flight completions are currently mid-thought.
  *
@@ -97,23 +132,69 @@ export declare class ReasoningTracker {
      * one stage do not notify; slot sampling owns bounded token-rate updates.
      */
     onChange(listener: () => void): () => void;
-    /** A completion was dispatched to llama-server and awaits its first output delta. */
-    begin(requestId: string): void;
     /**
-     * Record the engine slot this request was pinned to. Called exactly once per
-     * request, at dispatch - the pin is injected into the outbound body before
-     * the request goes out, so the association exists before the first chunk and
-     * `observe` never has to learn about it.
+     * Open a lease for a completion that has just been dispatched to
+     * llama-server and awaits its first output delta.
+     *
+     * A lease rather than an id the caller carries around, because every stuck
+     * "thinking" this tracker has produced was a release that did not happen on
+     * some branch of the proxy's event wiring. A lease makes both halves of that
+     * bug unrepresentable: nothing can advance a request without holding its
+     * lease, and a released lease is inert, so a chunk that lands after the
+     * release cannot resurrect the request it belongs to. (The same shape as
+     * `beginActivity` above, for the same reason.)
+     *
+     * Ids are minted here rather than by the caller: two callers sharing one id
+     * would silently share one request's state.
+     */
+    begin(): InferenceLease;
+    /**
+     * Forget every slot pin, because the engine's slots did not survive its
+     * relaunch.
+     *
+     * The mirror of `Scheduler.forgetSlots`, and required for the same reason: a
+     * pin that outlives the process it named is no longer evidence. Worse than
+     * useless, in fact - a stale pin can collide with a NEW request's slot id,
+     * and the reaper would read that unrelated busy row as proof the dead request
+     * is still alive. Dropping the pins demotes those requests to the
+     * conservative unpinned rule, which clears them once the engine is quiet.
+     */
+    forgetSlots(): void;
+    /**
+     * Drop tracked requests the engine's own account of itself contradicts.
+     *
+     * The safety net under the lease, and it exists because `active` outranks
+     * every engine signal on the rail: one release that never happened claims
+     * "thinking" until the service restarts. The ops tracker already refuses that
+     * bargain by probing the recorded pid, on the principle that a status stuck
+     * on "calibrating" forever is worse than no status at all. This is the
+     * inference half of the same rule.
+     *
+     * **It must never clear valid work**, so it acts only on positive evidence,
+     * and only on evidence a live request could not produce:
+     *
+     *  1. A request that has sent a chunk (or been pinned, or been dispatched)
+     *     within `INFERENCE_QUIET_MS` is alive. A streaming request is therefore
+     *     never a candidate at all, whatever the engine says this instant.
+     *  2. A PINNED request is checked against its own slot. llama-server marks a
+     *     slot processing for the whole task, prefill included, so a request that
+     *     is genuinely running makes its row busy. That row being idle is the
+     *     contradiction. This is what lets one chat's leak be cleared while
+     *     another chat keeps generating.
+     *  3. An UNPINNED request - or any request when the engine reports no
+     *     per-slot rows - cannot be attributed to a row, so it is cleared only
+     *     when the engine reports nothing running at all. Ambiguity is not
+     *     evidence.
+     *  4. The contradiction has to hold for `INFERENCE_STRIKES` samples in a row.
+     *     A single sample can race the dispatch window, where a request has been
+     *     begun and the engine has not picked it up yet; a run of them cannot.
+     *
+     * A failed slot sample is not evidence either, and reconciles nothing.
      *
-     * Idempotent and self-cleaning: a repeat for the same slot is a no-op, and a
-     * different slot replaces it, so a request that somehow moves slots (a
-     * restarted engine hands a task out again) reports where it is now.
+     * Returns what it reaped, so the caller can log a leak rather than silently
+     * paper over it.
      */
-    setSlot(requestId: string, slotId: number): void;
-    /** Note a chunk of `requestId`'s stream. Cheap enough to call per chunk. */
-    observe(requestId: string, text: string): void;
-    /** Forget the request. Must be called on end *and* on error, or the flag sticks. */
-    end(requestId: string): void;
+    reconcile(truth: EngineSlotTruth): ReapedRequest[];
     get active(): boolean;
     get count(): number;
     /** Aggregate request stages. Counts stay exact even with several parallel slots. */

package/dist/service/activity.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _ReasoningTracker_instances, _ReasoningTracker_requests, _ReasoningTracker_slots, _ReasoningTracker_tails, _ReasoningTracker_inlineReasoning, _ReasoningTracker_listeners, _ReasoningTracker_lastSnapshot, _ReasoningTracker_announce;
+var _ReasoningTracker_instances, _ReasoningTracker_requests, _ReasoningTracker_listeners, _ReasoningTracker_lastSnapshot, _ReasoningTracker_counter, _ReasoningTracker_announce, _ReasoningTracker_setSlot, _ReasoningTracker_observe, _ReasoningTracker_touch, _ReasoningTracker_drop;
 /**
  * What long-running work currently owns the brain, and which stage each live
  * inference request has reached.
@@ -179,6 +179,23 @@ export function chunkHasContent(text) {
         /"tool_calls"\s*:\s*\[\s*\{/u.test(text) ||
         /"type"\s*:\s*"(?:tool_use|input_json_delta)"/u.test(text));
 }
+/**
+ * How long a request may be silent before the reaper will consider it at all.
+ *
+ * Long enough to cover the gap between proxy dispatch and llama-server picking
+ * the task up, which is the one window where a healthy request and an idle
+ * engine legitimately coexist.
+ */
+const INFERENCE_QUIET_MS = 5000;
+/**
+ * How many consecutive contradicting samples clear a request.
+ *
+ * More than one because a single sample can catch a real dispatch mid-flight;
+ * small because the status sampler runs about once a second while anything
+ * claims to be busy, so a genuine leak is gone in seconds rather than surviving
+ * until someone restarts the service.
+ */
+const INFERENCE_STRIKES = 3;
 /**
  * Which in-flight completions are currently mid-thought.
  *
@@ -197,18 +214,9 @@ export class ReasoningTracker {
     constructor() {
         _ReasoningTracker_instances.add(this);
         _ReasoningTracker_requests.set(this, new Map());
-        /**
-         * The llama-server slot a request was pinned to at dispatch, so its proxy-side
-         * stage can be attributed to the engine row the panel actually shows. Set once
-         * per request (see `setSlot`), never on the per-chunk path.
-         */
-        _ReasoningTracker_slots.set(this, new Map());
-        /** Tail of the last transport chunk, so a field name split by TCP is still detected. */
-        _ReasoningTracker_tails.set(this, new Map());
-        /** Models/runtimes that leave reasoning inline as `<think>…</think>`. */
-        _ReasoningTracker_inlineReasoning.set(this, new Set());
         _ReasoningTracker_listeners.set(this, new Set());
-        _ReasoningTracker_lastSnapshot.set(this, "0:0:0:0");
+        _ReasoningTracker_lastSnapshot.set(this, "");
+        _ReasoningTracker_counter.set(this, 0);
     }
     /**
      * Watch stage counts, not the per-chunk traffic behind them.
@@ -221,74 +229,142 @@ export class ReasoningTracker {
         __classPrivateFieldGet(this, _ReasoningTracker_listeners, "f").add(listener);
         return () => __classPrivateFieldGet(this, _ReasoningTracker_listeners, "f").delete(listener);
     }
-    /** A completion was dispatched to llama-server and awaits its first output delta. */
-    begin(requestId) {
-        if (__classPrivateFieldGet(this, _ReasoningTracker_requests, "f").has(requestId))
-            return;
-        __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "processing");
-        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
-    }
     /**
-     * Record the engine slot this request was pinned to. Called exactly once per
-     * request, at dispatch - the pin is injected into the outbound body before
-     * the request goes out, so the association exists before the first chunk and
-     * `observe` never has to learn about it.
+     * Open a lease for a completion that has just been dispatched to
+     * llama-server and awaits its first output delta.
+     *
+     * A lease rather than an id the caller carries around, because every stuck
+     * "thinking" this tracker has produced was a release that did not happen on
+     * some branch of the proxy's event wiring. A lease makes both halves of that
+     * bug unrepresentable: nothing can advance a request without holding its
+     * lease, and a released lease is inert, so a chunk that lands after the
+     * release cannot resurrect the request it belongs to. (The same shape as
+     * `beginActivity` above, for the same reason.)
      *
-     * Idempotent and self-cleaning: a repeat for the same slot is a no-op, and a
-     * different slot replaces it, so a request that somehow moves slots (a
-     * restarted engine hands a task out again) reports where it is now.
+     * Ids are minted here rather than by the caller: two callers sharing one id
+     * would silently share one request's state.
      */
-    setSlot(requestId, slotId) {
-        if (!Number.isInteger(slotId) || slotId < 0)
-            return;
-        if (__classPrivateFieldGet(this, _ReasoningTracker_slots, "f").get(requestId) === slotId)
-            return;
-        __classPrivateFieldGet(this, _ReasoningTracker_slots, "f").set(requestId, slotId);
+    begin() {
+        __classPrivateFieldSet(this, _ReasoningTracker_counter, __classPrivateFieldGet(this, _ReasoningTracker_counter, "f") + 1, "f");
+        const id = `s${__classPrivateFieldGet(this, _ReasoningTracker_counter, "f")}`;
+        const now = Date.now();
+        __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(id, {
+            stage: "processing",
+            slotId: null,
+            tail: "",
+            inlineReasoning: false,
+            startedAt: now,
+            lastSignalAt: now,
+            strikes: 0,
+        });
         __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+        let open = true;
+        return {
+            id,
+            observe: (text) => {
+                if (!open)
+                    return;
+                __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_observe).call(this, id, text);
+            },
+            setSlot: (slotId) => {
+                if (!open)
+                    return;
+                __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_setSlot).call(this, id, slotId);
+            },
+            end: () => {
+                if (!open)
+                    return;
+                open = false;
+                __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_drop).call(this, [id]);
+            },
+        };
     }
-    /** Note a chunk of `requestId`'s stream. Cheap enough to call per chunk. */
-    observe(requestId, text) {
-        const current = __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").get(requestId);
-        if (current === "generating")
-            return;
-        if (!current)
-            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "processing");
-        // Node can split an SSE JSON field name at any byte. Keeping a small tail
-        // makes stage recognition independent of transport chunk boundaries without
-        // parsing or retaining the generated content itself.
-        const combined = `${__classPrivateFieldGet(this, _ReasoningTracker_tails, "f").get(requestId) ?? ""}${text}`;
-        __classPrivateFieldGet(this, _ReasoningTracker_tails, "f").set(requestId, combined.slice(-128));
-        if (__classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").has(requestId)) {
-            if (combined.includes("</think>")) {
-                __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").delete(requestId);
-                __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "generating");
-                __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
-            }
-            return;
-        }
-        if (combined.includes("<think>")) {
-            __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").add(requestId);
-            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "thinking");
-            __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
-            return;
-        }
-        if (chunkHasContent(combined)) {
-            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "generating");
-            __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
-            return;
+    /**
+     * Forget every slot pin, because the engine's slots did not survive its
+     * relaunch.
+     *
+     * The mirror of `Scheduler.forgetSlots`, and required for the same reason: a
+     * pin that outlives the process it named is no longer evidence. Worse than
+     * useless, in fact - a stale pin can collide with a NEW request's slot id,
+     * and the reaper would read that unrelated busy row as proof the dead request
+     * is still alive. Dropping the pins demotes those requests to the
+     * conservative unpinned rule, which clears them once the engine is quiet.
+     */
+    forgetSlots() {
+        let changed = false;
+        for (const state of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").values()) {
+            if (state.slotId === null)
+                continue;
+            state.slotId = null;
+            changed = true;
         }
-        if (chunkHasReasoning(combined) && current !== "thinking") {
-            __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").set(requestId, "thinking");
+        if (changed)
             __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
-        }
     }
-    /** Forget the request. Must be called on end *and* on error, or the flag sticks. */
-    end(requestId) {
-        __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").delete(requestId);
-        __classPrivateFieldGet(this, _ReasoningTracker_slots, "f").delete(requestId);
-        __classPrivateFieldGet(this, _ReasoningTracker_tails, "f").delete(requestId);
-        __classPrivateFieldGet(this, _ReasoningTracker_inlineReasoning, "f").delete(requestId);
-        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+    /**
+     * Drop tracked requests the engine's own account of itself contradicts.
+     *
+     * The safety net under the lease, and it exists because `active` outranks
+     * every engine signal on the rail: one release that never happened claims
+     * "thinking" until the service restarts. The ops tracker already refuses that
+     * bargain by probing the recorded pid, on the principle that a status stuck
+     * on "calibrating" forever is worse than no status at all. This is the
+     * inference half of the same rule.
+     *
+     * **It must never clear valid work**, so it acts only on positive evidence,
+     * and only on evidence a live request could not produce:
+     *
+     *  1. A request that has sent a chunk (or been pinned, or been dispatched)
+     *     within `INFERENCE_QUIET_MS` is alive. A streaming request is therefore
+     *     never a candidate at all, whatever the engine says this instant.
+     *  2. A PINNED request is checked against its own slot. llama-server marks a
+     *     slot processing for the whole task, prefill included, so a request that
+     *     is genuinely running makes its row busy. That row being idle is the
+     *     contradiction. This is what lets one chat's leak be cleared while
+     *     another chat keeps generating.
+     *  3. An UNPINNED request - or any request when the engine reports no
+     *     per-slot rows - cannot be attributed to a row, so it is cleared only
+     *     when the engine reports nothing running at all. Ambiguity is not
+     *     evidence.
+     *  4. The contradiction has to hold for `INFERENCE_STRIKES` samples in a row.
+     *     A single sample can race the dispatch window, where a request has been
+     *     begun and the engine has not picked it up yet; a run of them cannot.
+     *
+     * A failed slot sample is not evidence either, and reconciles nothing.
+     *
+     * Returns what it reaped, so the caller can log a leak rather than silently
+     * paper over it.
+     */
+    reconcile(truth) {
+        if (truth.busyCount === null)
+            return [];
+        const now = Date.now();
+        const quietBefore = now - INFERENCE_QUIET_MS;
+        const reaped = [];
+        for (const [id, state] of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f")) {
+            if (state.lastSignalAt > quietBefore) {
+                state.strikes = 0;
+                continue;
+            }
+            const contradicted = state.slotId !== null && truth.busySlots
+                ? !truth.busySlots.has(state.slotId)
+                : truth.busyCount === 0;
+            if (!contradicted) {
+                state.strikes = 0;
+                continue;
+            }
+            state.strikes += 1;
+            if (state.strikes < INFERENCE_STRIKES)
+                continue;
+            reaped.push({
+                id,
+                stage: state.stage,
+                slotId: state.slotId,
+                ageMs: now - state.startedAt,
+            });
+        }
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_drop).call(this, reaped.map((entry) => entry.id));
+        return reaped;
     }
     get active() {
         return this.snapshot.thinking > 0;
@@ -305,19 +381,18 @@ export class ReasoningTracker {
             generating: 0,
         };
         let slotStages;
-        for (const [requestId, stage] of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f")) {
-            result[stage] += 1;
-            const slot = __classPrivateFieldGet(this, _ReasoningTracker_slots, "f").get(requestId);
-            if (slot === undefined)
+        for (const state of __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").values()) {
+            result[state.stage] += 1;
+            if (state.slotId === null)
                 continue;
-            (slotStages ?? (slotStages = {}))[String(slot)] = stage;
+            (slotStages ?? (slotStages = {}))[String(state.slotId)] = state.stage;
         }
         if (slotStages)
             result.slotStages = slotStages;
         return result;
     }
 }
-_ReasoningTracker_requests = new WeakMap(), _ReasoningTracker_slots = new WeakMap(), _ReasoningTracker_tails = new WeakMap(), _ReasoningTracker_inlineReasoning = new WeakMap(), _ReasoningTracker_listeners = new WeakMap(), _ReasoningTracker_lastSnapshot = new WeakMap(), _ReasoningTracker_instances = new WeakSet(), _ReasoningTracker_announce = function _ReasoningTracker_announce() {
+_ReasoningTracker_requests = new WeakMap(), _ReasoningTracker_listeners = new WeakMap(), _ReasoningTracker_lastSnapshot = new WeakMap(), _ReasoningTracker_counter = new WeakMap(), _ReasoningTracker_instances = new WeakSet(), _ReasoningTracker_announce = function _ReasoningTracker_announce() {
     const snapshot = this.snapshot;
     // The slot join rides in the key too: pinning a request to a slot is a
     // state change even when no stage count moves, and it is the field the
@@ -341,5 +416,58 @@ _ReasoningTracker_requests = new WeakMap(), _ReasoningTracker_slots = new WeakMa
             // Status reporting must never break a proxied completion.
         }
     }
+}, _ReasoningTracker_setSlot = function _ReasoningTracker_setSlot(id, slotId) {
+    if (!Number.isInteger(slotId) || slotId < 0)
+        return;
+    const state = __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").get(id);
+    if (!state || state.slotId === slotId)
+        return;
+    state.slotId = slotId;
+    __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_touch).call(this, state);
+    __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+}, _ReasoningTracker_observe = function _ReasoningTracker_observe(id, text) {
+    const state = __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").get(id);
+    if (!state)
+        return;
+    __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_touch).call(this, state);
+    if (state.stage === "generating")
+        return;
+    // Node can split an SSE JSON field name at any byte. Keeping a small tail
+    // makes stage recognition independent of transport chunk boundaries without
+    // parsing or retaining the generated content itself.
+    const combined = `${state.tail}${text}`;
+    state.tail = combined.slice(-128);
+    if (state.inlineReasoning) {
+        if (combined.includes("</think>")) {
+            state.inlineReasoning = false;
+            state.stage = "generating";
+            __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+        }
+        return;
+    }
+    if (combined.includes("<think>")) {
+        state.inlineReasoning = true;
+        state.stage = "thinking";
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+        return;
+    }
+    if (chunkHasContent(combined)) {
+        state.stage = "generating";
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+        return;
+    }
+    if (chunkHasReasoning(combined) && state.stage !== "thinking") {
+        state.stage = "thinking";
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
+    }
+}, _ReasoningTracker_touch = function _ReasoningTracker_touch(state) {
+    state.lastSignalAt = Date.now();
+    state.strikes = 0;
+}, _ReasoningTracker_drop = function _ReasoningTracker_drop(ids) {
+    let removed = false;
+    for (const id of ids)
+        removed = __classPrivateFieldGet(this, _ReasoningTracker_requests, "f").delete(id) || removed;
+    if (removed)
+        __classPrivateFieldGet(this, _ReasoningTracker_instances, "m", _ReasoningTracker_announce).call(this);
 };
 //# sourceMappingURL=activity.js.map

package/dist/service/router.js

@@ -273,16 +273,6 @@ function handleModelsRoute(req, res, supervisor, getCatalog, scheduler = null) {
     res.end(body);
     return true;
 }
-/**
- * Correlates the chunks of one proxied stream for the reasoning tracker. A
- * counter rather than a uuid: it never leaves the process and only has to be
- * unique among the handful of streams in flight at once.
- */
-let streamCounter = 0;
-function nextStreamId() {
-    streamCounter += 1;
-    return `s${streamCounter}`;
-}
 /**
  * The reasoning tracker is module-scoped rather than per-router because both
  * proxy paths need it and `proxyBuffered` is a free function. One service
@@ -438,12 +428,16 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
     const slotId = slot ?? null;
     return new Promise((resolve) => {
         let settled = false;
-        const streamId = nextStreamId();
+        // Opened before anything can fail, so every exit below has a lease to
+        // release. Releasing is terminal and idempotent, which is what makes it
+        // safe to call `done()` from all six paths that can end this request
+        // without any of them having to know whether another got there first.
+        const lease = reasoning?.begin() ?? null;
         const done = () => {
-            // Always release the reasoning flag, including on the error and abort
-            // paths: a stream that dies mid-thought would otherwise pin the rail on
+            // Always release the stage, including on the error and abort paths: a
+            // stream that dies mid-thought would otherwise pin the rail on
             // "thinking" until the service restarts.
-            reasoning?.end(streamId);
+            lease?.end();
             if (!settled) {
                 settled = true;
                 resolve();
@@ -479,8 +473,13 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
             res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
             const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
             const upstreamResponseFailed = (error) => {
-                if (settled)
+                // The release runs even when the queue has already settled. On an
+                // interrupt the client's socket close settles first, and this is the
+                // event that says the upstream stream is finally over.
+                if (settled) {
+                    lease?.end();
                     return;
+                }
                 const message = `llama-server response ended unexpectedly: ${error.message}`;
                 telemetry.record({
                     at: new Date().toISOString(),
@@ -502,7 +501,7 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
                 let sawReasoning = false;
                 upstreamRes.on("data", (chunk) => {
                     const text = String(chunk);
-                    reasoning?.observe(streamId, text);
+                    lease?.observe(text);
                     if (chunkHasContent(text))
                         sawContent = true;
                     if (chunkHasReasoning(text))
@@ -580,13 +579,11 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
             }
             done();
         });
-        // This is the first authoritative inference-stage signal: the request is
-        // being dispatched to llama-server and is waiting for prompt processing or
-        // its first output delta. The slot association is set once here, at the
-        // same moment, so `observe` stays free of any per-chunk slot work.
-        reasoning?.begin(streamId);
+        // The slot association is set once, here at dispatch, so `observe` stays
+        // free of any per-chunk slot work - and so the reaper has a row to check
+        // this request against if its release is ever missed.
         if (slotId !== null)
-            reasoning?.setSlot(streamId, slotId);
+            lease?.setSlot(slotId);
         upstream.end(outbound);
     });
 }
@@ -751,6 +748,18 @@ function scheduleCompletion({ req, res, agent, telemetry, logger, scheduler, mod
         // relaunched - and not at dispatch time either, where a sibling admitted in
         // the same pass could see the same slot free and pin it too.
         let slot = null;
+        // A queued request outlives its client. The reader can interrupt, close the
+        // chat, or lose the socket while the job still waits behind another model's
+        // turn, and without this the job is admitted anyway: a full generation for
+        // nobody, on a slot the live chats are queued for, wired to a response that
+        // closed before the proxy could listen to it. One flag, read by the
+        // scheduler before it pins anything, keeps the request from ever reaching
+        // the engine. (`close` also fires on a healthy finish, by which point the
+        // job has long since been dispatched and the flag is never read again.)
+        let abandoned = false;
+        res.on("close", () => {
+            abandoned = true;
+        });
         const queued = scheduler.submit(model, (resident) => proxyBuffered({
             agent,
             model,
@@ -762,9 +771,15 @@ function scheduleCompletion({ req, res, agent, telemetry, logger, scheduler, mod
             body,
             reasoning: reasoningTracker,
             slot,
-        }), { session, onSlotFree: (id) => (slot = id) });
+        }), { session, onSlotFree: (id) => (slot = id), abandoned: () => abandoned });
         logger?.info?.(`queued ${req.method ?? "POST"} ${req.url ?? "completion"} for ${model.displayName}; queue depth ${scheduler.stats().queued}`);
-        queued.catch((error) => sendError(res, 502, `could not serve ${model.displayName}: ${errorMessage(error)}`));
+        queued.catch((error) => {
+            // The client may be the reason this failed, and writing into a socket it
+            // already closed throws where nothing is left to catch it.
+            if (res.writableEnded || res.destroyed)
+                return;
+            sendError(res, 502, `could not serve ${model.displayName}: ${errorMessage(error)}`);
+        });
     });
 }
 // The bench ranking is read from disk (one JSON per run). A completion request
@@ -806,6 +821,10 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
         if (state === "starting") {
             telemetry.reset();
             scheduler?.forgetSlots();
+            // The tracker's pins name the same vanished slots, and a pin that
+            // outlives the process it named is not evidence - it can collide with a
+            // new request's slot id and shield a dead request from the reaper.
+            reasoningTracker.forgetSlots();
         }
     });
     // GPU total VRAM is static hardware, so it is queried once at startup and
@@ -915,6 +934,23 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
         const slots = supervisor.state === "ready"
             ? await sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
             : null;
+        // Both truths are in hand exactly here, and nowhere else: `slots` is what
+        // llama-server says is running, `inference` is what the proxy believes. A
+        // missed release used to survive until the service restarted, because
+        // `reasoning` outranks every engine signal on the rail. Reconciling the two
+        // makes any such leak self-heal within a few samples, and `reconcile` is
+        // built so it can only ever clear a request the engine contradicts (see
+        // its own contract).
+        const reaped = reasoningTracker.reconcile({
+            busySlots: slots?.threads ? new Set(slots.threads.map((thread) => thread.slot)) : null,
+            busyCount: slots ? slots.busy : null,
+        });
+        for (const request of reaped) {
+            logger?.warn?.(`released inference stage ${request.id} (${request.stage}` +
+                `${request.slotId === null ? "" : `, slot ${request.slotId}`}) after ` +
+                `${Math.round(request.ageMs / 1000)}s the engine reported it idle - ` +
+                `a completion did not report its end`);
+        }
         return {
             version,
             // Additive, and separate from `version`: the package version says which
@@ -1071,13 +1107,13 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
                 let sawContent = false;
                 let sawReasoning = false;
                 if (isCompletion) {
-                    const streamId = nextStreamId();
+                    const lease = reasoningTracker.begin();
                     // Released on close, not just on end: an aborted stream would
                     // otherwise pin `/__host/status` on "thinking" forever.
-                    const releaseReasoning = () => reasoningTracker.end(streamId);
+                    const releaseReasoning = () => lease.end();
                     upstreamRes.on("data", (chunk) => {
                         const text = String(chunk);
-                        reasoningTracker.observe(streamId, text);
+                        lease.observe(text);
                         if (chunkHasContent(text))
                             sawContent = true;
                         if (chunkHasReasoning(text))

package/dist/service/scheduler.d.ts

@@ -202,6 +202,20 @@ export interface SchedulerSubmitOptions {
      * and their attribution is not per-slot.
      */
     onSlotFree?: ((slotId: number | null) => void) | null;
+    /**
+     * Asked before this job is admitted: has whoever queued it stopped caring?
+     *
+     * A completion whose client left is the ordinary case - an interrupt, a
+     * closed chat, a dead socket - and it can happen at any point while the job
+     * waits behind another model's turn. Admitting it anyway costs a full
+     * generation of GPU time for a reader that is gone, holds one of the slots
+     * the remaining chats are queued for, and hands the proxy a response that
+     * closed before it could wire a listener to it. Dropping the job here, before
+     * it is pinned to a slot, is the cheapest and least surprising place to
+     * refuse: nothing reaches the engine, no slot is erased for a handoff that
+     * will not happen, and the job's promise settles like any other.
+     */
+    abandoned?: (() => boolean) | null;
 }
 /** A queued request or host operation bound to a resolved catalog model. */
 export interface QueuedJob<TSupervisor extends SchedulerSupervisor = SchedulerSupervisor> {
@@ -212,6 +226,7 @@ export interface QueuedJob<TSupervisor extends SchedulerSupervisor = SchedulerSu
     session: string | null;
     onStart: (() => void) | null;
     onSlotFree: ((slotId: number | null) => void) | null;
+    abandoned: (() => boolean) | null;
     /**
      * The engine slot this job was pinned to at admission, or null when none was
      * named. Kept on the job so a later pass can exclude it from the ids it hands
@@ -275,7 +290,7 @@ export declare class Scheduler<TSupervisor extends SchedulerSupervisor = Schedul
      * Dispatch is deferred a microtask so a burst of requests submitted together
      * shares one turn rather than the first one taking a turn by itself.
      */
-    submit(model: Model, run: (supervisor: TSupervisor) => Promise<unknown>, { kind, exclusive, onStart, session, onSlotFree, }?: SchedulerSubmitOptions): Promise<unknown>;
+    submit(model: Model, run: (supervisor: TSupervisor) => Promise<unknown>, { kind, exclusive, onStart, session, onSlotFree, abandoned, }?: SchedulerSubmitOptions): Promise<unknown>;
     /**
      * Drop every recorded slot owner. The engine's slots do not survive a model
      * (re)launch, so their owners do not either - a stale entry would make the

package/dist/service/scheduler.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _Scheduler_instances, _Scheduler_batch, _Scheduler_running, _Scheduler_turnId, _Scheduler_freeSlotIds, _Scheduler_busy, _Scheduler_dirty, _Scheduler_slotTimer, _Scheduler_announce, _Scheduler_takeTurn, _Scheduler_take, _Scheduler_warmSessions, _Scheduler_claimJob, _Scheduler_sampleFreeSlots, _Scheduler_pollForSlot, _Scheduler_start, _Scheduler_eraseFor, _Scheduler_dispatch, _Scheduler_resetSlots, _Scheduler_pass;
+var _Scheduler_instances, _Scheduler_batch, _Scheduler_running, _Scheduler_turnId, _Scheduler_freeSlotIds, _Scheduler_busy, _Scheduler_dirty, _Scheduler_slotTimer, _Scheduler_announce, _Scheduler_takeTurn, _Scheduler_take, _Scheduler_purgeAbandoned, _Scheduler_warmSessions, _Scheduler_claimJob, _Scheduler_sampleFreeSlots, _Scheduler_pollForSlot, _Scheduler_start, _Scheduler_eraseFor, _Scheduler_dispatch, _Scheduler_resetSlots, _Scheduler_pass;
 const MAX_CONCURRENCY = 16;
 /** A short, safe description of an unknown error value for log lines. */
 function describeError(error) {
@@ -82,7 +82,7 @@ export class Scheduler {
      * Dispatch is deferred a microtask so a burst of requests submitted together
      * shares one turn rather than the first one taking a turn by itself.
      */
-    submit(model, run, { kind = "completion", exclusive = kind !== "completion", onStart = null, session = null, onSlotFree = null, } = {}) {
+    submit(model, run, { kind = "completion", exclusive = kind !== "completion", onStart = null, session = null, onSlotFree = null, abandoned = null, } = {}) {
         return new Promise((resolve, reject) => {
             this.queue.push({
                 modelId: model.id,
@@ -92,6 +92,7 @@ export class Scheduler {
                 session: session ?? null,
                 onStart,
                 onSlotFree,
+                abandoned: abandoned ?? null,
                 slotId: null,
                 run,
                 resolve,
@@ -182,6 +183,33 @@ _Scheduler_batch = new WeakMap(), _Scheduler_running = new WeakMap(), _Scheduler
     if (taken.length > 0)
         __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
     return taken;
+}, _Scheduler_purgeAbandoned = function _Scheduler_purgeAbandoned() {
+    const dropped = [];
+    const isAbandoned = (job) => {
+        try {
+            return job.abandoned?.() === true;
+        }
+        catch {
+            // A predicate that throws is not permission to drop the job.
+            return false;
+        }
+    };
+    __classPrivateFieldSet(this, _Scheduler_batch, __classPrivateFieldGet(this, _Scheduler_batch, "f").filter((job) => {
+        if (!isAbandoned(job))
+            return true;
+        dropped.push(job);
+        return false;
+    }), "f");
+    for (const job of __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, isAbandoned))
+        dropped.push(job);
+    if (dropped.length === 0)
+        return;
+    this.logger?.(`dropping ${dropped.length} queued job(s) whose caller went away`);
+    // Resolved, not rejected: the caller asked for this by leaving, and a
+    // rejection would only be reported into a socket that is already gone.
+    for (const job of dropped)
+        job.resolve(undefined);
+    __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
 }, _Scheduler_warmSessions = function _Scheduler_warmSessions() {
     const warm = new Set();
     for (const job of __classPrivateFieldGet(this, _Scheduler_running, "f"))
@@ -365,6 +393,11 @@ async function _Scheduler_pass() {
     // the sample the first time capacity is checked; consumed in `#start`.
     __classPrivateFieldSet(this, _Scheduler_freeSlotIds, null, "f");
     for (;;) {
+        // Before any decision is derived from the queue, drop what nobody is
+        // waiting for, so every count read below is honest. Per iteration rather
+        // than once per pass: a turn boundary is crossed inside this loop, and a
+        // caller can leave while the job ahead of it is being started.
+        __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_purgeAbandoned).call(this);
         // An exclusive operation owns the engine alone.
         if (this.activeJob !== null)
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/brain",
-  "version": "0.8.13",
+  "version": "0.8.14",
   "description": "Otto Brain - self-contained host for local GGUF models, with measured VRAM budgeting and reasoning-budget control",
   "license": "AGPL-3.0-or-later",
   "bin": {