@aron98/load-lock 1.5.0 → 1.6.0

package/dist/test/check-pins.test.js

@@ -0,0 +1,108 @@
+/**
+ * Tests for the version-pin sync check (issue #48): scripts/check-pins.mjs
+ * over planted files in a temp root, plus the real script on this repo.
+ * Light: no daemon, files only.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, 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 SCRIPT = join(REPO_ROOT, "scripts", "check-pins.mjs");
+const pins = (await import(pathToFileURL(SCRIPT).href));
+function plant(files) {
+    const root = mkdtempSync(join(tmpdir(), "ll-pins-"));
+    for (const [rel, body] of Object.entries(files)) {
+        mkdirSync(dirname(join(root, rel)), { recursive: true });
+        writeFileSync(join(root, rel), body);
+    }
+    return root;
+}
+const DECLARED = [
+    { path: "skills/load-lock/SKILL.md", kind: "spec" },
+    { path: "ace/mcp.json", kind: "spec" },
+    { path: "plugin/.claude-plugin/plugin.json", kind: "json", key: "version" },
+];
+function plantedRepo(skillPin, mcpPin, pluginVersion) {
+    return plant({
+        "skills/load-lock/SKILL.md": `Else run \`npx -y @aron98/load-lock@${skillPin} status\`.\n` +
+            `Upgrade with \`npm i -g @aron98/load-lock@latest\` (unpinned, ignored).\n`,
+        "ace/mcp.json": JSON.stringify({ mcpServers: { "load-lock": { command: "npx", args: ["-y", `@aron98/load-lock@${mcpPin}`] } } }, null, 2) + "\n",
+        "plugin/.claude-plugin/plugin.json": JSON.stringify({ name: "load-lock", version: pluginVersion, description: "x" }, null, 2) + "\n",
+    });
+}
+test("check-pins: in-sync planted files pass", () => {
+    const root = plantedRepo("1.6.0", "1.6.0", "1.6.0");
+    try {
+        assert.deepEqual(pins.checkPins(root, "1.6.0", DECLARED), []);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test("check-pins: mismatches are reported per pin, then --write fixes them all", () => {
+    const root = plantedRepo("1.5.0", "1.6.0-rc.1", "1.4.2");
+    try {
+        const problems = pins.checkPins(root, "1.6.0", DECLARED);
+        assert.equal(problems.length, 3, problems.join("\n"));
+        assert.ok(problems.some((p) => p.startsWith("skills/load-lock/SKILL.md:1: pins 1.5.0")), problems.join("\n"));
+        assert.ok(problems.some((p) => p.includes("ace/mcp.json") && p.includes("1.6.0-rc.1")), problems.join("\n"));
+        assert.ok(problems.some((p) => p.includes("plugin.json (version): pins 1.4.2")), problems.join("\n"));
+        const changed = pins.writePins(root, "1.6.0", DECLARED);
+        assert.deepEqual(changed.sort(), DECLARED.map((d) => d.path).sort());
+        assert.deepEqual(pins.checkPins(root, "1.6.0", DECLARED), []);
+        const skill = readFileSync(join(root, "skills/load-lock/SKILL.md"), "utf8");
+        assert.match(skill, /@aron98\/load-lock@1\.6\.0 status/);
+        assert.match(skill, /@aron98\/load-lock@latest/, "non-version tags are left alone");
+        const plugin = JSON.parse(readFileSync(join(root, "plugin/.claude-plugin/plugin.json"), "utf8"));
+        assert.deepEqual(plugin, { name: "load-lock", version: "1.6.0", description: "x" });
+        // idempotent
+        assert.deepEqual(pins.writePins(root, "1.6.0", DECLARED), []);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test("check-pins: --write keeps a JSON file's own formatting", () => {
+    const body = `{\n  "name": "load-lock-plugin",\n  "version": "1.5.0",\n  "keywords": ["a", "b"],\n` +
+        `  "deps": { "@aron98/load-lock": "1.5.0" }\n}\n`;
+    const root = plant({ "p.json": body });
+    const declared = [
+        { path: "p.json", kind: "json", key: "version" },
+        { path: "p.json", kind: "json", key: "deps.@aron98/load-lock" },
+    ];
+    try {
+        pins.writePins(root, "1.6.0", declared);
+        assert.equal(readFileSync(join(root, "p.json"), "utf8"), body.replaceAll("1.5.0", "1.6.0"));
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test("check-pins: a declared file that is missing or lost its pin fails", () => {
+    const root = plant({ "skills/load-lock/SKILL.md": "use `npx -y @aron98/load-lock@latest`\n" });
+    try {
+        const problems = pins.checkPins(root, "1.6.0", [
+            { path: "skills/load-lock/SKILL.md", kind: "spec" },
+            { path: "ace/mcp.json", kind: "spec" },
+        ]);
+        assert.equal(problems.length, 2, problems.join("\n"));
+        assert.match(problems[0], /SKILL\.md: no @aron98\/load-lock@<version> pin found/);
+        assert.match(problems[1], /ace\/mcp\.json: declared pinned file is missing/);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test("check-pins: the script passes on this repo", () => {
+    const r = spawnSync(process.execPath, [SCRIPT], { encoding: "utf8" });
+    assert.equal(r.status, 0, r.stdout + r.stderr);
+    assert.match(r.stdout, /pins ok/);
+    // every declared path is relative and inside the repo
+    for (const e of pins.PINNED)
+        assert.ok(!e.path.startsWith("/") && !e.path.includes(".."), e.path);
+});

package/dist/test/compat.test.d.ts

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

package/dist/test/compat.test.js

@@ -0,0 +1,190 @@
+/**
+ * Persisted state format compatibility (issue #51): a state dir written by a
+ * NEWER format (higher formatVersion, extra fields, unknown journal entry
+ * kinds) must load in the current code, and unknown fields must survive a
+ * rewrite. Also: what we write stays readable by older daemons (the journal
+ * stays a bare array; config.json keeps `config` + `history`).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { LLClient } from "../shared/client.js";
+import { Machine } from "../core/state.js";
+import { loadState, saveState, loadJournal, saveJournal, STATE_FORMAT_VERSION } from "../core/persist.js";
+import { daemonMainPath, probe, until } from "./testutil.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+mkdirSync(TMP_BASE, { recursive: true });
+const FUTURE = STATE_FORMAT_VERSION + 7;
+function newerConfigFile() {
+    return {
+        formatVersion: FUTURE,
+        futureTopLevel: { keep: "me" },
+        config: {
+            version: 4,
+            pools: { heavy: { capacity: 2, futurePoolField: "pool-x" }, gpu: { capacity: 1 } },
+            offerTimeoutMs: 30_000,
+            maxWaitMs: 5_000,
+            maxTurnWaitMs: 600_000,
+            startTimeoutMs: 120_000,
+            untrackedLeaseMs: 15 * 60_000,
+            guidance: { notes: "n", futureGuidance: 42 },
+            futureConfigField: ["a", "b"],
+        },
+        history: [{ ts: 1, author: "newer", reason: "r", changes: {}, resultingVersion: 4, futureHistoryField: true }],
+    };
+}
+function newerJournal(now) {
+    return [
+        // a held permit with an extra field + newer per-entry version
+        {
+            formatVersion: FUTURE,
+            requestId: "req_held",
+            pool: "heavy",
+            agentId: "A",
+            opKey: "op1",
+            reason: "build",
+            weight: 1,
+            state: "held",
+            permitToken: "pmt_held",
+            phase: "running_untracked",
+            claimedAt: now,
+            futureEntryField: { x: 1 },
+        },
+        // an entry kind this version doesn't know
+        { formatVersion: FUTURE, requestId: "req_future", pool: "heavy", agentId: "B", opKey: "op", reason: "r", weight: 1, state: "suspended", claimedAt: now },
+        // a held permit in a phase this version doesn't know
+        { requestId: "req_phase", pool: "gpu", agentId: "C", opKey: "op", reason: "r", weight: 1, state: "held", permitToken: "pmt_phase", phase: "paused_by_future", claimedAt: now },
+        // malformed garbage
+        "not an entry",
+        { state: "held" },
+        // a queued request with an extra field
+        { requestId: "req_q", pool: "heavy", agentId: "D", opKey: "op", reason: "r", weight: 1, state: "queued", enqueuedAt: now, claimedAt: now, futureQueued: "q" },
+    ];
+}
+function tmpDir() {
+    return mkdtempSync(join(TMP_BASE, "ll-compat-"));
+}
+test("compat: newer config.json loads and unknown fields survive a config change", () => {
+    const dir = tmpDir();
+    try {
+        writeFileSync(join(dir, "config.json"), JSON.stringify(newerConfigFile()));
+        const st = loadState(dir);
+        assert.equal(st.formatVersion, FUTURE);
+        assert.equal(st.config.pools.heavy.capacity, 2);
+        const m = new Machine(Date.now, st.config);
+        m.history.push(...st.history);
+        m.configure({ expectedVersion: 4, changes: { pools: { heavy: { capacity: 3 } }, guidance: { notes: "n2" } }, reason: "t", author: "me" });
+        saveState(dir, m.config, m.history);
+        const raw = JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+        assert.equal(raw.formatVersion, STATE_FORMAT_VERSION);
+        assert.deepEqual(raw.futureTopLevel, { keep: "me" });
+        assert.deepEqual(raw.config.futureConfigField, ["a", "b"]);
+        assert.equal(raw.config.pools.heavy.capacity, 3);
+        assert.equal(raw.config.pools.heavy.futurePoolField, "pool-x");
+        assert.equal(raw.config.guidance.notes, "n2");
+        assert.equal(raw.config.guidance.futureGuidance, 42);
+        assert.equal(raw.history[0].futureHistoryField, true);
+        assert.equal(raw.history.length, 2);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("compat: pre-versioning config.json reads as format 0; our writes keep the old shape", () => {
+    const dir = tmpDir();
+    try {
+        const old = newerConfigFile();
+        writeFileSync(join(dir, "config.json"), JSON.stringify({ config: old.config, history: [] }));
+        const st = loadState(dir);
+        assert.equal(st.formatVersion, 0);
+        saveState(dir, st.config, st.history);
+        const raw = JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+        // older daemons read exactly `config` + `history`
+        assert.equal(typeof raw.config, "object");
+        assert.ok(Array.isArray(raw.history));
+        // journal stays a bare array (what every released daemon reads)
+        saveJournal(dir, [{ requestId: "r", pool: "heavy", agentId: "A", opKey: "o", reason: "r", weight: 1, claimedAt: 1, state: "queued" }]);
+        const j = JSON.parse(readFileSync(join(dir, "journal.json"), "utf8"));
+        assert.ok(Array.isArray(j));
+        assert.equal(j[0].formatVersion, STATE_FORMAT_VERSION);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("compat: unknown journal entry kinds don't break restore; unknown fields round-trip", () => {
+    const dir = tmpDir();
+    try {
+        const now = Date.now();
+        writeFileSync(join(dir, "config.json"), JSON.stringify(newerConfigFile()));
+        writeFileSync(join(dir, "journal.json"), JSON.stringify(newerJournal(now)));
+        const st = loadState(dir);
+        const m = new Machine(Date.now, st.config);
+        const res = m.restore(loadJournal(dir), () => null);
+        assert.equal(res.kept, 2, "held + unknown-phase held");
+        assert.equal(res.queued, 1);
+        assert.equal(res.skipped, 2, "unknown kind + malformed entry");
+        const ev = m.eventsSince(0).find((e) => e.type === "daemon_recovered");
+        assert.match(String(ev?.detail), /skipped 2 unrecognized/, "skips are reported in the recovery event");
+        // unknown phase: kept, conservatively as untracked with a lease
+        const out = m.journalEntries();
+        const phase = out.find((e) => e.requestId === "req_phase");
+        assert.equal(phase.phase, "running_untracked");
+        assert.ok(phase.leaseDeadline && phase.leaseDeadline > now);
+        // unknown per-entry fields are written back while the entry lives
+        saveJournal(dir, out);
+        const back = loadJournal(dir);
+        assert.deepEqual(back.find((e) => e.requestId === "req_held").futureEntryField, { x: 1 });
+        assert.equal(back.find((e) => e.requestId === "req_q").futureQueued, "q");
+        assert.ok(back.every((e) => e.formatVersion === STATE_FORMAT_VERSION));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("compat: a daemon started on a newer-format state dir serves it and preserves unknown fields", async () => {
+    const dir = tmpDir();
+    const sock = join(dir, "daemon.sock");
+    writeFileSync(join(dir, "config.json"), JSON.stringify(newerConfigFile()));
+    writeFileSync(join(dir, "journal.json"), JSON.stringify(newerJournal(Date.now())));
+    const child = spawn(process.execPath, [daemonMainPath, "--state-dir", dir, "--socket", sock], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, LOAD_LOCK_STATE_DIR: dir, LOAD_LOCK_SOCKET: sock },
+    });
+    try {
+        await until("daemon listens", async () => await probe(sock));
+        const c = new LLClient({ socket: sock, stateDir: dir, spawnDaemon: false });
+        await c.connect();
+        const st = (await c.request("status", {}));
+        const heavy = st.pools.find((p) => p.pool === "heavy");
+        assert.ok(heavy, "heavy pool present");
+        assert.equal(heavy.holders.length, 1, "known held permit restored");
+        const cfg = (await c.request("get_config", {}));
+        await c.request("configure", {
+            expectedVersion: cfg.config.version,
+            changes: { pools: { heavy: { capacity: 5 } } },
+            reason: "compat test",
+            author: "test",
+        });
+        // the restored token still releases
+        const rel = (await c.request("release", { permitToken: "pmt_held" }));
+        assert.equal(rel.releasedNow, true);
+        c.close();
+        const raw = JSON.parse(readFileSync(join(dir, "config.json"), "utf8"));
+        assert.equal(raw.config.pools.heavy.capacity, 5);
+        assert.equal(raw.config.pools.heavy.futurePoolField, "pool-x");
+        assert.deepEqual(raw.config.futureConfigField, ["a", "b"]);
+        assert.deepEqual(raw.futureTopLevel, { keep: "me" });
+        const j = JSON.parse(readFileSync(join(dir, "journal.json"), "utf8"));
+        assert.ok(Array.isArray(j));
+        assert.equal(j.find((e) => e.requestId === "req_q")?.futureQueued, "q");
+    }
+    finally {
+        child.kill("SIGTERM");
+        await new Promise((r) => (child.exitCode !== null ? r() : child.once("exit", () => r())));
+        rmSync(dir, { recursive: true, force: true });
+    }
+});

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 {};