@nowcrew/daemon 0.5.18 → 0.5.20

package/dist/console.js

@@ -5,14 +5,24 @@
  * 做**原文透传**——保留思考文本、工具调用、工具返回正文,尽量还原原生 claude CLI 的观感。
  * 纯函数,无 IO,完整单测。
  *
- * 注:本转换器针对 claude 的 stream-json。codex 的 stream 格式不同,后续按 runtime 分派扩展;
- * 前端/server 消费的 ConsoleChunk 形状是 runtime 无关的。
+ * 除纯文本 text 外,可识别的工具调用(Edit/Write/Bash/TodoWrite/ExitPlanMode/Task…)
+ * 会附带结构化 payload(diff/命令/todo 清单/计划…),供前端做富渲染(红绿 diff、清单勾选);
+ * 前端不识别 payload.kind 时降级为纯文本行,协议向后兼容。
+ *
+ * 覆盖三种 runtime 的流:claude(stream-json)、codex(exec --json 的 item.* 事件)、
+ * kimi(OpenAI 消息风格行)。
  */
 import { detectDaemonLang, translateDaemon } from "./i18n.js";
 /** 单条工具返回正文上限(超出截断并标注),避免单条把终端/DB 撑爆。 */
 export const TOOL_RESULT_CAP = 4000;
 /** 工具输入摘要上限(标题行那一段)。 */
 const TOOL_INPUT_CAP = 160;
+/** payload 里单段文本(diff 单侧/plan/命令)上限:富渲染要保留足够内容,但不能无界。 */
+export const PAYLOAD_TEXT_CAP = 4000;
+/** todo 清单条数上限。 */
+const TODOS_MAX = 50;
+/** MultiEdit 拆分出的 diff 块上限。 */
+const MULTI_EDIT_MAX = 20;
 /** kimi 工具 arguments(JSON 字符串)容错解析为对象;失败返回 undefined。 */
 function parseKimiToolArgs(args) {
     if (!args)
@@ -25,19 +35,106 @@ function parseKimiToolArgs(args) {
         return undefined;
     }
 }
