@openclaw/lobster 2026.9.4 → 2026.9.6

package/node_modules/@clawdbot/lobster/dist/test/llm_invoke.test.js

@@ -1,10 +1,13 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
 import http from "node:http";
-import { mkdtemp, rm } from "node:fs/promises";
+import { promises as fsp } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { createDefaultRegistry } from "../src/commands/registry.js";
+import { keyToPath, stableStringify } from "../src/state/store.js";
 function streamOf(items) {
     return (async function* () {
         for (const item of items)
@@ -78,6 +81,226 @@ test("llm.invoke auto-detects OpenClaw provider and normalizes output", async ()
         await closeServer(server);
     }
 });
+test("llm.invoke re-invokes the adapter when --temperature changes", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-"));
+    const requestLog = [];
+    const server = http.createServer((req, res) => {
+        if (req.method !== "POST" || req.url !== "/invoke") {
+            res.writeHead(404);
+            res.end("nope");
+            return;
+        }
+        let buf = "";
+        req.setEncoding("utf8");
+        req.on("data", (d) => (buf += d));
+        req.on("end", () => {
+            const parsed = JSON.parse(buf || "{}");
+            requestLog.push(parsed);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: true,
+                result: {
+                    runId: `pi_${requestLog.length}`,
+                    model: parsed.model,
+                    prompt: parsed.prompt,
+                    output: { format: "text", text: `temperature=${parsed.temperature}` },
+                },
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    const ctxEnv = {
+        LOBSTER_PI_LLM_ADAPTER_URL: `http://127.0.0.1:${port}`,
+        LOBSTER_CACHE_DIR: cacheDir,
+    };
+    try {
+        const runWith = async (temperature) => {
+            const result = await cmd.run({
+                input: streamOf([]),
+                args: {
+                    _: [],
+                    provider: "pi",
+                    model: "test-model",
+                    prompt: "Sampling parameters matter",
+                    "schema-version": "v1",
+                    temperature,
+                },
+                ctx: baseCtx(ctxEnv, registry),
+            });
+            return collect(result.output);
+        };
+        const cold = await runWith(0.1);
+        assert.equal(cold[0].source, "pi");
+        assert.equal(requestLog.length, 1);
+        assert.equal(requestLog[0].temperature, 0.1);
+        const changed = await runWith(0.9);
+        assert.equal(changed[0].source, "pi");
+        assert.equal(requestLog.length, 2);
+        assert.equal(requestLog[1].temperature, 0.9);
+        assert.notEqual(changed[0].cacheKey, cold[0].cacheKey);
+        const replay = await runWith(0.1);
+        assert.equal(replay[0].source, "cache");
+        assert.equal(replay[0].cacheKey, cold[0].cacheKey);
+        assert.equal(requestLog.length, 2);
+    }
+    finally {
+        await rm(cacheDir, { recursive: true, force: true });
+        await closeServer(server);
+    }
+});
+test("llm.invoke re-invokes the adapter when --max-output-tokens changes", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-"));
+    const requestLog = [];
+    const server = http.createServer((req, res) => {
+        if (req.method !== "POST" || req.url !== "/invoke") {
+            res.writeHead(404);
+            res.end("nope");
+            return;
+        }
+        let buf = "";
+        req.setEncoding("utf8");
+        req.on("data", (d) => (buf += d));
+        req.on("end", () => {
+            const parsed = JSON.parse(buf || "{}");
+            requestLog.push(parsed);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: true,
+                result: {
+                    runId: `pi_${requestLog.length}`,
+                    output: { format: "text", text: `budget=${parsed.maxOutputTokens}` },
+                },
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    const ctxEnv = {
+        LOBSTER_PI_LLM_ADAPTER_URL: `http://127.0.0.1:${port}`,
+        LOBSTER_CACHE_DIR: cacheDir,
+    };
+    try {
+        const runWith = async (maxOutputTokens) => {
+            const result = await cmd.run({
+                input: streamOf([]),
+                args: {
+                    _: [],
+                    provider: "pi",
+                    model: "test-model",
+                    prompt: "Token budget matters",
+                    "schema-version": "v1",
+                    "max-output-tokens": maxOutputTokens,
+                },
+                ctx: baseCtx(ctxEnv, registry),
+            });
+            return collect(result.output);
+        };
+        const cold = await runWith(64);
+        assert.equal(cold[0].source, "pi");
+        assert.equal(requestLog.length, 1);
+        assert.equal(requestLog[0].maxOutputTokens, 64);
+        const changed = await runWith(4096);
+        assert.equal(changed[0].source, "pi");
+        assert.equal(requestLog.length, 2);
+        assert.equal(requestLog[1].maxOutputTokens, 4096);
+        assert.notEqual(changed[0].cacheKey, cold[0].cacheKey);
+    }
+    finally {
+        await rm(cacheDir, { recursive: true, force: true });
+        await closeServer(server);
+    }
+});
+test("llm.invoke does not replay a cache entry written before sampling was keyed", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-"));
+    const args = {
+        _: [],
+        provider: "pi",
+        model: "test-model",
+        prompt: "Cache key stability",
+        "schema-version": "v1",
+    };
+    // The identity earlier releases hashed: sampling parameters were absent from the payload,
+    // so an answer sampled at temperature 0.9 was stored under the same key a request that
+    // omits sampling computes. Reading that entry back would serve sampling nobody asked for.
+    const legacyKey = createHash("sha256")
+        .update(stableStringify({
+        provider: "pi",
+        prompt: "Cache key stability",
+        model: "test-model",
+        schemaVersion: "v1",
+        artifactHashes: [],
+        outputSchema: null,
+    }))
+        .digest("hex");
+    const requestLog = [];
+    const server = http.createServer((req, res) => {
+        if (req.method !== "POST" || req.url !== "/invoke") {
+            res.writeHead(404);
+            res.end("nope");
+            return;
+        }
+        let buf = "";
+        req.setEncoding("utf8");
+        req.on("data", (d) => (buf += d));
+        req.on("end", () => {
+            requestLog.push(JSON.parse(buf || "{}"));
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: true,
+                result: { runId: "pi_1", output: { format: "text", text: "fresh" } },
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    try {
+        await mkdir(path.join(cacheDir, "llm.invoke"), { recursive: true });
+        await writeFile(path.join(cacheDir, "llm.invoke", `${legacyKey}.json`), JSON.stringify({
+            cacheKey: legacyKey,
+            storedAt: "2026-08-01T00:00:00.000Z",
+            items: [
+                {
+                    kind: "llm.invoke",
+                    cacheKey: legacyKey,
+                    status: "completed",
+                    source: "pi",
+                    cached: false,
+                    output: { format: "text", text: "sampled at 0.9" },
+                },
+            ],
+        }), "utf8");
+        const result = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: baseCtx({
+                LOBSTER_PI_LLM_ADAPTER_URL: `http://127.0.0.1:${port}`,
+                LOBSTER_CACHE_DIR: cacheDir,
+            }, registry),
+        });
+        const items = await collect(result.output);
+        assert.equal(requestLog.length, 1);
+        assert.equal(items[0].source, "pi");
+        assert.equal(items[0].output.text, "fresh");
+        assert.notEqual(items[0].cacheKey, legacyKey);
+    }
+    finally {
+        await rm(cacheDir, { recursive: true, force: true });
+        await closeServer(server);
+    }
+});
 test("llm.invoke uses Pi adapter over local HTTP bridge", async () => {
     const registry = createDefaultRegistry();
     const cmd = registry.get("llm.invoke");
@@ -147,6 +370,693 @@ test("llm.invoke uses Pi adapter over local HTTP bridge", async () => {
         await closeServer(server);
     }
 });
+test("llm.invoke aborts the in-flight adapter request when ctx.signal aborts", { timeout: 20_000 }, async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const stalled = createStalledAdapter();
+    await stalled.listen();
+    const controller = new AbortController();
+    try {
+        const pending = cmd.run({
+            input: streamOf([]),
+            args: { _: [], provider: "http", prompt: "Summarize", "disable-cache": true },
+            ctx: {
+                ...baseCtx({ LOBSTER_LLM_ADAPTER_URL: `http://127.0.0.1:${stalled.port}/invoke` }, registry),
+                signal: controller.signal,
+            },
+        });
+        await stalled.requestReceived;
+        controller.abort();
+        const err = await pending.then(() => null, (e) => e);
+        assert.ok(err, "llm.invoke should reject once the run is aborted");
+        assert.ok(err.name === "AbortError" || err.code === "ABORT_ERR", `expected an abort error, got ${err.name}: ${err.message}`);
+        // The abort must stay recognizable; wrapping it hides the cancellation from
+        // workflow timeout and abort handling.
+        assert.doesNotMatch(String(err.message), /request failed/);
+        await stalled.requestClosed;
+    }
+    finally {
+        controller.abort();
+        await stalled.close();
+    }
+});
+test("llm.invoke stops waiting for a direct adapter that ignores ctx.signal", { timeout: 20_000 }, async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    let invoked = () => { };
+    const adapterInvoked = new Promise((resolve) => (invoked = resolve));
+    // A supported ctx.llmAdapters adapter that never resolves and never looks
+    // at ctx.signal.
+    const stubborn = {
+        invoke() {
+            invoked();
+            return new Promise(() => { });
+        },
+    };
+    const controller = new AbortController();
+    const pending = cmd.run({
+        input: streamOf([]),
+        args: { _: [], provider: "stubborn", prompt: "Summarize", "disable-cache": true },
+        ctx: {
+            ...baseCtx({}, registry),
+            llmAdapters: { stubborn },
+            signal: controller.signal,
+        },
+    });
+    await adapterInvoked;
+    controller.abort();
+    const err = await pending.then(() => null, (e) => e);
+    assert.ok(err, "llm.invoke should reject once the run is aborted");
+    assert.ok(err.name === "AbortError" || err.code === "ABORT_ERR", `expected an abort error, got ${err.name}: ${err.message}`);
+    assert.doesNotMatch(String(err.message), /request failed/);
+});
+test("llm.invoke observes a direct adapter that rejects after aborting the run", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const controller = new AbortController();
+    // An adapter that cancels the run from inside its own invoke and then fails:
+    // the shape of an SDK client that tears itself down on a fatal error.
+    const selfaborting = {
+        invoke() {
+            controller.abort();
+            return Promise.reject(new Error("adapter tore down its client"));
+        },
+    };
+    const unhandled = [];
+    const onUnhandled = (reason) => unhandled.push(reason);
+    process.on("unhandledRejection", onUnhandled);
+    try {
+        const err = await cmd
+            .run({
+            input: streamOf([]),
+            args: { _: [], provider: "selfaborting", prompt: "Summarize", "disable-cache": true },
+            ctx: {
+                ...baseCtx({}, registry),
+                llmAdapters: { selfaborting },
+                signal: controller.signal,
+            },
+        })
+            .then(() => null, (e) => e);
+        assert.ok(err?.name === "AbortError" || err?.code === "ABORT_ERR", `expected an abort error, got ${err?.name}: ${err?.message}`);
+        // The adapter's own rejection must not outlive the cancelled step. Nothing is
+        // waiting on it once the abort has won the race, and an unobserved rejection
+        // ends the process under Node's default handling.
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        assert.equal(unhandled.length, 0, `adapter rejection went unhandled: ${unhandled[0]?.message ?? unhandled[0]}`);
+    }
+    finally {
+        process.off("unhandledRejection", onUnhandled);
+    }
+});
+test("llm.invoke does not complete from cache when ctx.signal is already aborted", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-"));
+    await mkdir(path.join(cacheDir, "llm.invoke"), { recursive: true });
+    let requests = 0;
+    const server = http.createServer((req, res) => {
+        requests += 1;
+        req.resume();
+        req.on("end", () => {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: true,
+                result: { runId: "cached_1", output: { text: "hello", data: null } },
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    const env = {
+        LOBSTER_LLM_ADAPTER_URL: `http://127.0.0.1:${port}/invoke`,
+        LOBSTER_CACHE_DIR: cacheDir,
+    };
+    const args = { _: [], provider: "http", prompt: "Summarize" };
+    try {
+        // Populate the cache, then repeat the same call on a cancelled run.
+        const warm = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: baseCtx(env, registry),
+        });
+        assert.equal((await collect(warm.output))[0].cached, false);
+        assert.equal(requests, 1);
+        const controller = new AbortController();
+        controller.abort();
+        await assert.rejects(() => cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: { ...baseCtx(env, registry), signal: controller.signal },
+        }), (err) => err?.name === "AbortError" || err?.code === "ABORT_ERR");
+        assert.equal(requests, 1, "the cached run must not reach the adapter either");
+    }
+    finally {
+        await rm(cacheDir, { recursive: true, force: true });
+        await closeServer(server);
+    }
+});
+test("llm.invoke does not replay a cache hit when ctx.signal aborts while input is drained", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-"));
+    await mkdir(path.join(cacheDir, "llm.invoke"), { recursive: true });
+    let requests = 0;
+    const server = http.createServer((req, res) => {
+        requests += 1;
+        req.resume();
+        req.on("end", () => {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: true,
+                result: { runId: "cached_1", output: { text: "hello", data: null } },
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    const env = {
+        LOBSTER_LLM_ADAPTER_URL: `http://127.0.0.1:${port}/invoke`,
+        LOBSTER_CACHE_DIR: cacheDir,
+    };
+    const args = { _: [], provider: "http", prompt: "Summarize" };
+    try {
+        const warm = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: baseCtx(env, registry),
+        });
+        assert.equal((await collect(warm.output))[0].cached, false);
+        assert.equal(requests, 1);
+        // The step timeout fires while the upstream step is still producing input,
+        // which is after the entry check and before the cache lookup.
+        const controller = new AbortController();
+        // oxlint-disable-next-line require-yield -- Exercise cancellation before the first item.
+        const abortingInput = (async function* () {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            controller.abort();
+        })();
+        await assert.rejects(() => cmd.run({
+            input: abortingInput,
+            args,
+            ctx: { ...baseCtx(env, registry), signal: controller.signal },
+        }), (err) => err?.name === "AbortError" || err?.code === "ABORT_ERR");
+        assert.equal(requests, 1, "a cancelled run must not reach the adapter either");
+    }
+    finally {
+        await rm(cacheDir, { recursive: true, force: true });
+        await closeServer(server);
+    }
+});
+test("llm.invoke does not replay run state when ctx.signal aborts while input is drained", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const stateDir = await mkdtemp(path.join(tmpdir(), "lobster-state-"));
+    let requests = 0;
+    const server = http.createServer((req, res) => {
+        requests += 1;
+        req.resume();
+        req.on("end", () => {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: true,
+                result: { runId: "state_1", output: { text: "hello", data: null } },
+            }));
+        });
+    });
+    await new Promise((resolve) => server.listen(0, resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    const env = {
+        LOBSTER_LLM_ADAPTER_URL: `http://127.0.0.1:${port}/invoke`,
+        LOBSTER_STATE_DIR: stateDir,
+    };
+    const args = {
+        _: [],
+        provider: "http",
+        prompt: "Summarize",
+        "state-key": "step-1",
+        "disable-cache": true,
+    };
+    try {
+        const warm = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: baseCtx(env, registry),
+        });
+        assert.equal((await collect(warm.output))[0].cached, false);
+        assert.equal(requests, 1);
+        const controller = new AbortController();
+        // oxlint-disable-next-line require-yield -- Exercise cancellation before the first item.
+        const abortingInput = (async function* () {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            controller.abort();
+        })();
+        await assert.rejects(() => cmd.run({
+            input: abortingInput,
+            args,
+            ctx: { ...baseCtx(env, registry), signal: controller.signal },
+        }), (err) => err?.name === "AbortError" || err?.code === "ABORT_ERR");
+        assert.equal(requests, 1, "a cancelled run must not reach the adapter either");
+    }
+    finally {
+        await rm(stateDir, { recursive: true, force: true });
+        await closeServer(server);
+    }
+});
+test("llm.invoke does not call the adapter when ctx.signal is already aborted", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    let requests = 0;
+    const server = http.createServer((req, res) => {
+        requests += 1;
+        req.resume();
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: true, result: { runId: "r1", output: { data: {} } } }));
+    });
+    await new Promise((resolve) => server.listen(0, resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    try {
+        const controller = new AbortController();
+        controller.abort();
+        await assert.rejects(() => cmd.run({
+            input: streamOf([]),
+            args: { _: [], provider: "http", prompt: "Summarize", "disable-cache": true },
+            ctx: {
+                ...baseCtx({ LOBSTER_LLM_ADAPTER_URL: `http://127.0.0.1:${port}/invoke` }, registry),
+                signal: controller.signal,
+            },
+        }), (err) => err?.name === "AbortError" || err?.code === "ABORT_ERR");
+        assert.equal(requests, 0, "an already-cancelled run must not reach the adapter");
+    }
+    finally {
+        await closeServer(server);
+    }
+});
+test("llm.invoke does not retry schema validation after adapter cancellation", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const controller = new AbortController();
+    let calls = 0;
+    await assert.rejects(cmd.run({
+        input: streamOf([]),
+        args: {
+            _: [],
+            provider: "cancel-test",
+            prompt: "Decide",
+            "output-schema": '{"type":"object","required":["decision"]}',
+            "max-validation-retries": 2,
+        },
+        ctx: {
+            ...baseCtx({}, registry),
+            signal: controller.signal,
+            llmAdapters: {
+                "cancel-test": {
+                    source: "cancel-test",
+                    async invoke() {
+                        calls += 1;
+                        controller.abort(new Error("adapter cancelled during validation"));
+                        return {
+                            ok: true,
+                            result: {
+                                runId: "cancelled-attempt",
+                                output: { data: { unexpected: true } },
+                            },
+                        };
+                    },
+                },
+            },
+        },
+    }), /adapter cancelled during validation/);
+    assert.equal(calls, 1, "cancellation after an invalid response must suppress retries");
+});
+test("llm.invoke aborts while waiting for its reusable run-state lock", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-llm-state-lock-abort-"));
+    const stateDir = path.join(cacheDir, "state");
+    const stateKey = "blocked-run-state";
+    const lockPath = `${keyToPath(stateDir, stateKey)}.lock`;
+    await fsp.mkdir(lockPath, { recursive: true });
+    await fsp.writeFile(path.join(lockPath, "owner"), `${process.pid}::live-writer\n`, "utf8");
+    try {
+        const controller = new AbortController();
+        const pending = cmd.run({
+            input: streamOf([]),
+            args: {
+                _: [],
+                provider: "state-lock-abort-test",
+                prompt: "Decide",
+                "state-key": stateKey,
+            },
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                signal: controller.signal,
+                llmAdapters: {
+                    "state-lock-abort-test": {
+                        source: "state-lock-abort-test",
+                        async invoke() {
+                            throw new Error("adapter must not run while the state read is locked");
+                        },
+                    },
+                },
+            },
+        });
+        const completion = pending.then(() => ({ kind: "success" }), (error) => ({ kind: "error", error }));
+        await new Promise((resolve) => setImmediate(resolve));
+        controller.abort(new Error("LLM state read cancelled"));
+        const early = await Promise.race([
+            completion,
+            new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), 75)),
+        ]);
+        if (early.kind === "timeout")
+            await fsp.rm(lockPath, { recursive: true, force: true });
+        const settled = early.kind === "timeout" ? await completion : early;
+        assert.notEqual(early.kind, "timeout", "state-key reads must observe cancellation while locked");
+        assert.equal(settled.kind, "error");
+        if (settled.kind === "error") {
+            assert.match(settled.error?.message ?? "", /LLM state read cancelled/);
+        }
+    }
+    finally {
+        await fsp.rm(cacheDir, { recursive: true, force: true });
+    }
+});
+test("llm.invoke does not publish a reusable cache entry when cancellation races cache commit", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-cancel-publication-"));
+    const stateDir = path.join(cacheDir, "state");
+    const controller = new AbortController();
+    const originalRename = fsp.rename;
+    let cacheCommitAborted = false;
+    let calls = 0;
+    const adapter = {
+        source: "cache-cancel-test",
+        async invoke() {
+            calls += 1;
+            return {
+                ok: true,
+                result: {
+                    runId: `call-${calls}`,
+                    output: { data: { call: calls } },
+                },
+            };
+        },
+    };
+    const args = {
+        _: [],
+        provider: "cache-cancel-test",
+        prompt: "Decide",
+        "state-key": "cancelled-cache-publication",
+    };
+    try {
+        Object.defineProperty(fsp, "rename", {
+            configurable: true,
+            writable: true,
+            async value(from, to) {
+                const result = await originalRename(from, to);
+                if (!cacheCommitAborted &&
+                    String(to).startsWith(`${path.join(cacheDir, "llm.invoke")}${path.sep}`) &&
+                    String(to).endsWith(".json")) {
+                    cacheCommitAborted = true;
+                    controller.abort(new Error("cancelled during cache publication"));
+                }
+                return result;
+            },
+        });
+        await assert.rejects(cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                signal: controller.signal,
+                llmAdapters: { "cache-cancel-test": adapter },
+            },
+        }), /cancelled during cache publication/);
+    }
+    finally {
+        Object.defineProperty(fsp, "rename", {
+            configurable: true,
+            writable: true,
+            value: originalRename,
+        });
+    }
+    const retried = await cmd.run({
+        input: streamOf([]),
+        args,
+        ctx: {
+            ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+            llmAdapters: { "cache-cancel-test": adapter },
+        },
+    });
+    const retriedItems = await collect(retried.output);
+    assert.equal(calls, 2, "a cancelled invocation must not satisfy a later request from cache or run state");
+    assert.equal(retriedItems[0]?.source, "cache-cancel-test");
+    await rm(cacheDir, { recursive: true, force: true });
+});
+test("llm.invoke restores the previous cache entry when a refresh is cancelled after commit", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-refresh-cancel-"));
+    const stateDir = path.join(cacheDir, "state");
+    let calls = 0;
+    const adapter = {
+        source: "cache-refresh-cancel-test",
+        async invoke() {
+            calls += 1;
+            return {
+                ok: true,
+                result: {
+                    runId: `call-${calls}`,
+                    output: { data: { call: calls } },
+                },
+            };
+        },
+    };
+    const args = {
+        _: [],
+        provider: "cache-refresh-cancel-test",
+        prompt: "Decide",
+        "state-key": "refresh-cache-publication",
+    };
+    try {
+        const first = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                llmAdapters: { "cache-refresh-cancel-test": adapter },
+            },
+        });
+        assert.deepEqual((await collect(first.output))[0]?.output.data, { call: 1 });
+        const controller = new AbortController();
+        const originalRename = fsp.rename;
+        let cacheCommitAborted = false;
+        try {
+            Object.defineProperty(fsp, "rename", {
+                configurable: true,
+                writable: true,
+                async value(from, to) {
+                    const result = await originalRename(from, to);
+                    if (!cacheCommitAborted &&
+                        String(to).startsWith(`${path.join(cacheDir, "llm.invoke")}${path.sep}`)) {
+                        cacheCommitAborted = true;
+                        controller.abort(new Error("cancelled during cache refresh publication"));
+                    }
+                    return result;
+                },
+            });
+            await assert.rejects(cmd.run({
+                input: streamOf([]),
+                args: { ...args, refresh: true },
+                ctx: {
+                    ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                    signal: controller.signal,
+                    llmAdapters: { "cache-refresh-cancel-test": adapter },
+                },
+            }), /cancelled during cache refresh publication/);
+        }
+        finally {
+            Object.defineProperty(fsp, "rename", {
+                configurable: true,
+                writable: true,
+                value: originalRename,
+            });
+        }
+        const recovered = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                llmAdapters: { "cache-refresh-cancel-test": adapter },
+            },
+        });
+        const recoveredItems = await collect(recovered.output);
+        assert.equal(calls, 2, "the cancelled refresh must restore the existing run state");
+        assert.equal(recoveredItems[0]?.source, "run_state");
+        assert.deepEqual(recoveredItems[0]?.output.data, { call: 1 });
+        const recoveredCache = await cmd.run({
+            input: streamOf([]),
+            args: { _: [], provider: "cache-refresh-cancel-test", prompt: "Decide" },
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                llmAdapters: { "cache-refresh-cancel-test": adapter },
+            },
+        });
+        const recoveredCacheItems = await collect(recoveredCache.output);
+        assert.equal(recoveredCacheItems[0]?.source, "cache");
+        assert.deepEqual(recoveredCacheItems[0]?.output.data, { call: 1 });
+    }
+    finally {
+        await rm(cacheDir, { recursive: true, force: true });
+    }
+});
+test("llm.invoke rolls back cache and run-state publications after a cache directory sync failure", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-cache-dir-sync-failure-"));
+    const stateDir = path.join(cacheDir, "state");
+    const cacheNamespaceDir = path.join(cacheDir, "llm.invoke");
+    const originalOpen = fsp.open;
+    const fault = Object.assign(new Error("cache directory sync failed"), { code: "EIO" });
+    let failNextCacheDirectorySync = true;
+    let calls = 0;
+    const adapter = {
+        source: "cache-dir-sync-test",
+        async invoke() {
+            calls += 1;
+            return { ok: true, result: { runId: `call-${calls}`, output: { data: { call: calls } } } };
+        },
+    };
+    const args = {
+        _: [],
+        provider: "cache-dir-sync-test",
+        prompt: "Decide",
+        "state-key": "cache-directory-sync-failure",
+    };
+    try {
+        await fsp.mkdir(cacheNamespaceDir, { recursive: true });
+        Object.defineProperty(fsp, "open", {
+            configurable: true,
+            writable: true,
+            async value(...openArgs) {
+                const handle = await originalOpen(...openArgs);
+                if (failNextCacheDirectorySync &&
+                    String(openArgs[0]) === cacheNamespaceDir &&
+                    openArgs[1] === "r") {
+                    failNextCacheDirectorySync = false;
+                    return new Proxy(handle, {
+                        get(target, property, receiver) {
+                            if (property === "sync")
+                                return async () => Promise.reject(fault);
+                            const value = Reflect.get(target, property, receiver);
+                            return typeof value === "function" ? value.bind(target) : value;
+                        },
+                    });
+                }
+                return handle;
+            },
+        });
+        await assert.rejects(cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+                llmAdapters: { "cache-dir-sync-test": adapter },
+            },
+        }), /cache directory sync failed/);
+    }
+    finally {
+        Object.defineProperty(fsp, "open", {
+            configurable: true,
+            writable: true,
+            value: originalOpen,
+        });
+    }
+    const retried = await cmd.run({
+        input: streamOf([]),
+        args,
+        ctx: {
+            ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir, LOBSTER_STATE_DIR: stateDir }, registry),
+            llmAdapters: { "cache-dir-sync-test": adapter },
+        },
+    });
+    const items = await collect(retried.output);
+    assert.equal(calls, 2, "a failed publication must not be reused from cache or run state");
+    assert.equal(items[0]?.source, "cache-dir-sync-test");
+    await rm(cacheDir, { recursive: true, force: true });
+});
+test("llm.invoke reads a populated cache when lock creation is forbidden", async () => {
+    const registry = createDefaultRegistry();
+    const cmd = registry.get("llm.invoke");
+    assert.ok(cmd);
+    const cacheDir = await mkdtemp(path.join(tmpdir(), "lobster-readonly-cache-"));
+    const originalMkdir = fsp.mkdir;
+    let calls = 0;
+    const adapter = {
+        source: "readonly-cache-test",
+        async invoke() {
+            calls += 1;
+            return { ok: true, result: { runId: `call-${calls}`, output: { data: { call: calls } } } };
+        },
+    };
+    const args = { _: [], provider: "readonly-cache-test", prompt: "Decide" };
+    try {
+        const first = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir }, registry),
+                llmAdapters: { "readonly-cache-test": adapter },
+            },
+        });
+        await collect(first.output);
+        Object.defineProperty(fsp, "mkdir", {
+            configurable: true,
+            writable: true,
+            async value(filePath, options) {
+                if (String(filePath).endsWith(".lock")) {
+                    throw Object.assign(new Error("read-only cache directory"), { code: "EACCES" });
+                }
+                return originalMkdir(filePath, options);
+            },
+        });
+        const cached = await cmd.run({
+            input: streamOf([]),
+            args,
+            ctx: {
+                ...baseCtx({ LOBSTER_CACHE_DIR: cacheDir }, registry),
+                llmAdapters: { "readonly-cache-test": adapter },
+            },
+        });
+        const items = await collect(cached.output);
+        assert.equal(calls, 1);
+        assert.equal(items[0]?.source, "cache");
+    }
+    finally {
+        Object.defineProperty(fsp, "mkdir", {
+            configurable: true,
+            writable: true,
+            value: originalMkdir,
+        });
+        await rm(cacheDir, { recursive: true, force: true });
+    }
+});
 function baseCtx(envOverrides, registry) {
     return {
         stdin: process.stdin,
@@ -158,6 +1068,43 @@ function baseCtx(envOverrides, registry) {
         render: { json() { }, lines() { } },
     };
 }
+// An adapter that accepts the request and never answers, so the only thing that
+// can end the call is the caller cancelling it.
+function createStalledAdapter() {
+    const sockets = new Set();
+    let markReceived = () => { };
+    let markClosed = () => { };
+    const requestReceived = new Promise((resolve) => (markReceived = resolve));
+    const requestClosed = new Promise((resolve) => (markClosed = resolve));
+    const server = http.createServer((req, res) => {
+        req.resume();
+        req.on("end", () => {
+            res.on("close", () => markClosed());
+            markReceived();
+        });
+    });
+    server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.on("close", () => sockets.delete(socket));
+    });
+    return {
+        requestReceived,
+        requestClosed,
+        port: 0,
+        async listen() {
+            await new Promise((resolve) => server.listen(0, resolve));
+            const addr = server.address();
+            this.port = typeof addr === "object" && addr ? addr.port : 0;
+        },
+        async close() {
+            for (const socket of sockets)
+                socket.destroy();
+            if (!server.listening)
+                return;
+            await new Promise((resolve) => server.close(() => resolve()));
+        },
+    };
+}
 async function closeServer(server) {
     if (!server.listening)
         return;