@aron98/load-lock 0.0.0-stage → 0.1.0

package/dist/test/core.test.js

@@ -0,0 +1,281 @@
+/**
+ * Unit tests for the pure state machine (no I/O, injectable clock).
+ * Compile + run: npm test  (node --test dist/test/)
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Machine, defaultConfig } from "../core/state.js";
+import { ProtocolError } from "../shared/protocol.js";
+function mk(config = defaultConfig()) {
+    let t = 1_000_000; // fixed base for deterministic math
+    const clock = () => t;
+    return {
+        m: new Machine(clock, { ...config }),
+        advance: (ms) => {
+            t += ms;
+        },
+        now: () => t,
+    };
+}
+const A = "agentA", B = "agentB", C = "agentC";
+/** Current state of a request (snapshots returned by acquire() are frozen). */
+const stateOf = (m, id) => m.entryById(id).state;
+/** Current offer token of an agent's offered request. */
+const offerOf = (m, agentId) => {
+    const o = m.pending(agentId).offers[0];
+    assert.ok(o, `${agentId} should have an outstanding offer`);
+    return o.offerToken;
+};
+function grant(m, agent = A, op = "op1", extra = {}) {
+    const r = m.acquire({ agentId: agent, opKey: op, reason: "test", pool: "heavy", ...extra });
+    assert.equal(r.state, "granted", `expected grant for ${agent}`);
+    return r.entry;
+}
+test("immediate grant then FIFO queueing with positions", () => {
+    const { m } = mk();
+    const a = grant(m);
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    const c = m.acquire({ agentId: C, opKey: "op1", reason: "c" });
+    assert.equal(b.state, "queued");
+    assert.equal(c.state, "queued");
+    assert.equal(b.entry.position, 1);
+    assert.equal(c.entry.position, 2);
+    assert.equal(m.used("heavy"), 1);
+    // owner sees the permit token; the public snapshot never does
+    assert.ok(a.permitToken.startsWith("prm_"));
+    const st = m.status();
+    assert.equal(st.pools[0].holders[0].state, "held");
+    assert.equal(st.pools[0].holders[0].permitToken, undefined);
+    assert.equal(a.requestId, st.pools[0].holders[0].requestId);
+});
+test("idempotent acquire returns the same live request (tokens included)", () => {
+    const { m } = mk();
+    const a = grant(m, A, "op1");
+    const again = m.acquire({ agentId: A, opKey: "op1", reason: "again" });
+    assert.equal(again.state, "granted");
+    assert.equal(again.entry.requestId, a.requestId);
+    assert.equal(again.entry.permitToken, a.permitToken);
+    // distinct op keys are distinct requests
+    const other = m.acquire({ agentId: A, opKey: "op2", reason: "other" });
+    assert.equal(other.state, "queued");
+});
+test("strict FIFO offers on release; claim converts offer to permit", () => {
+    const { m } = mk();
+    const a = grant(m, A, "op1");
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    const c = m.acquire({ agentId: C, opKey: "op1", reason: "c" });
+    const bId = b.entry.requestId, cId = c.entry.requestId;
+    m.release(a.permitToken);
+    // B (head of queue) is offered, C stays queued
+    assert.equal(stateOf(m, bId), "offered");
+    assert.equal(stateOf(m, cId), "queued");
+    // outstanding offers consume capacity
+    assert.equal(m.used("heavy"), 1);
+    const bTok = offerOf(m, B);
+    assert.ok(bTok.startsWith("off_"));
+    const claimed = m.claim(bTok);
+    assert.equal(claimed.entry.state, "held");
+    assert.ok(claimed.entry.permitToken.startsWith("prm_"));
+    // duplicate claim of a consumed offer token is rejected
+    assert.throws(() => m.claim(bTok), (e) => e instanceof ProtocolError && e.code === "stale_token");
+});
+test("offer expiry pauses the request and passes capacity to the next waiter", () => {
+    const { m, advance } = mk();
+    const a = grant(m, A, "op1");
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    const c = m.acquire({ agentId: C, opKey: "op1", reason: "c" });
+    const bId = b.entry.requestId, cId = c.entry.requestId;
+    m.release(a.permitToken);
+    assert.equal(stateOf(m, bId), "offered");
+    const bTok = offerOf(m, B);
+    advance(30_001);
+    m.tick(m.now());
+    assert.equal(stateOf(m, bId), "paused");
+    assert.equal(stateOf(m, cId), "offered"); // capacity passed on
+    // claiming the expired offer is deterministically rejected
+    assert.throws(() => m.claim(bTok), (e) => e instanceof ProtocolError && e.code === "offer_expired");
+    assert.equal(stateOf(m, bId), "paused"); // never auto-recycled
+    // claim C's fresh offer, release -> free capacity
+    m.release(m.claim(offerOf(m, C)).entry.permitToken);
+    // rejoin goes to the tail of the FIFO (here: it's the only waiter)
+    const rejoined = m.rejoin({ requestId: bId });
+    assert.equal(rejoined.state, "offered");
+    assert.ok(rejoined.offerToken);
+});
+test("explicit decline frees the reserved capacity", () => {
+    const { m } = mk();
+    const a = grant(m, A, "op1");
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    const bId = b.entry.requestId;
+    m.release(a.permitToken);
+    m.decline(offerOf(m, B));
+    assert.equal(stateOf(m, bId), "paused");
+    const again = m.acquire({ agentId: A, opKey: "op2", reason: "again" });
+    assert.equal(again.state, "granted");
+});
+test("start deadline reclaims a claimed-but-never-started permit", () => {
+    const { m, advance } = mk();
+    const a = grant(m, A, "op1");
+    advance(120_001);
+    m.tick(m.now());
+    assert.equal(stateOf(m, a.requestId), "released");
+    // capacity freed: a fresh request grants directly
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    assert.equal(b.state, "granted");
+    // late explicit release of the reclaimed permit is idempotent, not an error
+    m.release(a.permitToken);
+});
+test("start_job is atomic against reclamation (race: tick first)", () => {
+    const { m, advance } = mk();
+    const a = grant(m, A, "op1");
+    advance(120_001);
+    m.tick(m.now()); // reclaims the never-started permit
+    assert.throws(() => m.startJob(a.permitToken, 12345, 12345), (e) => e instanceof ProtocolError && (e.code === "stale_token" || e.code === "wrong_state"));
+});
+test("start_job transitions to tracked; mark_started to untracked lease", () => {
+    const cfg = defaultConfig();
+    cfg.pools = { heavy: { capacity: 2 } };
+    const { m, advance } = mk(cfg);
+    const a = grant(m, A, "op1");
+    m.startJob(a.permitToken, 4242, 4242, "100");
+    assert.equal(m.entryById(a.requestId).phase, "running_tracked");
+    // tracked permits have no automatic deadline at all
+    advance(10 * 60_000);
+    m.tick(m.now());
+    assert.equal(stateOf(m, a.requestId), "held", "running tracked job is never revoked on duration");
+    const b = grant(m, B, "op1");
+    m.markStarted(b.permitToken);
+    assert.equal(m.entryById(b.requestId).phase, "running_untracked");
+    advance(14 * 60_000);
+    m.heartbeat(B); // adapter heartbeat renews the lease
+    advance(14 * 60_000);
+    m.tick(m.now());
+    assert.equal(stateOf(m, b.requestId), "held", "heartbeat renews the untracked lease");
+    advance(16 * 60_000);
+    m.tick(m.now());
+    assert.equal(stateOf(m, b.requestId), "released", "lease expires without heartbeats");
+});
+test("release is idempotent; cancel paths behave", () => {
+    const { m } = mk();
+    const a = grant(m, A, "op1");
+    // cancel a queued request
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    assert.equal(b.state, "queued");
+    const c = m.cancel({ requestId: b.entry.requestId });
+    assert.equal(c.entry.state, "cancelled");
+    // cancelling a held permit without admin fails
+    assert.throws(() => m.cancel({ requestId: a.requestId }), (e) => e instanceof ProtocolError);
+    // release: idempotent
+    const r1 = m.release(a.permitToken);
+    assert.equal(r1.releasedNow, true);
+    const r2 = m.release(a.permitToken);
+    assert.equal(r2.releasedNow, false);
+    assert.equal(r2.entry.state, "released");
+    // admin force-release works and frees capacity
+    const d = grant(m, C, "op1");
+    m.adminRelease(d.requestId);
+    assert.equal(stateOf(m, d.requestId), "released");
+});
+test("weighted requests: the FIFO head blocks lighter requests behind it", () => {
+    const cfg = defaultConfig();
+    cfg.pools = { heavy: { capacity: 3 } };
+    const { m } = mk(cfg);
+    const a = grant(m, A, "op1", { weight: 2 });
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b", weight: 2 });
+    const c = m.acquire({ agentId: C, opKey: "op1", reason: "c", weight: 2 });
+    const bId = b.entry.requestId, cId = c.entry.requestId;
+    assert.equal(b.state, "queued");
+    assert.equal(c.state, "queued"); // weight-2 head cannot be bypassed
+    m.release(a.permitToken);
+    assert.equal(stateOf(m, bId), "offered", "the heavy head is admitted first");
+    assert.equal(stateOf(m, cId), "queued", "the next heavy request still does not fit");
+    assert.equal(m.used("heavy"), 2);
+});
+test("configure: CAS versioning, capacity up admits, down never revokes", () => {
+    const { m } = mk();
+    const a = grant(m, A, "op1");
+    const b = m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    const bId = b.entry.requestId;
+    assert.equal(b.state, "queued");
+    // stale expected_version -> conflict
+    assert.throws(() => m.configure({ expectedVersion: 99, changes: {}, reason: "stale", author: "t" }), (e) => e instanceof ProtocolError && e.code === "version_conflict");
+    // capacity increase: queued request is admitted immediately
+    const r = m.configure({ expectedVersion: 1, changes: { pools: { heavy: { capacity: 2 } } }, reason: "more", author: "t" });
+    assert.equal(r.config.version, 2);
+    assert.equal(stateOf(m, bId), "offered");
+    // capacity decrease: holders keep their permits
+    m.configure({ expectedVersion: 2, changes: { pools: { heavy: { capacity: 1 } } }, reason: "less", author: "t" });
+    assert.equal(stateOf(m, a.requestId), "held");
+    // history persisted with author + reason
+    const hist = m.get_config().history;
+    assert.equal(hist.length, 2);
+    assert.equal(hist[1].author, "t");
+    assert.equal(hist[1].reason, "less");
+});
+test("events: durable identities, owner filtering, token stripping", () => {
+    const { m } = mk();
+    const a = grant(m, A, "op1");
+    m.acquire({ agentId: B, opKey: "op1", reason: "b" });
+    const before = m.latestEventId();
+    m.release(a.permitToken);
+    const evsB = m.eventsSince(before, B);
+    const offerB = evsB.find((e) => e.type === "offered");
+    assert.ok(offerB, "owner sees its own offered event");
+    const evsC = m.eventsSince(before, C);
+    assert.equal(evsC.find((e) => e.type === "offered"), undefined, "other agents do not see B's offered event");
+    const all = m.eventsSince(before, "*");
+    const offeredAll = all.filter((e) => e.type === "offered");
+    assert.ok(offeredAll.every((e) => e.entry.offerToken === undefined), "public event snapshots strip tokens");
+    assert.ok(all.every((e) => e.id > before && e.ts > 0), "durable event identities");
+    // claim tokens are attached by the daemon layer (owner-filtered pulls and
+    // watch pushes) — covered by the daemon integration tests.
+});
+test("journal: tracked-alive kept, tracked-dead released, claimed keeps deadline, untracked fresh lease", () => {
+    const cfg = defaultConfig();
+    cfg.pools = { heavy: { capacity: 4 } };
+    const { m, advance } = mk(cfg);
+    const a = grant(m, A, "alive");
+    m.startJob(a.permitToken, 111, 111, "start-111");
+    const b = grant(m, B, "dead");
+    m.startJob(b.permitToken, 222, 222, "start-222");
+    const c = grant(m, C, "claimed"); // never started
+    const d = grant(m, A, "untracked");
+    m.markStarted(d.permitToken);
+    const journal = m.journalEntries();
+    assert.equal(journal.length, 4);
+    const m2 = new Machine(() => m.now(), { ...defaultConfig() });
+    const res = m2.restore(journal, (e) => {
+        if (e.pid === 111)
+            return true; // alive
+        if (e.pid === 222)
+            return false; // dead
+        return null; // unknown
+    });
+    assert.equal(res.kept, 3);
+    assert.equal(res.releasedDead, 1);
+    // the restored permit keeps its token: a late explicit release works
+    const rel = m2.release(a.permitToken);
+    assert.equal(rel.releasedNow, true);
+    // restored claimed permit keeps the original start deadline
+    const before = m.now();
+    m2.tick(before + 1);
+    assert.equal(m2.entryById(c.requestId).state, "held");
+    m2.tick(before + 200_000);
+    assert.equal(m2.entryById(c.requestId).state, "released", "restored claimed permit still reclaims at its deadline");
+    // restored untracked permit got a fresh lease window
+    assert.equal(m2.entryById(d.requestId).phase, "running_untracked");
+    assert.ok(m2.entryById(d.requestId).leaseDeadline > before);
+});
+test("diagnose reports holder info and flags long holds without revoking", () => {
+    const { m, advance } = mk();
+    const a = grant(m, A, "op1");
+    m.startJob(a.permitToken, 333, 333, "start-333");
+    advance(31 * 60_000);
+    const diags = m.diagnose((e) => (e.pid === 333 ? true : null));
+    assert.equal(diags.length, 1);
+    assert.equal(diags[0].diagnostics.tracked, true);
+    assert.equal(diags[0].diagnostics.processAlive, true);
+    assert.equal(diags[0].diagnostics.longHold, true);
+    assert.equal(stateOf(m, a.requestId), "held", "long hold alone never revokes a running job");
+    assert.ok(diags[0].diagnostics.note.includes("pid 333"));
+});