-/** 把工具输入压成一行摘要:Bash 取 command,其它取首个字符串字段或紧凑 JSON。 */
+/** 把工具输入压成一行摘要:Bash 取 command,文件类工具取路径,其它取首个字符串字段或紧凑 JSON。 */
 function summarizeToolInput(name, input) {
     if (!input)
         return `⏺ ${name}`;
     if (name === "Bash" && typeof input.command === "string") {
         return `⏺ Bash(${clip(input.command.replace(/\s+/g, " "), TOOL_INPUT_CAP)})`;
     }
+    // 文件编辑类:old/new 全文在 payload 里富渲染,摘要只报文件路径,不把整段代码挤进标题行。
+    if ((name === "Edit" || name === "Write" || name === "MultiEdit") && typeof input.file_path === "string") {
+        return `⏺ ${name}(${clip(input.file_path, TOOL_INPUT_CAP)})`;
+    }
+    if (name === "TodoWrite" && Array.isArray(input.todos)) {
+        return `⏺ TodoWrite(${input.todos.length})`;
+    }
+    if (name === "ExitPlanMode")
+        return `⏺ ExitPlanMode`;
     const entries = Object.entries(input);
     const head = entries
         .map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`)
         .join(", ");
     return `⏺ ${name}(${clip(head.replace(/\s+/g, " "), TOOL_INPUT_CAP)})`;
 }
+const TODO_STATUSES = new Set(["pending", "in_progress", "completed"]);
+/** claude TodoWrite 的 todos 数组归一为 ConsoleTodo[](脏数据条目丢弃)。 */
+function normalizeTodos(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const t of raw.slice(0, TODOS_MAX)) {
+        if (!t || typeof t !== "object")
+            continue;
+        const rec = t;
+        const text = typeof rec.content === "string" && rec.content.trim()
+            ? rec.content.trim()
+            : typeof rec.subject === "string" ? rec.subject.trim() : "";
+        if (!text)
+            continue;
+        const status = typeof rec.status === "string" && TODO_STATUSES.has(rec.status)
+            ? rec.status
+            : "pending";
+        out.push({ text: clip(text, TOOL_INPUT_CAP), status });
+    }
+    return out;
+}
+function diffPayload(file, oldText, newText) {
+    return {
+        kind: "diff",
+        file,
+        oldText: clip(typeof oldText === "string" ? oldText : "", PAYLOAD_TEXT_CAP),
+        newText: clip(typeof newText === "string" ? newText : "", PAYLOAD_TEXT_CAP),
+    };
+}
+/** 已识别工具 → 结构化 payload;其余返回 undefined(仅纯文本摘要)。 */
+function toolPayload(name, input) {
+    if (!input)
+        return undefined;
+    if (name === "Bash" && typeof input.command === "string") {
+        return { kind: "command", command: clip(input.command, PAYLOAD_TEXT_CAP) };
+    }
+    if (name === "Edit" && typeof input.file_path === "string") {
+        return diffPayload(input.file_path, input.old_string, input.new_string);
+    }
+    if (name === "Write" && typeof input.file_path === "string" && typeof input.content === "string") {
+        return diffPayload(input.file_path, "", input.content);
+    }
+    if (name === "TodoWrite") {
+        const todos = normalizeTodos(input.todos);
+        if (todos.length)
+            return { kind: "todos", todos };
+    }
+    if (name === "ExitPlanMode" && typeof input.plan === "string" && input.plan.trim()) {
+        return { kind: "plan", plan: clip(input.plan.trim(), PAYLOAD_TEXT_CAP) };
+    }
+    if ((name === "Task" || name === "Agent") && typeof input.description === "string" && input.description.trim()) {
+        return { kind: "subagent", description: clip(input.description.trim(), TOOL_INPUT_CAP) };
+    }
+    return undefined;
+}
+/** 一个 tool_use 块 → 1..N 条 console 行(MultiEdit 拆成每处编辑一块 diff)。 */
+function toolUseChunks(name, input) {
+    if (name === "MultiEdit" && input && typeof input.file_path === "string" && Array.isArray(input.edits)) {
+        const file = input.file_path;
+        const chunks = [];
+        for (const ed of input.edits.slice(0, MULTI_EDIT_MAX)) {
+            if (!ed || typeof ed !== "object")
+                continue;
+            const rec = ed;
+            chunks.push({
+                stream: "tool",
+                text: `⏺ Edit(${clip(file, TOOL_INPUT_CAP)})`,
+                payload: diffPayload(file, rec.old_string, rec.new_string),
+            });
+        }
+        if (chunks.length)
+            return chunks;
+    }
+    const text = summarizeToolInput(name, input);
+    const payload = toolPayload(name, input);
+    return [payload ? { stream: "tool", text, payload } : { stream: "tool", text }];
+}
 /** 把 tool_result 的 content(string | block[])抽成纯文本。 */
 function extractToolResult(content) {
     if (typeof content === "string")
@@ -53,6 +150,72 @@ function extractToolResult(content) {
 function clip(s, cap) {
     return s.length > cap ? s.slice(0, cap) + `… (+${s.length - cap})` : s;
 }
+/** codex exec --json 的 item.completed → console 行(agent_message/reasoning/命令/文件变更/todo…)。 */
+function codexItemChunks(item, td) {
+    if (item.type === "agent_message" && item.text?.trim()) {
+        return [{ stream: "text", text: item.text.trim() }];
+    }
+    if (item.type === "reasoning" && item.text?.trim()) {
+        return [{ stream: "thinking", text: item.text.trim() }];
+    }
+    if (item.type === "command_execution" && item.command?.trim()) {
+        const command = item.command.trim();
+        const out = [{
+                stream: "tool",
+                text: `⏺ Bash(${clip(command.replace(/\s+/g, " "), TOOL_INPUT_CAP)})`,
+                payload: {
+                    kind: "command",
+                    command: clip(command, PAYLOAD_TEXT_CAP),
+                    ...(typeof item.exit_code === "number" ? { exitCode: item.exit_code } : {}),
+                },
+            }];
+        const output = item.aggregated_output?.trim();
+        if (output)
+            out.push({ stream: "tool_result", text: clip(output, TOOL_RESULT_CAP) });
+        return out;
+    }
+    if (item.type === "file_change" && Array.isArray(item.changes)) {
+        const files = item.changes
+            .filter((c) => !!c && typeof c === "object")
+            .map((c) => ({
+            path: typeof c.path === "string" ? c.path : "",
+            change: typeof c.kind === "string" ? c.kind : "update",
+        }))
+            .filter((f) => f.path);
+        if (!files.length)
+            return [];
+        return [{
+                stream: "tool",
+                text: `⏺ ${td("Files changed")}: ${clip(files.map((f) => f.path).join(", "), TOOL_INPUT_CAP)}`,
+                payload: { kind: "files", files },
+            }];
+    }
+    if (item.type === "todo_list" && Array.isArray(item.items)) {
+        const todos = item.items
+            .filter((t) => !!t && typeof t === "object")
+            .slice(0, TODOS_MAX)
+            .map((t) => ({
+            text: clip(typeof t.text === "string" ? t.text.trim() : "", TOOL_INPUT_CAP),
+            status: (t.completed === true ? "completed" : "pending"),
+        }))
+            .filter((t) => t.text);
+        if (!todos.length)
+            return [];
+        const done = todos.filter((t) => t.status === "completed").length;
+        return [{ stream: "tool", text: `⏺ Todos(${done}/${todos.length})`, payload: { kind: "todos", todos } }];
+    }
+    if (item.type === "web_search" && item.query?.trim()) {
+        return [{ stream: "tool", text: `⏺ WebSearch(${clip(item.query.trim(), TOOL_INPUT_CAP)})` }];
+    }
+    if (item.type === "mcp_tool_call" && (item.tool || item.server)) {
+        const label = [item.server, item.tool].filter(Boolean).join(".");
+        return [{ stream: "tool", text: `⏺ MCP(${clip(label, TOOL_INPUT_CAP)})` }];
+    }
+    if (item.type === "error" && item.message?.trim()) {
+        return [{ stream: "error", text: item.message.trim() }];
+    }
+    return [];
+}
 /** 把一个 stream-json 事件转成 0..N 条 console 行(完全透传)。 */
 export function toConsoleLines(event) {
     const e = (event ?? {});
@@ -72,13 +235,16 @@ export function toConsoleLines(event) {
         return [{ stream: "system", text: `● ${td("Claude session started")}` }];
     }
     if (e.type === "thread.started") {
-        return [{ stream: "system", text: "● codex 会话启动" }];
+        return [{ stream: "system", text: `● ${td("Codex session started")}` }];
     }
-    if (e.type === "item.completed" && e.item?.type === "agent_message" && e.item.text?.trim()) {
-        return [{ stream: "text", text: e.item.text.trim() }];
+    if (e.type === "item.completed" && e.item) {
+        return codexItemChunks(e.item, td);
     }
     if (e.type === "turn.completed") {
-        return [{ stream: "result", text: "本轮结束" }];
+        return [{ stream: "result", text: td("Run finished") }];
+    }
+    if (e.type === "turn.failed") {
+        return [{ stream: "error", text: e.error?.message?.trim() || td("Run failed") }];
     }
     if (e.type === "result") {
         const text = e.result?.trim() || (e.is_error ? td("Run failed") : td("Run finished"));
@@ -94,7 +260,7 @@ export function toConsoleLines(event) {
                 out.push({ stream: "text", text: block.text.trim() });
             }
             else if (block.type === "tool_use" && block.name) {
-                out.push({ stream: "tool", text: summarizeToolInput(block.name, block.input) });
+                out.push(...toolUseChunks(block.name, block.input));
             }
         }
         return out;
@@ -119,7 +285,7 @@ export function toConsoleLines(event) {
         for (const call of Array.isArray(e.tool_calls) ? e.tool_calls : []) {
             const name = call.function?.name;
             if (name)
-                out.push({ stream: "tool", text: summarizeToolInput(name, parseKimiToolArgs(call.function?.arguments)) });
+                out.push(...toolUseChunks(name, parseKimiToolArgs(call.function?.arguments)));
         }
         return out;
     }

package/dist/execution-event-limit.js

@@ -36,7 +36,7 @@ export function boundExecutionFrame(input, maxBytes) {
     if (input.type === "execution:activity") {
         frame = withBoundedString(frame, "detail", maxBytes, false);
     }
-    else if (input.type === "execution:console") {
+    else if (input.type === "execution:console" || input.type === "execution:output") {
         frame = withBoundedString(frame, "text", maxBytes, false);
     }
     else if (input.type === "execution:rejected") {

package/dist/execution-journal-lock.js

@@ -1,6 +1,7 @@
 import { mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, } from "node:fs/promises";
+import { renameSync } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { z } from "zod";
 const OwnerSchema = z.object({
     pid: z.number().int().positive(),
@@ -8,9 +9,15 @@ const OwnerSchema = z.object({
     token: z.string().uuid(),
 }).strict();
 export class JournalLockedError extends Error {
-    constructor(message) {
+    journalPath;
+    ownerPid;
+    constructor(message, diagnostics = {}) {
         super(message);
         this.name = "JournalLockedError";
+        if (diagnostics.journalPath !== undefined)
+            this.journalPath = diagnostics.journalPath;
+        if (diagnostics.ownerPid !== undefined)
+            this.ownerPid = diagnostics.ownerPid;
     }
 }
 export class JournalLockCorruptionError extends Error {
@@ -24,6 +31,7 @@ export const defaultJournalLockFileSystem = {
     readFile: (path) => readFile(path, "utf8"),
     readdir,
     rename,
+    renameSync,
     rm,
     rmdir,
     stat,
@@ -44,6 +52,141 @@ export function createJournalLeaseRegistry() {
     return { leases: new Map() };
 }
 const codeOf = (error) => error instanceof Error && "code" in error ? error.code : undefined;
+const ownerFileName = (token) => `owner.${token}.json`;
+const releasedLockName = (token) => `.journal.released.${token}.lock`;
+const RELEASED_LOCK_PATTERN = /^\.journal\.released\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.lock$/i;
+const MAX_RELEASED_LOCK_CLEANUP = 8;
+const throwIfAborted = (signal) => {
+    if (signal?.aborted)
+        throw signal.reason ?? new Error("Journal close aborted");
+};
+function awaitAbortable(operation, signal) {
+    if (signal === undefined)
+        return operation;
+    throwIfAborted(signal);
+    return new Promise((resolveOperation, rejectOperation) => {
+        let settled = false;
+        const settle = (continuation) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            continuation();
+        };
+        const onAbort = () => settle(() => {
+            rejectOperation(signal.reason ?? new Error("Journal close aborted"));
+        });
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        operation.then((value) => settle(() => resolveOperation(value)), (error) => settle(() => rejectOperation(error)));
+    });
+}
+async function parseLockOwner(lockDirectory, fileName, fileSystem) {
+    const path = join(lockDirectory, fileName);
+    try {
+        const owner = OwnerSchema.parse(JSON.parse(await fileSystem.readFile(path)));
+        if (fileName !== ownerFileName(owner.token))
+            throw new Error("owner token does not match filename");
+        return owner;
+    }
+    catch (error) {
+        throw new JournalLockCorruptionError(path, error);
+    }
+}
+export async function inspectJournalLock(options) {
+    const fileSystem = options.fileSystem ?? defaultJournalLockFileSystem;
+    const lockDirectory = join(options.directory, ".journal.lock");
+    const orphanGraceMs = options.orphanGraceMs ?? 30_000;
+    const now = options.now ?? (() => new Date());
+    const missingDuringOwnerRead = (error) => codeOf(error) === "ENOENT"
+        || (error instanceof Error && codeOf(error.cause) === "ENOENT");
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let names;
+        try {
+            names = (await fileSystem.readdir(lockDirectory)).map(String).sort();
+        }
+        catch (error) {
+            if (codeOf(error) === "ENOENT") {
+                return { status: "unlocked", detail: "lock directory does not exist" };
+            }
+            return { status: "corrupt", detail: `lock directory cannot be read: ${error.message}` };
+        }
+        if (names.length === 0) {
+            try {
+                const lockStat = await fileSystem.stat(lockDirectory);
+                const ageMs = now().valueOf() - lockStat.mtimeMs;
+                return ageMs < orphanGraceMs
+                    ? { status: "installing", detail: "lock owner installation is in progress" }
+                    : { status: "stale", detail: "empty lock directory exceeded the owner installation grace period" };
+            }
+            catch (error) {
+                if (codeOf(error) === "ENOENT" && attempt === 0)
+                    continue;
+                if (codeOf(error) === "ENOENT") {
+                    return { status: "unlocked", detail: "lock directory disappeared during inspection" };
+                }
+                return { status: "corrupt", detail: `empty lock directory cannot be inspected: ${error.message}` };
+            }
+        }
+        if (names.length !== 1 || !/^owner\.[0-9a-f-]+\.json$/i.test(names[0])) {
+            return { status: "corrupt", detail: "lock directory must contain one owner" };
+        }
+        let owner;
+        try {
+            owner = await parseLockOwner(lockDirectory, names[0], fileSystem);
+        }
+        catch (error) {
+            if (attempt === 0 && missingDuringOwnerRead(error))
+                continue;
+            return { status: "corrupt", detail: error.message };
+        }
+        let inspection;
+        try {
+            const identity = await options.inspectIdentity(owner.pid);
+            inspection = identity === owner.processIdentity
+                ? {
+                    status: "owned",
+                    ownerPid: owner.pid,
+                    ownerAlive: true,
+                    detail: `owned by live process ${owner.pid}`,
+                }
+                : {
+                    status: "stale",
+                    ownerPid: owner.pid,
+                    ownerAlive: false,
+                    detail: `owner process ${owner.pid} is absent or its identity changed`,
+                };
+        }
+        catch (error) {
+            inspection = {
+                status: "corrupt",
+                ownerPid: owner.pid,
+                detail: `owner process cannot be inspected: ${error.message}`,
+            };
+        }
+        try {
+            const confirmedOwner = await parseLockOwner(lockDirectory, names[0], fileSystem);
+            const confirmedNames = (await fileSystem.readdir(lockDirectory)).map(String).sort();
+            const unchanged = JSON.stringify(confirmedOwner) === JSON.stringify(owner)
+                && JSON.stringify(confirmedNames) === JSON.stringify(names);
+            if (!unchanged && attempt === 0)
+                continue;
+            if (!unchanged)
+                return { status: "corrupt", detail: "lock snapshot changed during bounded inspection" };
+            return inspection;
+        }
+        catch (error) {
+            if (attempt === 0 && missingDuringOwnerRead(error))
+                continue;
+            if (missingDuringOwnerRead(error)) {
+                return { status: "corrupt", detail: "lock snapshot remained unstable after bounded inspection" };
+            }
+            return { status: "corrupt", detail: error.message };
+        }
+    }
+    return { status: "corrupt", detail: "lock snapshot remained unstable after bounded inspection" };
+}
 function processLeaseMap(registry) {
     return registry.leases;
 }
@@ -52,21 +195,29 @@ export function createJournalLease(options) {
     const registry = processLeaseMap(options.registry ?? defaultRegistry);
     const now = options.now ?? (() => new Date());
     const orphanGraceMs = options.orphanGraceMs ?? 30_000;
+    const journalPath = resolve(options.directory);
     const lockDirectory = join(options.directory, ".journal.lock");
     let attached = false;
     let status = "open";
-    const ownerFileName = (token) => `owner.${token}.json`;
-    const parseOwner = async (fileName) => {
-        const path = join(lockDirectory, fileName);
+    const cleanupReleasedDirectory = async (path) => {
         try {
-            const owner = OwnerSchema.parse(JSON.parse(await fileSystem.readFile(path)));
-            if (fileName !== ownerFileName(owner.token))
-                throw new Error("owner token does not match filename");
-            return owner;
+            await fileSystem.rm(path, { recursive: true, force: true });
+            await options.syncDirectory(options.directory);
         }
-        catch (error) {
-            throw new JournalLockCorruptionError(path, error);
+        catch { /* released tombstones never block ownership or reverse a committed close */ }
+    };
+    const cleanupReleasedDirectories = async () => {
+        let names;
+        try {
+            names = (await fileSystem.readdir(options.directory)).map(String).sort();
         }
+        catch {
+            return;
+        }
+        await Promise.all(names
+            .filter((name) => RELEASED_LOCK_PATTERN.test(name))
+            .slice(0, MAX_RELEASED_LOCK_CLEANUP)
+            .map((name) => cleanupReleasedDirectory(join(options.directory, name))));
     };
     const readOwner = async () => {
         let names;
@@ -81,7 +232,7 @@ export function createJournalLease(options) {
         if (names.length === 0) {
             const lockStat = await fileSystem.stat(lockDirectory);
             if (now().valueOf() - lockStat.mtimeMs < orphanGraceMs) {
-                throw new JournalLockedError("Execution journal lock owner installation is in progress");
+                throw new JournalLockedError("Execution journal lock owner installation is in progress", { journalPath });
             }
             try {
                 await fileSystem.rmdir(lockDirectory);
@@ -96,7 +247,7 @@ export function createJournalLease(options) {
         if (names.length !== 1 || !/^owner\.[0-9a-f-]+\.json$/i.test(names[0])) {
             throw new JournalLockCorruptionError(lockDirectory, new Error("lock directory must contain one owner"));
         }
-        return { owner: await parseOwner(names[0]), fileName: names[0] };
+        return { owner: await parseLockOwner(lockDirectory, names[0], fileSystem), fileName: names[0] };
     };
     const validateInstalledOwner = async (lease) => {
         const observed = await readOwner();
@@ -151,9 +302,6 @@ export function createJournalLease(options) {
                         lockDirectorySynced: false,
                         executionsDirectorySynced: false,
                         releasing: false,
-                        ownerRemoved: false,
-                        lockDirectoryRemoved: false,
-                        releaseSynced: false,
                     };
                     registry.set(options.directory, lease);
                     attached = true;
@@ -169,7 +317,7 @@ export function createJournalLease(options) {
                     continue;
                 const identity = await options.inspectIdentity(observed.owner.pid);
                 if (identity === observed.owner.processIdentity) {
-                    throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`);
+                    throw new JournalLockedError(`Execution journal is locked by process ${observed.owner.pid}`, { journalPath, ownerPid: observed.owner.pid });
                 }
                 await options.hooks?.beforeRemoveObservedOwner?.(observed.owner);
                 try {
@@ -196,37 +344,48 @@ export function createJournalLease(options) {
         }
     };
     const acquire = async () => {
-        if (status !== "open")
-            throw new JournalLockedError(`Journal lease is ${status}`);
+        if (status !== "open") {
+            throw new JournalLockedError(`Journal lease is ${status}`, { journalPath });
+        }
         if (attached) {
             const lease = registry.get(options.directory);
-            if (lease === undefined)
-                throw new JournalLockedError("In-process journal lease is missing");
+            if (lease === undefined) {
+                throw new JournalLockedError("In-process journal lease is missing", { journalPath });
+            }
             await finishInstall(lease);
             return;
         }
         const existing = registry.get(options.directory);
         if (existing !== undefined) {
-            if (existing.releasing)
-                throw new JournalLockedError("Journal lease release is pending");
+            if (existing.releasing) {
+                throw new JournalLockedError("Journal lease release is pending", {
+                    journalPath,
+                    ownerPid: existing.owner.pid,
+                });
+            }
             await finishInstall(existing);
             existing.refs += 1;
             attached = true;
             return;
         }
+        void cleanupReleasedDirectories();
         await install();
     };
