dsh-connect 0.6.7 → 0.7.1

package/lib/runner.js

@@ -10,9 +10,13 @@ import { copyFile, readFile } from "node:fs/promises";
 import { basename, isAbsolute, join } from "node:path";
 import { SessionId } from "@deepseek-ai/dsh-session";
 import { createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
-import { createAsyncQueue } from "./stream.js";
+import { createAsyncQueue, applyStreamChunk, applyToolCall, toolCallSummary, questionTextOf, summarizeTurn, classifyError, mapReason, truncate, fmtTokens, textOf, } from "./stream.js";
 import { helpText, parseCommand } from "./commands.js";
+import { menuTitle, rootMenuSections, reasonLabel, goalPhaseLabel, listWorkspaces } from "./menus.js";
+import { MenuController } from "./menu-controller.js";
 import { messages } from "./i18n.js";
+import { DEFAULT_LOCK_TIMEOUT_MS, acquire as lockAcquire, canWrite as lockCanWrite, isLockTimedOut as lockIsTimedOut, release as lockRelease, } from "./mirror-lock.js";
+import { formatRemindAt, parseRemindTime } from "./scheduler.js";
 export function resolveConnectConfig(config) {
     return {
         agentPreset: config.agentPreset,
@@ -25,280 +29,10 @@ export function resolveConnectConfig(config) {
         stateDir: config.stateDir,
         autoMirror: config.autoMirror ?? true, // Enabled by default
         streamHeartbeatMs: config.streamHeartbeatMs ?? 60_000,
-        notifyLevel: config.notifyLevel ?? "important",
+        notifyLevel: config.notifyLevel ?? "result",
         progressTimeoutMs: config.progressTimeoutMs ?? 5 * 60_000, // Proactive progress notice after 5 min of silence
     };
 }
-/**
- * Assemble one `assistant/chunk` event into the streaming queue with visible
- * structure. DSH streams one block per LLM content block and block boundaries
- * carry no newline of their own, so without separators every block (and the
- * reasoning phase vs the final answer) would be glued together in the chat
- * card. This inserts a blank line between blocks and before the answer, keeps
- * the thinking hint once per turn, expands reasoning soft breaks (Feishu's
- * streaming card collapses single `\n`), and falls back to whole-block text
- * for blocks that arrived only via `block-end`. Every push refreshes
- * `lastPushAt` so the liveness heartbeat knows the card is still moving.
- * @param state - the turn's mutable assembly state.
- * @param thinkingHint - localized hint text pushed at the first reasoning delta.
- * @param chunk - the assistant chunk event's `chunk` payload.
- */
-/** Every line-break run becomes a paragraph break (Feishu's streaming card collapses single `\n`). */
-function expandLineBreaks(text) {
-    return text.replace(/\r\n?/g, "\n").replace(/\n+/g, "\n\n");
-}
-export function applyStreamChunk(state, thinkingHint, chunk, level = "full") {
-    if (chunk.type === "text-delta" || chunk.type === "reasoning-delta") {
-        const isReasoning = chunk.type === "reasoning-delta";
-        // Reasoning content is only streamed in `full` mode; `important` shows
-        // just the thinking hint and `result` shows nothing until the answer.
-        if (isReasoning && level !== "full") {
-            if (level === "important" && !state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-                state.pushedAny = true;
-                state.lastPushAt = Date.now();
-            }
-            return;
-        }
-        if (state.pushedAny) {
-            const newBlock = chunk.index !== undefined && state.lastIndex !== undefined && chunk.index !== state.lastIndex;
-            const reasoningToAnswer = !isReasoning && state.reasoning;
-            if (newBlock || reasoningToAnswer)
-                state.chunks.push("\n\n");
-        }
-        if (isReasoning) {
-            if (!state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-            }
-            const text = chunk.text ?? "";
-            if (text !== "") {
-                state.chunks.push(expandLineBreaks(text));
-            }
-            state.reasoning = true;
-        }
-        else {
-            const text = chunk.text ?? "";
-            state.chunks.push(text);
-            state.lastText += text;
-            state.reasoning = false;
-        }
-        state.lastIndex = chunk.index;
-        state.pushedAny = true;
-        state.lastPushAt = Date.now();
-        return;
-    }
-    if (chunk.type === "block-end") {
-        // Short blocks may arrive whole here with no preceding delta chunks.
-        // Fall back to the block text when this index never streamed deltas, so
-        // no content is silently dropped (guarded by index against duplication;
-        // each step restarts block indices, and a tool call resets `lastIndex`,
-        // so a same-index block-end after streamed deltas is reliably detected).
-        const index = chunk.index;
-        const blockType = chunk.block?.type;
-        const text = chunk.block?.text;
-        if (blockType === "reasoning" && level !== "full") {
-            // Reasoning block text is never streamed outside `full` mode.
-            if (level === "important" && !state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-                state.pushedAny = true;
-                state.lastPushAt = Date.now();
-            }
-            return;
-        }
-        if (typeof text === "string" && text.length > 0 && (index === undefined || index !== state.lastIndex)) {
-            if (state.pushedAny)
-                state.chunks.push("\n\n");
-            if (blockType === "reasoning" && !state.hintPushed) {
-                state.hintPushed = true;
-                state.chunks.push(thinkingHint);
-            }
-            state.chunks.push(blockType === "reasoning" ? expandLineBreaks(text) : text);
-            if (blockType !== "reasoning")
-                state.lastText += text;
-            state.lastIndex = index;
-            state.pushedAny = true;
-            state.reasoning = blockType === "reasoning";
-            state.lastPushAt = Date.now();
-        }
-    }
-}
-/**
- * Push a localized tool-call status line into the streaming queue so long
- * tool-execution stretches stay visibly alive (the Web GUI shows tool calls;
- * the chat card should too). Ends the reasoning phase and drops the block
- * index so the next content block gets its own separator instead of stacking
- * one on top of the tool line's own blank lines.
- * @param state - the turn's mutable assembly state.
- * @param label - the localized status line, e.g. "🔧 调用工具 `pwsh` — …".
- */
-export function applyToolCall(state, label) {
-    state.chunks.push(`\n\n${label}\n\n`);
-    state.reasoning = false;
-    state.lastIndex = undefined;
-    state.pushedAny = true;
-    state.lastPushAt = Date.now();
-}
-/** Pull a short human summary out of a tool call's `arguments` JSON (whitespace folded to one line). */
-export function toolCallSummary(argumentsJson) {
-    if (typeof argumentsJson !== "string")
-        return undefined;
-    const fold = (value) => value.replace(/\s+/g, " ").trim();
-    try {
-        const parsed = JSON.parse(argumentsJson);
-        const description = parsed?.description;
-        if (typeof description === "string" && description !== "") {
-            const folded = fold(description);
-            return folded.length > 60 ? `${folded.slice(0, 60)}…` : folded;
-        }
-        for (const key of ["file_path", "path"]) {
-            const value = parsed?.[key];
-            if (typeof value === "string" && value !== "") {
-                const folded = fold(value);
-                return folded.length > 60 ? `${folded.slice(0, 60)}…` : folded;
-            }
-        }
-    }
-    catch {
-        // Not JSON — no summary.
-    }
-    return undefined;
-}
-/** Pull the first question's text out of an `ask_user_question` arguments JSON (whitespace folded to one line). */
-export function questionTextOf(argumentsJson) {
-    if (typeof argumentsJson !== "string")
-        return "";
-    try {
-        const parsed = JSON.parse(argumentsJson);
-        const first = Array.isArray(parsed?.questions) ? parsed.questions[0] : undefined;
-        const text = typeof first?.question === "string" ? first.question : "";
-        const folded = text.replace(/\s+/g, " ").trim();
-        return folded.length > 60 ? `${folded.slice(0, 60)}…` : folded;
-    }
-    catch {
-        // Not JSON — no question text.
-    }
-    return "";
-}
-function mapReason(kind) {
-    switch (kind) {
-        case "completed":
-        case "aborted":
-        case "blocked":
-        case "error":
-        case "max-tokens":
-        case "interrupted":
-            return kind;
-        default:
-            return "unknown";
-    }
-}
-export function summarizeTurn(events, firstSeq) {
-    let started = false;
-    let text = "";
-    let reason = "unknown";
-    let code;
-    let message;
-    let model;
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let cacheReadTokens = 0;
-    let contextSize;
-    let contextWindow;
-    let steps = 0;
-    let turnStartTime;
-    let turnEndTime;
-    for (const event of events) {
-        if (event.seq < firstSeq)
-            continue;
-        if (event.type === "turn/start") {
-            started = true;
-            turnStartTime = typeof event.time === "number" ? event.time : undefined;
-            continue;
-        }
-        if (!started)
-            continue;
-        if (event.type === "step/start")
-            steps += 1;
-        if (event.type === "request/context") {
-            const provider = typeof event.data.provider === "string" ? event.data.provider : undefined;
-            const m = typeof event.data.model === "string" ? event.data.model : undefined;
-            if (provider !== undefined && m !== undefined)
-                model = `${provider}/${m}`;
-            if (typeof event.data.contextWindow === "number")
-                contextWindow = event.data.contextWindow;
-        }
-        if (event.type === "assistant/message") {
-            const usage = event.data.usage;
-            if (usage !== undefined) {
-                inputTokens += typeof usage.inputTokens === "number" ? usage.inputTokens : 0;
-                outputTokens += typeof usage.outputTokens === "number" ? usage.outputTokens : 0;
-                cacheReadTokens += typeof usage.cacheReadTokens === "number" ? usage.cacheReadTokens : 0;
-                if (typeof usage.inputTokens === "number")
-                    contextSize = usage.inputTokens;
-            }
-            const joined = event.data.message.content
-                .filter((block) => block.type === "text")
-                .map((block) => block.text)
-                .join("");
-            if (joined !== "")
-                text = joined;
-        }
-        if (event.type === "turn/end") {
-            turnEndTime = typeof event.time === "number" ? event.time : undefined;
-            reason = mapReason(event.data.reason.kind);
-            if (event.data.reason.kind === "error") {
-                code = event.data.reason.error.code;
-                message = event.data.reason.error.message;
-            }
-        }
-    }
-    const elapsedMs = turnStartTime !== undefined && turnEndTime !== undefined && turnEndTime >= turnStartTime
-        ? turnEndTime - turnStartTime
-        : undefined;
-    return {
-        reason,
-        text,
-        ...(code === undefined ? {} : { code }),
-        ...(message === undefined ? {} : { message }),
-        ...(model === undefined ? {} : { model }),
-        ...(inputTokens > 0 ? { inputTokens } : {}),
-        ...(outputTokens > 0 ? { outputTokens } : {}),
-        ...(cacheReadTokens > 0 ? { cacheReadTokens } : {}),
-        ...(contextSize === undefined ? {} : { contextSize }),
-        ...(contextWindow === undefined ? {} : { contextWindow }),
-        ...(steps > 0 ? { steps } : {}),
-        ...(elapsedMs === undefined ? {} : { elapsedMs }),
-    };
-}
-function truncate(text, max = 500) {
-    return text.length <= max ? text : `${text.slice(0, max)}…`;
-}
-/** Classify an error message into an advice bucket (keyword-based, best-effort). */
-export function classifyError(detail) {
-    const d = detail.toLowerCase();
-    if (/(permission|forbidden|denied|not have access|no access|unauthorized|403|sandbox|acl |isn't permitted|not permitted|access denied)/.test(d))
-        return "permission";
-    if (/(timeout|econnrefused|econnreset|enotfound|enetunreach|etimedout|socket|network|proxy|tls|certificate|fetch failed|connect |unreachable|dns)/.test(d))
-        return "network";
-    if (/(model|quota|rate ?limit|429|insufficient|balance|token(s)? (limit|length)|max_tokens|context length|credit)/.test(d))
-        return "model";
-    return "generic";
-}
-/** Thousands-separated token count for display. */
-function fmtTokens(n) {
-    return n.toLocaleString("en-US");
-}
-function textOf(message) {
-    if (message === undefined)
-        return "";
-    return message.content
-        .filter((b) => b.type === "text" && typeof b.text === "string")
-        .map((b) => b.text ?? "")
-        .join("");
-}
 /** Lightweight fold of `schedule/change` events (create / delete / dispatch). */
 function foldReminders(events) {
     const active = new Map();
@@ -364,6 +98,8 @@ export class AgentRunner {
     adapter;
     bindings;
     adapters;
+    requeue;
+    reminders;
     queue = [];
     running = false;
     agent;
@@ -374,7 +110,16 @@ export class AgentRunner {
     notifyLevel;
     progressTimeoutMs;
     t;
-    constructor(ctx, config, channel, chatKey, chatType, adapter, bindings, adapters) {
+    menu;
+    constructor(ctx, config, channel, chatKey, chatType, adapter, bindings, adapters, 
+    /**
+     * Route a replayed queued message back into the runner of its own channel
+     * (wired by ConnectService). Without it, replayed messages would run in
+     * whichever runner happened to release the lock.
+     */
+    requeue, 
+    /** Persistent chat-level reminders (`/remind`), wired by ConnectService. */
+    reminders) {
         this.ctx = ctx;
         this.config = config;
         this.channel = channel;
@@ -383,6 +128,8 @@ export class AgentRunner {
         this.adapter = adapter;
         this.bindings = bindings;
         this.adapters = adapters;
+        this.requeue = requeue;
+        this.reminders = reminders;
         this.workDir = config.workDir ?? this.resolveDefaultWorkDir();
         // A per-chat language override (set via the settings menu) wins over config.
         const stored = this.bindings.get(channel, chatKey);
@@ -390,54 +137,16 @@ export class AgentRunner {
         this.notifyLevel = stored?.notifyLevel ?? config.notifyLevel;
         this.progressTimeoutMs = stored?.progressTimeoutMs ?? config.progressTimeoutMs;
         this.t = messages(this.language);
+        this.menu = new MenuController(this);
     }
     menuTitle(menuId) {
-        switch (menuId) {
-            case "root":
-                return this.t.menuRoot;
-            case "workspace":
-                return this.t.menuWorkspace;
-            case "chat":
-                return this.t.menuChat;
-            case "settings":
-                return this.t.menuSettings;
-            case "model":
-                return this.t.menuModel;
-            case "reasoning":
-                return this.t.menuReasoning;
-            case "notify":
-                return this.t.menuNotify;
-            case "language":
-                return this.t.menuSettingsLanguage;
-            case "progress":
-                return this.t.progressMenuTitle;
-        }
+        return menuTitle(menuId, this.t);
     }
     rootMenuSections() {
-        return [
-            { title: this.t.rootSectionWorkspace, ids: ["workspace"], columnsPerRow: 1 },
-            { title: this.t.rootSectionChat, ids: ["chat", "history"], columnsPerRow: 1 },
-            { title: this.t.rootSectionTask, ids: ["task", "goals", "schedule"], columnsPerRow: 2 },
-            { title: this.t.rootSectionSystem, ids: ["status", "plugins", "compact", "settings"], columnsPerRow: 2 },
-        ];
+        return rootMenuSections(this.t);
     }
     reasonLabel(reason) {
-        switch (reason) {
-            case "completed":
-                return this.t.reasonCompleted;
-            case "aborted":
-                return this.t.reasonAborted;
-            case "blocked":
-                return this.t.reasonBlocked;
-            case "error":
-                return this.t.reasonError;
-            case "max-tokens":
-                return this.t.reasonMaxTokens;
-            case "interrupted":
-                return this.t.reasonInterrupted;
-            default:
-                return this.t.reasonUnknown;
-        }
+        return reasonLabel(reason, this.t);
     }
     /** Prefer the user's first DSH workspace over the process cwd as default. */
     resolveDefaultWorkDir() {
@@ -514,16 +223,18 @@ export class AgentRunner {
             else {
                 turn.milestone = this.t.toolCalling(name, undefined);
             }
-            // `result` mode shows nothing until the final answer; `important` shows
-            // the tool name with a step counter, `full` also carries the summary.
-            if (this.notifyLevel === "result")
+            // `result` mode shows nothing until the final answer.
+            if (this.notifyLevel === 'result')
+                return;
+            // Keep the streaming card short: push a status line only once per distinct
+            // tool (not once per call, which would log "tool #51" spam), and label it
+            // with the tool name rather than a running counter.
+            if (turn.lastToolName === name)
                 return;
-            const base = name === "ask_user_question"
+            turn.lastToolName = name;
+            const label = name === 'ask_user_question'
                 ? this.t.questionToolCall(questionTextOf(event.data.arguments))
-                : this.t.toolStepLabel(turn.toolCount, name);
-            const label = name === "ask_user_question" || this.notifyLevel !== "full" || summary === undefined
-                ? base
-                : `${base} — ${summary}`;
+                : this.t.toolCalling(name, this.notifyLevel === 'full' ? summary : undefined);
             applyToolCall(turn, label);
         }
     }
@@ -685,7 +396,7 @@ export class AgentRunner {
             await this.sendTurnStats(msg, outcome);
             // Release lock after task completion
             if (usesLock)
-                this.releaseLock();
+                await this.releaseLock();
             if (outcome.reason !== "completed") {
                 await this.sendSummary(msg, outcome);
             }
@@ -693,7 +404,7 @@ export class AgentRunner {
         catch (error) {
             // Release lock even on error
             if (usesLock)
-                this.releaseLock();
+                await this.releaseLock();
             const detail = error instanceof Error ? error.message : String(error);
             await this.adapter
                 .sendText(this.target(msg), this.t.processingFailedAdvice(truncate(detail, 400), this.errorAdvice(detail)))
@@ -901,7 +612,7 @@ export class AgentRunner {
         this.turn = {
             firstSeq, chunks, lastText: "",
             reasoning: false, hintPushed: false, lastIndex: undefined, pushedAny: false,
-            startedAt: now, lastPushAt: now, toolCount: 0, contextNudged: false, compactAfterTurn: false,
+            startedAt: now, lastPushAt: now, toolCount: 0, lastToolName: undefined, contextNudged: false, compactAfterTurn: false,
         };
         // Liveness heartbeat: while the agent is working, keep the streaming card
         // visibly alive even through long reasoning or tool-execution stretches
@@ -922,26 +633,29 @@ export class AgentRunner {
             }, heartbeatMs)
             : undefined;
         // Proactive progress watchdog: when no standalone card/text has been sent
-        // for `progressTimeoutMs` (default 5 min, user-configurable), send a status
-        // card reporting the latest milestone so a long turn never looks frozen.
-        // Streaming-card heartbeats deliberately do NOT reset this — the user asked
-        // for an explicit, separate nudge.
+        // for `progressTimeoutMs` (default 5 min, user-configurable), re-sync the
+        // latest milestone INTO the streaming card (via its chunk stream) so a long
+        // turn never looks frozen — WITHOUT posting a separate message. The card is
+        // edited in place, keeping the chat history clean. Streaming-card heartbeats
+        // deliberately do NOT reset this: the progress watchdog only fires when no
+        // explicit milestone sync has been pushed for the configured interval.
         const progressTimeoutMs = this.progressTimeoutMs;
-        let lastStandaloneNoticeAt = now;
+        let lastProgressNoticeAt = now;
         const progressWatchdog = progressTimeoutMs > 0
             ? setInterval(() => {
                 const turn = this.turn;
                 if (turn === undefined)
                     return;
-                const elapsed = Date.now() - lastStandaloneNoticeAt;
+                const elapsed = Date.now() - lastProgressNoticeAt;
                 if (elapsed < progressTimeoutMs)
                     return;
-                lastStandaloneNoticeAt = Date.now();
+                lastProgressNoticeAt = Date.now();
                 const minutes = Math.max(1, Math.round((Date.now() - turn.startedAt) / 60_000));
                 const status = turn.milestone ?? this.t.progressThinking;
-                void this.adapter
-                    .sendText(this.target(msg), this.t.progressReminder(minutes, status))
-                    .catch(() => undefined);
+                // Edit the existing streaming card in place instead of sending a new
+                // message: the milestone is appended to the same card via the chunk
+                // stream, so progress updates never clutter the chat with new bubbles.
+                turn.chunks.push(`\n\n${this.t.progressReminder(minutes, status)}\n\n`);
             }, PROGRESS_WATCHDOG_CHECK_MS)
             : undefined;
         // End the chunk stream unconditionally: if `followup` / `whenIdle` /
@@ -1306,7 +1020,7 @@ export class AgentRunner {
             }
             case "dir": {
                 if (command.path === undefined) {
-                    await this.openMenu(target, msg, "workspace", ["root"]);
+                    await this.menu.openMenu(target, msg, "workspace", ["root"]);
                     break;
                 }
                 const path = command.path;
@@ -1330,15 +1044,15 @@ export class AgentRunner {
                 break;
             }
             case "chat": {
-                await this.openMenu(target, msg, "chat", ["root"]);
+                await this.menu.openMenu(target, msg, "chat", ["root"]);
                 break;
             }
             case "menu": {
-                await this.openMenu(target, msg, "root");
+                await this.menu.openMenu(target, msg, "root");
                 break;
             }
             case "settings": {
-                await this.openMenu(target, msg, "settings", ["root"]);
+                await this.menu.openMenu(target, msg, "settings", ["root"]);
                 break;
             }
             case "plugins": {
@@ -1370,7 +1084,7 @@ export class AgentRunner {
                 break;
             }
             case "model": {
-                await this.openMenu(target, msg, "model", ["root"]);
+                await this.menu.openMenu(target, msg, "model", ["root"]);
                 break;
             }
             case "notify": {
@@ -1405,6 +1119,18 @@ export class AgentRunner {
                 await this.handleAppend(command.text, target, msg);
                 break;
             }
+            case "remind": {
+                await this.handleRemind(command.text, target, msg);
+                break;
+            }
+            case "send": {
+                await this.handleSend(command.path, target);
+                break;
+            }
+            case "broadcast": {
+                await this.handleBroadcast(command.text, target, msg);
+                break;
+            }
             case "help": {
                 await this.adapter.sendText(target, helpText(this.t));
                 break;
@@ -1446,6 +1172,103 @@ export class AgentRunner {
         this.touchBinding(msg);
         await this.adapter.sendText(target, this.t.psReceived(text));
     }
+    /**
+     * `/remind <time> <text>` — persist a chat-level reminder that fires
+     * without waking the agent (see src/scheduler.ts).
+     */
+    async handleRemind(argText, target, msg) {
+        if (this.reminders === undefined) {
+            await this.adapter.sendText(target, this.t.reminderNoText);
+            return;
+        }
+        const arg = argText.trim();
+        if (arg === "") {
+            await this.adapter.sendText(target, this.t.reminderNoText);
+            return;
+        }
+        const space = arg.indexOf(" ");
+        const time = space === -1 ? arg : arg.slice(0, space);
+        const body = space === -1 ? "" : arg.slice(space + 1).trim();
+        const dueAt = parseRemindTime(time);
+        if (dueAt === undefined) {
+            await this.adapter.sendText(target, this.t.reminderParseFailed(time));
+            return;
+        }
+        if (body === "") {
+            await this.adapter.sendText(target, this.t.reminderNoText);
+            return;
+        }
+        this.reminders.add({
+            channel: this.channel,
+            chatKey: this.chatKey,
+            chatType: this.chatType,
+            text: body,
+            dueAt,
+            ownerKey: msg.senderKey,
+        });
+        await this.adapter.sendText(target, this.t.reminderSet(formatRemindAt(dueAt, this.language), body));
+    }
+    /**
+     * `/send <path>` — deliver a file from the workspace through the channel's
+     * `sendFile` capability; falls back to sending the path as text.
+     */
+    async handleSend(pathArg, target) {
+        if (pathArg === "") {
+            await this.adapter.sendText(target, this.t.sendUsage);
+            return;
+        }
+        const path = isAbsolute(pathArg) ? pathArg : join(this.workDir, pathArg);
+        let size;
+        try {
+            if (!existsSync(path)) {
+                await this.adapter.sendText(target, this.t.sendNotFound(path));
+                return;
+            }
+            const stat = statSync(path);
+            if (stat.isDirectory()) {
+                await this.adapter.sendText(target, this.t.sendIsDir(path));
+                return;
+            }
+            size = stat.size;
+        }
+        catch {
+            await this.adapter.sendText(target, this.t.sendNotFound(path));
+            return;
+        }
+        if (size > 20 * 1024 * 1024) {
+            await this.adapter.sendText(target, this.t.sendTooLarge(path));
+            return;
+        }
+        if (this.adapter.sendFile === undefined) {
+            await this.adapter.sendText(target, `${this.t.sendUnsupported}\n${path}`);
+            return;
+        }
+        try {
+            await this.adapter.sendFile(target, path);
+            await this.adapter.sendText(target, this.t.sendSent(path));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            await this.adapter.sendText(target, this.t.sendFailed(truncate(detail)));
+        }
+    }
+    /**
+     * `/broadcast <text>` — admins push a message to every bound chat.
+     * Admin gating lives in the connect service (allowUsers).
+     */
+    async handleBroadcast(text, target, msg) {
+        const service = this.ctx.get("connect");
+        if (service?.broadcast === undefined) {
+            await this.adapter.sendText(target, this.t.broadcastUnsupported);
+            return;
+        }
+        const result = await service.broadcast(msg.senderKey, text);
+        if (!result.ok) {
+            await this.adapter.sendText(target, result.reason === "disabled" ? this.t.broadcastDisabled : this.t.broadcastNotAdmin);
+            return;
+        }
+        await this.adapter.sendText(target, this.t.broadcastSent(result.count ?? 0));
+    }
     recordSession(sessionId, title, ownerKey) {
         const binding = this.bindings.get(this.channel, this.chatKey);
         const others = (binding?.sessions ?? []).filter((s) => s.sessionId !== sessionId);
@@ -1553,198 +1376,12 @@ export class AgentRunner {
         await this.disposeAgent();
     }
     listWorkspaces() {
-        const registry = this.ctx.get("workspaceRegistry");
-        const out = [];
-        const seen = new Set();
-        const add = (path, title) => {
-            if (path === "")
-                return;
-            const key = path.replace(/[\\/]+$/, "").toLowerCase();
-            if (seen.has(key))
-                return;
-            seen.add(key);
-            out.push({ path, title: title || path });
-        };
-        add(this.workDir, this.t.currentDir);
-        for (const w of registry?.list?.() ?? [])
-            add(w.path, w.title);
-        for (const p of this.config.workspaces)
-            add(p, p);
-        return out;
-    }
-    async openMenu(target, msg, menuId, stack = [], cardId) {
-        const items = await this.menuItems(menuId);
-        const options = items.map((i) => ({ id: i.id, label: i.label }));
-        options.push({ id: "menu:exit", label: this.t.menuExit });
-        if (stack.length > 0)
-            options.push({ id: "menu:back", label: this.t.menuBack });
-        // Determine columns per row based on menu type
-        // Workspace and chat lists use 1 column (full width), others use 2 columns
-        const columnsPerRow = (menuId === "workspace" || menuId === "chat") ? 1 : 2;
-        const { choice, messageId } = await this.adapter.promptChoice(target, {
-            title: this.menuTitle(menuId),
-            options,
-            columnsPerRow,
-            ...(menuId === "root" ? { sections: this.rootMenuSections(), footer: this.t.rootMenuFooter } : {}),
-        }, cardId);
-        if (choice === undefined)
-            return;
-        if (choice === "menu:exit") {
-            await this.adapter.closeMenu(messageId, this.t.menuClosed);
-            return;
-        }
-        if (choice === "menu:back") {
-            const parent = stack[stack.length - 1];
-            await this.openMenu(target, msg, parent, stack.slice(0, -1), messageId);
-            return;
-        }
-        const item = items.find((i) => i.id === choice);
-        if (item === undefined) {
-            // The tap belonged to a previous card generation (e.g. a rapid second
-            // tap on the old menu while the new one was still being redrawn). Don't
-            // silently swallow it: redraw the current menu so the chain stays usable.
-            await this.openMenu(target, msg, menuId, stack, messageId);
-            return;
-        }
-        const feedback = await item.onSelect(target, msg, messageId);
-        if (item.leaf === true) {
-            // Every leaf press must answer visibly: send the action's result feedback
-            // (if any) before returning to the root menu on the same card.
-            if (feedback !== undefined && feedback !== "") {
-                await this.adapter.sendText(target, feedback).catch(() => undefined);
-            }
-            await this.openMenu(target, msg, "root", [], messageId);
-        }
-    }
-    async menuItems(menuId) {
-        switch (menuId) {
-            case "root":
-                return [
-                    { id: "workspace", label: this.t.menuWorkspaceAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "workspace", ["root"], cardId) },
-                    { id: "chat", label: this.t.menuChatAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "chat", ["root"], cardId) },
-                    { id: "status", label: this.t.menuStatusAction, leaf: true, onSelect: async (t) => { await this.showStatus(t); } },
-                    { id: "task", label: this.t.menuTaskAction, leaf: true, onSelect: async (t) => { await this.showTasks(t); } },
-                    { id: "history", label: this.t.menuHistoryAction, leaf: true, onSelect: async (t) => { await this.showHistory(t, 10); } },
-                    { id: "goals", label: this.t.menuGoalsAction, leaf: true, onSelect: async (t) => { await this.showGoals(t); } },
-                    { id: "schedule", label: this.t.menuScheduleAction, leaf: true, onSelect: async (t) => { await this.showSchedule(t); } },
-                    { id: "compact", label: this.t.menuCompactAction, leaf: true, onSelect: async (t) => { await this.compact(t); } },
-                    { id: "plugins", label: this.t.menuPluginsAction, leaf: true, onSelect: async (t) => { await this.showPlugins(t); } },
-                    { id: "settings", label: this.t.menuSettingsAction, onSelect: (t, m, cardId) => this.openMenu(t, m, "settings", ["root"], cardId) },
-                ];
-            case "workspace": {
-                const workspaces = this.listWorkspaces();
-                return workspaces.map((w) => ({
-                    id: `dir:${w.path}`,
-                    label: `${w.path === this.workDir ? "● " : ""}${w.title}${w.title !== w.path ? `  (${w.path})` : ""}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        this.workDir = w.path;
-                        await this.newChat(m);
-                        return this.t.dirSwitched(w.path);
-                    },
-                }));
-            }
-            case "chat": {
-                const binding = this.bindings.get(this.channel, this.chatKey);
-                const active = binding?.sessionId;
-                const hasWebMirror = binding?.webMirrorSessionId !== undefined;
-                const items = (await this.collectWorkdirSessions()).map(({ sessionId, title }) => {
-                    const isMirrored = hasWebMirror && binding?.webMirrorSessionId === sessionId;
-                    const mirrorIndicator = isMirrored ? ` ${this.t.webMirrorIndicator}` : "";
-                    const activeIndicator = sessionId === active ? "●" : "○";
-                    return {
-                        id: `session:${sessionId}`,
-                        label: `${activeIndicator} ${title || sessionId}${mirrorIndicator}`,
-                        leaf: true,
-                        onSelect: async (t, m) => {
-                            await this.switchTo(sessionId, m.senderKey);
-                            return this.t.sessionSwitched(title || sessionId);
-                        },
-                    };
-                });
-                if (items.length === 0) {
-                    items.push({
-                        id: "none:history",
-                        label: this.t.noSessionsInWorkdir(this.workDir),
-                        leaf: true,
-                        onSelect: async () => this.t.noSessionsInWorkdir(this.workDir),
-                    });
-                }
-                items.push({
-                    id: "action:new",
-                    label: this.t.menuNewChat,
-                    leaf: true,
-                    onSelect: async (t, m, messageId) => {
-                        // Reuse the menu card for the confirm prompt so no stale card is left behind.
-                        if (await this.confirmAction(t, this.t.confirmNewText, messageId)) {
-                            await this.newChat(m);
-                            return this.t.newChatDone;
-                        }
-                        return this.t.actionCancelled;
-                    },
-                });
-                return items;
-            }
-            case "settings":
-                return [
-                    { id: "model", label: this.t.menuSettingsModel, onSelect: (t, m, cardId) => this.openMenu(t, m, "model", ["settings", "root"], cardId) },
-                    { id: "reasoning", label: this.t.menuSettingsReasoning, onSelect: (t, m, cardId) => this.openMenu(t, m, "reasoning", ["settings", "root"], cardId) },
-                    { id: "notify", label: this.t.menuSettingsNotify, onSelect: (t, m, cardId) => this.openMenu(t, m, "notify", ["settings", "root"], cardId) },
-                    { id: "progress", label: this.t.menuSettingsProgress, onSelect: (t, m, cardId) => this.openMenu(t, m, "progress", ["settings", "root"], cardId) },
-                    { id: "language", label: this.t.menuSettingsLanguage, onSelect: (t, m, cardId) => this.openMenu(t, m, "language", ["settings", "root"], cardId) },
-                    { id: "overview", label: this.t.menuSettingsOverview, leaf: true, onSelect: async (t) => { await this.showSettings(t); } },
-                ];
-            case "language":
-                return [
-                    {
-                        id: "lang:zh",
-                        label: `${this.language === "zh" ? "● " : ""}${this.t.languageZh}`,
-                        leaf: true,
-                        onSelect: async (t, m) => { await this.setLanguage("zh", t, m); },
-                    },
-                    {
-                        id: "lang:en",
-                        label: `${this.language === "en" ? "● " : ""}${this.t.languageEn}`,
-                        leaf: true,
-                        onSelect: async (t, m) => { await this.setLanguage("en", t, m); },
-                    },
-                ];
-            case "model":
-                return await this.modelMenuItems();
-            case "reasoning":
-                return this.reasoningMenuItems();
-            case "notify":
-                return [
-                    { id: "full", label: this.t.notifyFull },
-                    { id: "important", label: this.t.notifyImportant },
-                    { id: "result", label: this.t.notifyResult },
-                ].map((o) => ({
-                    id: `notify:${o.id}`,
-                    label: `${this.notifyLevel === o.id ? "● " : ""}${o.label}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        await this.setNotifyLevel(o.id, t, m);
-                    },
-                }));
-            case "progress": {
-                const presets = [
-                    { id: "progress:0", label: this.t.progressOff, ms: 0 },
-                    { id: "progress:120000", label: this.t.progressMinutes(2), ms: 2 * 60_000 },
-                    { id: "progress:300000", label: this.t.progressMinutes(5), ms: 5 * 60_000 },
-                    { id: "progress:600000", label: this.t.progressMinutes(10), ms: 10 * 60_000 },
-                    { id: "progress:900000", label: this.t.progressMinutes(15), ms: 15 * 60_000 },
-                    { id: "progress:1800000", label: this.t.progressMinutes(30), ms: 30 * 60_000 },
-                ];
-                return presets.map((o) => ({
-                    id: o.id,
-                    label: `${this.progressTimeoutMs === o.ms ? "● " : ""}${o.label}`,
-                    leaf: true,
-                    onSelect: async (t, m) => {
-                        await this.setProgressTimeout(o.ms, t, m);
-                    },
-                }));
-            }
-        }
+        return listWorkspaces({
+            registry: this.ctx.get("workspaceRegistry"),
+            workDir: this.workDir,
+            currentDirLabel: this.t.currentDir,
+            workspaces: this.config.workspaces,
+        });
     }
     async showStatus(target) {
         const agent = this.agent;
@@ -1845,41 +1482,6 @@ export class AgentRunner {
         lines.push(this.t.stateDirField(this.config.stateDir ?? ".dsh-connect"));
         await this.adapter.sendText(target, lines.join("\n"));
     }
-    async modelMenuItems() {
-        const choices = await this.listModelChoices();
-        const current = this.defaultSelection();
-        const items = choices.map((c) => ({
-            id: `model:${c.provider}:${c.model}`,
-            label: `${c.provider === current.provider && c.model === current.model ? "● " : ""}${c.name}`,
-            leaf: true,
-            onSelect: async (t, m) => {
-                await this.setModel(c.provider, c.model, m);
-                return this.t.modelSet(c.name);
-            },
-        }));
-        if (items.length === 0) {
-            items.push({ id: "model:none", label: this.t.noModelsFound, leaf: true, onSelect: async () => this.t.noModelsFound });
-        }
-        return items;
-    }
-    async listModelChoices() {
-        const llm = this.ctx.get("llm");
-        const providers = llm?.listProviders?.() ?? [];
-        const out = [];
-        for (const p of providers) {
-            let models = [];
-            try {
-                models = (await llm?.listModels?.(p.id)) ?? [];
-            }
-            catch {
-                // Skip providers whose catalog cannot be listed.
-            }
-            for (const m of models) {
-                out.push({ provider: p.id, model: m.id, name: this.t.modelName(m.name || m.id, p.name || p.id) });
-            }
-        }
-        return out;
-    }
     async setModel(provider, model, msg) {
         const svc = this.ctx.get("agentDefaultModel");
         const cur = this.defaultSelection();
@@ -1890,37 +1492,6 @@ export class AgentRunner {
         });
         await this.newChat(msg);
     }
-    reasoningMenuItems() {
-        const current = this.defaultSelection();
-        const efforts = [
-            { id: "low", name: this.t.effortLow },
-            { id: "medium", name: this.t.effortMedium },
-            { id: "high", name: this.t.effortHigh },
-        ];
-        const items = [
-            {
-                id: "effort:default",
-                label: `${current.reasoningEffort === undefined ? "● " : ""}${this.t.effortDefault}`,
-                leaf: true,
-                onSelect: async (t, m) => {
-                    await this.setReasoning(undefined, m);
-                    return this.t.reasoningSet(this.t.effortDefault);
-                },
-            },
-        ];
-        for (const e of efforts) {
-            items.push({
-                id: `effort:${e.id}`,
-                label: `${e.id === current.reasoningEffort ? "● " : ""}${e.name}`,
-                leaf: true,
-                onSelect: async (t, m) => {
-                    await this.setReasoning(e.id, m);
-                    return this.t.reasoningSet(e.name);
-                },
-            });
-        }
-        return items;
-    }
     async setReasoning(effort, msg) {
         const svc = this.ctx.get("agentDefaultModel");
         const cur = this.defaultSelection();
@@ -2181,40 +1752,41 @@ export class AgentRunner {
         await this.adapter.sendText(target, lines.join("\n"));
     }
     goalPhaseLabel(phase) {
-        switch (phase) {
-            case "active":
-                return this.t.goalPhaseActive;
-            case "paused":
-                return this.t.goalPhasePaused;
-            case "blocked":
-                return this.t.goalPhaseBlocked;
-            case "complete":
-                return this.t.goalPhaseComplete;
-            default:
-                return phase;
-        }
+        return goalPhaseLabel(phase, this.t);
     }
     async showSchedule(target) {
-        const agent = this.agent;
-        if (agent === undefined) {
-            await this.adapter.sendText(target, this.t.noActiveSession);
-            return;
-        }
-        const reminders = foldReminders(agent.session.events);
-        if (reminders.length === 0) {
-            await this.adapter.sendText(target, this.t.noReminders);
-            return;
-        }
+        // Agent-level reminders (session `schedule` tool) + persistent chat-level
+        // reminders (`/remind`), merged into one list.
+        const agentReminders = this.agent === undefined ? [] : foldReminders(this.agent.session.events);
+        const persisted = this.reminders?.listFor(this.channel, this.chatKey) ?? [];
         const now = Date.now();
         const locale = this.language === "en" ? "en-US" : "zh-CN";
-        const lines = reminders.map((r) => {
+        const agentLines = agentReminders.map((r) => {
             const due = Date.parse(r.scheduledAt) <= now;
             const state = due ? this.t.reminderDue : this.t.reminderClock;
             const kind = r.kind === "every" ? this.t.reminderEvery(Math.round((r.everySeconds ?? 0) / 60)) : this.t.reminderOnce;
             const when = new Date(Date.parse(r.scheduledAt)).toLocaleString(locale);
             return this.t.reminderLine(state, r.id, r.prompt, kind, when);
         });
-        await this.adapter.sendText(target, this.t.remindersCount(reminders.length, lines.join("\n")));
+        const persistedLines = persisted.map((r) => {
+            const due = r.dueAt <= now;
+            const state = due ? this.t.reminderDue : this.t.reminderClock;
+            const when = new Date(r.dueAt).toLocaleString(locale);
+            return this.t.reminderLine(state, r.id, r.text, this.t.reminderOnce, when);
+        });
+        const total = agentLines.length + persistedLines.length;
+        if (total === 0) {
+            await this.adapter.sendText(target, this.t.noReminders);
+            return;
+        }
+        const parts = [];
+        if (agentLines.length > 0)
+            parts.push(...agentLines);
+        if (persistedLines.length > 0) {
+            parts.push(this.t.reminderPersistedHeader);
+            parts.push(...persistedLines);
+        }
+        await this.adapter.sendText(target, this.t.remindersCount(total, parts.join("\n")));
     }
     async showAllWorkspaces(target) {
         const registry = this.ctx.get("workspaceRegistry");
@@ -2299,7 +1871,7 @@ export class AgentRunner {
         }
         // Process any queued messages before releasing
         const queuedCount = binding.queuedMessages?.length ?? 0;
-        this.releaseLock();
+        await this.releaseLock();
         let message = this.t.unlockSuccess;
         if (queuedCount > 0) {
             message += `\n${this.t.queueProcessed(queuedCount)}`;
@@ -2332,7 +1904,8 @@ export class AgentRunner {
         await this.adapter.sendText(target, this.t.lockRenewed(timeoutMin));
     }
     /**
-     * Export conversation history to Markdown or PDF.
+     * Export conversation history as Markdown (a future PDF pipeline can be
+     * added here; `/export pdf` currently falls back to Markdown).
      */
     async handleExport(target, format) {
         const agent = this.agent;
@@ -2340,12 +1913,6 @@ export class AgentRunner {
             await this.adapter.sendText(target, this.t.exportNoSession);
             return;
         }
-        // Default to markdown if not specified
-        const exportFormat = format ?? "markdown";
-        if (exportFormat === "pdf") {
-            await this.adapter.sendText(target, this.t.exportPdfNotSupported);
-            return;
-        }
         try {
             const markdown = this.generateMarkdown(agent);
             const fileName = `conversation-${agent.id}-${Date.now()}.md`;
@@ -2414,54 +1981,35 @@ export class AgentRunner {
      */
     canWrite(channel) {
         const binding = this.bindings.get(this.channel, this.chatKey);
-        if (binding?.lockOwner === undefined)
-            return true; // No lock, free access
-        // Check timeout
-        if (this.isLockTimedOut(binding)) {
-            this.releaseTimeoutLock(binding);
+        if (binding === undefined)
+            return true; // No binding, free access
+        if (lockCanWrite(binding, channel)) {
+            // A timed-out lock counts as free; release it so the next acquire sees a clean state.
+            if (lockIsTimedOut(binding))
+                this.releaseTimeoutLock(binding);
             return true;
         }
-        return binding.lockOwner === channel;
+        return false;
     }
     /**
      * Acquire session lock for the given channel.
      * Returns true if lock acquired, false if already locked by another channel.
      */
     acquireLock(channel) {
-        const binding = this.bindings.get(this.channel, this.chatKey);
+        let binding = this.bindings.get(this.channel, this.chatKey);
         if (binding === undefined)
             return true;
-        // Check timeout before acquiring
-        if (this.isLockTimedOut(binding)) {
+        // A timed-out lock is treated as free: release it (with the user notice)
+        // before acquiring so the next state is clean.
+        if (lockIsTimedOut(binding)) {
             this.releaseTimeoutLock(binding);
-            // After timeout release, try to acquire again
-            const refreshed = this.bindings.get(this.channel, this.chatKey);
-            if (refreshed !== undefined && (refreshed.lockOwner === undefined || refreshed.lockOwner === channel)) {
-                const defaultTimeoutMs = refreshed.lockTimeoutMs ?? 5 * 60 * 1000;
-                this.bindings.put({
-                    ...refreshed,
-                    lockOwner: channel,
-                    lockAcquiredAt: Date.now(),
-                    lockTimeoutMs: defaultTimeoutMs,
-                    lastActiveAt: Date.now()
-                });
-                return true;
-            }
-        }
-        if (binding.lockOwner === undefined || binding.lockOwner === channel) {
-            // Lock is free or already owned by this channel
-            const timeoutMs = binding.lockTimeoutMs ?? 5 * 60 * 1000;
-            this.bindings.put({
-                ...binding,
-                lockOwner: channel,
-                lockAcquiredAt: Date.now(),
-                lockTimeoutMs: timeoutMs,
-                lastActiveAt: Date.now()
-            });
-            return true;
+            binding = this.bindings.get(this.channel, this.chatKey) ?? binding;
         }
-        // Locked by other channel - queue the message if from Web
-        return false;
+        const next = lockAcquire(binding, channel);
+        if (next === undefined)
+            return false; // Locked by another channel
+        this.bindings.put({ ...next, lastActiveAt: Date.now() });
+        return true;
     }
     /**
      * Queue a message for later execution when lock is released.
@@ -2479,6 +2027,8 @@ export class AgentRunner {
             replyRef: msg.replyRef,
             images: msg.images,
             files: msg.files,
+            // Keep the true source channel so replay routes to the right runner.
+            channel: msg.channel,
         });
         this.bindings.put({ ...binding, queuedMessages: queued });
         return queued.length;
@@ -2496,69 +2046,64 @@ export class AgentRunner {
         const count = messages.length;
         // Clear queue immediately to prevent duplicate processing
         this.bindings.put({ ...binding, queuedMessages: [] });
-        // Notify about queued messages being processed
-        if (count > 0) {
-            const adapter = this.adapters?.get(this.channel);
-            if (adapter) {
-                await adapter.sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.queueProcessed(count)).catch(() => undefined);
-            }
-            // Re-enqueue messages into the runner's processing queue
-            // Construct minimal InboundMessage objects from queued data
-            for (const queued of messages) {
-                const inboundMsg = {
-                    channel: "web", // Queued messages are from Web channel
-                    chatKey: this.chatKey,
-                    chatType: this.chatType,
-                    senderKey: queued.senderKey,
-                    text: queued.text,
-                    replyRef: queued.replyRef,
-                    images: queued.images,
-                    files: queued.files,
-                };
-                // Add to the runner's internal queue for processing
+        // Notify about queued messages being processed.
+        await this.adapter
+            .sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.queueProcessed(count))
+            .catch(() => undefined);
+        // Replay each queued message through the service routing so it lands in
+        // the runner of its own channel (a web message goes to the web runner,
+        // never the releasing feishu runner). Without a router we fall back to
+        // the local queue so behavior stays functional in isolation.
+        for (const queued of messages) {
+            const inboundMsg = {
+                channel: queued.channel ?? "web",
+                chatKey: this.chatKey,
+                chatType: this.chatType,
+                senderKey: queued.senderKey,
+                text: queued.text,
+                replyRef: queued.replyRef,
+                images: queued.images,
+                files: queued.files,
+            };
+            if (this.requeue !== undefined) {
+                this.requeue(inboundMsg);
+            }
+            else {
                 this.queue.push(inboundMsg);
             }
-            // Trigger processing if not already running
-            void this.drain();
         }
+        if (this.requeue === undefined)
+            void this.drain();
     }
-    /** Release session lock. */
-    releaseLock() {
+    /**
+     * Release session lock. Awaits the queued-message drain, then clears the
+     * lock from a FRESH read: the drain's queue-clearing put must not be
+     * overwritten by a stale binding object (which would resurrect the queue
+     * and cause duplicate processing on the next release).
+     */
+    async releaseLock() {
         const binding = this.bindings.get(this.channel, this.chatKey);
-        if (binding !== undefined && binding.lockOwner !== undefined) {
-            // Process queued messages before releasing
-            void this.processQueuedMessages();
-            this.bindings.put({ ...binding, lockOwner: undefined, lockAcquiredAt: undefined });
-        }
-    }
-    /** Check if lock has timed out. */
-    isLockTimedOut(binding) {
-        if (binding.lockOwner === undefined || binding.lockAcquiredAt === undefined) {
-            return false;
-        }
-        const timeoutMs = binding.lockTimeoutMs ?? 5 * 60 * 1000; // Default 5 minutes
-        const elapsed = Date.now() - binding.lockAcquiredAt;
-        return elapsed > timeoutMs;
+        if (binding === undefined || binding.lockOwner === undefined)
+            return;
+        await this.processQueuedMessages();
+        const fresh = this.bindings.get(this.channel, this.chatKey) ?? binding;
+        this.bindings.put(lockRelease(fresh));
     }
-    /** Check and release timed-out locks. */
+    /** Check and release timed-out locks (delegates to the pure lock module). */
     checkAndReleaseTimeoutLock() {
         const binding = this.bindings.get(this.channel, this.chatKey);
-        if (binding && this.isLockTimedOut(binding)) {
+        if (binding !== undefined && lockIsTimedOut(binding)) {
             this.releaseTimeoutLock(binding);
         }
     }
     /** Release a timed-out lock and notify. */
     releaseTimeoutLock(binding) {
-        const timeoutMin = Math.round((binding.lockTimeoutMs ?? 5 * 60 * 1000) / 60000);
+        const timeoutMin = Math.round((binding.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS) / 60000);
         const lockedBy = binding.lockOwner;
-        this.bindings.put({
-            ...binding,
-            lockOwner: undefined,
-            lockAcquiredAt: undefined
-        });
+        this.bindings.put(lockRelease(binding));
         // Notify users about timeout release
         const adapter = this.adapters?.get(this.channel);
-        if (adapter && lockedBy) {
+        if (adapter !== undefined && lockedBy !== undefined) {
             void adapter.sendText({ chatKey: this.chatKey, chatType: this.chatType }, this.t.lockTimeoutReleased(timeoutMin)).catch(() => undefined);
         }
     }