@aron98/load-lock 1.2.1 → 1.4.0

package/dist/core/daemon.js

@@ -20,11 +20,21 @@ import { createServer } from "node:net";
 import { existsSync, mkdirSync, unlinkSync, writeFileSync, readFileSync, rmSync } from "node:fs";
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
+import { spawn } from "node:child_process";
 import { Machine } from "./state.js";
 import { loadState, saveState, loadJournal, saveJournal, socketPath as defaultSocket, stateDir as defaultStateDir } from "./persist.js";
 import { inspectMachine } from "./sysinfo.js";
 import { ProtocolError } from "../shared/protocol.js";
 import { isWindows, probeTransport } from "../shared/transport.js";
+import { packageVersion, compareVersions } from "../shared/version.js";
+/** Package version of the copy of load-lock this daemon process runs from. */
+const DAEMON_VERSION = packageVersion();
+/**
+ * Env marker set on the respawned daemon: the version this process already
+ * restarted for. Prevents restart loops when a newer client pings twice —
+ * only one respawn per version bump.
+ */
+const RESTARTED_FOR_ENV = "LOAD_LOCK_RESTARTED_FOR";
 export class Daemon {
     machine;
     server = null;
@@ -34,11 +44,14 @@ export class Daemon {
      *  restart via the event cursor) and the process can exit promptly. */
     conns = new Set();
     waiters = new Map();
+    /** wait_for_completion calls blocked on tracked jobs; multiple waiters per job are fine. */
+    completionWaiters = new Map();
     sentEventId;
     stateDirPath;
     socketPath;
     sweepTimer = null;
     expiryTimer = null;
+    restartTimer = null;
     stopped = false;
     constructor(opts = {}) {
         this.stateDirPath = defaultStateDir(opts.stateDir);
@@ -104,10 +117,28 @@ export class Daemon {
         if (this.stopped)
             return;
         this.stopped = true;
+        // Resolve blocked wait_for_completion calls first so no promise dangles.
+        // Responses may not make it out (conns are destroyed below) — that is
+        // fine: clients see the disconnect, reconnect, and re-issue the wait.
+        for (const [, waiters] of this.completionWaiters) {
+            for (const w of waiters) {
+                clearTimeout(w.timer);
+                w.resolve({
+                    state: "job_unknown",
+                    requestId: w.requestId,
+                    waitedMs: this.machine.now() - w.registeredAt,
+                    nextAction: "daemon is stopping — call wait_for_completion again after it is back",
+                    detail: "daemon stopping",
+                });
+            }
+        }
+        this.completionWaiters.clear();
         if (this.sweepTimer)
             clearInterval(this.sweepTimer);
         if (this.expiryTimer)
             clearTimeout(this.expiryTimer);
+        if (this.restartTimer)
+            clearTimeout(this.restartTimer);
         for (const w of this.watchers)
             w.socket.destroy();
         this.watchers.clear();
@@ -171,6 +202,8 @@ export class Daemon {
             this.send(sock, { id: null, ok: false, error: { code: "invalid", message: "malformed JSON line" } });
             return;
         }
+        // Version handshake: remember the client's version for skew detection.
+        const clientVersion = typeof msg.clientVersion === "string" ? msg.clientVersion : undefined;
         let result;
         let agentId;
         try {
@@ -187,6 +220,9 @@ export class Daemon {
             else {
                 this.send(sock, { id: msg.id, ok: false, error: { code: "internal", message: String(err?.message ?? err) } });
             }
+            // Respond first, then consider a self-restart — even on errors, a
+            // newer client means this daemon is running stale on-disk code.
+            this.maybeScheduleSelfRestart(clientVersion);
             return;
         }
         // Tool-boundary delivery: surface this agent's outstanding offers/queue
@@ -195,6 +231,63 @@ export class Daemon {
             result.pending = this.machine.pending(agentId);
         }
         this.send(sock, { id: msg.id, ok: true, result });
+        this.maybeScheduleSelfRestart(clientVersion);
+    }
+    // -------------------------------------------------------- version handshake
+    /**
+     * Self-restart handshake (issue #34): if a client identifies a NEWER
+     * package version than this daemon runs, schedule a respawn so the daemon
+     * picks up the updated on-disk code (e.g. after `npm i -g
+     * @aron98/load-lock` while the daemon kept running). Skew detection is
+     * entirely daemon-side and best-effort: pre-handshake clients that send
+     * no version never trigger a restart.
+     */
+    maybeScheduleSelfRestart(clientVersion) {
+        if (this.stopped || this.restartTimer || !clientVersion)
+            return;
+        if (compareVersions(clientVersion, DAEMON_VERSION) <= 0)
+            return;
+        const restartedFor = process.env[RESTARTED_FOR_ENV];
+        if (restartedFor && compareVersions(clientVersion, restartedFor) <= 0)
+            return; // already tried
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            this.selfRestart(clientVersion);
+        }, 250);
+        this.restartTimer.unref?.();
+    }
+    /**
+     * Drain + respawn onto the updated on-disk code. Persists state and the
+     * journal FIRST, then stops (destroying all client connections — they
+     * reconnect to the fresh daemon), then spawns the replacement with the
+     * exact same argv so a daemon started via the old copy runs the new copy's
+     * code, and exits.
+     */
+    selfRestart(clientVersion) {
+        if (this.stopped)
+            return;
+        // Best-effort persistence; a failed save must not block the restart.
+        try {
+            saveState(this.stateDirPath, this.machine.config, this.machine.history);
+            saveJournal(this.stateDirPath, this.machine.journalEntries());
+        }
+        catch {
+            /* journal is best-effort */
+        }
+        this.stop();
+        try {
+            const child = spawn(process.execPath, process.argv.slice(1), {
+                detached: true,
+                stdio: "ignore",
+                cwd: process.cwd(),
+                env: { ...process.env, [RESTARTED_FOR_ENV]: clientVersion },
+            });
+            child.unref();
+        }
+        catch {
+            /* if the respawn fails the next client contact re-triggers it */
+        }
+        process.exit(0);
     }
     // --------------------------------------------------------------- dispatch
     /** Returns [result, agentIdForPendingAttachment]. */
@@ -202,7 +295,10 @@ export class Daemon {
         const m = this.machine;
         switch (method) {
             case "hello":
-                return [{ protocolVersion: 1, pid: process.pid, startedAt: m.startedAt, configVersion: m.config.version }, undefined];
+                return [
+                    { protocolVersion: 1, pid: process.pid, startedAt: m.startedAt, configVersion: m.config.version, daemonVersion: DAEMON_VERSION },
+                    undefined,
+                ];
             case "acquire": {
                 const params = p;
                 let res = m.acquire(params);
@@ -265,8 +361,11 @@ export class Daemon {
                 const res = m.pending(String(p.agentId));
                 return [res, String(p.agentId)];
             }
-            case "status":
-                return [m.status(p.pool ? String(p.pool) : undefined), undefined];
+            case "status": {
+                const res = m.status(p.pool ? String(p.pool) : undefined);
+                res.daemon.daemonVersion = DAEMON_VERSION;
+                return [res, undefined];
+            }
             case "get_config":
                 return [m.get_config(), undefined];
             case "configure": {
@@ -314,6 +413,24 @@ export class Daemon {
                 m.adminRelease(String(p.requestId));
                 return [{ ok: true }, undefined];
             }
+            case "wait_for_completion": {
+                // Bounded "sleep until the job finishes" for a daemon-tracked job
+                // (issue #36) — the execution-phase counterpart of wait_for_turn.
+                const requestId = String(p.requestId ?? "");
+                if (!requestId)
+                    throw new ProtocolError("invalid", "wait_for_completion: requestId is required");
+                const requested = Number(p.timeoutMs ?? 0);
+                if (!Number.isFinite(requested) || requested < 0) {
+                    throw new ProtocolError("invalid", "wait_for_completion: timeoutMs must be a non-negative number of milliseconds");
+                }
+                // Same bounded-sleep contract as wait_for_turn: one call is capped by
+                // maxTurnWaitMs; longer waits are checkpointed (still_running) and re-issued.
+                const timeoutMs = Math.min(requested, m.config.maxTurnWaitMs);
+                const res = await this.waitForJobCompletion(requestId, timeoutMs);
+                if (timeoutMs !== requested)
+                    res.effectiveWaitMs = timeoutMs;
+                return [res, undefined];
+            }
             default:
                 throw new ProtocolError("invalid", `unknown method "${method}"`);
         }
@@ -333,6 +450,181 @@ export class Daemon {
             this.waiters.set(requestId, { requestId, resolve, timer });
         });
     }
+    // ---------------------------------------------- wait_for_completion (issue #36)
+    /**
+     * Bounded blocking wait for a daemon-tracked job's completion. Mirrors
+     * waitForAdmission: the call is held server-side and woken by
+     * resolveCompletionWaiters() when the job is observed done — which always
+     * happens AFTER the permit has been released (finish() frees capacity
+     * before the event is emitted, and waiters are resolved after that).
+     * timeoutMs 0 is check-only. Never blocks unbounded.
+     */
+    async waitForJobCompletion(requestId, timeoutMs) {
+        const m = this.machine;
+        let entry;
+        try {
+            entry = m.entryById(requestId);
+        }
+        catch {
+            return {
+                state: "job_unknown",
+                requestId,
+                waitedMs: 0,
+                nextAction: "no request with this id exists (yet) — check the id, or acquire first",
+                detail: "unknown request id",
+            };
+        }
+        if (entry.state === "held") {
+            if (entry.phase !== "running_tracked") {
+                const why = entry.phase === "claimed"
+                    ? "permit is held but no process is attached yet — start the job (run_with_permit / attach_pid / start_job) first"
+                    : "permit is running untracked (no process association) — completion is not observable; attach a pid or poll your job directly";
+                return { state: "job_unknown", requestId, waitedMs: 0, startedAt: entry.startedAt, nextAction: why, detail: `held permit in phase "${entry.phase}"` };
+            }
+            if (timeoutMs === 0) {
+                return {
+                    state: "still_running",
+                    requestId,
+                    waitedMs: 0,
+                    startedAt: entry.startedAt,
+                    nextAction: "job still running — call wait_for_completion again (with a timeout) to sleep until it finishes",
+                    detail: "check-only",
+                };
+            }
+            // Register a completion waiter; woken by resolveCompletionWaiters()
+            // when the job ends, or checkpointed by the bounded timer below.
+            return await new Promise((resolve) => {
+                const registeredAt = m.now();
+                const waiter = {
+                    requestId,
+                    resolve,
+                    timer: null,
+                    registeredAt,
+                };
+                waiter.timer = setTimeout(() => {
+                    const arr = this.completionWaiters.get(requestId);
+                    if (arr) {
+                        const idx = arr.indexOf(waiter);
+                        if (idx >= 0)
+                            arr.splice(idx, 1);
+                        if (arr.length === 0)
+                            this.completionWaiters.delete(requestId);
+                    }
+                    resolve({
+                        state: "still_running",
+                        requestId,
+                        waitedMs: m.now() - registeredAt,
+                        startedAt: entry.startedAt,
+                        nextAction: "job still running — call wait_for_completion again to keep sleeping honestly",
+                        detail: "wait budget elapsed",
+                    });
+                }, timeoutMs);
+                waiter.timer.unref?.();
+                const arr = this.completionWaiters.get(requestId) ?? [];
+                arr.push(waiter);
+                this.completionWaiters.set(requestId, arr);
+            });
+        }
+        // Terminal or pre-execution states: classify from the entry's last event.
+        return this.classifyEntryCompletion(requestId, 0);
+    }
+    /**
+     * Classify a request whose entry is no longer held (released, reclaimed,
+     * cancelled, or never started) into a structured completion result, using
+     * the most recent event for the request.
+     */
+    classifyEntryCompletion(requestId, waitedMs) {
+        const m = this.machine;
+        const ev = m.lastEventForRequest(requestId, 0);
+        const startedAt = ev?.entry?.startedAt;
+        if (!ev) {
+            return {
+                state: "job_unknown",
+                requestId,
+                waitedMs,
+                nextAction: "no completion is observable for this request id — verify the id or re-acquire",
+                detail: "entry is no longer held and no matching event was found",
+            };
+        }
+        switch (ev.type) {
+            case "released":
+            case "auto_released":
+                return {
+                    state: "finished",
+                    requestId,
+                    durationMs: startedAt !== undefined ? ev.ts - startedAt : undefined,
+                    permitReleased: true,
+                    waitedMs,
+                    startedAt,
+                    nextAction: "job finished and the permit is released — capacity is free; proceed with the next step",
+                    detail: ev.detail,
+                };
+            case "reclaimed":
+                if ((ev.detail ?? "").includes("admin")) {
+                    return {
+                        state: "stopped_by_request",
+                        requestId,
+                        waitedMs,
+                        startedAt,
+                        nextAction: "the permit was force-released by an admin while you were waiting — re-acquire before running more heavy work",
+                        detail: ev.detail,
+                    };
+                }
+                return {
+                    state: "job_unknown",
+                    requestId,
+                    waitedMs,
+                    startedAt,
+                    nextAction: "the permit was reclaimed before completion could be observed — re-acquire before running more heavy work",
+                    detail: ev.detail,
+                };
+            case "cancelled":
+                return {
+                    state: "job_unknown",
+                    requestId,
+                    waitedMs,
+                    startedAt,
+                    nextAction: "the request was cancelled — re-acquire before running more heavy work",
+                    detail: ev.detail,
+                };
+            default:
+                return {
+                    state: "job_unknown",
+                    requestId,
+                    waitedMs,
+                    startedAt,
+                    nextAction: "no completion is observable for this request id — verify the id or re-acquire",
+                    detail: `entry is in state "${ev.entry?.state ?? "unknown"}" (last event: ${ev.type})`,
+                };
+        }
+    }
+    /**
+     * Wake blocked wait_for_completion calls whose tracked job has ended.
+     * Called after every machine transition (afterOp, sweep, expiry timer) —
+     * always AFTER finish() has freed capacity and after the event flush, so
+     * a woken agent observes the pool as free. Entries still held are skipped.
+     */
+    resolveCompletionWaiters() {
+        if (this.completionWaiters.size === 0)
+            return;
+        const m = this.machine;
+        for (const [requestId, waiters] of [...this.completionWaiters]) {
+            let entry;
+            try {
+                entry = m.entryById(requestId);
+            }
+            catch {
+                entry = undefined;
+            }
+            if (entry && entry.state === "held")
+                continue; // job still running
+            this.completionWaiters.delete(requestId);
+            for (const w of waiters) {
+                clearTimeout(w.timer);
+                w.resolve(this.classifyEntryCompletion(requestId, m.now() - w.registeredAt));
+            }
+        }
+    }
     // ------------------------------------------------------------- post-op pass
     /** Runs after every dispatch: sweep deadlines, auto-claim for waiters, flush events, journal. */
     afterOp() {
@@ -367,6 +659,10 @@ export class Daemon {
             for (const ev of fresh)
                 this.broadcast(ev);
         }
+        // Wake completion waiters whose job ended in this op — after the events
+        // flushed, i.e. after finish() already freed the capacity (ordering
+        // guarantee: a woken agent sees the pool as free).
+        this.resolveCompletionWaiters();
         // Persist held permits for restart reconciliation.
         try {
             saveJournal(this.stateDirPath, m.journalEntries());
@@ -393,6 +689,8 @@ export class Daemon {
                 for (const ev of fresh)
                     this.broadcast(ev);
             }
+            // Reclaims performed by the tick above must also wake waiters.
+            this.resolveCompletionWaiters();
             try {
                 saveJournal(this.stateDirPath, this.machine.journalEntries());
             }
@@ -452,6 +750,10 @@ export class Daemon {
             for (const ev of fresh)
                 this.broadcast(ev);
         }
+        // Wake completion waiters woken by this sweep (tracked job confirmed
+        // dead => auto-released above) — after capacity was freed and events
+        // flushed, per the wake ordering guarantee.
+        this.resolveCompletionWaiters();
     }
 }
 // --------------------------------------------------------------------- helpers

package/dist/core/persist.js

@@ -3,9 +3,11 @@
  * State dir: $XDG_STATE_HOME/load-lock (default ~/.local/state/load-lock;
  * Windows: %LOCALAPPDATA%\load-lock — see shared/transport.ts).
  *
- * Only *configuration* persists across daemon restarts. Permits and queue
- * are ephemeral by design (see docs/ARCHITECTURE.md — restart behavior):
- * tokens are daemon-instance-scoped, and agents re-acquire after a restart.
+ * Configuration persists across daemon restarts, plus the journal
+ * (journal.json): held permits AND queued/offered requests. Held permits
+ * are restored conservatively (tracked jobs re-checked for liveness, same
+ * permit tokens so late releases stay idempotent); queued requests are
+ * re-queued FIFO with the same requestIds (see docs/ARCHITECTURE.md).
  */
 import { mkdirSync, writeFileSync, renameSync, readFileSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";

package/dist/core/state.d.ts

@@ -75,6 +75,11 @@ export declare class Machine {
     /** Events with id > since, newest last. */
     eventsSince(since: number, agentId?: string, limit?: number): MachineEvent[];
     latestEventId(): number;
+    /**
+     * Newest event with id > `since` whose entry is the given request, or null.
+     * Scans backwards, so the first match is the most recent one.
+     */
+    lastEventForRequest(requestId: string, since: number): MachineEvent | null;
     private emit;
     snapshot(e: Entry): EntrySnapshot;
     private ownerSnapshot;
@@ -180,16 +185,18 @@ export declare class Machine {
     get_config(): GetConfigResult;
     configure(p: ConfigureParams): ConfigureResult;
     history: ConfigHistoryEntry[];
-    /** Held permits to persist for conservative restart reconciliation. */
+    /** Held permits (first) and queued/offered requests to persist across restarts. */
     journalEntries(): JournalEntry[];
     /**
-     * Restore held permits after a daemon restart (conservative reconciliation):
+     * Restore state after a daemon restart (conservative reconciliation):
+     *  - queued (incl. previously offered): re-queued FIFO by original enqueue
+     *    time, same requestIds so idempotent re-acquire still works; pools no
+     *    longer in the config are dropped. Offered entries restart as queued
+     *    and get a fresh offer (old offer tokens are invalid after restart).
      *  - tracked: re-check liveness via the supplied probe; dead => release,
      *    alive => keep (same token, so a late explicit release still works).
      *  - claimed: keep the start deadline (reclaimed by tick if already past).
      *  - untracked: keep, with a FRESH lease window from restore time.
-     * Queued/offered requests are deliberately NOT restored — queued agents
-     * re-acquire (documented restart behavior).
      */
     restore(journal: JournalEntry[], liveness: (e: {
         pid?: number;
@@ -198,6 +205,7 @@ export declare class Machine {
     }) => boolean | null): {
         kept: number;
         releasedDead: number;
+        queued: number;
     };
 }
 export {};

package/dist/core/state.js

@@ -87,6 +87,20 @@ export class Machine {
     latestEventId() {
         return this.nextEventId - 1;
     }
+    /**
+     * Newest event with id > `since` whose entry is the given request, or null.
+     * Scans backwards, so the first match is the most recent one.
+     */
+    lastEventForRequest(requestId, since) {
+        for (let i = this.events.length - 1; i >= 0; i--) {
+            const ev = this.events[i];
+            if (ev.id <= since)
+                break;
+            if (ev.entry?.requestId === requestId)
+                return ev;
+        }
+        return null;
+    }
     emit(type, entry, extra) {
         const targetAgent = entry ? entry.agentId : "*";
         const ev = {
@@ -134,6 +148,8 @@ export class Machine {
             s.leaseDeadline = e.leaseDeadline;
         if (e.lastSeen)
             s.lastSeen = e.lastSeen;
+        if (e.startedAt !== undefined)
+            s.startedAt = e.startedAt;
         return s;
     }
     ownerSnapshot(e) {
@@ -830,7 +846,7 @@ export class Machine {
     }
     history = [];
     // ----------------------------------------------------------------- journal
-    /** Held permits to persist for conservative restart reconciliation. */
+    /** Held permits (first) and queued/offered requests to persist across restarts. */
     journalEntries() {
         const out = [];
         for (const e of this.entries.values()) {
@@ -845,6 +861,7 @@ export class Machine {
                 opKey: e.opKey,
                 reason: e.reason,
                 weight: e.weight,
+                state: "held",
                 permitToken: e.permitToken,
                 phase: e.phase ?? "claimed",
                 pid: e.pid,
@@ -855,21 +872,45 @@ export class Machine {
                 leaseDeadline: e.leaseDeadline,
             });
         }
+        for (const e of this.entries.values()) {
+            if (e.state !== "queued" && e.state !== "offered")
+                continue;
+            out.push({
+                requestId: e.id,
+                pool: e.pool,
+                agentId: e.agentId,
+                agentLabel: e.agentLabel,
+                cwd: e.cwd,
+                opKey: e.opKey,
+                reason: e.reason,
+                weight: e.weight,
+                state: "queued",
+                enqueuedAt: e.enqueuedAt ?? e.since,
+                claimedAt: e.since,
+            });
+        }
         return out;
     }
     /**
-     * Restore held permits after a daemon restart (conservative reconciliation):
+     * Restore state after a daemon restart (conservative reconciliation):
+     *  - queued (incl. previously offered): re-queued FIFO by original enqueue
+     *    time, same requestIds so idempotent re-acquire still works; pools no
+     *    longer in the config are dropped. Offered entries restart as queued
+     *    and get a fresh offer (old offer tokens are invalid after restart).
      *  - tracked: re-check liveness via the supplied probe; dead => release,
      *    alive => keep (same token, so a late explicit release still works).
      *  - claimed: keep the start deadline (reclaimed by tick if already past).
      *  - untracked: keep, with a FRESH lease window from restore time.
-     * Queued/offered requests are deliberately NOT restored — queued agents
-     * re-acquire (documented restart behavior).
      */
     restore(journal, liveness) {
         let kept = 0;
         let releasedDead = 0;
+        const queuedEntries = [];
         for (const j of journal) {
+            if (j.state === "queued") {
+                queuedEntries.push({ j, at: j.enqueuedAt ?? j.claimedAt });
+                continue;
+            }
             const e = {
                 id: j.requestId,
                 pool: j.pool,
@@ -882,20 +923,20 @@ export class Machine {
                 state: "held",
                 since: j.claimedAt,
                 permitToken: j.permitToken,
-                phase: j.phase,
+                phase: j.phase ?? "claimed",
                 pid: j.pid,
                 pgid: j.pgid,
                 pidStartTime: j.pidStartTime,
                 startedAt: j.startedAt,
                 lastSeen: this.now(),
             };
-            if (j.phase === "claimed") {
+            if (e.phase === "claimed") {
                 e.startDeadline = j.claimedAt + this.config.startTimeoutMs;
             }
-            else if (j.phase === "running_untracked") {
+            else if (e.phase === "running_untracked") {
                 e.leaseDeadline = this.now() + this.config.untrackedLeaseMs; // fresh window
             }
-            else if (j.phase === "running_tracked") {
+            else if (e.phase === "running_tracked") {
                 const alive = liveness(e);
                 if (alive === false) {
                     // Confirmed dead while we were down: release, but keep a terminal
@@ -915,11 +956,40 @@ export class Machine {
             this.byKey.set(`${e.agentId}\u0000${e.opKey}`, e.id);
             kept++;
         }
+        // Re-queue queued requests, oldest first, preserving FIFO fairness.
+        queuedEntries.sort((a, b) => a.at - b.at);
+        let queued = 0;
+        for (const { j } of queuedEntries) {
+            if (!this.config.pools[j.pool])
+                continue; // pool removed while down
+            const e = {
+                id: j.requestId,
+                pool: j.pool,
+                agentId: j.agentId,
+                agentLabel: j.agentLabel,
+                cwd: j.cwd,
+                opKey: j.opKey,
+                reason: j.reason,
+                weight: j.weight,
+                state: "queued",
+                since: this.now(),
+                enqueuedAt: j.enqueuedAt ?? j.claimedAt,
+            };
+            this.entries.set(e.id, e);
+            this.byKey.set(`${e.agentId}\u0000${e.opKey}`, e.id);
+            if (!this.queues.has(e.pool))
+                this.queues.set(e.pool, []);
+            this.queues.get(e.pool).push(e.id);
+            queued++;
+        }
+        // Admit newly-eligible waiters (capacity freed while we were down).
+        for (const name of this.poolNames())
+            this.admit(name);
         this.pushEvent({
             type: "daemon_recovered",
             targetAgent: "*",
-            detail: `restored ${kept} held permit(s) from journal (${releasedDead} confirmed dead and released)`,
+            detail: `restored ${kept} held permit(s) from journal (${releasedDead} confirmed dead and released); re-queued ${queued} waiting request(s)`,
         });
-        return { kept, releasedDead };
+        return { kept, releasedDead, queued };
     }
 }

package/dist/dashboard/frame.js

@@ -59,13 +59,17 @@ export function renderFrame(view, width = 100, height = 40) {
     const syncAge = view.lastSyncAt ? fmtDuration(Math.max(0, view.now - view.lastSyncAt)) : "never";
     push(`load-lock dashboard — machine-wide heavy-work budget   ${state}   synced ${syncAge} ago`);
     if (view.daemon) {
-        push(`daemon pid ${view.daemon.pid} · uptime ${fmtDuration(view.daemon.uptimeMs)} · config v${view.daemon.configVersion} · protocol v${view.daemon.protocolVersion} · events through #${view.latestEventId}`);
+        push(`daemon pid ${view.daemon.pid} · uptime ${fmtDuration(view.daemon.uptimeMs)} · config v${view.daemon.configVersion} · protocol v${view.daemon.protocolVersion}` +
+            (view.daemon.daemonVersion ? ` · daemon v${view.daemon.daemonVersion}` : "") +
+            ` · events through #${view.latestEventId}`);
     }
     else {
         push(`daemon: unreachable — it auto-spawns on the next load-lock command`);
     }
     if (view.daemonRestartNote)
         push(`note: ${view.daemonRestartNote}`);
+    if (view.versionSkewNote)
+        push(`note: ${view.versionSkewNote}`);
     if (view.machine) {
         const m = view.machine;
         const cg = m.cgroupCpuQuota != null ? ` · cgroup ${m.cgroupVersion ?? ""} quota ${m.cgroupCpuQuota / 100} CPU` : "";

package/dist/dashboard/view.d.ts

@@ -105,6 +105,8 @@ export interface DaemonView {
     uptimeMs: number;
     protocolVersion: number;
     configVersion: number;
+    /** Package version of the daemon's code (pre-handshake daemons omit it). */
+    daemonVersion?: string;
 }
 /** The complete render-ready snapshot of the machine-wide budget. */
 export interface DashboardView {
@@ -112,6 +114,8 @@ export interface DashboardView {
     state: FeedState;
     /** False right after a daemon restart was detected (history was reset). */
     daemonRestartNote?: string;
+    /** Set when the running daemon is older than the installed copy. */
+    versionSkewNote?: string;
     daemon: DaemonView | null;
     pools: PoolView[];
     events: EventLine[];