-    const close = async () => {
+    const close = async (closeOptions = {}) => {
         if (status === "closed")
             return;
+        const signal = closeOptions.signal;
+        throwIfAborted(signal);
         if (!attached) {
             status = "closed";
             return;
         }
         const lease = registry.get(options.directory);
-        if (lease === undefined)
-            throw new JournalLockedError("In-process journal lease is missing");
+        if (lease === undefined) {
+            throw new JournalLockedError("In-process journal lease is missing", { journalPath });
+        }
         if (status === "open" && lease.refs > 1) {
+            throwIfAborted(signal);
             lease.refs -= 1;
             attached = false;
             status = "closed";
@@ -234,28 +393,28 @@ export function createJournalLease(options) {
         }
         status = "closing";
         lease.releasing = true;
-        if (!lease.ownerRemoved) {
-            await fileSystem.unlink(join(lockDirectory, lease.ownerFile));
-            lease.ownerRemoved = true;
-        }
-        if (!lease.lockDirectoryRemoved) {
-            await fileSystem.rmdir(lockDirectory);
-            lease.lockDirectoryRemoved = true;
-        }
-        if (!lease.releaseSynced) {
-            await options.syncDirectory(options.directory);
-            lease.releaseSynced = true;
-        }
+        await awaitAbortable((async () => {
+            await validateInstalledOwner(lease);
+            await options.hooks?.beforeReleaseOwner?.(lease.owner, {
+                ...(signal === undefined ? {} : { signal }),
+            });
+            await validateInstalledOwner(lease);
+        })(), signal);
+        throwIfAborted(signal);
+        const releasedDirectory = join(options.directory, releasedLockName(lease.owner.token));
+        fileSystem.renameSync(lockDirectory, releasedDirectory);
         lease.refs -= 1;
         registry.delete(options.directory);
         attached = false;
         status = "closed";
+        void cleanupReleasedDirectory(releasedDirectory);
     };
     return {
         acquire,
         assertUsable: () => {
-            if (status !== "open")
-                throw new JournalLockedError(`Execution journal lease is ${status}`);
+            if (status !== "open") {
+                throw new JournalLockedError(`Execution journal lease is ${status}`, { journalPath });
+            }
         },
         close,
     };