package/dist/test/daemon.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/daemon.test.js

@@ -0,0 +1,384 @@
+/**
+ * Integration tests: a REAL daemon process over a real Unix socket, with
+ * multiple independent client connections (and separate CLI processes via
+ * run-helper/mcp tests). State dirs live in /tmp/opencode, never the user's.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { connect } from "node:net";
+import { fileURLToPath } from "node:url";
+import { LLClient } from "../shared/client.js";
+import { isProcessAlive, processStartTime } from "../core/daemon.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+mkdirSync(TMP_BASE, { recursive: true });
+const daemonMain = join(dirname(fileURLToPath(import.meta.url)), "..", "core", "daemon-main.js");
+async function startDaemon() {
+    const dir = mkdtempSync(join(TMP_BASE, "ll-daemon-"));
+    const sock = join(dir, "daemon.sock");
+    const child = spawn(process.execPath, [daemonMain, "--state-dir", dir, "--socket", sock], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, LOAD_LOCK_STATE_DIR: dir, LOAD_LOCK_SOCKET: sock },
+    });
+    const deadline = Date.now() + 10_000;
+    for (;;) {
+        if (await probe(sock))
+            break;
+        if (Date.now() > deadline) {
+            child.kill("SIGKILL");
+            throw new Error("daemon did not come up");
+        }
+        await delay(100);
+    }
+    const handle = {
+        child,
+        dir,
+        sock,
+        client: () => new LLClient({ socket: sock, stateDir: dir, spawnDaemon: false }),
+        stop: async () => {
+            if (child.exitCode === null && !child.killed) {
+                child.kill("SIGTERM");
+                await new Promise((resolve) => {
+                    const t = setTimeout(() => {
+                        child.kill("SIGKILL");
+                        resolve();
+                    }, 3000);
+                    child.once("exit", () => {
+                        clearTimeout(t);
+                        resolve();
+                    });
+                });
+            }
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+    return handle;
+}
+function probe(sock) {
+    return new Promise((resolve) => {
+        const s = connect(sock);
+        s.once("connect", () => {
+            s.destroy();
+            resolve(true);
+        });
+        s.once("error", () => resolve(false));
+    });
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function until(desc, fn, timeoutMs = 15_000, step = 200) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        if (await fn())
+            return;
+        if (Date.now() > deadline)
+            throw new Error(`timeout waiting for: ${desc}`);
+        await delay(step);
+    }
+}
+const ACQ = (agentId, opKey, extra = {}) => ({
+    agentId,
+    opKey,
+    reason: "integration test",
+    ...extra,
+});
+test("concurrent burst: exactly one grant, FIFO queue, no missed wakeup", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        // tight timings for the test
+        await c.request("configure", {
+            expectedVersion: 1,
+            changes: { offerTimeoutMs: 60_000, maxWaitMs: 0 },
+            reason: "test timings",
+            author: "test",
+        });
+        const clients = [];
+        for (let i = 0; i < 5; i++) {
+            const cl = d.client();
+            await cl.connect();
+            clients.push(cl);
+        }
+        const results = await Promise.all(clients.map((cl, i) => cl.request("acquire", ACQ(`agent${i}`, `op${i}`))));
+        const granted = results.filter((r) => r.state === "granted");
+        const queued = results.filter((r) => r.state === "queued");
+        assert.equal(granted.length, 1, "exactly one concurrent grant");
+        assert.equal(queued.length, 4);
+        assert.deepEqual(queued.map((r) => r.entry.position).sort(), [1, 2, 3, 4], "queue positions assigned exactly once");
+        // capacity invariant
+        const st = await c.request("status", {});
+        assert.ok(st.pools[0].used <= st.pools[0].capacity);
+        // release: the FIFO head must see an offer; nobody else
+        const winner = granted[0];
+        const headIdx = results.findIndex((r) => r.entry?.position === 1);
+        const headAgent = `agent${headIdx}`;
+        assert.ok(headIdx >= 0);
+        const events = [];
+        const watcher = d.client();
+        await watcher.connect();
+        await watcher.watch(headAgent, (ev) => events.push(ev));
+        // Regression (live opencode verification found this): a "*" multiplexer
+        // watcher (e.g. the OpenCode plugin serving all sessions) must also
+        // receive the claim token on offered events.
+        const starEvents = [];
+        const starWatcher = d.client();
+        await starWatcher.connect();
+        await starWatcher.watch("*", (ev) => starEvents.push(ev));
+        await c.request("release", { permitToken: winner.entry.permitToken });
+        const p = (await clients[headIdx].request("pending", { agentId: headAgent }));
+        assert.equal(p.offers.length, 1, "queued head receives the offer");
+        assert.ok(p.offers[0].offerToken);
+        await until("watcher got offered event", () => events.some((e) => e.type === "offered"));
+        const offeredEv = events.find((e) => e.type === "offered");
+        assert.ok(offeredEv.offerToken, "watch push for the owner carries the claim token");
+        await until("star watcher got offered event", () => starEvents.some((e) => e.type === "offered"));
+        const starEv = starEvents.find((e) => e.type === "offered");
+        assert.ok(starEv.offerToken, 'watch push for a "*" multiplexer carries the claim token');
+        const claimed = await clients[headIdx].request("claim", { offerToken: p.offers[0].offerToken });
+        assert.equal(claimed.entry.state, "held");
+        // capacity again: claim consumed the offer, no double admission
+        const st2 = (await c.request("status", {}));
+        assert.equal(st2.pools[0].used, 1);
+        assert.equal(st2.pools[0].capacity, 1);
+        for (const cl of clients)
+            cl.close();
+        watcher.close();
+        starWatcher.close();
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("bounded blocking wait auto-claims when capacity frees in time", async () => {
+    const d = await startDaemon();
+    try {
+        const a = d.client();
+        const b = d.client();
+        await a.connect();
+        await b.connect();
+        const g = (await a.request("acquire", ACQ("A", "op1")));
+        assert.equal(g.state, "granted");
+        const t0 = Date.now();
+        const bPromise = b.request("acquire", ACQ("B", "op1", { waitMs: 8000 }));
+        await delay(500);
+        await a.request("release", { permitToken: g.entry.permitToken });
+        const r = (await bPromise);
+        assert.equal(r.state, "granted", "waiter is auto-claimed on admission");
+        assert.ok(r.entry.permitToken, "waiter receives the permit token");
+        assert.ok(Date.now() - t0 < 5000, "woke promptly after the release");
+        a.close();
+        b.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("offer expiry pauses and hands capacity to the next waiter; rejoin works", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        await c.request("configure", {
+            expectedVersion: 1,
+            changes: { offerTimeoutMs: 1000, maxWaitMs: 0 },
+            reason: "fast expiry",
+            author: "test",
+        });
+        const a = d.client();
+        const b = d.client();
+        await a.connect();
+        await b.connect();
+        const g = (await a.request("acquire", ACQ("A", "op1")));
+        const q = (await b.request("acquire", ACQ("B", "op1")));
+        assert.equal(q.state, "queued");
+        await a.request("release", { permitToken: g.entry.permitToken });
+        const pb = (await b.request("pending", { agentId: "B" }));
+        assert.equal(pb.offers.length, 1);
+        // do NOT claim; let it expire
+        await until("offer expired", async () => {
+            const st = (await c.request("status", {}));
+            return st.pools[0].paused.length === 1;
+        });
+        const st = (await c.request("status", {}));
+        assert.equal(st.pools[0].offers.length, 0, "expired offer does not keep consuming capacity");
+        // claim after expiry is rejected; rejoin re-queues
+        await assert.rejects(b.request("claim", { offerToken: pb.offers[0].offerToken }), (e) => e.code === "offer_expired");
+        const rj = (await b.request("rejoin", { requestId: q.entry.requestId }));
+        assert.equal(rj.state, "offered", "rejoined request is admitted into the free capacity");
+        a.close();
+        b.close();
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("tracked process: auto-release on death; PID identity checked via /proc start time", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        const g = (await c.request("acquire", ACQ("A", "op1")));
+        const sleeper = spawn("sleep", ["60"], { stdio: "ignore" });
+        const st0 = processStartTime(sleeper.pid);
+        assert.ok(st0, "reads /proc start time on Linux");
+        // PID-reuse defense: wrong start time => treated as a different (dead) process
+        assert.equal(isProcessAlive(sleeper.pid, "9999"), false);
+        assert.equal(isProcessAlive(sleeper.pid, st0), true);
+        const att = (await c.request("attach_pid", { permitToken: g.entry.permitToken, pid: sleeper.pid }));
+        assert.equal(att.entry.phase, "running_tracked");
+        // kill the tracked process; the daemon sweep must auto-release
+        sleeper.kill("SIGKILL");
+        await until("auto-release after tracked process death", async () => {
+            const st = (await c.request("status", {}));
+            return st.pools[0].holders.length === 0;
+        });
+        const st = (await c.request("status", {}));
+        assert.equal(st.pools[0].used, 0, "capacity is freed, not leaked");
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("subprocess survival: parent exits, child keeps the permit until it really ends", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        const g = (await c.request("acquire", ACQ("A", "op1")));
+        // parent exits immediately; a child (sleep 4) keeps the process group alive
+        const parent = spawn("bash", ["-c", "sleep 4 & exit 0"], { stdio: "ignore", detached: true });
+        const pgid = parent.pid;
+        await delay(300); // let bash exit, leave the orphan sleep in the pgid
+        const att = (await c.request("start_job", { permitToken: g.entry.permitToken, pid: parent.pid, pgid }));
+        assert.equal(att.entry.phase, "running_tracked");
+        // parent is gone but the process group still runs: permit must be retained
+        await delay(1200);
+        let st = (await c.request("status", {}));
+        assert.equal(st.pools[0].holders.length, 1, "permit retained while a subprocess of the job lives");
+        // once the whole group is gone, the daemon releases
+        await until("auto-release when the process group fully exits", async () => {
+            st = (await c.request("status", {}));
+            return st.pools[0].holders.length === 0;
+        }, 15_000);
+        assert.equal(st.pools[0].used, 0);
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("daemon restart: journal restores a running tracked permit; token still releases", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        const g = (await c.request("acquire", ACQ("A", "op1")));
+        const permitToken = g.entry.permitToken;
+        const sleeper = spawn("sleep", ["60"], { stdio: "ignore" });
+        await c.request("attach_pid", { permitToken: permitToken, pid: sleeper.pid });
+        c.close();
+        // ---- restart
+        d.child.kill("SIGTERM");
+        await new Promise((r) => d.child.once("exit", r));
+        const child2 = spawn(process.execPath, [daemonMain, "--state-dir", d.dir, "--socket", d.sock], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, LOAD_LOCK_STATE_DIR: d.dir, LOAD_LOCK_SOCKET: d.sock },
+        });
+        await until("restarted daemon listens", async () => await probe(d.sock));
+        const c2 = new LLClient({ socket: d.sock, stateDir: d.dir, spawnDaemon: false });
+        await c2.connect();
+        const st = (await c2.request("status", {}));
+        assert.equal(st.pools[0].holders.length, 1, "running permit survives the restart");
+        assert.equal(st.pools[0].holders[0].phase, "running_tracked");
+        assert.equal(st.pools[0].holders[0].pid, sleeper.pid);
+        // the SAME permit token still releases (idempotency across restart)
+        const rel = (await c2.request("release", { permitToken: permitToken }));
+        assert.equal(rel.releasedNow, true);
+        // ---- restart with a job that died while we were down
+        const g2 = (await c2.request("acquire", ACQ("B", "op1")));
+        const short = spawn("sleep", ["30"], { stdio: "ignore" });
+        await c2.request("attach_pid", { permitToken: g2.entry.permitToken, pid: short.pid });
+        short.kill("SIGKILL");
+        await delay(300); // dies before the restart
+        c2.close();
+        child2.kill("SIGTERM");
+        await new Promise((r) => child2.once("exit", r));
+        const child3 = spawn(process.execPath, [daemonMain, "--state-dir", d.dir, "--socket", d.sock], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, LOAD_LOCK_STATE_DIR: d.dir, LOAD_LOCK_SOCKET: d.sock },
+        });
+        await until("third daemon listens", async () => await probe(d.sock));
+        const c3 = new LLClient({ socket: d.sock, stateDir: d.dir, spawnDaemon: false });
+        await c3.connect();
+        const st3 = (await c3.request("status", {}));
+        assert.equal(st3.pools[0].holders.length, 0, "confirmed-dead job is released at restore, capacity free");
+        // duplicate release of the already-released permit is a clean idempotent no-op
+        const rel2 = (await c3.request("release", { permitToken: g2.entry.permitToken }));
+        assert.equal(rel2.releasedNow, false);
+        c3.close();
+        child3.kill("SIGTERM");
+        await new Promise((r) => child3.once("exit", r));
+        sleeper.kill("SIGKILL");
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("forgotten untracked permit: lease reclaims it (heartbeat would renew)", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        await c.request("configure", {
+            expectedVersion: 1,
+            changes: { untrackedLeaseMs: 10_000 },
+            reason: "short lease",
+            author: "test",
+        });
+        const g = (await c.request("acquire", ACQ("A", "op1")));
+        await c.request("mark_started", { permitToken: g.entry.permitToken });
+        // no heartbeats: the lease must reclaim the permit
+        await until("untracked lease reclaims the permit", async () => {
+            const st = (await c.request("status", {}));
+            return st.pools[0].holders.length === 0;
+        }, 25_000);
+        const st = (await c.request("status", {}));
+        assert.equal(st.pools[0].used, 0);
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("offers_for_cwd returns cwd-matched offers with tokens (hook support)", async () => {
+    const d = await startDaemon();
+    try {
+        const a = d.client();
+        const b = d.client();
+        await a.connect();
+        await b.connect();
+        const cwd = mkdtempSync(join(TMP_BASE, "ll-cwd-"));
+        const g = (await a.request("acquire", ACQ("A", "op1", { cwd })));
+        await b.request("acquire", ACQ("B", "op1", { cwd }));
+        await a.request("release", { permitToken: g.entry.permitToken });
+        const r = (await b.request("offers_for_cwd", { cwd }));
+        assert.equal(r.offers.length, 1);
+        assert.ok(r.offers[0].offerToken);
+        const r2 = (await b.request("offers_for_cwd", { cwd: "/nonexistent" }));
+        assert.equal(r2.offers.length, 0);
+        a.close();
+        b.close();
+        rmSync(cwd, { recursive: true, force: true });
+    }
+    finally {
+        await d.stop();
+    }
+});

package/dist/test/hook.test.d.ts

@@ -0,0 +1 @@
+export {};