@aron98/load-lock 1.5.0 → 1.6.1

package/dist/test/mcp.test.js

@@ -8,13 +8,21 @@ import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { startDaemon, delay, mcpMainPath } from "./testutil.js";
-async function connectMcp(d) {
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startDaemon, delay, mcpMainPath, cliMainPath } from "./testutil.js";
+async function connectMcp(d, extraEnv = {}, args = [mcpMainPath]) {
     const client = new Client({ name: "load-lock-test", version: "0.1.0" }, { capabilities: {} });
+    // The test runner itself may be inside a harness session: drop inherited
+    // session identity so each test controls it (issue #50).
+    const env = { ...d.env };
+    for (const k of ["LOAD_LOCK_AGENT", "CLAUDE_CODE_SESSION_ID", "OPENCODE_SESSION_ID"])
+        delete env[k];
     const transport = new StdioClientTransport({
         command: process.execPath,
-        args: [mcpMainPath],
-        env: d.env,
+        args,
+        env: { ...env, ...extraEnv },
     });
     await client.connect(transport);
     return client;
@@ -24,15 +32,53 @@ async function callJson(c, name, args) {
     assert.equal(res.isError, undefined, `tool ${name} errored: ${JSON.stringify(res.content)}`);
     return JSON.parse(res.content[0].text);
 }
+test("mcp: `load-lock mcp` serves the same MCP server as load-lock-mcp (#65)", async () => {
+    const d = await startDaemon();
+    const viaBin = await connectMcp(d);
+    const viaCli = await connectMcp(d, {}, [cliMainPath, "mcp"]);
+    try {
+        const names = async (c) => (await c.listTools()).tools.map((t) => t.name).sort();
+        assert.deepEqual(await names(viaCli), await names(viaBin), "identical tool set");
+        assert.equal(viaCli.getServerVersion()?.name, viaBin.getServerVersion()?.name);
+        const acq = await callJson(viaCli, "acquire", { reason: "build", op_key: "cli-mcp", agent_id: "cliMcpAgent" });
+        assert.equal(acq.state, "granted");
+        await callJson(viaCli, "release", { permit_token: acq.permit_token });
+    }
+    finally {
+        await viaCli.close();
+        await viaBin.close();
+        await d.stop();
+    }
+});
+test("mcp: initialize reports this package's version from package.json (#97)", async () => {
+    const d = await startDaemon();
+    const viaBin = await connectMcp(d); // load-lock-mcp entry point
+    const viaCli = await connectMcp(d, {}, [cliMainPath, "mcp"]); // `load-lock mcp`
+    try {
+        const pkgVersion = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json"), "utf8")).version;
+        assert.ok(pkgVersion, "package.json has a version");
+        assert.equal(viaBin.getServerVersion()?.version, pkgVersion, "load-lock-mcp serverInfo.version matches package.json");
+        assert.equal(viaCli.getServerVersion()?.version, pkgVersion, "`load-lock mcp` serverInfo.version matches package.json");
+        assert.notEqual(pkgVersion, "0.1.0", "guards against the old hard-coded constant");
+    }
+    finally {
+        await viaCli.close();
+        await viaBin.close();
+        await d.stop();
+    }
+});
 test("mcp: tool listing + acquire/release/configure round trip", async () => {
     const d = await startDaemon();
     const c = await connectMcp(d);
     try {
         const tools = await c.listTools();
         const names = tools.tools.map((t) => t.name);
-        for (const expected of ["acquire", "claim", "release", "cancel", "rejoin", "pending", "wait_for_turn", "status", "inspect_machine", "get_config", "configure", "run_with_permit", "job_status", "job_stop", "attach_pid", "mark_started", "wait_for_completion"]) {
+        for (const expected of ["acquire", "claim", "release", "cancel", "rejoin", "pending", "wait_for_turn", "status", "inspect_machine", "get_config", "configure", "run_with_permit", "job_status", "job_stop", "attach_pid", "mark_started", "wait_for_completion", "agent_guide"]) {
             assert.ok(names.includes(expected), `tool ${expected} registered`);
         }
+        // agent_guide (issue #61): the same text `load-lock agent-guide` prints.
+        const guide = await c.callTool({ name: "agent_guide", arguments: {} });
+        assert.equal(guide.content[0].text, readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "..", "docs", "AGENT_GUIDE.md"), "utf8"));
         const acq = await callJson(c, "acquire", { reason: "build", op_key: "mcp-rt", agent_id: "mcpAgentA", label_prefix: "omac" });
         assert.equal(acq.state, "granted");
         assert.ok(acq.permit_token, "acquire result carries permit_token");
@@ -265,8 +311,8 @@ test("mcp: wait_for_completion on a daemon-tracked request_id (attach_pid) and j
 });
 test("mcp: multiple server processes share one machine-wide budget", async () => {
     const d = await startDaemon();
-    const c1 = await connectMcp(d);
-    const c2 = await connectMcp(d); // separate process = separate harness session
+    const c1 = await connectMcp(d, { CLAUDE_CODE_SESSION_ID: "budget-session-1" });
+    const c2 = await connectMcp(d, { CLAUDE_CODE_SESSION_ID: "budget-session-2" }); // separate harness session
     try {
         const a1 = await callJson(c1, "acquire", { reason: "agent1 build", op_key: "a1" });
         assert.equal(a1.state, "granted");
@@ -287,3 +333,43 @@ test("mcp: multiple server processes share one machine-wide budget", async () =>
         await d.stop();
     }
 });
+test("mcp: two server processes from one harness session share an identity (issue #50)", async () => {
+    const d = await startDaemon();
+    // Same parent process, no session env: both resolve to the same harness
+    // ancestor, like a plugin-bundled + a standalone registration.
+    const c1 = await connectMcp(d);
+    const c2 = await connectMcp(d);
+    const other = await connectMcp(d, { CLAUDE_CODE_SESSION_ID: "other-session" });
+    try {
+        const filler = await callJson(other, "acquire", { reason: "other build", op_key: "fill" });
+        assert.equal(filler.state, "granted");
+        const a = await callJson(c1, "acquire", { reason: "session build", op_key: "shared-op" });
+        assert.equal(a.state, "queued");
+        if (process.platform === "linux")
+            assert.match(a.entry.agentId, /^proc:\d+:\d+$/);
+        // acquire through one server shows up in pending through the other
+        const viaOther = await callJson(c2, "pending", {});
+        assert.deepEqual(viaOther.queue.map((e) => e.requestId), [a.request_id]);
+        // and the op_key dedupes across both registrations
+        const again = await callJson(c2, "acquire", { reason: "session build", op_key: "shared-op" });
+        assert.equal(again.request_id, a.request_id);
+        // a server from a different session gets a distinct id and sees none of it
+        const otherPending = await callJson(other, "pending", {});
+        assert.equal(otherPending.queue.length, 0);
+        assert.equal(otherPending.held[0].agentId, "claude-code:other-session");
+        assert.notEqual(otherPending.held[0].agentId, a.entry.agentId);
+        // the release hands the offer to the shared identity: visible via either server
+        await callJson(other, "release", { permit_token: filler.permit_token });
+        const p1 = await callJson(c1, "pending", {});
+        assert.equal(p1.offers.length, 1);
+        const claimed = await callJson(c2, "claim", { offer_token: p1.offers[0].offerToken });
+        assert.equal(claimed.state, "held");
+        await callJson(c1, "release", { permit_token: claimed.permit_token });
+    }
+    finally {
+        await c1.close();
+        await c2.close();
+        await other.close();
+        await d.stop();
+    }
+});

package/dist/test/plugin.test.d.ts

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

package/dist/test/plugin.test.js

@@ -0,0 +1,144 @@
+/**
+ * Claude Code plugin contract tests (issue #61): the manifest, hooks file
+ * and root marketplace.json under plugins/claude-code, checked against the
+ * documented plugin format and ACE's import rules (#64), plus the hook and
+ * MCP commands run exactly the way the plugin runs them (through the
+ * launcher, against this checkout's dist/ on an isolated daemon).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { cliMainPath, startDaemon } from "./testutil.js";
+import { POLICY_BRIEF } from "../policy/text.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(HERE, "..", "..");
+const PLUGIN_ROOT = join(REPO_ROOT, "plugins", "claude-code");
+const readJson = (p) => JSON.parse(readFileSync(p, "utf8"));
+const manifest = readJson(join(PLUGIN_ROOT, ".claude-plugin", "plugin.json"));
+const hooksFile = readJson(join(PLUGIN_ROOT, "hooks", "hooks.json"));
+const marketplace = readJson(join(REPO_ROOT, ".claude-plugin", "marketplace.json"));
+const PKG_VERSION = readJson(join(REPO_ROOT, "package.json")).version;
+const ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
+const LAUNCHER_ARG = `${ROOT_VAR}/scripts/load-lock.mjs`;
+/** A hook's shell-form command, capturing the hook event. */
+const HOOK_COMMAND = /^node "\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/load-lock\.mjs" hook claude-code ([a-z-]+)$/;
+/** ACE plugin_hooks_command_safe (#64): no shell metacharacters. */
+const ACE_UNSAFE = /[;&|`]|\$\(/;
+function filesUnder(dir) {
+    return readdirSync(dir).flatMap((name) => {
+        const p = join(dir, name);
+        return statSync(p).isDirectory() ? filesUnder(p) : [relative(PLUGIN_ROOT, p).split(sep).join("/")];
+    });
+}
+/** Every hook handler as [event, handler]. */
+function handlers() {
+    return Object.entries(hooksFile.hooks).flatMap(([ev, groups]) => groups.flatMap((g) => g.hooks.map((h) => [ev, h])));
+}
+test("plugin.json: name, version pin, MCP server through the launcher, no secrets", () => {
+    assert.equal(manifest.name, "load-lock-plugin", "must differ from the skill's name (ACE install-dir clash, #64)");
+    assert.match(manifest.name, /^[a-z0-9]+(-[a-z0-9]+)*$/);
+    assert.equal(manifest.version, PKG_VERSION);
+    assert.equal(manifest.userConfig, undefined);
+    assert.equal(manifest.skills, undefined, "no skill in the plugin (#61)");
+    assert.deepEqual(Object.keys(manifest.mcpServers), ["load-lock"]);
+    const mcp = manifest.mcpServers["load-lock"];
+    assert.equal(mcp.command, "node");
+    assert.deepEqual(mcp.args, [LAUNCHER_ARG, "--bin", "load-lock-mcp"]);
+    assert.equal(mcp.env, undefined);
+    assert.equal(mcp.headers, undefined);
+});
+test("hooks.json: SessionStart policy + async await-offer watcher, Stop wakeup, shell form via the launcher", () => {
+    const got = handlers().map(([ev, h]) => [ev, HOOK_COMMAND.exec(h.command)?.[1], Boolean(h.async), Boolean(h.asyncRewake)]);
+    assert.deepEqual(got, [
+        ["SessionStart", "session-start", false, false],
+        ["SessionStart", "await-offer", true, true],
+        ["Stop", "stop", false, false],
+    ]);
+    for (const [, h] of handlers()) {
+        assert.equal(h.type, "command");
+        // Shell form (#63): one command string, no exec-form `args`; the root is quoted for paths with spaces.
+        assert.equal(h.args, undefined);
+        assert.ok(h.command.includes(`"${LAUNCHER_ARG}"`), h.command);
+        assert.doesNotMatch(h.command, ACE_UNSAFE);
+        assert.ok(Number.isInteger(h.timeout) && h.timeout > 0);
+    }
+    // asyncRewake hooks keep their timeout: leave room for the watcher's own 10 min bound.
+    const watcher = handlers().find(([, h]) => h.asyncRewake)[1];
+    assert.ok(watcher.timeout * 1000 > 10 * 60_000);
+});
+test("plugin folder: paths resolve inside it, ACE layout only, no SKILL.md or package.json", () => {
+    const launcher = LAUNCHER_ARG.replace(ROOT_VAR, PLUGIN_ROOT);
+    assert.ok(existsSync(launcher));
+    assert.ok(resolve(launcher).startsWith(PLUGIN_ROOT + sep));
+    const allowedDirs = ["skills", "commands", "agents", "hooks", "monitors", "themes", "output-styles", "bin", "scripts", ".claude-plugin"];
+    const allowedRoot = [".mcp.json", ".lsp.json", "settings.json", "README.md", "LICENSE", "CHANGELOG.md"];
+    for (const f of filesUnder(PLUGIN_ROOT)) {
+        assert.ok(allowedRoot.includes(f) || allowedDirs.includes(f.split("/")[0]), `unexpected file for ACE: ${f}`);
+        assert.notEqual(f.split("/").pop(), "SKILL.md");
+        assert.notEqual(f.split("/").pop(), "package.json");
+    }
+    // bin/ would land on the Bash tool's PATH and keeps a plugin off claude.ai; the launcher is not a CLI.
+    assert.ok(!existsSync(join(PLUGIN_ROOT, "bin")));
+});
+test("marketplace.json: the root marketplace lists the plugin subfolder", () => {
+    assert.equal(marketplace.name, "load-lock");
+    assert.ok(marketplace.owner?.name);
+    assert.equal(marketplace.plugins.length, 1);
+    const entry = marketplace.plugins[0];
+    assert.equal(entry.name, manifest.name);
+    assert.equal(entry.source, "./plugins/claude-code");
+    assert.equal(resolve(REPO_ROOT, entry.source), PLUGIN_ROOT);
+    assert.equal(entry.version, undefined, "plugin.json is the version authority");
+    for (const k of ["commands", "agents", "skills", "hooks", "mcpServers", "strict"])
+        assert.equal(entry[k], undefined, k);
+});
+test("plugin commands run as the plugin runs them (launcher -> PATH copy of this checkout)", async () => {
+    const d = await startDaemon();
+    const tmp = mkdtempSync(join(process.env.LL_TEST_TMP ?? tmpdir(), "ll-plug-"));
+    try {
+        const bin = join(tmp, "bin");
+        mkdirSync(bin);
+        symlinkSync(cliMainPath, join(bin, "load-lock"));
+        const env = { ...d.env, PATH: bin, LOAD_LOCK_LAUNCHER_DEBUG: "1" };
+        for (const k of ["LOAD_LOCK_AGENT", "CLAUDE_CODE_SESSION_ID", "OPENCODE_SESSION_ID"])
+            delete env[k];
+        // Hooks run as the harness runs a shell-form command: through sh, with
+        // CLAUDE_PLUGIN_ROOT in the environment and `node` resolved from PATH.
+        symlinkSync(process.execPath, join(bin, "node"));
+        const sub = (args) => args.map((a) => a.replace(ROOT_VAR, PLUGIN_ROOT));
+        const runHook = (event, input) => {
+            const h = handlers().find(([, x]) => HOOK_COMMAND.exec(x.command)?.[1] === event)[1];
+            return spawnSync(h.command, { shell: "/bin/sh", env: { ...env, CLAUDE_PLUGIN_ROOT: PLUGIN_ROOT }, input: JSON.stringify(input), encoding: "utf8" });
+        };
+        const s = runHook("session-start", { session_id: "plug-1", cwd: tmp, source: "startup", hook_event_name: "SessionStart" });
+        assert.equal(s.status, 0, s.stderr);
+        assert.ok(s.stdout.startsWith(POLICY_BRIEF), s.stdout);
+        assert.match(s.stdout, /load-lock now: pool "heavy"/);
+        assert.match(s.stderr, /launcher: path /);
+        const t = runHook("stop", { session_id: "plug-1", cwd: tmp, hook_event_name: "Stop" });
+        assert.equal(t.status, 0, t.stderr);
+        assert.equal(t.stdout, "", "no offer, no continuation");
+        const mcp = manifest.mcpServers["load-lock"];
+        const transport = new StdioClientTransport({ command: process.execPath, args: sub(mcp.args), env, stderr: "ignore" });
+        const client = new Client({ name: "plugin-test", version: "0.0.0" }, { capabilities: {} });
+        await client.connect(transport);
+        try {
+            const names = (await client.listTools()).tools.map((x) => x.name);
+            for (const n of ["acquire", "claim", "pending", "agent_guide"])
+                assert.ok(names.includes(n), n);
+        }
+        finally {
+            await client.close();
+        }
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+        await d.stop();
+    }
+});

package/dist/test/runtimes.test.d.ts

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

package/dist/test/runtimes.test.js

@@ -0,0 +1,282 @@
+/**
+ * Runtime-copy bookkeeping (issue #52):
+ *  - daemon.json records the daemon's package root + version
+ *  - the client envelope carries clientRoot; the daemon keeps a known-copies
+ *    list (runtimes.json) deduped by real path, ignoring bogus hints and
+ *    dropping copies whose path is gone
+ *  - `doctor` lists the copies
+ *  - self-restart onto the newer client's copy (issue #53), with bogus or
+ *    mismatched hints falling back to the same-argv respawn, no loops
+ *
+ * Real daemons over real sockets in temp state dirs (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, writeFileSync, readFileSync, realpathSync, symlinkSync, cpSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { connect, createServer } from "node:net";
+import { LLClient } from "../shared/client.js";
+import { packageVersion, packageRoot } from "../shared/version.js";
+import { loadRuntimes } from "../shared/runtimes.js";
+import { restartEntry } from "../core/daemon.js";
+import { startDaemon, cliMainPath, probe, delay, until } from "./testutil.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+mkdirSync(TMP_BASE, { recursive: true });
+/** Send one raw envelope line; resolve the first response (or null). */
+function rawRequest(sockPath, envelope, timeoutMs = 3000) {
+    return new Promise((resolve) => {
+        let buf = "";
+        const s = connect(sockPath, () => s.write(JSON.stringify(envelope) + "\n"));
+        const done = (v) => {
+            s.destroy();
+            resolve(v);
+        };
+        s.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            const idx = buf.indexOf("\n");
+            if (idx !== -1)
+                done(JSON.parse(buf.slice(0, idx)));
+        });
+        s.on("error", () => done(null));
+        setTimeout(() => done(null), timeoutMs).unref?.();
+    });
+}
+/** Plant a fake package root with the given package.json name/version. */
+function plantCopy(base, name, pkgName, version) {
+    const dir = join(base, name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: pkgName, version }));
+    return dir;
+}
+test("daemon.json records the daemon's package root and version", async () => {
+    const d = await startDaemon();
+    try {
+        const info = JSON.parse(readFileSync(join(d.dir, "daemon.json"), "utf8"));
+        assert.equal(info.pid, d.child.pid);
+        assert.equal(info.version, packageVersion());
+        assert.equal(info.packageRoot, realpathSync(packageRoot()));
+        // The daemon's own copy is the first known runtime.
+        assert.ok(loadRuntimes(d.dir).some((c) => c.path === info.packageRoot && c.version === packageVersion()));
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("client envelope carries clientRoot", async () => {
+    const capDir = mkdtempSync(join(TMP_BASE, "ll-capture-"));
+    const capSock = join(capDir, "cap.sock");
+    let captured = "";
+    const server = createServer((s) => {
+        s.on("data", (chunk) => {
+            captured += chunk.toString("utf8");
+            const idx = captured.indexOf("\n");
+            if (idx !== -1)
+                s.write(JSON.stringify({ id: JSON.parse(captured.slice(0, idx)).id, ok: true, result: {} }) + "\n");
+        });
+    });
+    await new Promise((r) => server.listen(capSock, r));
+    try {
+        const c = new LLClient({ socket: capSock, stateDir: capDir, spawnDaemon: false });
+        await c.connect();
+        await c.request("hello", {});
+        c.close();
+        const envelope = JSON.parse(captured.trim());
+        assert.equal(envelope.clientRoot, packageRoot());
+    }
+    finally {
+        await new Promise((r) => server.close(() => r()));
+        rmSync(capDir, { recursive: true, force: true });
+    }
+});
+test("known copies: recorded from handshakes, deduped by real path, bogus hints ignored, gone paths dropped", async () => {
+    const d = await startDaemon();
+    const base = mkdtempSync(join(TMP_BASE, "ll-copies-"));
+    try {
+        const a = plantCopy(base, "a", "@aron98/load-lock", "0.0.1");
+        const b = plantCopy(base, "b", "@aron98/load-lock", "0.0.2");
+        const foreign = plantCopy(base, "foreign", "some-other-pkg", "9.9.9");
+        symlinkSync(a, join(base, "a-link"));
+        // No clientVersion: these hints never trigger a self-restart.
+        for (const root of [a, join(base, "a-link"), foreign, join(base, "missing"), b]) {
+            const r = await rawRequest(d.sock, { id: 1, method: "hello", params: {}, clientRoot: root });
+            assert.ok(r?.ok, `hello with clientRoot ${root}`);
+        }
+        let copies = loadRuntimes(d.dir);
+        const paths = copies.map((c) => c.path);
+        assert.equal(paths.filter((p) => p === realpathSync(a)).length, 1, "symlinked hint deduped by real path");
+        assert.ok(copies.some((c) => c.path === realpathSync(b) && c.version === "0.0.2"), "version read from disk");
+        assert.ok(!paths.some((p) => p.includes("foreign") || p.includes("missing")), `bogus hints ignored: ${paths}`);
+        // Copy a disappears (e.g. npx cache cleaned); the next new sighting
+        // prunes it, and a reader never reports it either.
+        rmSync(a, { recursive: true, force: true });
+        const c = plantCopy(base, "c", "@aron98/load-lock", "0.0.3");
+        await rawRequest(d.sock, { id: 1, method: "hello", params: {}, clientRoot: c });
+        const raw = JSON.parse(readFileSync(join(d.dir, "runtimes.json"), "utf8"));
+        assert.ok(!raw.copies.some((x) => x.path === join(realpathSync(base), "a")), "gone copy pruned on disk");
+        copies = loadRuntimes(d.dir);
+        assert.ok(copies.some((x) => x.version === "0.0.3"));
+    }
+    finally {
+        await d.stop();
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+test("doctor lists the daemon's runtime and known copies", async () => {
+    const d = await startDaemon();
+    const base = mkdtempSync(join(TMP_BASE, "ll-copies-"));
+    try {
+        const a = plantCopy(base, "a", "@aron98/load-lock", "0.0.1");
+        await rawRequest(d.sock, { id: 1, method: "hello", params: {}, clientRoot: a });
+        const r = await new Promise((resolve) => {
+            const child = spawn(process.execPath, [cliMainPath, "doctor", "--json"], { env: d.env });
+            let stdout = "";
+            child.stdout.on("data", (b) => (stdout += b));
+            child.stdin.end();
+            child.once("exit", (code) => resolve({ code, stdout }));
+        });
+        assert.equal(r.code, 0);
+        const report = JSON.parse(r.stdout);
+        assert.equal(report.daemonRuntime.path, realpathSync(packageRoot()));
+        assert.equal(report.daemonRuntime.version, packageVersion());
+        const listed = report.knownRuntimes.map((c) => `${c.version}@${c.path}`);
+        assert.ok(listed.includes(`0.0.1@${realpathSync(a)}`), `planted copy listed: ${listed}`);
+        assert.ok(listed.includes(`${packageVersion()}@${realpathSync(packageRoot())}`), `own copy listed: ${listed}`);
+    }
+    finally {
+        await d.stop();
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+// ------------------------------------------------------------- issue #53
+/**
+ * Plant a runnable load-lock copy: the built dist/ (minus tests), the real
+ * package.json with a different version, node_modules symlinked to ours.
+ */
+function plantRuntime(base, name, version) {
+    const root = realpathSync(packageRoot());
+    const dir = join(base, name);
+    mkdirSync(dir, { recursive: true });
+    cpSync(join(root, "dist"), join(dir, "dist"), { recursive: true, filter: (src) => !src.startsWith(join(root, "dist", "test")) });
+    const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ ...pkg, version }));
+    symlinkSync(join(root, "node_modules"), join(dir, "node_modules"));
+    return realpathSync(dir);
+}
+/** Start a daemon from a planted copy; only raw (version-less) envelopes talk to it. */
+async function startCopyDaemon(copy, dir) {
+    const sock = join(dir, "daemon.sock");
+    const child = spawn(process.execPath, [join(copy, "dist", "core", "daemon-main.js"), "--state-dir", dir, "--socket", sock], {
+        stdio: "ignore",
+        detached: true,
+    });
+    child.unref();
+    await until("planted daemon up", () => probe(sock), 10_000, 100);
+    return { sock, pid: child.pid };
+}
+function killFromJson(dir) {
+    try {
+        process.kill(JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8")).pid, "SIGKILL");
+    }
+    catch {
+        /* gone */
+    }
+}
+async function helloRaw(sock, extra = {}) {
+    const r = await rawRequest(sock, { id: 1, method: "hello", params: {}, ...extra }, 2000);
+    return r?.ok ? r.result : null;
+}
+async function waitNewPid(sock, oldPid) {
+    let hello = null;
+    await until("daemon respawned", async () => {
+        if (!(await probe(sock)))
+            return false;
+        hello = await helloRaw(sock);
+        return hello !== null && hello.pid !== oldPid;
+    });
+    return hello;
+}
+test("restartEntry: only a matching load-lock copy with a daemon entry qualifies", () => {
+    const base = mkdtempSync(join(TMP_BASE, "ll-entry-"));
+    try {
+        const good = plantCopy(base, "good", "@aron98/load-lock", "0.2.0");
+        mkdirSync(join(good, "dist", "core"), { recursive: true });
+        writeFileSync(join(good, "dist", "core", "daemon-main.js"), "");
+        const noEntry = plantCopy(base, "noentry", "@aron98/load-lock", "0.2.0");
+        const foreign = plantCopy(base, "foreign", "not-load-lock", "0.2.0");
+        mkdirSync(join(foreign, "dist", "core"), { recursive: true });
+        writeFileSync(join(foreign, "dist", "core", "daemon-main.js"), "");
+        assert.equal(restartEntry(good, "0.2.0"), join(realpathSync(good), "dist", "core", "daemon-main.js"));
+        assert.equal(restartEntry(good, "0.3.0"), null, "claimed version must match the copy on disk");
+        assert.equal(restartEntry(noEntry, "0.2.0"), null, "copy without a daemon entry");
+        assert.equal(restartEntry(foreign, "0.2.0"), null, "foreign package");
+        assert.equal(restartEntry(join(base, "missing"), "0.2.0"), null, "nonexistent path");
+        assert.equal(restartEntry(undefined, "0.2.0"), null, "no hint");
+    }
+    finally {
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+test("self-restart moves the daemon onto the newer client's copy; state and journal survive", async () => {
+    const base = mkdtempSync(join(TMP_BASE, "ll-2c-"));
+    const dir = join(base, "s");
+    mkdirSync(dir);
+    const sleeper = spawn("sleep", ["60"], { stdio: "ignore" });
+    try {
+        const oldCopy = plantRuntime(base, "old", "0.1.0");
+        const newCopy = plantRuntime(base, "new", "0.2.0");
+        const { sock, pid } = await startCopyDaemon(oldCopy, dir);
+        assert.equal((await helloRaw(sock)).daemonVersion, "0.1.0");
+        // A tracked permit held on the old daemon.
+        const g = await rawRequest(sock, { id: 2, method: "acquire", params: { agentId: "A", opKey: "op1", reason: "two copies" } });
+        const permitToken = g.result.entry.permitToken;
+        await rawRequest(sock, { id: 3, method: "attach_pid", params: { permitToken, pid: sleeper.pid } });
+        // A newer client from a different copy shows up.
+        assert.ok(await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: newCopy }));
+        const h = await waitNewPid(sock, pid);
+        assert.equal(h.daemonVersion, "0.2.0", "daemon now runs the newer copy");
+        const info = JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8"));
+        assert.equal(info.packageRoot, newCopy);
+        assert.equal(info.version, "0.2.0");
+        const st = await rawRequest(sock, { id: 4, method: "status", params: {} });
+        assert.equal(st.result.pools[0].holders.length, 1, "held permit survives the move");
+        assert.equal(st.result.pools[0].holders[0].pid, sleeper.pid);
+        const rel = await rawRequest(sock, { id: 5, method: "release", params: { permitToken } });
+        assert.equal(rel.result.releasedNow, true, "same permit token still releases");
+        // Stable afterwards: the same newer client does not restart it again.
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: newCopy });
+        await delay(600);
+        assert.equal((await helloRaw(sock)).pid, h.pid);
+    }
+    finally {
+        sleeper.kill("SIGKILL");
+        killFromJson(dir);
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+test("bogus or mismatched copy hint: no respawn onto it, same-argv fallback, no restart loop", async () => {
+    const base = mkdtempSync(join(TMP_BASE, "ll-2c-"));
+    const dir = join(base, "s");
+    mkdirSync(dir);
+    try {
+        const oldCopy = plantRuntime(base, "old", "0.1.0");
+        // Claims 0.2.0 but the copy on disk is 0.3.0.
+        const mismatched = plantRuntime(base, "mismatch", "0.3.0");
+        const { sock, pid } = await startCopyDaemon(oldCopy, dir);
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: mismatched });
+        const h = await waitNewPid(sock, pid);
+        assert.equal(h.daemonVersion, "0.1.0", "respawned on its own copy, not the mismatched hint");
+        assert.equal(JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8")).packageRoot, oldCopy);
+        // Further bogus hints for the same or an older version: no loop.
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: mismatched });
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: join(base, "nowhere") });
+        await helloRaw(sock, { clientVersion: "0.1.5", clientRoot: "/" });
+        await delay(800);
+        assert.equal((await helloRaw(sock)).pid, h.pid, "no restart loop");
+    }
+    finally {
+        killFromJson(dir);
+        rmSync(base, { recursive: true, force: true });
+    }
+});

package/dist/test/setup.test.d.ts

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