@aron98/load-lock 1.4.0 → 1.6.0

package/dist/test/hook.test.js

@@ -6,7 +6,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { startDaemon, delay, cliMainPath } from "./testutil.js";
@@ -72,6 +73,9 @@ test("hooks: claude-code stop with a matching offer -> decision block carrying t
         assert.ok(out.reason.includes(offer.offerToken), "reason tells the agent which offer_token to claim");
         assert.ok(out.reason.includes("claim"), "reason instructs claiming");
         assert.ok(out.reason.includes(offer.opKey));
+        // issue #55: tool names differ per wiring (loose MCP vs plugin-bundled)
+        assert.ok(out.reason.includes("load-lock claim tool"), "reason names the claim tool neutrally");
+        assert.ok(!out.reason.includes("mcp__"), "reason hard-codes no MCP tool prefix");
         // stop_hook_active: never loop
         const quiet = await runHook(d, ["claude-code", "stop"], { session_id: "s1", cwd, stop_hook_active: true });
         assert.equal(quiet.code, 0);
@@ -119,6 +123,7 @@ test("hooks: cursor stop with a matching offer -> followup_message carrying the
         assert.ok(out.followup_message.includes(offer.offerToken), "message tells the agent which offer_token to claim");
         assert.ok(out.followup_message.includes("claim"), "message instructs claiming");
         assert.ok(out.followup_message.includes(offer.opKey));
+        assert.ok(!out.followup_message.includes("mcp__"), "message hard-codes no MCP tool prefix");
         assert.equal(out.decision, undefined, "Cursor does not use the Claude/Codex decision shape");
         // loop_count > 0: never chain followups (Cursor's loop guard)
         const quiet = await runHook(d, ["cursor", "stop"], {
@@ -163,6 +168,8 @@ test("hooks: claude-code await-offer wakes (exit 2 + stderr, no token leak) on o
         const r = await awaiting;
         assert.equal(r.code, 2, "asyncRewake contract: exit code 2 wakes Claude");
         assert.ok(r.stderr.includes("claim"), "stderr explains how to claim");
+        assert.ok(r.stderr.includes("load-lock claim tool"), "stderr names the claim tool neutrally");
+        assert.ok(!r.stderr.includes("mcp__"), "stderr hard-codes no MCP tool prefix");
         assert.ok(!r.stderr.includes("off_"), "the offer token itself is NOT in stderr (session must claim via pending)");
         assert.equal(r.stdout, "");
         // timeout path: no offer in window -> exit 0, silent
@@ -174,3 +181,174 @@ test("hooks: claude-code await-offer wakes (exit 2 + stderr, no token leak) on o
         await d.stop();
     }
 });
+// ------------------------------------------------------------ dedupe (#54)
+// Duplicate wiring (loose hooks + plugin, two plugins) fires every hook
+// twice with the same stdin. The daemon's hook_once lets exactly one act.
+test("dedupe: duplicate session-start hooks inject the policy once per firing", async () => {
+    const d = await startDaemon();
+    try {
+        for (const ev of [
+            ["claude-code", "session-start"],
+            ["codex", "session-start"],
+            ["codex", "subagent-start"],
+        ]) {
+            const input = { session_id: `dup-${ev.join("-")}`, cwd: "/tmp", source: "startup" };
+            const rs = await Promise.all([runHook(d, ev, input), runHook(d, ev, input)]);
+            assert.deepEqual(rs.map((r) => r.code), [0, 0]);
+            assert.equal(rs.filter((r) => r.stdout.startsWith(POLICY_MARK)).length, 1, `${ev.join("/")}: exactly one injection`);
+            assert.equal(rs.filter((r) => r.stdout === "").length, 1, "the duplicate is silent");
+            // a later compaction is a new occurrence -> injected again
+            const again = await runHook(d, ev, { ...input, source: "compact" });
+            assert.ok(again.stdout.startsWith(POLICY_MARK), "compact re-injects");
+            // other sessions are independent
+            const other = await runHook(d, ev, { ...input, session_id: `${input.session_id}-other` });
+            assert.ok(other.stdout.startsWith(POLICY_MARK));
+        }
+        // no session id -> no dedupe possible, both act (today's behaviour)
+        const rs = await Promise.all([
+            runHook(d, ["claude-code", "session-start"], { cwd: "/tmp" }),
+            runHook(d, ["claude-code", "session-start"], { cwd: "/tmp" }),
+        ]);
+        assert.ok(rs.every((r) => r.stdout.startsWith(POLICY_MARK)));
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("dedupe: duplicate stop hooks deliver one continuation (claude-code, codex, cursor)", async () => {
+    for (const [harness, input, field] of [
+        ["claude-code", (cwd) => ({ session_id: "dup-s", cwd }), "reason"],
+        ["codex", (cwd) => ({ session_id: "dup-s", cwd, stop_hook_active: false }), "reason"],
+        ["cursor", (cwd) => ({ conversation_id: "dup-c", workspace_roots: [cwd], loop_count: 0 }), "followup_message"],
+    ]) {
+        const d = await startDaemon();
+        try {
+            const cwd = mkdtempSync(join(TMP_BASE, "ll-hook-wt-"));
+            const offer = await outstandingOffer(d, cwd);
+            const rs = await Promise.all([runHook(d, [harness, "stop"], input(cwd)), runHook(d, [harness, "stop"], input(cwd))]);
+            assert.deepEqual(rs.map((r) => r.code), [0, 0]);
+            const delivered = rs.filter((r) => r.stdout !== "");
+            assert.equal(delivered.length, 1, `${harness}: exactly one continuation`);
+            assert.ok(JSON.parse(delivered[0].stdout)[field].includes(offer.offerToken));
+        }
+        finally {
+            await d.stop();
+        }
+    }
+});
+test("dedupe: duplicate await-offer watchers -> one live watcher; key freed when it exits", async () => {
+    const d = await startDaemon();
+    try {
+        const cwd = mkdtempSync(join(TMP_BASE, "ll-hook-wt-"));
+        const c = d.client();
+        await c.connect();
+        await c.request("acquire", { agentId: "dup-holder", opKey: "h", reason: "holding" });
+        await c.request("acquire", { agentId: "dup-waiter", opKey: "w", reason: "waiting", cwd });
+        const env = { LOAD_LOCK_AWAIT_MS: "8000" };
+        const a = runHook(d, ["claude-code", "await-offer"], { session_id: "dup-w", cwd }, env);
+        const b = runHook(d, ["claude-code", "await-offer"], { session_id: "dup-w", cwd }, env);
+        // the loser exits at once, silently, while the winner keeps watching
+        const loser = await Promise.race([a, b]);
+        assert.equal(loser.code, 0);
+        assert.equal(loser.stderr, "");
+        const held = (await c.request("pending", { agentId: "dup-holder" }));
+        await c.request("release", { permitToken: held.held[0].permitToken });
+        const rs = await Promise.all([a, b]);
+        assert.deepEqual(rs.map((r) => r.code).sort(), [0, 2], "exactly one watcher woke the session");
+        // the winner exited -> its connection closed -> the key is free again
+        const next = await runHook(d, ["claude-code", "await-offer"], { session_id: "dup-w", cwd: "/nowhere" }, { LOAD_LOCK_AWAIT_MS: "600" });
+        assert.equal(next.code, 0);
+        const r = (await c.request("hook_once", { harness: "claude-code", sessionId: "dup-w", event: "await-offer", hold: true }));
+        assert.equal(r.first, true, "no stale hold after the watchers are gone");
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("dedupe: hook_once TTL keys expire; params are validated", async () => {
+    const d = await startDaemon();
+    try {
+        const c = d.client();
+        await c.connect();
+        const k = { harness: "codex", sessionId: "ttl", event: "stop", occurrence: "o1", ttlMs: 1000 };
+        assert.equal((await c.request("hook_once", k)).first, true);
+        assert.equal((await c.request("hook_once", k)).first, false);
+        assert.equal((await c.request("hook_once", { ...k, occurrence: "o2" })).first, true, "occurrence is part of the key");
+        await delay(1100);
+        assert.equal((await c.request("hook_once", k)).first, true, "expired keys can be claimed again");
+        await assert.rejects(c.request("hook_once", { harness: "codex", event: "stop" }), /sessionId/);
+        c.close();
+    }
+    finally {
+        await d.stop();
+    }
+});
+/**
+ * A daemon predating hook_once: answers `unknown method` for it, serves one
+ * cwd-matched offer and pushes one `offered` event to watchers.
+ */
+async function oldDaemon(cwd) {
+    const dir = mkdtempSync(join(TMP_BASE, "ll-old-daemon-"));
+    const sock = join(dir, "daemon.sock");
+    const entry = { requestId: "req_old", pool: "heavy", opKey: "w", reason: "waiting", cwd, offerToken: "off_old", offerExpiresAt: Date.now() + 30_000 };
+    const seen = [];
+    const server = createServer((s) => {
+        let buf = "";
+        s.on("error", () => s.destroy());
+        s.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            let idx;
+            while ((idx = buf.indexOf("\n")) !== -1) {
+                const msg = JSON.parse(buf.slice(0, idx));
+                buf = buf.slice(idx + 1);
+                seen.push(msg.method);
+                const reply = (o) => s.write(JSON.stringify(o) + "\n");
+                if (msg.method === "offers_for_cwd")
+                    reply({ id: msg.id, ok: true, result: { offers: [entry] } });
+                else if (msg.method === "watch") {
+                    reply({ id: msg.id, ok: true, result: { ok: true } });
+                    setTimeout(() => reply({ event: true, type: "offered", entry }), 300);
+                }
+                else
+                    reply({ id: msg.id, ok: false, error: { code: "invalid", message: `unknown method "${msg.method}"` } });
+            }
+        });
+    });
+    await new Promise((r) => server.listen(sock, r));
+    const env = { ...process.env, LOAD_LOCK_STATE_DIR: dir, LOAD_LOCK_SOCKET: sock, LOAD_LOCK_NO_SPAWN: "1" };
+    return {
+        handle: { env },
+        seen,
+        close: () => {
+            server.close();
+            rmSync(dir, { recursive: true, force: true });
+        },
+    };
+}
+test("dedupe fallback: a daemon without hook_once -> every hook acts as before", async () => {
+    const cwd = mkdtempSync(join(TMP_BASE, "ll-hook-wt-"));
+    const old = await oldDaemon(cwd);
+    try {
+        const d = old.handle;
+        const two = (args, input, env) => Promise.all([runHook(d, args, input, env), runHook(d, args, input, env)]);
+        for (const r of await two(["claude-code", "session-start"], { session_id: "old", cwd, source: "startup" })) {
+            assert.ok(r.stdout.startsWith(POLICY_MARK), "both inject (no dedupe available)");
+        }
+        for (const h of ["claude-code", "codex"]) {
+            for (const r of await two([h, "stop"], { session_id: "old", cwd })) {
+                assert.equal(JSON.parse(r.stdout).decision, "block", `${h} stop still delivers`);
+            }
+        }
+        for (const r of await two(["cursor", "stop"], { conversation_id: "old", workspace_roots: [cwd], loop_count: 0 })) {
+            assert.ok(JSON.parse(r.stdout).followup_message.includes("off_old"));
+        }
+        for (const r of await two(["claude-code", "await-offer"], { session_id: "old", cwd }, { LOAD_LOCK_AWAIT_MS: "5000" })) {
+            assert.equal(r.code, 2, "both watchers still wake");
+        }
+        assert.ok(old.seen.includes("hook_once"), "the hooks did try the new method");
+    }
+    finally {
+        old.close();
+    }
+});

package/dist/test/identity.test.d.ts

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

package/dist/test/identity.test.js

@@ -0,0 +1,155 @@
+/**
+ * Session-derived agent identity (issue #49): the shared resolver
+ * (override → harness session env → stable harness ancestor → fallback)
+ * against planted /proc trees, plus the CLI default identity end to end:
+ * same session → one id (op-key dedupe, `pending`), different sessions →
+ * distinct ids.
+ */
+import test, { before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { sessionIdentity, harnessAncestor, readProc } from "../shared/identity.js";
+import { startDaemon, runCli } from "./testutil.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+mkdirSync(TMP_BASE, { recursive: true });
+/** Plant /proc/<pid>/{stat,cmdline} entries: [pid, ppid, comm, startTime, argv]. */
+function plantProc(rows) {
+    const root = mkdtempSync(join(TMP_BASE, "ll-proc-"));
+    for (const [pid, ppid, comm, start, argv] of rows) {
+        mkdirSync(join(root, String(pid)));
+        // Fields after comm: state ppid pgrp session tty tpgid flags minflt
+        // cminflt majflt cmajflt utime stime cutime cstime priority nice
+        // num_threads itrealvalue starttime ...
+        const after = ["S", ppid, pid, pid, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 20, 0, 1, 0, start, 1000, 10];
+        writeFileSync(join(root, String(pid), "stat"), `${pid} (${comm}) ${after.join(" ")}\n`);
+        writeFileSync(join(root, String(pid), "cmdline"), argv.join("\0") + "\0");
+    }
+    return root;
+}
+const tree = plantProc([
+    [100, 1, "claude", 5000, ["claude"]],
+    [110, 100, "bash", 5100, ["/bin/bash", "-c", "load-lock acquire"]],
+    [111, 100, "bash", 5200, ["/bin/bash", "-c", "load-lock pending"]],
+    // npx launcher between the harness and the CLI: node running npx-cli.js, then sh.
+    [120, 110, "node", 5300, ["node", "/usr/lib/node_modules/npm/bin/npx-cli.js", "-y", "@aron98/load-lock"]],
+    [121, 120, "sh", 5301, ["sh", "-c", "load-lock acquire"]],
+    [200, 1, "codex", 6000, ["codex"]],
+    [210, 200, "zsh", 6100, ["zsh", "-c", "load-lock acquire"]],
+    // comm with spaces and parens must parse.
+    [300, 1, "tmux: (server)", 7000, ["tmux"]],
+    [310, 300, "fish", 7100, ["fish"]],
+    // a shell chain that ends at init: no harness.
+    [400, 1, "bash", 8000, ["bash"]],
+]);
+after(() => rmSync(tree, { recursive: true, force: true }));
+const resolve = (startPid, env = {}, override) => sessionIdentity({ fallback: "cli:u@h", env, startPid, procRoot: tree, platform: "linux", override });
+test("identity: two calls from the same harness session resolve to the same id", () => {
+    const a = resolve(110);
+    const b = resolve(111);
+    assert.equal(a.source, "ancestor");
+    assert.equal(a.id, "proc:100:5000");
+    assert.equal(b.id, a.id);
+    assert.equal(a.label, "claude:100");
+    // npx/sh wrappers are walked past too.
+    assert.equal(resolve(121).id, a.id);
+});
+test("identity: different harness sessions resolve to different ids", () => {
+    assert.equal(resolve(210).id, "proc:200:6000");
+    assert.notEqual(resolve(210).id, resolve(110).id);
+    assert.equal(resolve(310).id, "proc:300:7000");
+    assert.equal(readProc(300, tree)?.comm, "tmux: (server)");
+});
+test("identity: a reused pid with a new start time is a different session", () => {
+    const reused = plantProc([[100, 1, "claude", 9999, ["claude"]], [110, 100, "bash", 10000, ["bash"]]]);
+    try {
+        const id = sessionIdentity({ fallback: "f", env: {}, startPid: 110, procRoot: reused, platform: "linux" }).id;
+        assert.equal(id, "proc:100:9999");
+        assert.notEqual(id, resolve(110).id);
+    }
+    finally {
+        rmSync(reused, { recursive: true, force: true });
+    }
+});
+test("identity: falls back when the walk reaches init, /proc is missing, or not on Linux", () => {
+    assert.equal(harnessAncestor(400, tree), null);
+    assert.deepEqual(resolve(400), { id: "cli:u@h", label: "cli:u@h", source: "fallback" });
+    assert.equal(resolve(99999).source, "fallback");
+    const mac = sessionIdentity({ fallback: "cli:u@h", env: {}, startPid: 110, procRoot: tree, platform: "darwin" });
+    assert.equal(mac.source, "fallback");
+});
+test("identity: harness session env vars beat the ancestor walk", () => {
+    const cc = resolve(110, { CLAUDE_CODE_SESSION_ID: "ee690007-78c4-48d0-8f80-77b74e95a7fd" });
+    assert.deepEqual(cc, {
+        id: "claude-code:ee690007-78c4-48d0-8f80-77b74e95a7fd",
+        label: "claude-code:ee690007",
+        source: "harness-env",
+    });
+    // OpenCode: the bare sessionID, i.e. the native plugin's agentId.
+    assert.equal(resolve(110, { OPENCODE_SESSION_ID: "ses_abc123" }).id, "ses_abc123");
+});
+test("identity: overrides still win (explicit > LOAD_LOCK_AGENT > harness env)", () => {
+    const env = { LOAD_LOCK_AGENT: "pinned", CLAUDE_CODE_SESSION_ID: "s1" };
+    assert.equal(resolve(110, env).id, "pinned");
+    assert.equal(resolve(110, env).source, "env");
+    assert.equal(resolve(110, env, " explicit ").id, "explicit");
+    assert.equal(resolve(110, { LOAD_LOCK_AGENT: "  " }).source, "ancestor", "blank override ignored");
+});
+// ------------------------------------------------------------ CLI end to end
+let d;
+before(async () => {
+    d = await startDaemon();
+    // The test runner itself may be running inside a harness session.
+    for (const k of ["LOAD_LOCK_AGENT", "CLAUDE_CODE_SESSION_ID", "OPENCODE_SESSION_ID"])
+        delete d.env[k];
+});
+after(async () => {
+    await d.stop();
+});
+function cliIn(env, args) {
+    return runCli({ ...d, env: { ...d.env, ...env } }, args);
+}
+async function acquireJson(env, opKey, extra = []) {
+    const r = await cliIn(env, ["acquire", "--op-key", opKey, "--reason", "identity test", "--json", ...extra]);
+    assert.ok(r.code === 0 || r.code === 68, r.stderr); // 68 = queued
+    return JSON.parse(r.stdout);
+}
+test("cli: same session shares one identity; different sessions get distinct ids", async () => {
+    const a1 = await acquireJson({ CLAUDE_CODE_SESSION_ID: "aaaaaaaa-1" }, "op/shared");
+    const a2 = await acquireJson({ CLAUDE_CODE_SESSION_ID: "aaaaaaaa-1" }, "op/shared");
+    const b = await acquireJson({ CLAUDE_CODE_SESSION_ID: "bbbbbbbb-2" }, "op/shared");
+    assert.equal(a1.entry.agentId, "claude-code:aaaaaaaa-1");
+    assert.equal(a1.entry.agentLabel, "claude-code:aaaaaaaa", "short readable label");
+    assert.equal(a2.entry.requestId, a1.entry.requestId, "same session: op-key dedupe returns the existing request");
+    assert.equal(b.entry.agentId, "claude-code:bbbbbbbb-2");
+    assert.notEqual(b.entry.requestId, a1.entry.requestId, "different sessions are not merged");
+    // Fill the pool so the next requests queue, then check `pending` isolation.
+    const status = JSON.parse((await cliIn({}, ["status", "--json"])).stdout);
+    const cap = status.config.pools.heavy.capacity;
+    for (let i = 2; i < cap; i++)
+        await acquireJson({ CLAUDE_CODE_SESSION_ID: "filler" }, `op/fill-${i}`);
+    const qa = await acquireJson({ CLAUDE_CODE_SESSION_ID: "aaaaaaaa-1" }, "op/queued");
+    assert.equal(qa.state, "queued");
+    const pa = JSON.parse((await cliIn({ CLAUDE_CODE_SESSION_ID: "aaaaaaaa-1" }, ["pending", "--json"])).stdout);
+    const pb = JSON.parse((await cliIn({ CLAUDE_CODE_SESSION_ID: "bbbbbbbb-2" }, ["pending", "--json"])).stdout);
+    assert.ok(JSON.stringify(pa).includes(qa.entry.requestId), "own queue entry visible");
+    assert.ok(!JSON.stringify(pb).includes(qa.entry.requestId), "other session does not see it");
+});
+test("cli: without session env, calls from one parent process share an ancestor identity", async () => {
+    if (process.platform !== "linux")
+        return;
+    const r1 = await acquireJson({}, "op/ancestor");
+    const r2 = await acquireJson({}, "op/ancestor");
+    // The CLI's parent is this test process (node, not a wrapper).
+    const start = readFileSync(`/proc/${process.pid}/stat`, "utf8").split(") ")[1].split(" ")[19];
+    assert.equal(r1.entry.agentId, `proc:${process.pid}:${start}`);
+    assert.equal(r2.entry.requestId, r1.entry.requestId);
+});
+test("cli: --agent and LOAD_LOCK_AGENT overrides still win", async () => {
+    const env = await acquireJson({ LOAD_LOCK_AGENT: "pinned-agent", CLAUDE_CODE_SESSION_ID: "aaaaaaaa-1" }, "op/override");
+    assert.equal(env.entry.agentId, "pinned-agent");
+    assert.equal(env.entry.agentLabel, undefined, "explicit ids label themselves");
+    const flag = await acquireJson({ CLAUDE_CODE_SESSION_ID: "aaaaaaaa-1" }, "op/override", ["--agent", "flag-agent"]);
+    assert.equal(flag.entry.agentId, "flag-agent");
+});

package/dist/test/install.test.js

@@ -5,7 +5,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync, readFileSync, writeFileSync, existsSync, cpSync } from "node:fs";
+import { mkdtempSync, rmSync, mkdirSync, readFileSync, writeFileSync, existsSync, cpSync, symlinkSync, lstatSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -424,6 +424,7 @@ test("claude-code: install/uninstall round-trip on a populated HOME; re-install
     const md = readFileSync(claudeMd, "utf8");
     assert.ok(md.includes("# My rules"), "existing CLAUDE.md content preserved");
     assert.equal(count(md, MARKER_BEGIN), 1, "exactly one marked section");
+    assert.ok(!md.includes("mcp__"), "section names tools neutrally (plugin tools are namespaced differently)");
     assert.ok(existsSync(join(claudeDir, "skills", "load-lock", "SKILL.md")), "skill installed");
     // -- idempotent re-install: no duplicate hook entries (issue #19)
     r = await runCli(home, ["install", "--harness", "claude-code"]);
@@ -464,6 +465,43 @@ test("claude-code: bare HOME install then uninstall removes exactly what we adde
     assert.ok(!("load-lock" in cj.mcpServers), "our MCP server key removed");
     rmSync(home, { recursive: true, force: true });
 });
+test("claude-code: an ACE-stamped skill survives install and uninstall byte for byte (#89)", async () => {
+    const home = tempHome();
+    const skillDir = join(home, ".claude", "skills", "load-lock");
+    mkdirSync(skillDir, { recursive: true });
+    const aceSkill = "---\nname: load-lock\ndescription: from ACE\n---\nACE copy\n";
+    const stamp = JSON.stringify({ artifact: "load-lock", version: "1.4.0" }) + "\n";
+    writeFileSync(join(skillDir, "SKILL.md"), aceSkill);
+    writeFileSync(join(skillDir, ".ace.json"), stamp);
+    let r = await runCli(home, ["install", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `install failed: ${r.stderr}`);
+    assert.match(r.stdout, /kept the skill .*managed by ACE/);
+    assert.equal(readFileSync(join(skillDir, "SKILL.md"), "utf8"), aceSkill, "install must not overwrite ACE's skill");
+    // the rest of the loose wiring is still installed
+    const cj = JSON.parse(readFileSync(join(home, ".claude.json"), "utf8"));
+    assert.ok(cj.mcpServers["load-lock"], "MCP server installed");
+    r = await runCli(home, ["uninstall", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `uninstall failed: ${r.stderr}`);
+    assert.match(r.stdout, /kept the skill .*managed by ACE/);
+    assert.equal(readFileSync(join(skillDir, "SKILL.md"), "utf8"), aceSkill, "uninstall must not delete ACE's skill");
+    assert.equal(readFileSync(join(skillDir, ".ace.json"), "utf8"), stamp, "ACE stamp untouched");
+    rmSync(home, { recursive: true, force: true });
+});
+test("claude-code: a symlinked skill dir is neither written through nor removed (#89)", async () => {
+    const home = tempHome();
+    const checkout = join(home, "dev", "skill");
+    mkdirSync(checkout, { recursive: true });
+    writeFileSync(join(checkout, "SKILL.md"), "mine\n");
+    mkdirSync(join(home, ".claude", "skills"), { recursive: true });
+    symlinkSync(checkout, join(home, ".claude", "skills", "load-lock"));
+    let r = await runCli(home, ["install", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `install failed: ${r.stderr}`);
+    assert.equal(readFileSync(join(checkout, "SKILL.md"), "utf8"), "mine\n", "install must not write through the symlink");
+    r = await runCli(home, ["uninstall", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `uninstall failed: ${r.stderr}`);
+    assert.ok(lstatSync(join(home, ".claude", "skills", "load-lock")).isSymbolicLink(), "symlink kept");
+    rmSync(home, { recursive: true, force: true });
+});
 test("claude-code: uninstall with nothing installed is a harmless no-op", async () => {
     const home = tempHome();
     const r = await runCli(home, ["uninstall", "--harness", "claude-code"]);
@@ -472,6 +510,101 @@ test("claude-code: uninstall with nothing installed is a harmless no-op", async
     assert.ok(!existsSync(join(home, ".claude.json")), "no files created by uninstall");
     rmSync(home, { recursive: true, force: true });
 });
+// claude-code plugin migration (#62)
+const PLUGIN_KEY = "load-lock-plugin@load-lock";
+/** `doctor --json` against a temp HOME and a state dir no daemon ever runs in. */
+async function doctorMode(home) {
+    const state = join(home, "st");
+    const r = await runCli(home, ["doctor", "--json"], {
+        LOAD_LOCK_STATE_DIR: state,
+        LOAD_LOCK_SOCKET: join(state, "d.sock"),
+        LOAD_LOCK_NO_SPAWN: "1",
+    });
+    assert.equal(r.code, 0, `doctor failed: ${r.stderr}`);
+    const rep = JSON.parse(r.stdout);
+    return { mode: rep.claudeCodeMode, warnings: rep.warnings };
+}
+function enablePlugin(home, on) {
+    const file = join(home, ".claude", "settings.json");
+    const s = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+    s.enabledPlugins = { ...s.enabledPlugins, [PLUGIN_KEY]: on };
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(s, null, 2) + "\n");
+}
+test("claude-code: loose → plugin migration, --legacy, uninstall; doctor reports the mode", async () => {
+    const home = tempHome();
+    const claudeDir = join(home, ".claude");
+    mkdirSync(claudeDir, { recursive: true });
+    writeFileSync(join(home, ".claude.json"), JSON.stringify({ mcpServers: { fetch: { command: "uvx" } } }, null, 2) + "\n");
+    writeFileSync(join(claudeDir, "settings.json"), JSON.stringify({ theme: "dark", hooks: { Stop: [{ hooks: [{ type: "command", command: "/usr/local/bin/user-stop" }] }] } }, null, 2) + "\n");
+    writeFileSync(join(claudeDir, "CLAUDE.md"), "# My rules\n");
+    const claudeJson = join(home, ".claude.json");
+    const settingsFile = join(claudeDir, "settings.json");
+    const claudeMd = join(claudeDir, "CLAUDE.md");
+    const skill = join(claudeDir, "skills", "load-lock", "SKILL.md");
+    let r = await runCli(home, ["install", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `install failed: ${r.stderr}`);
+    assert.equal((await doctorMode(home)).mode, "loose");
+    // the user enables the plugin: both are active, doctor flags it
+    enablePlugin(home, true);
+    let d = await doctorMode(home);
+    assert.equal(d.mode, "both");
+    assert.ok(d.warnings.some((w) => /plugin and the loose/.test(w)), "doctor flags both");
+    // -- install moves the loose entries out, reporting each step
+    r = await runCli(home, ["install", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `migrating install failed: ${r.stderr}`);
+    assert.match(r.stdout, new RegExp(`plugin ${PLUGIN_KEY} is enabled`));
+    assert.match(r.stdout, /removed mcpServers\.load-lock/);
+    assert.match(r.stdout, /removed load-lock hooks/);
+    assert.match(r.stdout, /removed the load-lock section/);
+    let cj = JSON.parse(readFileSync(claudeJson, "utf8"));
+    assert.ok(!("load-lock" in cj.mcpServers), "loose MCP server removed");
+    assert.ok(cj.mcpServers.fetch, "user MCP server untouched");
+    let s = JSON.parse(readFileSync(settingsFile, "utf8"));
+    assert.ok(!("SessionStart" in s.hooks), "loose SessionStart hooks removed");
+    assert.deepEqual(s.hooks.Stop, [{ hooks: [{ type: "command", command: "/usr/local/bin/user-stop" }] }], "user hook untouched");
+    assert.equal(s.enabledPlugins[PLUGIN_KEY], true, "plugin state untouched");
+    assert.equal(s.theme, "dark");
+    assert.equal(readFileSync(claudeMd, "utf8"), "# My rules\n", "CLAUDE.md section removed exactly");
+    assert.ok(existsSync(skill), "the skill stays (the plugin ships none)");
+    assert.equal((await doctorMode(home)).mode, "plugin");
+    // a second run is a no-op
+    r = await runCli(home, ["install", "--harness", "claude-code"]);
+    assert.equal(r.code, 0);
+    assert.match(r.stdout, /no loose MCP server, hooks or CLAUDE\.md section to remove/);
+    // -- --legacy keeps the loose install next to the plugin
+    r = await runCli(home, ["install", "--harness", "claude-code", "--legacy"]);
+    assert.equal(r.code, 0, `legacy install failed: ${r.stderr}`);
+    assert.match(r.stdout, /--legacy: plugin .* is enabled too/);
+    cj = JSON.parse(readFileSync(claudeJson, "utf8"));
+    assert.ok(cj.mcpServers["load-lock"], "--legacy installs the loose MCP server");
+    s = JSON.parse(readFileSync(settingsFile, "utf8"));
+    assert.equal(s.hooks.SessionStart.length, 2, "--legacy installs the loose hooks");
+    assert.equal((await doctorMode(home)).mode, "both");
+    // -- uninstall removes loose entries only and points at /plugin uninstall
+    r = await runCli(home, ["uninstall", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `uninstall failed: ${r.stderr}`);
+    assert.match(r.stdout, new RegExp(`/plugin uninstall ${PLUGIN_KEY}`));
+    s = JSON.parse(readFileSync(settingsFile, "utf8"));
+    assert.equal(s.enabledPlugins[PLUGIN_KEY], true, "uninstall never edits plugin state");
+    assert.ok(!("SessionStart" in s.hooks), "loose hooks removed");
+    cj = JSON.parse(readFileSync(claudeJson, "utf8"));
+    assert.ok(!("load-lock" in cj.mcpServers), "loose MCP server removed");
+    assert.equal(readFileSync(claudeMd, "utf8"), "# My rules\n");
+    assert.ok(!existsSync(skill), "our skill removed");
+    assert.equal((await doctorMode(home)).mode, "plugin");
+    rmSync(home, { recursive: true, force: true });
+});
+test("claude-code: a disabled plugin doesn't stop the loose install", async () => {
+    const home = tempHome();
+    enablePlugin(home, false);
+    const r = await runCli(home, ["install", "--harness", "claude-code"]);
+    assert.equal(r.code, 0, `install failed: ${r.stderr}`);
+    const cj = JSON.parse(readFileSync(join(home, ".claude.json"), "utf8"));
+    assert.ok(cj.mcpServers["load-lock"], "loose MCP server installed");
+    assert.equal((await doctorMode(home)).mode, "loose");
+    rmSync(home, { recursive: true, force: true });
+});
 // --------------------------------------------------------------------- codex
 test("codex: install/uninstall round-trip on a populated HOME; re-install never duplicates hooks", async () => {
     const home = tempHome();
@@ -510,6 +643,7 @@ test("codex: install/uninstall round-trip on a populated HOME; re-install never
     const md = readFileSync(agentsMd, "utf8");
     assert.ok(md.includes("# My codex rules"), "existing AGENTS.md content preserved");
     assert.equal(count(md, MARKER_BEGIN), 1, "exactly one marked section");
+    assert.ok(!md.includes("mcp__"), "section names tools neutrally");
     // -- idempotent re-install: no duplicate hook entries (issue #19)
     r = await runCli(home, ["install", "--harness", "codex"], { CODEX_HOME: codexDir });
     assert.equal(r.code, 0, `re-install failed: ${r.stderr}`);

package/dist/test/launcher.test.d.ts

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