@otto-code/brain 0.8.9 → 0.8.12

package/dist/service/scheduler.js

@@ -3,18 +3,68 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Scheduler_instances, _Scheduler_announce, _Scheduler_take, _Scheduler_serveTurn;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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;
 const MAX_CONCURRENCY = 16;
+/** A short, safe description of an unknown error value for log lines. */
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 export class Scheduler {
-    constructor({ supervisor, loadModel, logger = null, onChange = null }) {
+    constructor({ supervisor, loadModel, logger = null, onChange = null, freeSlots = null, slotPollMs = 2500, eraseSlot = null, }) {
         _Scheduler_instances.add(this);
+        /** Submitted, not yet claimed by a turn. */
+        this.queue = [];
+        this.lastTurnId = null;
+        /**
+         * Per model: the session whose jobs most recently filled its slots. That
+         * session's KV state is the one llama-server's LCP selection will match
+         * against, so its queued jobs go first on the next dispatch.
+         */
+        this.hotSessions = new Map();
+        /** The exclusive operation in flight, if any. Reported by `stats()`. */
+        this.activeJob = null;
+        /**
+         * Engine slot -> the session that last ran on it (see OWNERSHIP). The value
+         * is null for keyless jobs: a keyless job cannot prove ownership of anything
+         * after it settles, so the next keyed chat landing on that slot is treated as
+         * a handoff and the slot is erased for it. Wiped wholesale whenever the
+         * engine reloads a model - slot ids do not survive the relaunch.
+         */
+        this.slotOwners = new Map();
+        /** Claimed by the current turn, waiting for a slot. Empty between turns. */
+        _Scheduler_batch.set(this, []);
+        /** Started, not yet settled. Invariant: every member's model is `#turnId`. */
+        _Scheduler_running.set(this, new Set());
+        /** The model that owns the engine for this turn, or null between turns. */
+        _Scheduler_turnId.set(this, null);
+        /**
+         * Distinct engine slot ids, one per job this pass may still admit, drawn from
+         * the pass's own free-slot sample (`null` when the engine reported no
+         * per-slot rows - then nothing is pinned). A job pops one as it is admitted
+         * in `#start`, so two jobs admitted in the same pass can never be named the
+         * same slot - the failure mode a job-side sample at dispatch time would
+         * produce. Reset whenever the engine is relaunched, because slot ids do not
+         * survive a model switch.
+         */
+        _Scheduler_freeSlotIds.set(this, null);
+        /** A dispatch pass is running. Only one may read/mutate the state at a time. */
+        _Scheduler_busy.set(this, false);
+        /** State changed mid-pass; run one more pass before yielding. */
+        _Scheduler_dirty.set(this, false);
+        _Scheduler_slotTimer.set(this, null);
         this.supervisor = supervisor;
         this.loadModel = loadModel; // async (model) => resolves once it is ready
         this.logger = logger; // optional (message: string) => void
-        this.queue = []; // { modelId, model, run, resolve, reject }
-        this.lastTurnId = null;
-        this.pumping = false;
         this.onChange = onChange;
+        this.freeSlots = freeSlots;
+        this.slotPollMs = slotPollMs;
+        this.eraseSlot = eraseSlot;
     }
     /** Id of the model that is actually loaded and ready, or null. */
     get loadedId() {
@@ -22,72 +72,94 @@ export class Scheduler {
             ? this.supervisor.model.id
             : null;
     }
-    /** How many requests may run at once against the resident model. */
+    /** How many requests may run at once against the resident model (static ceiling). */
     get concurrency() {
         return Math.max(1, Math.min(MAX_CONCURRENCY, this.supervisor.profile?.parallelSlots || 1));
     }
     /**
      * Queue a job for an already-resolved catalog model. `run` is invoked once
      * that model is the resident one; the returned promise settles when run does.
-     * Pumping is deferred a microtask so a burst of requests submitted together
-     * share one turn rather than the first one snapshotting a turn by itself.
+     * 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) {
+    submit(model, run, { kind = "completion", exclusive = kind !== "completion", onStart = null, session = null, onSlotFree = null, } = {}) {
         return new Promise((resolve, reject) => {
-            this.queue.push({ modelId: model.id, model, run, resolve, reject });
+            this.queue.push({
+                modelId: model.id,
+                model,
+                kind,
+                exclusive,
+                session: session ?? null,
+                onStart,
+                onSlotFree,
+                slotId: null,
+                run,
+                resolve,
+                reject,
+            });
             __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
-            queueMicrotask(() => this.pump());
+            queueMicrotask(() => void __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_dispatch).call(this));
         });
     }
-    async pump() {
-        if (this.pumping)
-            return;
-        this.pumping = true;
-        try {
-            while (this.queue.length) {
-                // Prefer a model other than the one that just took a turn, so the two
-                // sides alternate; fall back to the head of the queue when only one
-                // model is waiting (it simply keeps its turn).
-                const pick = this.queue.find((j) => j.modelId !== this.lastTurnId) || this.queue[0];
-                const turnId = pick.modelId;
-                if (this.loadedId !== turnId) {
-                    try {
-                        this.logger?.(`switching to ${pick.model.displayName}`);
-                        await this.loadModel(pick.model);
-                    }
-                    catch (error) {
-                        // The model would not load - fail exactly its queued jobs and move on.
-                        for (const job of __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, (j) => j.modelId === turnId))
-                            job.reject(error);
-                        continue;
-                    }
-                }
-                this.lastTurnId = turnId;
-                __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
-                await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_serveTurn).call(this, turnId);
-            }
-        }
-        finally {
-            this.pumping = false;
-        }
+    /**
+     * 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
+     * next admission think a FRESH slot still holds a previous chat's KV and
+     * erase it (an unnecessary re-prefill), or, worse, let a keyless job be
+     * mistaken for the owner of a slot it is not.
+     *
+     * Called from two places: `#pass` clears the owners the moment a turn begins
+     * on a different model than the one it last served (a model switch, where
+     * the scheduler itself sees the relaunch), and the router calls it on the
+     * supervisor's `starting` state - the relaunch that keeps the SAME model
+     * resident (a live profile edit), where the turn never changes and only the
+     * supervisor says the slots are gone. Both paths are idempotent.
+     */
+    forgetSlots() {
+        this.slotOwners.clear();
     }
     /** Queue snapshot for the status endpoint / UI. */
     stats() {
         const waiting = {};
-        for (const job of this.queue) {
+        const waitingModelIds = {};
+        // Batched jobs have left the queue but have not started: to everyone
+        // outside the scheduler they are still waiting.
+        for (const job of [...this.queue, ...__classPrivateFieldGet(this, _Scheduler_batch, "f")]) {
             const name = job.model.displayName;
             waiting[name] = (waiting[name] || 0) + 1;
+            waitingModelIds[job.modelId] = (waitingModelIds[job.modelId] || 0) + 1;
         }
-        return { queued: this.queue.length, waiting, lastTurn: this.lastTurnId };
+        const active = this.activeJob && this.activeJob.kind !== "completion"
+            ? { modelId: this.activeJob.modelId, kind: this.activeJob.kind }
+            : null;
+        return {
+            queued: this.queue.length + __classPrivateFieldGet(this, _Scheduler_batch, "f").length,
+            waiting,
+            waitingModelIds,
+            lastTurn: this.lastTurnId,
+            active,
+        };
     }
 }
-_Scheduler_instances = new WeakSet(), _Scheduler_announce = function _Scheduler_announce() {
+_Scheduler_batch = new WeakMap(), _Scheduler_running = new WeakMap(), _Scheduler_turnId = new WeakMap(), _Scheduler_freeSlotIds = new WeakMap(), _Scheduler_busy = new WeakMap(), _Scheduler_dirty = new WeakMap(), _Scheduler_slotTimer = new WeakMap(), _Scheduler_instances = new WeakSet(), _Scheduler_announce = function _Scheduler_announce() {
     try {
         this.onChange?.();
     }
     catch {
         // Status reporting is not allowed to fail a queued completion.
     }
+}, _Scheduler_takeTurn = function _Scheduler_takeTurn(turnId) {
+    const taken = [];
+    for (const job of this.queue) {
+        if (job.modelId !== turnId)
+            continue;
+        if (taken.length > 0 && job.exclusive)
+            break; // boundary waits its turn
+        taken.push(job);
+        if (job.exclusive)
+            break; // at the head: it runs solo
+    }
+    return __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, (job) => taken.includes(job));
 }, _Scheduler_take = function _Scheduler_take(pred) {
     const kept = [];
     const taken = [];
@@ -97,26 +169,286 @@ _Scheduler_instances = new WeakSet(), _Scheduler_announce = function _Scheduler_
     if (taken.length > 0)
         __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
     return taken;
-}, _Scheduler_serveTurn = 
-/** Serve one model's snapshot with bounded concurrency. */
-async function _Scheduler_serveTurn(turnId) {
-    const jobs = __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, (j) => j.modelId === turnId);
-    let next = 0;
-    const worker = async () => {
-        while (next < jobs.length) {
-            const job = jobs[next];
-            next += 1;
-            try {
-                job.resolve(await job.run());
+}, _Scheduler_warmSessions = function _Scheduler_warmSessions() {
+    const warm = new Set();
+    for (const job of __classPrivateFieldGet(this, _Scheduler_running, "f"))
+        if (job.session)
+            warm.add(job.session);
+    return warm;
+}, _Scheduler_claimJob = function _Scheduler_claimJob(turnId) {
+    if (__classPrivateFieldGet(this, _Scheduler_batch, "f").length === 0)
+        return null;
+    const warm = __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_warmSessions).call(this);
+    const chosen = warm.size > 0
+        ? (__classPrivateFieldGet(this, _Scheduler_batch, "f").find((job) => job.session !== null && warm.has(job.session)) ??
+            __classPrivateFieldGet(this, _Scheduler_batch, "f")[0])
+        : __classPrivateFieldGet(this, _Scheduler_batch, "f")[0];
+    __classPrivateFieldGet(this, _Scheduler_batch, "f").splice(__classPrivateFieldGet(this, _Scheduler_batch, "f").indexOf(chosen), 1);
+    if (chosen.session)
+        this.hotSessions.set(turnId, chosen.session);
+    return chosen;
+}, _Scheduler_sampleFreeSlots = 
+/**
+ * The engine's idle slot count, or null when it cannot be sampled - in which
+ * case the static profile count is the best available answer rather than
+ * "wait forever". Also carries the free slot ids when the engine reports
+ * them, so `#pass` can pin each admitted job to a distinct one.
+ */
+async function _Scheduler_sampleFreeSlots() {
+    if (!this.freeSlots)
+        return null;
+    try {
+        const free = await this.freeSlots();
+        if (free === null || free === undefined || (typeof free === "number" && Number.isNaN(free)))
+            return null;
+        if (typeof free === "number")
+            return { idle: Math.max(0, free) };
+        return {
+            idle: Math.max(0, free.idle),
+            ...(Array.isArray(free.ids) && free.ids.length > 0 ? { ids: free.ids } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}, _Scheduler_pollForSlot = function _Scheduler_pollForSlot() {
+    if (__classPrivateFieldGet(this, _Scheduler_slotTimer, "f"))
+        return;
+    __classPrivateFieldSet(this, _Scheduler_slotTimer, setTimeout(() => {
+        __classPrivateFieldSet(this, _Scheduler_slotTimer, null, "f");
+        void __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_dispatch).call(this);
+    }, this.slotPollMs), "f");
+}, _Scheduler_start = 
+/**
+ * Start a job and wire its completion back into the dispatcher. The settle
+ * callback is what asks for the next decision. `await`ed by the pass: a
+ * handoff erase must reach the engine's task queue BEFORE this job's
+ * completion is posted (see OWNERSHIP), so the pass yields for the erase.
+ */
+async function _Scheduler_start(job) {
+    __classPrivateFieldGet(this, _Scheduler_running, "f").add(job);
+    if (job.exclusive)
+        this.activeJob = job;
+    // Name the slot this job is admitted to, from this pass's own sample,
+    // before `run()` is invoked. One id per job, never reused: two jobs
+    // admitted in the same pass must never be pinned to the same slot.
+    if (!job.exclusive && job.onSlotFree) {
+        const slotId = __classPrivateFieldGet(this, _Scheduler_freeSlotIds, "f") ? (__classPrivateFieldGet(this, _Scheduler_freeSlotIds, "f").shift() ?? null) : null;
+        job.slotId = slotId;
+        // OWNERSHIP: the slot now belongs to this job's session. A job may only
+        // reuse a slot's KV when it is the same session that last ran there -
+        // llama-server keeps a released slot's prompt, so a different session
+        // would inherit the previous chat's KV (the cross-chat bleed). Erase the
+        // slot - and WAIT for the engine to acknowledge it - before the job's
+        // run() reaches the engine, so the handoff lands in the engine's task
+        // queue ahead of this completion. Same-session reuse keeps the KV: that
+        // is the cache --cache-ram exists to protect, and settling never erases.
+        if (slotId !== null) {
+            // A slot with NO entry is fresh (just launched, or just relaunched):
+            // it holds nothing, so nothing may be erased for it - the first chat
+            // to land there is the one the KV is being paid for. A slot WITH an
+            // entry holds that session's KV (or a keyless client's, recorded as
+            // null): handing it to a DIFFERENT session would inherit that KV, so
+            // the erase is owed. The entry's mere existence is the distinction -
+            // `get() ?? null` collapses it and erases fresh slots.
+            const hasPrevious = this.slotOwners.has(slotId);
+            const previous = this.slotOwners.get(slotId) ?? null;
+            if (hasPrevious && previous !== job.session) {
+                await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_eraseFor).call(this, slotId, previous, job.session);
+            }
+            this.slotOwners.set(slotId, job.session);
+        }
+        try {
+            job.onSlotFree(slotId);
+        }
+        catch {
+            // Slot attribution must never fail the job it belongs to.
+        }
+    }
+    __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
+    void (async () => {
+        try {
+            job.onStart?.();
+            job.resolve(await job.run());
+        }
+        catch (error) {
+            job.reject(error);
+        }
+        finally {
+            __classPrivateFieldGet(this, _Scheduler_running, "f").delete(job);
+            if (this.activeJob === job)
+                this.activeJob = null;
+            // OWNERSHIP: settling does NOT erase and does NOT clear the owner entry.
+            // The engine keeps a released slot's KV indefinitely (nothing in our
+            // configuration clears or parks it - see OWNERSHIP in the header), and
+            // that is exactly what this job's session wants back on its next turn:
+            // the chat's KV, paid for once, reused on every following request.
+            // Erasing here would hand the same chat its own re-prefill cost, and a
+            // DIFFERENT chat is protected the moment it is admitted, when the
+            // owner mismatch is known for sure. So the slot keeps its KV and its
+            // owner until the next admission - whoever that is - decides otherwise.
+            __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
+            void __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_dispatch).call(this);
+        }
+    })();
+}, _Scheduler_eraseFor = 
+/**
+ * Erase one slot's KV before it is handed to a different owner (see
+ * OWNERSHIP). `from` is the session whose KV the slot currently holds
+ * (null for a keyless previous owner), `to` is the session about to run on
+ * it. Resolves once the engine acknowledges the erase, so the caller can
+ * post the new completion only after the clean state is guaranteed to sit
+ * in the engine's task queue first. Never throws or rejects: a failure
+ * degrades to the old (bleedy) behavior but must not fail the completion it
+ * protects.
+ */
+async function _Scheduler_eraseFor(slotId, from, to) {
+    if (!this.eraseSlot)
+        return;
+    try {
+        this.logger?.(`erasing slot ${slotId} before handoff${from ? ` from ${from}` : ""} to ${to}`);
+        await this.eraseSlot(slotId);
+    }
+    catch (error) {
+        this.logger?.(`slot ${slotId} erase failed: ${describeError(error)}`);
+    }
+}, _Scheduler_dispatch = 
+/**
+ * Ask for a scheduling decision. Safe to call from anywhere, any number of
+ * times: overlapping calls collapse into one more pass after the current one,
+ * so the state a pass reads never moves underneath it.
+ */
+async function _Scheduler_dispatch() {
+    if (__classPrivateFieldGet(this, _Scheduler_busy, "f")) {
+        __classPrivateFieldSet(this, _Scheduler_dirty, true, "f");
+        return;
+    }
+    __classPrivateFieldSet(this, _Scheduler_busy, true, "f");
+    try {
+        do {
+            __classPrivateFieldSet(this, _Scheduler_dirty, false, "f");
+            await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_pass).call(this);
+        } while (__classPrivateFieldGet(this, _Scheduler_dirty, "f"));
+    }
+    finally {
+        __classPrivateFieldSet(this, _Scheduler_busy, false, "f");
+    }
+}, _Scheduler_resetSlots = function _Scheduler_resetSlots() {
+    this.forgetSlots();
+    __classPrivateFieldSet(this, _Scheduler_freeSlotIds, null, "f");
+}, _Scheduler_pass = 
+/**
+ * One decision pass: start as many jobs as residency, exclusivity, the turn
+ * boundary and capacity allow, then return. Each iteration re-derives
+ * everything, so there is no state to keep consistent between them.
+ */
+async function _Scheduler_pass() {
+    // The engine's idle count, sampled at most once per pass, plus how many
+    // jobs this pass has started against it (the sample cannot see those yet).
+    let measured = null;
+    let sampled = false;
+    let startedHere = 0;
+    // Distinct slot ids this pass may pin, one per admitted job. Refilled from
+    // the sample the first time capacity is checked; consumed in `#start`.
+    __classPrivateFieldSet(this, _Scheduler_freeSlotIds, null, "f");
+    for (;;) {
+        // An exclusive operation owns the engine alone.
+        if (this.activeJob !== null)
+            return;
+        // 1. Between turns: a turn may only begin on a drained engine, because
+        //    it may need a different model resident.
+        if (__classPrivateFieldGet(this, _Scheduler_turnId, "f") === null) {
+            if (__classPrivateFieldGet(this, _Scheduler_running, "f").size > 0)
+                return; // its settle callback re-dispatches
+            if (this.queue.length === 0)
+                return; // idle
+            // Prefer a model other than the one that just ran, so two sides
+            // alternate; fall back to the head when only one model is waiting.
+            const pick = this.queue.find((job) => job.modelId !== this.lastTurnId) ?? this.queue[0];
+            if (this.loadedId !== pick.modelId) {
+                try {
+                    this.logger?.(`switching to ${pick.model.displayName}`);
+                    await this.loadModel(pick.model);
+                }
+                catch (error) {
+                    // The model would not load - fail exactly its queued jobs, move on.
+                    for (const job of __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, (j) => j.modelId === pick.modelId))
+                        job.reject(error);
+                    continue;
+                }
+                // A relaunched engine has all its slots back; the old sample is void,
+                // and slot ids do not survive the relaunch, so the owners that named
+                // them are void too - a stale entry would make the next admission
+                // erase a FRESH slot (an unnecessary re-prefill) or mistake a keyless
+                // job for its owner.
+                sampled = false;
+                startedHere = 0;
+                __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_resetSlots).call(this);
             }
-            catch (error) {
-                job.reject(error);
+            __classPrivateFieldSet(this, _Scheduler_turnId, pick.modelId, "f");
+            this.lastTurnId = pick.modelId;
+            __classPrivateFieldSet(this, _Scheduler_batch, __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_takeTurn).call(this, pick.modelId), "f");
+            __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
+        }
+        const turnId = __classPrivateFieldGet(this, _Scheduler_turnId, "f");
+        // 2. Batch drained: keep the turn open by absorbing the queue head when
+        //    it belongs to this turn. This is what lets a steady stream of chats
+        //    each hold their own slot instead of trading one.
+        if (__classPrivateFieldGet(this, _Scheduler_batch, "f").length === 0) {
+            const head = this.queue[0];
+            if (head !== undefined && !head.exclusive && head.modelId === turnId) {
+                __classPrivateFieldSet(this, _Scheduler_batch, __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, (job) => job === head), "f");
+            }
+            else {
+                // Boundary: another model's job, an exclusive operation, or nothing.
+                // The turn ends as soon as its own jobs have drained.
+                if (__classPrivateFieldGet(this, _Scheduler_running, "f").size > 0)
+                    return;
+                __classPrivateFieldSet(this, _Scheduler_turnId, null, "f");
+                __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
+                if (this.queue.length === 0)
+                    return;
+                continue; // pick the next turn
             }
         }
-    };
-    const pool = [];
-    for (let i = 0; i < Math.min(this.concurrency, jobs.length); i += 1)
-        pool.push(worker());
-    await Promise.all(pool);
+        // 3. An exclusive operation runs alone, on a drained engine. (Awaited:
+        // `#start` may pause on a handoff erase, and the pass must not read or
+        // mutate the state a started job depends on while it is in flight.)
+        if (__classPrivateFieldGet(this, _Scheduler_batch, "f").length === 1 && __classPrivateFieldGet(this, _Scheduler_batch, "f")[0].exclusive) {
+            if (__classPrivateFieldGet(this, _Scheduler_running, "f").size > 0)
+                return;
+            await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_start).call(this, __classPrivateFieldGet(this, _Scheduler_batch, "f").shift());
+            return;
+        }
+        // 4. Capacity. The ceiling is the KV pool we own; the measurement is
+        //    there to notice slots taken by traffic we did not schedule. They
+        //    are combined, never both subtracted - see CAPACITY in the header.
+        if (!sampled) {
+            measured = await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_sampleFreeSlots).call(this);
+            sampled = true;
+            // Drop any id a running job already holds. That job may have been
+            // admitted only moments ago and not yet reached the engine, so this
+            // sample can still see its slot idle; handing the same id out twice
+            // would pin two requests to one slot (see `QueuedJob.slotId`).
+            const held = new Set();
+            for (const job of __classPrivateFieldGet(this, _Scheduler_running, "f"))
+                if (job.slotId !== null)
+                    held.add(job.slotId);
+            const ids = measured?.ids?.filter((id) => !held.has(id)) ?? null;
+            __classPrivateFieldSet(this, _Scheduler_freeSlotIds, ids && ids.length > 0 ? ids : null, "f");
+        }
+        const room = Math.min(this.concurrency - __classPrivateFieldGet(this, _Scheduler_running, "f").size, measured === null ? Number.POSITIVE_INFINITY : measured.idle - startedHere);
+        if (room < 1) {
+            if (__classPrivateFieldGet(this, _Scheduler_running, "f").size === 0)
+                __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_pollForSlot).call(this);
+            return;
+        }
+        // 5. Start the next job. Affinity decides which of the batch goes first.
+        const job = __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_claimJob).call(this, turnId);
+        if (!job)
+            return;
+        startedHere += 1;
+        await __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_start).call(this, job);
+    }
 };
 //# sourceMappingURL=scheduler.js.map

package/dist/service/serve.d.ts

@@ -1,7 +1,11 @@
 import http from "node:http";
 import type { BrainConfig } from "../config/schema.js";
 import type { Model } from "../types.js";
+import { type HostJob } from "./host-api.js";
 import { Supervisor } from "./supervisor.js";
+/** Model pulls only write the model store, so independent entries can transfer together. */
+export declare function canRunAlongsideModelPull(kind: HostJob["kind"]): boolean;
+export declare function componentOnlyArgs(args: string[], components: string[]): string[];
 /**
  * Pull the client's presented key from the request. Accepts, in order, an
  * `Authorization: Bearer …`, an `x-api-key` (OpenAI/Anthropic convention, and