@aron98/load-lock 1.4.0 → 1.6.0

package/dist/test/launcher.test.js

@@ -0,0 +1,222 @@
+/**
+ * Tests for the dependency-free plugin launcher (issue #60):
+ * plugins/claude-code/scripts/load-lock.mjs over planted fake runtime
+ * copies (PATH, state dir) and a fake npx-cli.js. Light: no daemon, no
+ * network; every case runs in its own temp HOME/state dir.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, symlinkSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(HERE, "..", "..");
+const LAUNCHER = join(REPO_ROOT, "plugins", "claude-code", "scripts", "load-lock.mjs");
+const PKG_VERSION = JSON.parse(readFileSync(join(REPO_ROOT, "package.json"), "utf8")).version;
+const L = await import(pathToFileURL(LAUNCHER).href);
+const TMP_BASE = process.env.LL_TEST_TMP ?? tmpdir();
+mkdirSync(TMP_BASE, { recursive: true });
+/** A fake entry that reports what it was run with, then exits per FAKE_EXIT / FAKE_HANG. */
+const FAKE_ENTRY = (tag) => `
+let s = "";
+process.stdin.on("data", (d) => (s += d));
+process.stdin.on("end", () => {
+  process.stdout.write(JSON.stringify({ entry: ${JSON.stringify(tag)}, argv: process.argv.slice(2), stdin: s }) + "\\n");
+  if (process.env.FAKE_HANG === "1") setInterval(() => {}, 1000);
+  else process.exitCode = Number(process.env.FAKE_EXIT ?? 0);
+});
+`;
+/** Plant a fake @aron98/load-lock package root with both bins. */
+function plantPkg(root, version, name = "@aron98/load-lock") {
+    mkdirSync(join(root, "dist", "cli"), { recursive: true });
+    mkdirSync(join(root, "dist", "mcp"), { recursive: true });
+    writeFileSync(join(root, "package.json"), JSON.stringify({ name, version }));
+    writeFileSync(join(root, "dist", "cli", "main.js"), FAKE_ENTRY(`cli@${version}`));
+    writeFileSync(join(root, "dist", "mcp", "main.js"), FAKE_ENTRY(`mcp@${version}`));
+    return root;
+}
+function sandbox() {
+    const dir = mkdtempSync(join(TMP_BASE, "ll-launch-"));
+    const bin = join(dir, "bin");
+    const state = join(dir, "state");
+    mkdirSync(bin, { recursive: true });
+    mkdirSync(state, { recursive: true });
+    const env = {
+        HOME: dir,
+        PATH: bin, // only planted copies; the launcher runs node via process.execPath
+        LOAD_LOCK_STATE_DIR: state,
+        LOAD_LOCK_LAUNCHER_DEBUG: "1",
+        // No npx unless a test plants one: a missing override never falls back.
+        LOAD_LOCK_LAUNCHER_NPX_CLI: join(dir, "no-npx-cli.js"),
+    };
+    return { dir, bin, state, env };
+}
+/** Put a POSIX-npm-style `load-lock` link for `root` on the sandbox PATH. */
+function linkOnPath(sb, root) {
+    symlinkSync(join(root, "dist", "cli", "main.js"), join(sb.bin, "load-lock"));
+}
+function run(sb, args, extraEnv = {}, input = '{"session_id":"s1"}') {
+    const t0 = Date.now();
+    const r = spawnSync(process.execPath, [LAUNCHER, ...args], {
+        env: { ...sb.env, ...extraEnv },
+        input,
+        encoding: "utf8",
+        timeout: 20_000,
+    });
+    return { ...r, ms: Date.now() - t0 };
+}
+const posix = process.platform !== "win32";
+test("launcher pin equals package.json version", () => {
+    const text = readFileSync(LAUNCHER, "utf8");
+    assert.match(text, new RegExp(`"@aron98/load-lock@${PKG_VERSION.replace(/\./g, "\\.")}"`));
+});
+test("PATH branch: a new-enough load-lock on PATH runs its compiled entry with stdin and args", { skip: !posix }, () => {
+    const sb = sandbox();
+    try {
+        linkOnPath(sb, plantPkg(join(sb.dir, "global", "lib", "node_modules", "@aron98", "load-lock"), "99.0.0"));
+        const r = run(sb, ["hook", "claude-code", "stop"]);
+        assert.equal(r.status, 0, r.stderr);
+        const out = JSON.parse(r.stdout);
+        assert.equal(out.entry, "cli@99.0.0");
+        assert.deepEqual(out.argv, ["hook", "claude-code", "stop"]);
+        assert.equal(out.stdin, '{"session_id":"s1"}');
+        assert.match(r.stderr, /launcher: path 99\.0\.0/);
+        const m = run(sb, ["--bin", "load-lock-mcp"], {}, "");
+        assert.equal(m.status, 0, m.stderr);
+        assert.equal(JSON.parse(m.stdout).entry, "mcp@99.0.0");
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});
+test("state branch: a too-old PATH copy is skipped for the newest known copy >= pin", { skip: !posix }, () => {
+    const sb = sandbox();
+    try {
+        linkOnPath(sb, plantPkg(join(sb.dir, "old"), "0.1.0"));
+        const a = plantPkg(join(sb.dir, "copy-a"), "98.0.0");
+        const b = plantPkg(join(sb.dir, "copy-b"), "98.1.0");
+        const tooOld = plantPkg(join(sb.dir, "copy-old"), "0.0.1");
+        const notOurs = plantPkg(join(sb.dir, "copy-other"), "999.0.0", "something-else");
+        writeFileSync(join(sb.state, "runtimes.json"), JSON.stringify({
+            copies: [a, tooOld, notOurs, join(sb.dir, "gone")].map((path) => ({ path, version: "x", lastSeen: 1 })),
+        }));
+        writeFileSync(join(sb.state, "daemon.json"), JSON.stringify({ pid: 1, startedAt: 1, socket: "s", packageRoot: b }));
+        const r = run(sb, ["hook", "claude-code", "stop"]);
+        assert.equal(r.status, 0, r.stderr);
+        assert.equal(JSON.parse(r.stdout).entry, "cli@98.1.0");
+        assert.match(r.stderr, /launcher: state 98\.1\.0/);
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});
+test("npx branch: pinned --package, --offline only in hook mode, bin after --", () => {
+    const sb = sandbox();
+    try {
+        const npxCli = join(sb.dir, "npx-cli.js");
+        writeFileSync(npxCli, `process.stdout.write(JSON.stringify(process.argv.slice(2)) + "\\n");`);
+        const env = { LOAD_LOCK_LAUNCHER_NPX_CLI: npxCli };
+        const h = run(sb, ["hook", "claude-code", "session-start"], env);
+        assert.equal(h.status, 0, h.stderr);
+        assert.deepEqual(JSON.parse(h.stdout), [
+            "--yes", "--offline", `--package=@aron98/load-lock@${PKG_VERSION}`, "--", "load-lock", "hook", "claude-code", "session-start",
+        ]);
+        const m = run(sb, ["--bin", "load-lock-mcp"], env, "");
+        assert.equal(m.status, 0, m.stderr);
+        assert.deepEqual(JSON.parse(m.stdout), ["--yes", `--package=@aron98/load-lock@${PKG_VERSION}`, "--", "load-lock-mcp"]);
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});
+test("no runtime at all: hooks exit 0, SessionStart prints one install hint, the MCP server fails loudly", () => {
+    const sb = sandbox();
+    try {
+        const s = run(sb, ["hook", "claude-code", "session-start"]);
+        assert.equal(s.status, 0);
+        assert.equal(s.stdout.trim().split("\n").length, 1);
+        assert.match(s.stdout, /npm i -g @aron98\/load-lock/);
+        for (const ev of ["stop", "await-offer"]) {
+            const r = run(sb, ["hook", "claude-code", ev]);
+            assert.equal(r.status, 0);
+            assert.equal(r.stdout, "");
+        }
+        const m = run(sb, ["--bin", "load-lock-mcp"], {}, "");
+        assert.equal(m.status, 1);
+        assert.match(m.stderr, /no runtime found/);
+        assert.equal(run(sb, ["--bin", "nope"]).status, 64);
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});
+test("exit codes: hooks pass 0/2 through and swallow the rest; the MCP server passes everything through", { skip: !posix }, () => {
+    const sb = sandbox();
+    try {
+        linkOnPath(sb, plantPkg(join(sb.dir, "pkg"), "99.0.0"));
+        assert.equal(run(sb, ["hook", "claude-code", "await-offer"], { FAKE_EXIT: "2" }).status, 2);
+        assert.equal(run(sb, ["hook", "claude-code", "stop"], { FAKE_EXIT: "1" }).status, 0);
+        // SessionStart that already printed output gets no extra hint.
+        const s = run(sb, ["hook", "claude-code", "session-start"], { FAKE_EXIT: "1" });
+        assert.equal(s.status, 0);
+        assert.doesNotMatch(s.stdout, /npm i -g/);
+        assert.equal(run(sb, ["--bin", "load-lock-mcp"], { FAKE_EXIT: "3" }, "").status, 3);
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});
+test("timeout: a stalled hook is killed and exits 0 fast; await-offer is not bounded by it", { skip: !posix }, () => {
+    const sb = sandbox();
+    try {
+        const npxCli = join(sb.dir, "npx-cli.js");
+        // A stalled npx whose own child holds stdout: the process group dies too.
+        writeFileSync(npxCli, `const { spawn } = require("node:child_process");
+       spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { stdio: "inherit" });
+       setInterval(() => {}, 1000);`);
+        writeFileSync(join(sb.dir, "package.json"), JSON.stringify({ type: "commonjs" }));
+        const env = { LOAD_LOCK_LAUNCHER_NPX_CLI: npxCli, LOAD_LOCK_LAUNCHER_TIMEOUT_MS: "300" };
+        const r = run(sb, ["hook", "claude-code", "session-start"], env);
+        assert.equal(r.status, 0);
+        assert.ok(r.ms < 5000, `took ${r.ms}ms`);
+        assert.match(r.stdout, /npm i -g/); // nothing came out, so the hint does
+        linkOnPath(sb, plantPkg(join(sb.dir, "pkg"), "99.0.0"));
+        const w = spawnSync(process.execPath, [LAUNCHER, "hook", "claude-code", "await-offer"], {
+            env: { ...sb.env, FAKE_HANG: "1", LOAD_LOCK_LAUNCHER_TIMEOUT_MS: "200" },
+            input: "{}",
+            encoding: "utf8",
+            timeout: 1500,
+        });
+        assert.equal(w.error?.code, "ETIMEDOUT", "await-offer must outlive the hook timeout");
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});
+test("resolution helpers: Windows npm shim layout, npx.cmd fallback, state dir precedence", () => {
+    const sb = sandbox();
+    try {
+        // Windows npm global layout: <prefix>\load-lock.cmd + <prefix>\node_modules\@aron98\load-lock
+        const prefix = join(sb.dir, "npm-prefix");
+        plantPkg(join(prefix, "node_modules", "@aron98", "load-lock"), "99.2.0");
+        writeFileSync(join(prefix, "load-lock.cmd"), "@echo off\r\n");
+        const found = L.pathCopy({ PATH: prefix }, "win32", "dist/cli/main.js");
+        assert.equal(found?.version, "99.2.0");
+        assert.equal(found?.source, "path");
+        const noNode = join(sb.dir, "nodeless", "node.exe");
+        assert.deepEqual(L.npxCommand({}, "win32", noNode), { command: "npx.cmd", args: [], shell: true });
+        assert.deepEqual(L.npxCommand({}, "linux", noNode), { command: "npx", args: [], shell: false });
+        assert.equal(L.stateDir({ LOAD_LOCK_STATE_DIR: "/x" }, "linux"), "/x");
+        assert.equal(L.stateDir({ XDG_STATE_HOME: "/xdg", HOME: "/h" }, "linux"), join("/xdg", "load-lock"));
+        assert.equal(L.stateDir({ HOME: "/h" }, "linux"), join("/h", ".local", "state", "load-lock"));
+        assert.equal(L.stateDir({ LOCALAPPDATA: "C:/AppData" }, "win32"), join("C:/AppData", "load-lock"));
+        assert.equal(L.compareVersions("1.10.0", "1.9.9"), 1);
+        assert.equal(L.compareVersions("1.5.0", "1.5"), 0);
+        assert.equal(L.compareVersions("1.4.9", "1.5.0"), -1);
+    }
+    finally {
+        rmSync(sb.dir, { recursive: true, force: true });
+    }
+});

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,36 @@ 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: 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 +294,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 +316,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/reconnect.test.d.ts

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